2019 ist gekommen und wahrscheinlich hat jeder die Besonderheit dieser Zahl bemerkt: Sie setzt sich tatsächlich aus zwei Unterzahlen (20 und 19) zusammen, die eine Folge von aufeinanderfolgenden absteigenden Zahlen darstellen.

Herausforderung

Geben Sie bei einer gegebenen Zahl xdie Länge der maximalen Folge von aufeinanderfolgenden absteigenden Zahlen zurück, die gebildet werden können, indem man die Subnummern von verwendet x.

Anmerkungen :

• Unternummern dürfen keine führenden Nullen enthalten (zB 1009nicht aufteilbar in 10, 09)
• Aufeinanderfolgend und absteigend bedeutet, dass eine Zahl in der Folge gleich der vorherigen Zahl -1 sein muss oder $n_{i+1} = n_{i}-1$ (z. B. 52kann nicht aufgeteilt werden, 5,2weil 5und 2nicht aufeinanderfolgend 2 ≠ 5 - 1)
• die Reihenfolge muss mit der vollen Zahl, zB in erhalten werden 7321kann man nicht verwerfen 7die Reihenfolge und erhalten 3, 2,1
• nur eine Sequenz kann aus der Zahl erhalten werden, beispielsweise 3211098kann nicht aufgeteilt in zwei Sequenzen 3, 2, 1und 10, 9,8

Eingang

• Eine Ganzzahl ( >= 0): kann eine Zahl, eine Zeichenfolge oder eine Ziffernliste sein

Ausgabe

• Eine einzelne Ganzzahl angesichts der maximalen Anzahl absteigender Teilzahlen (beachten Sie, dass die Untergrenze dieser Zahl ist 1, dh eine Zahl wird in einer absteigenden Folge von Länge eins für sich zusammengesetzt)

Beispiele:

2019         --> 20,19           --> output : 2
201200199198 --> 201,200,199,198 --> output : 4
3246         --> 3246            --> output : 1
87654        --> 8,7,6,5,4       --> output : 5
123456       --> 123456          --> output : 1
1009998      --> 100,99,98       --> output : 3
100908       --> 100908          --> output : 1
1110987      --> 11,10,9,8,7     --> output : 5
210          --> 2,1,0           --> output : 3
1            --> 1               --> output : 1
0            --> 0               --> output : 1
312          --> 312             --> output : 1
191          --> 191             --> output : 1

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln mit Standard-E / A-Regeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp, verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu (z. B. TIO ).
• Außerdem wird dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

Jelly ,  15  9 Bytes

Bugfix dank Dennis

ŻṚẆDfŒṖẈṀ

Probieren Sie es online! (321dauertsogareine halbe Minute, da der Code mindestens$O(N^2)$ )

Wie?

ŻṚẆDfŒṖẈṀ - Link: integer, n
Ż         - [0..n]
 Ṛ        - reverse
  Ẇ       - all contiguous slices (of implicit range(n)) = [[n],...,[2],[1],[0],[n,n-1],...,[2,1],[1,0],...,[n,n-1,n-2,...,2,1,0]]
   D      - to decimal (vectorises)
     ŒṖ   - partitions of (implicit decimal digits of) n
    f     - filter discard from left if in right
       Ẉ  - length of each
        Ṁ - maximum

JavaScript (ES6), 56 Byte

Ein Port von ArBos Python-Antwort ist deutlich kürzer. Es schlägt jedoch in einigen Testfällen aufgrund zu vieler Rekursionen fehl.

f=(n,a=0,c=0,s)=>a<0?f(n,a-~c):n==s?c:f(n,--a,c+1,[s]+a)

Probieren Sie es online!

JavaScript (ES6), 66 Byte

Übernimmt die Eingabe als Zeichenfolge.

f=(s,n=x='',o=p=n,i=0)=>s[i++]?o==s?i:f(s,--n,o+n,i):f(s,p+s[x++])

Probieren Sie es online!

Kommentiert

f = (               // f = recursive function taking:
  s,                //   s = input number, as a string
  n =               //   n = counter
  x = '',           //   x = position of the next digit to be added to p
  o = p = n,        //   o = generated output; p = prefix
  i = 0             //   i = number of consecutive descending numbers
) =>                //
  s[i++] ?          // increment i; if s[i] was defined:
    o == s ?        //   if o is matching s:
      i             //     stop recursion and return i
    :               //   else:
      f(            //     do a recursive call with:
        s,          //       s unchanged
        --n,        //       n - 1
        o + n,      //       (n - 1) appended to o
        i           //       i unchanged (but it was incremented above)
      )             //     end of recursive call
  :                 // else:
    f(              //   this is a dead end; try again with one more digit in the prefix:
      s,            //     s unchanged
      p + s[x++]    //     increment x and append the next digit to p
    )               //   end of recursive call

