2019 has come and probably everyone has noticed the peculiarity of this number: it's in fact composed by two sub-numbers (20 and 19) representing a sequence of consecutive descending numbers.

Challenge

Given a number x, return the length of the maximum sequence of consecutive, descending numbers that can be formed by taking sub-numbers of x.

Notes :

• sub-numbers cannot contain leading zeros (e.g. 1009 cannot be split into 10,09)


• consecutive and descending means that a number in the sequence must be equal to the previous number -1, or $n_{i+1} = n_{i}-1$ (e.g. 52 cannot be split into 5,2 because 5 and 2 are not consecutive, 2 ≠ 5 - 1)


• the sequence must be obtained by using the full number, e.g. in 7321 you can't discard 7 and get the sequence 3,2,1
  


• only one sequence can be obtained from the number, e.g. 3211098 cannot be split into two sequences 3,2,1 and 10,9,8
  

Input

• An integer number (>= 0) : can be a number, or a string, or list of digits

Output

• A single integer given the maximum number of decreasing sub-numbers (note that the lower-bound of this number is 1, i.e. a number is composed by itself in a descending sequence of length one)

Examples :

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

General rules:

• This is code-golf, so shortest answer in bytes wins.
  
  Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.


• 
  Standard rules apply for your answer with default I/O rules, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.


• 
  Default Loopholes are forbidden.


• If possible, please add a link with a test for your code (i.e. TIO).


• Also, adding an explanation for your answer is highly recommended.

JavaScript (ES6), 66 bytes

Takes input as a string.

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++])

Try it online!

Jelly,  15  9 bytes

Bugfix thanks to Dennis

ŻṚẆDfŒṖẈṀ

Try it online! (even 321 takes half a minute since the code is at least $O(N^2)$)

How?

ŻṚẆ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

Perl 6, 43 41 bytes

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

Try it online!

Regex based solution. I'm trying to come up with a better way to match from a descending list instead, but Perl 6 doesn't do partitions well

Explanation:

{                                        }  # 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

                     set               # Coerced to a set

                   2>                  # Is smaller than length 2?

                                     +$0  # Return the length of the list

05AB1E, 10 bytes

ÝRŒʒJQ}€gà

Extremely slow, so the TIO below only works for test cases below 750..

Try it online.

Explanation:

Ý           # 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

Try it online here, or verify all the test cases at once here.

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

Japt, 30 bytes

;õ0 Ô+J f,+Uì q",?" +J mèJ ²ÎÉ

Try it online! or Check most test cases

This doesn't score well, but it uses a unique method and there might be room to golf it a lot more. It also performs well enough that all test cases other than 201200199198 avoid timing out.

Explanation:

;                                 #Set J = ","

 õ0                               #Get the range [0...input]

    Ô                             #Reverse it

     +J                           #Add a comma to the end, casting to a string by joining with ","

        f                         #Get the substring that matches this regex:

         ,                        # Starts with a comma

          +Uì                     # Has all the digits of the input 

              q",?"               # Optionally, there can be commas between any digits

                    +J            # Ends with a comma

                       mèJ        #Count the number of commas in the result

                           ²Î     #Use 2 instead if no substring matched

                             É    #Subtract 1