2019 has come and probably eveyone 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 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)


• the sequence must be obtained by 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

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.

Perl 6, 42 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

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  8 bytes

-1 thanks to Dennis

ẆUDfŒṖẈṀ

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

How?

ẆUDfŒṖẈṀ - Link: integer, n

Ẇ        - all contiguous slices (of implicit range(n)) = [[1],[2],[3],...,[n],[1,2],[2,3],...,[n-1,n],[1,2,3],...,[1,2,3,...n-2,n-1,n]]

 U       - reverse each

  D      - to decimal (vectorises)

    ŒṖ   - partitions of (implicit decimal digits of) n

   f     - filter discard from left if in right

      Ẉ  - length of each

       Ṁ - maximum

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

Jelly, 11 bytes

ŒṖḌ’DɗƑƇẈṀ

Byte for byte, no match for the other Jelly solution, but this one should be roughly $Oleft(n^{0.3}right)$.

Try it online!

How it works

ŒṖḌ’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.