Perl 6 , 43 41 40 Bytes

-1 byte dank nwellnhof

{/(<-[0]>.*?|0)+<?{[==] 1..*Z+$0}>/;+$0}

Probieren Sie es online!

Regex-basierte Lösung. Ich versuche stattdessen, einen besseren Weg zu finden, um eine Übereinstimmung von einer absteigenden Liste zu erzielen, aber Perl 6 macht Partitionen nicht gut

Erläuterung:

{                                        }  # Anonymous code block
 /                                /;        # Match in the input
   <-[0]>.*?      # Non-greedy number not starting with 0
            |0    # Or 0
  (           )+  # Repeatedly for the rest of the number
                <?{             }>  # Where
                        1..*Z+$0       # Each matched number plus the ascending numbers
                                       # For example 1,2,3 Z+ 9,8,7 is 10,10,10
                   [==]                # Are all equal
                                    +$0  # Return the length of the list

Python 3 , 232 228 187 181 180 150 149 Bytes

-1 danke an @ Jonathan Frech

e=enumerate
t=int
h=lambda n,s=1:max([1]+[i-len(n[j:])and h(n[j:],s+1)or s+1for j,_ in e(n)for i,_ in e(n[:j],1)if(t(n[:j])-t(n[j:j+i])==1)*t(n[0])])

Probieren Sie es online!

Anfänglicher Code ohne Golf:

def count_consecutives(left, right, so_far=1):
    for i,_ in enumerate(left, start=1):
        left_part_of_right, right_part_of_right = right[:i], right[i:]
        if (int(left) - int(left_part_of_right)) == 1:
            if i == len(right):
                return so_far + 1
            return count_consecutives(left_part_of_right, right_part_of_right, so_far + 1)
    return so_far

def how_many_consecutives(n):
    for i, _ in enumerate(n):
        left, right = n[:i], n[i:]
        for j, _ in enumerate(left, start=1):            
            left_part_of_right = right[:j]
            if int(left) - int(left_part_of_right) == 1 and int(n[i]) > 0:     
                return count_consecutives(left, right)
    return 1

Python 2 , 78 74 73 Bytes

l=lambda n,a=0,c=0,s="":c*(n==s)or a and l(n,a-1,c+1,s+`a-1`)or l(n,a-~c)

Probieren Sie es online!

_{-1 Byte danke an Arnauld}

Übernimmt die Eingabe als Zeichenfolge. Das Programm stößt ziemlich schnell auf Pythons Rekursionstiefenbegrenzung, kann jedoch die meisten Testfälle abschließen.

Wie es funktioniert

l=lambda n,                              # The input number, in the form of a string
         a=0,                            # The program will attempt to reconstruct n by
                                         #  building a string by pasting decreasing
                                         #  numbers, stored in a, after each other.
         c=0,                            # A counter of the amount of numbers
         s="":                           # The current constructed string
              c*(n==s)                   # Return the counter if s matches n
              or                         # Else
              a and l(n,a-1,c+1,s+`a-1`) # If a is not yet zero, paste a-1 after s
              or                         # Else
              l(n,a-~c)                  # Start again, from one higher than last time

05AB1E , 10 Bytes

ÝRŒʒJQ}€gà

Extrem langsam, daher funktioniert der TIO unten nur für Testfälle unter 750.

Probieren Sie es online aus .

Erläuterung:

Ý           # Create a list in the range [0, (implicit) input]
            #  i.e. 109 → [0,1,2,...,107,108,109]
 R          # Reverse it
            #  i.e. [0,1,2,...,107,108,109] → [109,108,107,...,2,1,0]
  Π        # Get all possible sublists of this list
            #  i.e. [109,108,107,...,2,1,0]
            #   → [[109],[109,108],[109,108,107],...,[2,1,0],[1],[1,0],[0]]
   ʒ  }     # Filter it by:
    J       #  Where the sublist joined together
            #   i.e. [10,9] → "109"
            #   i.e. [109,108,107] → "109108107"
     Q      #  Are equal to the (implicit) input
            #   i.e. 109 and "109" → 1 (truthy)
            #   i.e. 109 and "109108107" → 0 (falsey)
       €g   # After filtering, take the length of each remaining inner list
            #  i.e. [[109],[[10,9]] → [1,2]
         à  # And only leave the maximum length (which is output implicitly)
            #  i.e. [1,2] → 2

