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 bytes

RṚẆDfŒṖẈṀ

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

How?

RṚẆDfŒṖẈṀ - Link: integer, n

R         - range = [1,2,3,...,n]

 Ṛ        - reverse = [n,...,3,2,1]

  Ẇ       - all contiguous slices = [[n],...,[3],[2],[1],[n,n-1],...,[2,1],[n,n-1,n-2],...,[3,2,1],...,[n,n-1,n-2,...,3,2,1]]

   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