[Question]
  [
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](/questions/tagged/code-golf "show questions tagged '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](https://codegolf.meta.stackexchange.com/questions/2419/default-for-code-golf-program-function-or-snippet/2422#2422) for your answer with [default I/O rules](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/), so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
* [Default Loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
* If possible, please add a link with a test for your code (i.e. [TIO](https://tio.run/#)).
* Also, adding an explanation for your answer is highly recommended.
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~15~~ 9 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
Bugfix thanks to Dennis
```
ŻṚẆDfŒṖẈṀ
```
**[Try it online!](https://tio.run/##ASIA3f9qZWxsef//xbvhuZrhuoZEZsWS4bmW4bqI4bmA////MjEw "Jelly – 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
```
[Answer]
# JavaScript (ES6), 56 bytes
A port of [ArBo's Python answer](https://codegolf.stackexchange.com/a/178753/58563) is significantly shorter. However, it fails on some test cases because of too much recursion.
```
f=(n,a=0,c=0,s)=>a<0?f(n,a-~c):n==s?c:f(n,--a,c+1,[s]+a)
```
[Try it online!](https://tio.run/##jdDBisIwEAbg@z5FyKnBic5UazPF6IOIh5C1y4o0YqpHX71W0F3b6rI/5DKEj59/584u@uP3odZV@Nw2TWmTCpxF8O2Lyi7dAlfl7aYvXhWVtXHli9tBawd@RLCOm5FTjQ9VDPvteB@@kjKRKRJLcY9SYjIRKQKx@I3WSxFO9eFUi0KkHz3A5PNsJjuAgRzmkMHsFZD1AUJkZiOfgPYEzMDmFTAdAETIJu8ABNQS0Db5R4OU8GeCxwZAgO82GDaQT1/vDUQ3HYD6AA4B/BNorg "JavaScript (Node.js) – Try It Online")
---
# 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!](https://tio.run/##lZLdboJAEEbv@xQbboQw1Jnlb9dk9UFML4yVhsawpGDj29OpSisLGp2ECz4mJ@fb5XPzvWm2X2XdRpV933VdYfwGKnM0sxlYU5sKSoOBWTbrMgzfVtaYZlUuCl6KogpsyN@D02sdNusjrwTd1laN3e9e9/bDL3xPImlPXCYIxHwuJAJp8T9RtBT20NaHViyEfBkDJDJEk1ZeDyDgjCmaHzUEJC4glknmGPxG4pYBuQCVZ2niDQAKcsgghWQKkLoAknGS9g5nwDl61IAQteb61wDuz/W5/QQgngKgGhqcoocNiFCrfGBAQOwAfBYPnIEk/LuE/j8AArx1C@MK3tXqxUAM534FHAPwKUBM0q3A0RMA0uQCOLoD6H4A "JavaScript (Node.js) – Try It Online")
### Commented
```
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
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~43 41~~ 40 bytes
*-1 byte thanks to nwellnhof*
```
{/(<-[0]>.*?|0)+<?{[==] 1..*Z+$0}>/;+$0}
```
[Try it online!](https://tio.run/##dZBNboMwEEb3PsXIqioIgzNjft0Gco9SFl0EKRJtUCCLiObs1E1KCy31xvKbN5/HbnbHOh5ez3BfQQZDv3Y2fkFlrlbbd3K9zbYvsqwEVmr15N3RJV8/fm5DdTiCU@/fdq2b56pt6n3nSN/PpQu9AGhfzuApG4TyuZNYOdeDixIkqkKX4jJoYgPjsp2gCSfkxg6nrjl18ABaWF@T7TFs0i@f0RLbZHBk334oAh3Gs6wZ@J3PIk3iKJzWUkwwxgjDJT8SrIMwiie1Gfibz0TG2DF/fDu7HX1Ecz@4@jStzcBCPjOZNJn4jGxvQPuOpfk10@0bkZH@@5bgAw "Perl 6 – 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
                   [==]                # Are all equal
                                    +$0  # Return the length of the list
```
[Answer]
# [Python 3](https://docs.python.org/3/), 232 228 187 181 180 150 149 bytes
-1 thanks to @[Jonathan Frech](https://codegolf.stackexchange.com/users/73111/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])])
```
[Try it online!](https://tio.run/##dVLLboMwELzzFauecONUGEgCSD70UPUjCEIOOAUEBoFpElX9dmockiak9WU9szPrx25zklktnGHglIu@4i2T3JA0F9LIaMmqXcpA4I6SoGJHMyTRIsyXJRemCIsgQkykkJ33uFsQVLegwl6FAseQC@CmQCPMrzAMiggTlO9NeQZoKXWFYpFHiFKCnkdsRShCQ1Yf4oqJU5zUouNJL/NP3gGFDAxQy0j5HljX8VbGh1xmcdOqm5sfSiUw8GPDE8lTDCyRPStRoE1n/TULlE55DE9b8T56g1H39b0Vb5Mo0OhVy4Ip9/SiHlax/48z9PUk76Q5Hc2PrGpK/YJQE@MybQy2RXyEfylXU7alaJ/43m2KYHBsd31LrTB4m/XKncmI7birO6GjSMvy/YeKI2t5s5qEEMv3NrMCNrHm5hme5x1izx3@xRMZOowjcvm/WM3hjrdYzUvTywnp4Zl@L7jWemz9rQc/lvxznsxOtndGhFTvzn0bfgA "Python 3 – Try It Online")
Initial ungolfed code:
```
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
```
[Answer]
# [Python 2](https://docs.python.org/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)
```
[Try it online!](https://tio.run/##TYrRCgIhFETf9yvEJ20tNGqLwH9ZcxcS9Cpee9iXft1uBNHAwJyZKVt7ZDj2kEqujeGGA/mAa6urf1YMGWJIoQmjSbJHG126L46BclYrT0bL@c3vBFiLMlfmmIOFRUGPvVF@NArHmeL8Gb/1y8teaoBGzDWXww/MP1wv0/nEZX8D "Python 2 – Try It Online")
 -1 byte thanks to Arnauld 
Takes input as a string. The program rather quickly runs into Python's recursion depth limit, but it can finish most of the test cases.
### How it works
```
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
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 10 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ÝRŒʒJQ}€gà
```
Extremely slow, so the TIO below only works for test cases below 750..
[Try it online](https://tio.run/##yy9OTMpM/f//8Nygo5NOTfIKrH3UtCb98IL//w0NLAE).
**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
```
[Answer]
# Pyth, 16 bytes
```
lef!.EhM.+vMT./z
```
Try it online [here](https://pyth.herokuapp.com/?code=lef%21.EhM.%2BvMT.%2Fz&input=2019&debug=0), or verify all the test cases at once [here](https://pyth.herokuapp.com/?code=lef%21.EhM.%2BvMT.%2Fz&test_suite=1&test_suite_input=2019%0A201200199198%0A3246%0A87654%0A123456%0A1009998%0A100908%0A1110987%0A210&debug=0).
```
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
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 11 bytes
```
ŒṖḌ’Dɗ\ƑƇẈṀ
```
Byte for byte, no match for the other Jelly solution, but this one should be roughly \$O\left(n^{0.3}\right)\$.
[Try it online!](https://tio.run/##y0rNyan8///opIc7pz3c0fOoYabLyekxxyYea3@4q@Phzob/R/coHG5/1LRGwf3/fyMDQ0sdBSBpZABkWRpaWugoGBuZmOkoWJibmZroKBgaGZuYArmGBgaWliBZEMMARBsaGlhamAM1GxoAeToKBiCmMZBpaQgA "Jelly – 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.
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 26 bytes
```
Ｆ⊕ＬθＦ⊕Ｌθ⊞υ⭆κ⁻Ｉ…θιλＩ﹪⌕υθ⊕Ｌθ
```
[Try it online!](https://tio.run/##fY27CgIxEEV7v2LKGYig24mlIAgGFvyCkMRNME7My9/PxsJS63POvdqprKMKvd9jBrywzvZpuVqDV8tLdZiICP7CuRWHTcCtZs@LVC98CJCeW8GTKhVlDAaTAE8kIIziuJmHWb/UtBDx7Nl8RtJwfhyNsPdptz/07Tus "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
Ｆ⊕Ｌθ
```
Loop `i` from 0 to the length of the input.
```
Ｆ⊕Ｌθ
```
Loop `k` from 0 to the length of the input.
```
⊞υ⭆κ⁻Ｉ…θ⊕ιλ
```
Calculate the first `k` numbers in the descending sequence starting from the number given by the first `i` digits of the input, concatenate them, and accumulate each resulting string in the predefined empty list.
```
Ｉ﹪⌕υθ⊕Ｌθ
```
Find the position of the first matching copy of the input and reduce it modulo 1 more than the length of the input.
Example: For an input of `2019` the following strings are generated:
```
 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` is then found at index 12, which is reduced modulo 5 to give 2, the desired answer.
[Answer]
## 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]]
```
Input is a list of digits.
[Try it online!](https://tio.run/##ZZBNDoIwEIX3nqKGDchIij@IxnoDT1C7mDYiRCDEn4QFZxenaEKNfcmk@eb1ddoc79dzWfaZOPUVtkX1rKIKG1ae68sjj3zuBRP0fL0zgZC4azsjhFRdpw8c2v1cewZQiHY65WGswtCP@QxDHXiGTmkhJSpFuUXNBKPYI/ObW1E/WMSyYMLsknIBHGLYKvgA9gW2Dg2SreloWFJzBckIUthAAmtYjcgGLMm1dn3xkLkdlP5j/gutLKZ0dziCjmvccndAut6NoifQR7xMVuLl3s9N07wB "Haskell – Try It Online")
Function `#` builds a list of all possible splits by looking at both
* prepending the current number `a` to all splits returned by a recursive call with the rest of the input (`x<-b#c`), but only if the next number not zero (`b>0`) (or it's the last number in the input (`c==[]`)) and `a` is one greater than the first number of the respective previous split `x` (`a==x!!0+1`).
and
* appending the next digit `b` from the input list to the current number `a` and going on with the rest of the input (`(10*a+b)#c`)
Base case is when the input list is empty (i.e. does not pattern match `(b:c)`). The recursion starts with the current number `a` being `0` (`(0#)`), which never hits the first branch (prepending `a` to all previous splits), because it will never be greater than any number of the splits.
Take the length of each split and find the maximum (`maximum.map length`).
A variant with also 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)]
```
which basically works the same way, but instead of keeping the whole split in a list, it only keeps a pair `(r,x)` of the length of the split `r` an the first number in the split `x`. 
[Answer]
# [Python 3](https://docs.python.org/3/), ~~302~~ ~~282~~ 271 bytes
-10 bytes thanks to the tip by @ElPedro.
Takes input as a string. Basically, it takes increasing larger slices of the number from the left, and sees if for that slice of the number a sequence can be formed using all the numbers.
```
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
```
[Try it online!](https://tio.run/##VVHLbsIwELz7K1b04hRTeZ0AcST3HokTV5QDahNqVAxKXIkK0V9PvU6gxRfvzD5m1j59@4@jS/t@bdqt29WsNNZ5tjKftWPvdQM77sRBeINJwaA5tmDBOlhzFCt@SKaRBttAGZAxJXebwlaBJ5p4a8yKu6Roa//VutmPJ34ANHtji0rEHuHDMHZLYRRvqPNBlmZFybOJXSGi7P7P1PlmitR5GfBgyxZ2uidnyXOE1c3T3cb5n3zv686/bbu6AwMbpiRqAU@gKFIyII06JyZjqcoWFCHLl4t5RuGcoUqz@UijlFoP1WkEMh8TiFLny6FDoRwrhqQcrhTVWKwx3hVjtDH5o6XvPsPKpzb8HZ9crjB7hct18hIKD1vPqUaEx@x8G@MknP4X "Python 3 – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 27 bytes
```
ò pÊÔpÊqÊfl²i1Uì q"l?"¹ÌèÊÉ
```
[Try it online!](https://ethproductions.github.io/japt/?v=1.4.6&code=8iBwytRwynHKZmyyaTFV7CBxImw/IrnM6MrJ&input=MjEyMDE=) or [Check most test cases](https://ethproductions.github.io/japt/?v=1.4.6&code=8iBwytRwynHKZmyyaTFV7CBxImw/IrnM6MrJ&input=WzIwMTkKMzI0Ngo4NzY1NAoxMjM0NTYKMTAwOTk5OAoxMDA5MDgKMTExMDk4NwoyMTAKMQowCjE5MQozMTJdCi1t)
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:
```
ò                              #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
```
[Answer]
# Dyalog APL, 138 bytes
Bit of a mouthful, but it works fast for big numbers too. If you [try it online](https://tio.run/##SyzI0U2pTMzJT////1Hf1EdtE6of9XToP@rdqqHxqHPRo64mzcPTDR91LNezNdLVNzR41LX00AqQ6KPeFY96lxg@6lpkqFP9qHfNo86Fho/aJgM1Wj1qmwgUMHzU3WJg@6irGSRkoPOoox0qDxQHqtAxUAAaO0NPB2gY2CC4fC2MVjBSACpSsPz/HwA), prefix the dfn by `⎕←` and provide input on the right as a list of digits.
```
{⌈/⍵((≢⊂)×1∧.=2-/10⊥¨⊂)⍨⍤1⊢1,{⍬≡1↓⍵:↑⍬1⋄0=⊃⍵:0,∇1↓⍵⋄↑,0 1∘.,⊂⍤1∇1↓⍵}1↓⍵}
```
### Explanation
First, the inner dfn on the right which recursively constructs a list of possible ways to partition (with `⊂`) the list of digits. For example `1 0 1 0 ⊂ 2 0 1 9` returns the nested vector `(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.
```
We use `1,` to add a column of 1s at the start and end up with a matrix of valid partitions for ⍵.
Now the function train on the left in parens. Due to `⍨` the left argument to the train is the row of the partitions matrix and the right argument is the user input.
The train is a pile of forks with an atop as the far left tine.
```
((≢⊂)×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.
```
If the partition creates a sequence of descending numbers, the train returns the length of the sequence. Otherwise zero.
`⍤1⊢` applies the function train between the user input and each row of the partitions matrix, returning a value for each row of the matrix. `⊢` is necessary to disambiguate between operand to `⍤` and argument to the derived function of `⍤`.
`⌈/` finds the maximum.
Could find a shorter algorithm but I wanted to try this way which is the most direct and declarative I could think of.
[Answer]
## Haskell, 65 bytes
```
f i=[y|x<-[0..],y<-[1..length i],i==(show=<<[x+y-1,x+y-2..x])]!!0
```
Input is a string.
[Try it online!](https://tio.run/##TY09DoMwDEb3niJlAjVEdviNRI7QE0QZGKBEBYoKUkHq3VOiDokHy@99tjy067MbR2t7YqQ6vnuTKmBM0@MckLGxmx/bQIymRsp4HV4f2TRqvx0pUtc5Y7tO9PUKdmrNTCSZ2uVO4uVt5o2RPrkQVyrigCKifyKOOJxGoKi9zXheeqqrssg9Is/yIogRQIjw2gkIGRFEXQVPEYLUj4HNkAcrAiNtfw "Haskell – Try It Online")
Completely different to my [other answer](https://codegolf.stackexchange.com/a/178425/34531). A simple brute force that tries all lists of consecutive descending numbers until it finds one that equals the input list.
If we limit the input number to 64-bit integers, we can save 6 bytes by looping `y` through `[1..19]`, because the largest 64-bit integer has 19 digits and there's no need to test lists with more elements.
### Haskell, 59 bytes
```
f i=[y|x<-[0..],y<-[1..19],i==(show=<<[x+y-1,x+y-2..x])]!!0
```
[Try it online!](https://tio.run/##TY3PCoMwDIfve4rqSVktSf0bsI@wJyg9eJgoUydzMIW9e2fZoc0h5Pt@CRm67XGfJmt7Nip9fPc20yCE4cc5oBBIho9KJdvw/Ki21fv1yJC7LoXYTWqiCOzcjQtTbO7WG0vW17i8BevTC3OlYwlIMf8TcyThNITUeJvLovLU1FVZeESZF2UQIwBReO0EhIwI1NTBU4Qg9WNgc5TBCmFs7A8 "Haskell – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/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`)
```
Another slow, brute-force solution.
[Try it online!](https://tio.run/##RYsxDsIwEARreMU2kX3ijHCoiBReQhGjYDiLXCKTAl5vElHQrFYzmukzP0atS0SLS3mG4doHaDOEt01OEMeMBFHkoPeb1Z2nFckfOc@JJBqzT6OoHcJkX3Pmn0ws7DwRtW2nHZW11bWt/YHhGcsefb3ck2@2mymLzjDVsYc7o@oNKlhlRKtE5Qs "Python 2 – Try It Online")
[Answer]
# TSQL, 169 bytes
Note: this can only be executed when the input can be converted to an integer.
Recursive sql used for looping.
Golfed:
```
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=@
```
**[Try it out](https://data.stackexchange.com/stackoverflow/query/962931/how-many-consecutive-descending-numbers-in-my-number)**
[Answer]
# [R](https://www.r-project.org/), 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}
```
[Try it online!](https://tio.run/##fdHLaoQwFAbgfZ8i0IUJHCEn3pIpdunSRekLWKvoYnTqhQqlz26PM7XO2NFANge@/PmTZszDMe@rtCvriicQh1VaJA1PhPjK64YPrKwYHmIRhcdk4BF8FmVa8JfsvU8zfkraLpPQZh@87d/ajhwgDALARogFJOGrCEM66yn6HnNuKYnGYr9LMPZo289MSUDDljXN6r479R07MPVwYUoSNWi0tTAEmpI1tPUtcyfmKNf/lzYN2VYaTkwHvudaK6YhAB88cO8xb2KoHNeb82Z2Ge6loZTGUK1bRr2oFrW6w5yZSb1OOw930xCl0cEqDQEpD6jjRjeF8u8hl3@jr5ZbL3m@5BVa2DXZuOQ9hrts/AE "R – Try It Online")
More than 2 weeks have passed without any R answer, so I decided to post my own :)
The code is pretty fast since it uses a "limited" brute force approach
### Unrolled code and explanation :
```
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
}
```
]