Pyth, 16 Bytes

lef!.EhM.+vMT./z

Versuchen Sie es online hier oder überprüfen alle Testfälle auf einmal hier .

lef!.EhM.+vMT./z   Implicit: z=input as string
             ./z   Get all divisions of z into disjoint substrings
  f                Filter the above, as T, keeping those where the following is truthy:
          vMT        Parse each substring as an int
        .+           Get difference between each pair
      hM             Increment each
   !.E               Are all elements 0? { NOT(ANY(...)) }
 e                 Take the last element of the filtered divisions
                     Divisions are generated with fewest substrings first, so last remaining division is also the longest
l                  Length of the above, implicit print

Jelly , 11 Bytes

ŒṖḌ’Dɗ\ƑƇẈṀ

$O\left(n^{0.3}\right)$

Probieren Sie es online!

Wie es funktioniert

ŒṖḌ’Dɗ\ƑƇẈṀ  Main link. Argument: n (integer)

ŒṖ           Yield all partitions of n's digit list in base 10.
        Ƈ    Comb; keep only partitions for which the link to the left returns 1.
       Ƒ       Fixed; yield 1 if calling the link to the left returns its argument.
      \          Cumulatively reduce the partition by the link to the left.
     ɗ             Combine the three links to the left into a dyadic chain.
  Ḍ                  Undecimal; convert a digit list into an integer.
   ’                 Decrement the result.
    D                Decimal; convert the integer back to a digit list.

Holzkohle , 26 Bytes

Ｆ⊕ＬθＦ⊕Ｌθ⊞υ⭆κ⁻Ｉ…θιλＩ﹪⌕υθ⊕Ｌθ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

Ｆ⊕Ｌθ

Schleife ivon 0 bis zur Länge der Eingabe.

Ｆ⊕Ｌθ

Schleife kvon 0 bis zur Länge der Eingabe.

⊞υ⭆κ⁻Ｉ…θ⊕ιλ

Berechnen Sie die ersten kZahlen in absteigender Reihenfolge ausgehend von der Zahl, die durch die ersten iZiffern der Eingabe angegeben wird, verketten Sie sie und akkumulieren Sie die resultierenden Zeichenfolgen in der vordefinierten leeren Liste.

Ｉ﹪⌕υθ⊕Ｌθ

Suchen Sie die Position der ersten passenden Kopie der Eingabe und reduzieren Sie das Modulo 1 um mehr als die Länge der Eingabe.

Beispiel: Für eine Eingabe werden 2019folgende Zeichenketten generiert:

 0
 1  0
 2  0-1
 3  0-1-2
 4  0-1-2-3
 5  
 6  2
 7  21
 8  210
 9  210-1
10  
11  20
12  2019
13  201918
14  20191817
15  
16  201
17  201200
18  201200199
19  201200199198
20  
21  2019
22  20192018
23  201920182017
24  2019201820172016

2019 wird dann bei Index 12 gefunden, der modulo 5 reduziert wird, um 2 zu ergeben, die gewünschte Antwort.

Haskell, 87 Bytes

