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

Python 3, 232 228 187 181 180 150 bytes

e=enumerate

t=int

h=lambda n,s=1:max([1]+[i-len(n[j:])and h(n[j:],s+1)or s+1 for 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!

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

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

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!

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.

Python 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!

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.

Charcoal, 26 bytes

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

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.

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!

Completely different to my other answer. 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!

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`)

Another slow, brute-force solution.

Try it online!

Japt, 27 bytes

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

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:

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