maximum.map length.(0#)
a#(b:c)=[a:x|c==[]||b>0,x<-b#c,a==x!!0+1]++(10*a+b)#c
a#b=[[a]]

Die Eingabe ist eine Liste von Ziffern.

Probieren Sie es online!

Function erstellt #eine Liste aller möglichen Teilungen, indem beide betrachtet werden

• Voranstellen der aktuellen Nummer avor allen Teilungen, die von einem rekursiven Aufruf mit dem Rest der Eingabe ( x<-b#c) zurückgegeben wurden, jedoch nur, wenn die nächste Nummer nicht Null ( b>0) (oder die letzte Nummer in der Eingabe ( c==[])) ist und aeine Nummer größer als die erste ist Nummer des jeweils vorherigen Split x( a==x!!0+1).

und

• Anhängen der nächsten Ziffer baus der Eingabeliste an die aktuelle Nummer aund Fortfahren mit dem Rest der Eingabe ( (10*a+b)#c)

Der Grundfall ist, wenn die Eingabeliste leer ist (dh nicht mit dem Muster übereinstimmt (b:c)). Die Rekursion beginnt mit der aktuellen Zahl abeing 0( (0#)), die niemals den ersten Zweig trifft (vor aallen vorherigen Teilungen), da sie niemals größer als eine beliebige Anzahl der Teilungen ist.

Nimm die Länge jeder Teilung und finde das Maximum ( maximum.map length).

Eine Variante mit ebenfalls 87 Bytes:

fst.maximum.(0#)
a#(b:c)=[(r+1,a)|c==[]||b>0,(r,x)<-b#c,a==x+1]++(10*a+b)#c
a#b=[(1,a)]

Das funktioniert im Prinzip genauso, aber anstatt den gesamten Split in einer Liste zu behalten, behält es nur ein Paar (r,x)der Länge des Split und rdie erste Zahl im Split bei x.

Python 3 , 302 282 271 Bytes

-10 Bytes dank dem Tipp von @ElPedro.

Übernimmt die Eingabe als Zeichenfolge. Grundsätzlich werden immer größere Abschnitte der Zahl von links benötigt, und es wird geprüft, ob für diesen Abschnitt der Zahl eine Sequenz unter Verwendung aller Zahlen gebildet werden kann.

R=range
I=int
L=len
def g(n,m,t=1):
 for i in R(1,L(m)+1):
  if I(m)==I(n[:i])+1:
   if i==L(n):return-~t
   return g(n[i:],n[:i],t+1)
 return 1
def f(n):
 for i in R(L(n)):
  x=n[:i]
  for j in R(1,L(x)+1):
   if (I(x)==I(n[i:i+j])+1)*I(n[i]):return g(n[i:],x)
 return 1

Probieren Sie es online!

Japt , 27 Bytes

ò pÊÔpÊqÊfl²i1Uì q"l?"¹ÌèÊÉ

Probieren Sie es online! oder Überprüfen Sie die meisten Testfälle

Dies schneidet nicht gut ab, verwendet jedoch eine einzigartige Methode und es gibt möglicherweise viel mehr Platz zum Golfen. Es funktioniert auch so gut, dass alle Testfälle außer 201200199198Timeout vermieden werden.

Erläuterung:

ò                              #Get the range [0...input]
  pÊ                           #Add an "l" to the end
    Ô                          #Reverse it
     pÊ                        #Add an "l" to the end
       qÊ                      #Add an "l" between each number and turn to a string
         f            ¹        #Find the substrings that match this regex:
          l²                   # The string "ll"
            i1                 # With this inserted between the "l"s:
              Uì               #  All the digits of the input
                 q"l?"         #  With optional spaces between each one
                       Ì       #Get the last match
                        èÊ     #Count the number of "l"s
                          É    #Subtract 1

Haskell, 65 Bytes

f i=[y|x<-[0..],y<-[1..length i],i==(show=<<[x+y-1,x+y-2..x])]!!0

Die Eingabe ist eine Zeichenfolge.

Probieren Sie es online!

Ganz anders als meine andere Antwort . Eine einfache Brute Force, die alle Listen mit aufeinanderfolgenden absteigenden Zahlen ausprobiert, bis eine gefunden wird, die der Eingabeliste entspricht.

Wenn wir die Eingabenummer auf 64-Bit-Ganzzahlen beschränken, können wir durch yDurchlaufen 6 Bytes sparen [1..19], da die größte 64-Bit-Ganzzahl 19 Stellen hat und keine Listen mit mehr Elementen getestet werden müssen.

Haskell, 59 Bytes

f i=[y|x<-[0..],y<-[1..19],i==(show=<<[x+y-1,x+y-2..x])]!!0

Probieren Sie es online!

Python 2 , 95 Bytes

lambda n:max(j-i for j in range(n+1)for i in range(-1,j)if''.join(map(str,range(j,i,-1)))==`n`)

Eine weitere langsame Brute-Force-Lösung.

Probieren Sie es online!

Dyalog APL, 138 Bytes

Ein bisschen bissig, aber es funktioniert auch bei großen Zahlen schnell. Wenn Sie es online versuchen, stellen Sie dem DFN das Präfix voran ⎕←und geben Sie rechts eine Liste mit Ziffern ein.

{⌈/⍵((≢⊂)×1∧.=2-/10⊥¨⊂)⍨⍤1⊢1,{⍬≡1↓⍵:↑⍬1⋄0=⊃⍵:0,∇1↓⍵⋄↑,0 1∘.,⊂⍤1∇1↓⍵}1↓⍵}

Erläuterung

Zuerst die innere dfn auf der rechten Seite, die rekursiv eine Liste möglicher Wege aufbaut, um ⊂die Liste der Ziffern (mit ) zu partitionieren . Gibt beispielsweise 1 0 1 0 ⊂ 2 0 1 9den verschachtelten Vektor zurück (2 0)(1 9).

{
   ⍬≡1↓⍵: ↑⍬1       ⍝ Edge case: If ⍵ is singleton list, return the column matrix (0 1)
   0=⊃⍵: 0,∇1↓⍵     ⍝ If head of ⍵ is 0, return 0 catenated to this dfn called on tail ⍵
   ↑,0 1∘.,⊂⍤1∇1↓⍵  ⍝ Finds 1 cat recursive call on tail ⍵ and 0 cat recursive call on ⍵. 
}                    ⍝ Makes a matrix with a row for each possibility.

Wir verwenden 1,, um eine Spalte von 1s am Anfang und am Ende mit einer Matrix von gültigen Partitionen für ⍵ hinzuzufügen.

Nun trainiert die Funktion links in Parens. Aufgrund ⍨des linken Arguments ist der Zug die Zeile der Partitionsmatrix und das rechte Argument ist die Benutzereingabe. Der Zug ist ein Stapel Gabeln mit einer Spitze als äußerster linker Zinken.

((≢⊂)×1∧.=2-/10⊥¨⊂)⍨     ⍝ ⍨ swaps left and right arguments of the train.
                  ⊂       ⍝ Partition ⍵ according to ⍺. 
             10⊥¨         ⍝ Decode each partition (turns strings of digits into numbers)
          2-/             ⍝ Difference between adjacent cells
      1∧.=                ⍝ All equal 1?
   ⊂                      ⍝ Partition ⍵ according to ⍺ again
  ≢                       ⍝ Number of cells (ie number of partitions)
     ×                    ⍝ Multiply.

Wenn die Partition eine Folge von absteigenden Zahlen erstellt, gibt der Zug die Länge der Folge zurück. Sonst null

⍤1⊢Wendet den Funktionszug zwischen der Benutzereingabe und jeder Zeile der Partitionsmatrix an und gibt einen Wert für jede Zeile der Matrix zurück. ⊢ist notwendig, um zwischen Operand ⍤und Argument für die abgeleitete Funktion von zu unterscheiden ⍤.

⌈/ findet das Maximum.

Konnte einen kürzeren Algorithmus finden, aber ich wollte diesen Weg ausprobieren, der der direkteste und aussagekräftigste ist, den ich mir vorstellen kann.

TSQL, 169 Bytes

Hinweis: Dies kann nur ausgeführt werden, wenn die Eingabe in eine Ganzzahl konvertiert werden kann.

Rekursives SQL, das zum Schleifen verwendet wird.

Golf gespielt:

DECLARE @ varchar(max) = '1211109876';

WITH C as(SELECT left(@,row_number()over(order by 1/0))+0t,@+null z,0i
FROM spt_values UNION ALL
SELECT t-1,concat(z,t),i+1FROM C WHERE i<9)SELECT
max(i)FROM C WHERE z=@

Ungolfed:

DECLARE @ varchar(max) = '1211109876';

WITH C as
(
  SELECT
    left(@,row_number()over(order by 1/0))+0t,
    @+null z,
    0i
  FROM
    spt_values
  UNION ALL
  SELECT
    t-1,
    concat(z,t),
    i+1
  FROM C
  WHERE i<9
)
SELECT max(i)
FROM C
WHERE z=@

Versuch es

R 101 Bytes

function(a,N=nchar(a)){for(x in 1:N)F=max(F,which(Reduce(paste0,seq(substr(a,1,x),,-1,N),a=T)==a));F}

Probieren Sie es online!

Mehr als 2 Wochen sind vergangen, ohne eine Antwort von R zu bekommen, also habe ich beschlossen, meine eigenen zu posten :)

Der Code ist ziemlich schnell, da er einen "begrenzten" Brute-Force-Ansatz verwendet

Abgerollter Code und Erklärung:

function(a){                  # get string a as input (e.g. "2019")

  N = nchar(a)                # set N = length of a (e.g. 4)
  Y = 0                       # initialize Y = 0 (in the actual code we abuse F)

  for(x in 1:N){              # for x in 1 ... N    

    S = substr(a,1,x)         # get the first x characters of a (e.g. "20" for x=2)

    Q = seq(S,,-1,N)          # create a decreasing sequence (step = -1) 
                              # of length N starting from S converted into integer
                              # (e.g. Q = c(20,19,18,17) for x=2)

    R = Reduce(paste0,Q,a=T)  # concatenate all the increasing sub-sequences of Q
                              # (e.g. R = c("20","2019","201918","20191817") for x=2)

    I = which(R == a)         # Get the index where R == a, if none return empty vector
                              # (e.g. I = 2 for x=2)

    Y = max(Y,I)              # store the maximum index found into Y
  }
  return(Y)                   # return Y
}