[Question]
  [
Given a string containing a sequence of ascending consecutive positive integers, but with no separators (such as `7891011`), output a list of the separated integers. For that example, the output should be `[7, 8, 9, 10, 11]`.
To disambiguate the possible outputs, we add the restriction that the output must always have at least two elements. This means that the output for `7891011` is definitely `[7, 8, 9, 10, 11]`, and not the singleton list `[7891011]`.
## Test cases
```
1234          -> [1, 2, 3, 4]
7891011       -> [7, 8, 9, 10, 11]
6667          -> [66, 67]
293031323334  -> [29, 30, 31, 32, 33, 34]
9991000       -> [999, 1000]
910911        -> [910, 911]
```
## Rules
Input must be taken as a single unseparated string, integer, or list of digits, in decimal only.
Output must be a proper list/array type, or a string with non-digit separators.
You may assume the input is always valid. This means you **do not have to handle** inputs like:
* the empty string
* `5` (the output would need to have length \$ < 2 \$)
* `43` (cannot make an ascending sequence)
* `79` (cannot make a consecutive sequence)
* `66` (ditto)
* `01` (zero is not a positive integer)
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code in bytes wins.
  
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), ~~8~~ 6 bytes
```
Ṁ∧⟦₂?c
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r//@HOhkcdyx/NX/aoqck@@f//qP@WhgaGhgA "Brachylog – Try It Online")
*Thanks to @UnrelatedString for -2 bytes*.
Takes an integer as the output variable, and unifies the answer with the input variable (so the opposite of what is usually done).
Atrociously slow, as concatenation on integers computes constraints on the digits with powers of 10, instead of being "string" concatenation.
### Explanation
```
Ṁ         The answer has 2 or more elements
 ∧        And
   ⟦₂?    The answer is a range between 2 integers
     ?c   The given input is the concatenation of this range
```
[Answer]
# Regex (.NET) + `x` flag, ~~418~~ ~~209~~ ~~204~~ ~~199~~ ~~132~~ ~~115~~ 99 bytes
*-209 bytes (418 → 209) thanks to Neil*
`(\5$|(.*(?=(0.*1|1.*2|2.*3|3.*4|4.*5|5.*6|6.*7|7.*8|8.*9)(?<=(.)))|(?=9+(?<4>1))).9*(?=(\2\4 0*)))*`
Returns its result as the list of captures on the Balancing Group 1 stack.
[Try it online!](https://tio.run/##RY@xasMwFEV3f4Uxgkhq8rAsx46Suil06lDo1iHJYFwlNjiykRVSEmXtB/QT@yPuox26PLj3cA@8vjtrO9S6bUdii43VB/2xWy6NPtPHyUi3c@IpcLouaAxceAE88Qlw6SXw1KfA534OPPMZ8NznwBd@AVwxur4vKDDGPE7VHcb0QWAE9evaJts0jDkWfJw8TqOn7tg3rX6fPh9MZ/Vr6Zy25q1unB76stIRW5FLEa/2CMuqpqQNGxOSxvQnx67NnpJjQSy8lK6q9YCY/bUXdj1blMzqbnA3VIjVfw5npsM/28boMELj9@dXSNAEB9ud@mEjdlCVvTtZPbDodhtFItMgXygRCxFkWZYHiZKxFDKREolSSOI4wKuE@AE "PowerShell – Try It Online")
```
# Main loop - Iterates once for each matched number in the squashed sequence.
# There is no need to anchor, because the input is guaranteed to be valid.
(                       # \1 = push matched number onto the Group 1 stack
    \5$                 # Stop immediately if the previous iteration identified
                        # this as being next, and there is nothing following it.
|
    # Using greedy quantifiers, the following, up to and including "9*",
    # matches the number with as many digits as possible that is followed by
    # the next consecutive number.
    (                   # \2 = the prefix portion of the number that won't
                        #      change when incremented
        .*
        (?=
            # Depending on this next digit, capture its incremented form in \4.
            # Only digits that do not carry when incremented are handled here.
            (
                0.*1 |
                1.*2 |
                2.*3 |
                3.*4 |
                4.*5 |
                5.*6 |
                6.*7 |
                7.*8 |
                8.*9
            )
            (?<=(.))    # \4
        )
    |
        # Treat a prefix of all 9s as a special case, because when incremented
        # it will be one digit longer, e.g. 999 -> 1000. In this case, \2 will
        # be empty.
        (?=
            9+
            (?<4>1)     # \4 - Technically this should capture "10", but since
                        #      our input is guaranteed to be valid, we can
                        #      assume that the "0*" below will match the
                        #      correct number of zeroes.
        )
    )
    .                   # Skip over the first digit that will be different when
                        # incremented.
    9*                  # Skip over the portion that will become all 0s when
                        # incremented.
    
    # Match the next consecutive number. This constraint is what tells the
    # above how many digits to match.
    (?=
        (               # \5 = Capture the next number. This allows the last
                        #      number in the sequence to be matched as a whole
                        #      unambiguously, in case its digits form their own
                        #      "nested" squashed sequence.
            \2
            \4          # Note that since this is followed by a "0", to get
                        # this to parse correctly we could either concatenate
                        # them as "\4[0]*", or enable the /x flag (ignore
                        # whitespace) and use "\4 0*".
            0*          # Technically this should match the same number of 0s
                        # however many 9s were matched by "9*" above, but since
                        # our input is guaranteed to be valid, we can assume it
                        # will do this without being forced, since none of the
                        # numbers in the sequence will have leading zeroes.
        )
    )
)*                      # Iterate as many times as possible, with minimum zero.
```
Solving this problem is a bit verbose in pure regex, since it has no concept of alphanumeric/ASCII order or sorting. So each digit needs to be handled as a separate case.
Rejecting invalid input takes **138 bytes**: `^(\6$|(?!0)(.*(?=(0.*1|1.*2|2.*3|3.*4|4.*5|5.*6|6.*7|7.*8|8.*9)(?<=(.)))|(?=9+(?<4>10))).(9)*(?=(?(7)\7))(?=(\2\4(?<-5>0)*(?(5)^))(.*)))*$`
# Regex (PCRE) + `x` flag, 107 bytes
`(\4$|(?|(.*)(?=(?:0.*1|1.*2|2.*3|3.*4|4.*5|5.*6|6.*7|7.*8|8.*9)(?<=(.)))|()(?=9+(1))).9*(?=(\2\3 0*))(?C))*`
Returns its result using a `(?C)` callout to report each split point (the number of split points will be one less than the number of consecutive integers).
[Try it online!](https://tio.run/##fVT/btpIEP7fTzHhLtddYywbpyTEmOguRWqlXlqhVOopIMuYBTZxbGttl0tq/r0HuEe8Bymd9Q/iADoLod2Z2fm@@WZ2/TjuLH1/@wsP/SCbMxjEvmD6aqj4K0@AG99NwYFx64/1@mFmZX89PX29XfXWK7Ilk7Nfc3KVE12l5MohV5eGrpq5qavdvKurVm7p6ll@pqtv87e62st7unqen@vqRX6hq308MnCITinNiTzebxMTN3pflbkm3YkFhkrRc02puqX78C0N1Nhx47ZpKy/Uk3TOI8m9aRI8XL628QitzHs8jGtavjE/jcRQ4WEKMTpTlwkRCeJHYZJCoY76yJLEWzL6HZEvL30MgMEAKqtcFnYWzgMbBEszEYJpb5TCWuYfYOIheGGyZsIusB6fXN8LgihLiWxFvXFnQeQ/gOpT@K4AfuUZPc6SlTvz/Afid4Z@JgRDpnGU8JRHIbWL0ArasJVNCeHxkNR54jusPWAhiWnHnDqGDRnGWF03hUju5IElLorggnmpFTriLLVBkgRVMBuayqAUcSrK04IlWZCWa6nhYpGwVAMsCmGX6ar0RKUgd9a0Jo2DVyoQPcY8YCTW4PP1eOSOvt6Obt6N3mnwWwlTLuq8RlU1XwA5EYzW5S@KLi4I1oDRGrRksoKQAA/xi@NwOr@E02QS4oQ1cpY4VeJmW5DjS8NK9wLzEVnRs5SvUGzJ0oCHjJRjwkOtFI/adRMaDfUD5glSQZVCSPlqMdjfzCeCaXDz5ePHKo/uu9gTQuttwp@Z3BnFrxJWA6uRVIpTJh46BuR5hXLilAqPx5/G7s2nP3@/vX7f5FgffaaAQLLV5M0kfENtLNa0X4Ut1oKnjPwvQVOT@kRSCWxPliakBf/98y@0Xuy7nJsj3GGA3T5Cr/KeOHCsnGoOWiPZ@lYTAliQsL18uzrvZJmyr7y@DbtSZce9LI3g3qm7OGNLeclsG9rt@32ONU9O67K1ozU3Y@@dXW58UAg9lrPgW1V3mkxbe/MBbeBHsstvhg/iw6Frc0gFBcBri@Oo3kMH@HGyGDFwZGuq8j6E37yAz2Hupd60UWmFewhzbHokfU2CvxqcQ/yC22v7Zm@Myv@FYAxnhe4e5@qlUjZbs2udKecXfdMwTaXX650r3b5lWKbVtSz09PvoMQwF//um@cNfBN4y2XYCeUV/Ag "C++ (gcc) – Try It Online") - PCRE1  
[Try it online!](https://tio.run/##fVbvUuJIEP/OU7TZu92ZGHIJKIIhWq5SpVW7usVi3d6qlQphgGhIUknQ0w1f7wHuEe9BzuuZTCAItykLMt093b9f/0MvjusTz3t9N2JjP2Tw5bTfazinV2c95/ryYuD8fnE2OId27Z0fesF8xKAbewlr6NOjmjd1E3Dimzuwoa98fHp6GDbnfzw/fxtMW09T8kpu937JyXFOdJWSY5scHxq6auamrjbyhq4286au7uV7urqf7@tqK2/p6kF@oKvtvK2rHbzStYlOKc0Jv97ZJSYe9I7Kfd02bptgqBQ1p5Sqr/RteEUDNbadeNe0KtjTbORHHHtVlPjhZF3mRyhl7mzTrip5ZF4WJUc1P8wgRmXmsCSJEuJFYZqByI46Y2nqThj9gZEPDz00gG4XpJS/CjkLR4EFCcvmSQimtdhwyc9eNGIaDKMogMgeu0HKKPyoAT4ilPR509hv3VlC7I@BiGI5EyYdOdKKFM5IUe3r0/OTflulUqlB6r@waExK8PBbKanYYy1EFP6QCI4LJl40z@AQlmwp56iIayAQHILyJgPisqLgLeU2VGiBfZmL2qImnBXJ7mIijsAN0yeWWCJLs2fHc4MAw0qu8uQMg8h7ANXT4DHyR6CO3MwtE8Yzw8@wYwPhapW@XzmiZXSjwFKE0@N5OnWGrvdAvPqRN08ShuWJo9TP/Chch21w2AKd64ekjBrfYA8FLCQxrZt3tmHBHG2aDSfDguKJX5jYMqggXfQcKuJ5ZoHkh5UDNWHleeZm3tQRbNTVe@EtYek8yLQi85ac7a8X33tCMh6nDJXIGEFNsumagRoVGS954YyX8WexHzAie@Hrl0Gfxpq8@r3Xv3IGvf7ni8uTQe@sFPe@DXqXZ/z8XkCR3xKAQVf9upOwZfqrAyA@pV2Fsb2RBAfPbsaccRLNnNjNMpaEJMGevrz@9Ek6qN7BYc3Ynxnmrnyzt@mlW7LhBRksG7B0oVW6UtvWYIWDcZSAmOwXXn1RcBzUALcwKebHD7Wi9tQqe6jSj17A3IRIX0WReLXX8Qvq1VIJf7rnYGsRKt3rfLr5yRB/q2Tiu6RUCcPLVIQ6sg3Icxl3x5a17vev@s7l1eeTwel5FXZ594UCxuQ7i3y4DT9QC/mb1prZ@CnxMdk/xWpqPGUimzBGRUoU@Oevv0FZyZc@F1vAd41t4H7KpdqQ5WhlyZxVIwHDxfzG8ZLuDWfLK@6XY75kzHvBnWcR3NtlfYdswreHZcHu7v1bsCVgn5bsta3Uq7b39tI3/uIQus2nwMt5jonya3qnlGmXVYBd8Ld4588QJ@RhU7XYhIIJwI2DjareQx387WDRomvzGkl6F@GjG@Ai5315V2Eq426G2dZEHL7Gg6/1z2Z8gW1dvnjTTYv/WyW4ehgjq8HZXFGFwfJMq6u9UOIWXP4/UHQa/qK8mo3mXu2g3TEN06y1Wq2DWqPTNJpms9FsoqbTQY1h1PCzY5r/euPAnaSv9UA4r7f/Aw "C++ (gcc) – Try It Online") - PCRE2 v10.33  
[Attempt This Online!](https://ato.pxeger.com/run?1=fVbdUttGFL7t-CkOSpvsCluVbDA2smAoeAZmEsg4zjQNMBohr22BLGn0A4XIt32A3vamN73MA9HLTh-kZ1crW8ZuPGBrz-_3nZ-1__jqRn6W8H974rpfL5WGH7kxazY6yvXz4NWIjb2AwfvjQb9pH1-c9O2P52dD--ezk-EpdGqvvMD1sxGDnnDSpgc1d-rEYEeX12DBQPnp4eHuppX98vj4aThtP0zJX1k6bnSe78jVzvc5OcyJplJyaJHDfV1TjdzQ1Gbe1NRW3tLUnXxHU3fzXU1t521N3cv3NLWTdzS1iy49i2iU0pxw9-42MfCgdVUe66p51QJdpag5plQtUv793b_0JRqlDmpk2dG2YVaoJOnICzmVqij2gsmqzAtRypzZul1Vcs_cNIwPal6QQoTK1GZxHMbEDYMkBVEsdcaSxJkw-gUz7--7aAC9HkgpfxRyFox8E2KWZnEAhjlfC8nPbjhidbgJQx9Ca-z4CaPwpQb4EqlkzMvmbvvaFGJvDET0zp4wGciWVqQIRormfzw-PRp0VCqVdUi8JxaOSQkefiwlFXvsicjCXySEw4KJG2Yp7MOCLeUcFeEGAsE-KC8qIJwVBb2Uq0ChBfZFLWrzmghWFLuHhTgAJ0geWGyKKs0ebdfxfUwrucqTfeOH7h2obh3uQ28E6shJnbJgvDL8DFsWEK5W6etlIFpm1wssRTotypKpfeO4d8RtHLhZHDNsTxQmXuqFwSpsncMW6BwvIGXW6BJnyGcBiWjDuLZ0EzK0aTXtFBuKJ-4wsWRSQbqYOVREWWqC5IedAzVm5XnmpO7UFmzU5XMRLWZJ5qf1ovKmXPUPZ5_7QjIeJwyVyBhBTdLpioEaFhUveeHKl_lnkeczImfhw_vhgEZ16fq5P7iwh_3Bu7Pzo2H_pBT3Pw375yf8_FpAkZ8SgE6X87oVs0X5qwsg3qVdhbG1VgQbz07K7HEczuzISVMWByTGmT7_-PatDFD1wWVN2a8p1q58sjbpZViyFgUZLAawDFGvTGV904AVAcZhDGKzn3j3RcNxUX28lEmxP15QL3pPzXKGKvPo-syJiYxVNIl3exW_oF5tlYinuTaOFqEyvMa3m5908bcsJj5LSpU0vE1FqgNLhzyXebcs2evB4GJgn1-8Oxoen1Zhl75PFDAnv7PIm6vgDTWRv2GumI0fYg-L_U2sRp2XTFQTxqhIiAL__PY7KEv5IuZ8A_ievgncN7lUB7JcrTTOWDUTMLyYXwRe0L3kbHnHvXLNF4z5LDhZGsKtVfb3hk347WGasL19-xJsCdijJfv6RupV21trERu_cQjdFFPg5TzHRPkhuVbKsssuwDZ4G6Lz1w1uyN26ar4OBQuANw4OqnoLDfA2g0WLnsV7JOmdBfeOjxc5n8vrClOZdz3NpiHi8Os8-cr8rOcX2Fbl8xfTNP-_qwSvHsbIcnHWr6jCYHGm1au9UOItuPg9UEwafqMUP3b-fG4YzdZOba_TNXTDqLXb7b1as9vSW0ar2WqhpttFja7X8L1rGIXXfw) - PCRE2 v10.40+
This is a straightforward port of the .NET version.
```
# Main loop - Iterates once for each matched number in the squashed sequence.
# There is no need to anchor, because the input is guaranteed to be valid.
(
    \4$                 # Stop immediately if the previous iteration identified
                        # this as being next, and there is nothing following it.
|
    # Using greedy quantifiers, the following, up to and including "9*",
    # matches the number with as many digits as possible that is followed by
    # the next consecutive number.
    (?|
        (.*)            # \2 = the prefix portion of the number that won't
                        #      change when incremented
        (?=
            # Depending on this next digit, capture its incremented form in \3.
            # Only digits that do not carry when incremented are handled here.
            (?:
                0.*1 |
                1.*2 |
                2.*3 |
                3.*4 |
                4.*5 |
                5.*6 |
                6.*7 |
                7.*8 |
                8.*9
            )
            (?<=(.))    # \3
        )
    |
        # Treat a prefix of all 9s as a special case, because when incremented
        # it will be one digit longer, e.g. 999 -> 1000. In this case, \2 will
        # be empty.
        ()              # \2 = empty prefix
        (?=
            9+
            (1)         # \3 - Technically this should capture "10", but since
                        #      our input is guaranteed to be valid, we can
                        #      assume that the "0*" below will match the
                        #      correct number of zeroes.
        )
    )
    .                   # Skip over the first digit that will be different when
                        # incremented.
    9*                  # Skip over the portion that will become all 0s when
                        # incremented.
    (?=
        (               # \4 = Capture the next number. This allows the last
                        #      number in the sequence to be matched as a whole
                        #      unambiguously, in case its digits form their own
                        #      "nested" squashed sequence.
            \2
            \3          # Note that since this is followed by a "0", to get
                        # this to parse correctly we could either concatenate
                        # them as "\3[0]*", or enable the /x flag (ignore
                        # whitespace) and use "\3 0*".
            0*          # Technically this should match the same number of 0s
                        # however many 9s were matched by "9*" above, but since
                        # our input is guaranteed to be valid, we can assume it
                        # will do this without being forced, since none of the
                        # numbers in the sequence will have leading zeroes.
        )
    )
    (?C)                # PCRE callout - report each split point to the caller
)*
```
Rejecting invalid input is not so straightforward to port from the .NET version, and takes **175 bytes**: `^(?>\7$((9(?=9*\4\5(\3?+0)))*(?=(?(6)\6))\4\5\3?+)?|(?|(?!0)(.*)(?=(?:0.*1|1.*2|2.*3|3.*4|4.*5|5.*6|6.*7|7.*8|8.*9)(?<=(.)))|()(?=9+(10))).(?=(?1)(.*))9*(?=(\4\5 0*)\6)(?C))*$`
# Regex (PCRE2) + `x` flag, 166 bytes
`(?=(.*))(?:^(?3)|((?<=(?=^((?|(.*)(?=(?:0.*1|1.*2|2.*3|3.*4|4.*5|5.*6|6.*7|7.*8|8.*9)(?<=(.)))|()(?=9+(1))).9*(?=(\4\5 0*)))*(?=\1$)(?>\6$|)(?(?=$)^)|(?2)).))(?3)|.+)`
Returns its result as the list of individual matches.
[Attempt This Online!](https://ato.pxeger.com/run?1=XVDLbtswEESv-gpGICIuY9OiZMuWFVWXukGAIinc3qKYUA36gciyISlAgTDXfkCuvQQo2mu_Jz32S7q00xxykLi7M7Mz5Pcfu9Xu8c-b36cZFoTWJCVuzyWC7Gq9VLXelcVcM68neKbUqihbNd9udutS1znLIcmnvcbrEA-_BQ7VUltC1eqqbZhS788_TJSCDpGAK93eVzdxFtua0XXqJ7RMF8hv2KfP784vIIE7sl4wWl41bV3qCivoyus0dfPKBSQ3t18QwXHH73QlJA5BPmFHjN6k-7Sbop2vVFGWjNYdpNENABCqD2hZNK3SdY32cJSmH6eTM3VxqSbT6eX0_y56Q4xBBZA7G2UNer7aWv-EYGSZENsTWgqP_P324CX3LzogeC9dzFeMbq78a1I0hFZw4HvEE7R6yYsmx8d7k2d0YkONkfQqp9o0S4b3vH_18jj7edsuuqOnXyxLmeAALBvPWBaCYSw7TXE6w8JYyDKysS-4NFLwwASChyYUvG_6gg_MQPDIRIIPzVDwkRkJHsN-hcC3M8zK4xMmsRExt7vyfj4gPlqCbXNJkfI2j6jBEwcUZijLAuTbVJhInMAh7ePz8dSVQdh3hqNY-lI6URQNnSAO_VCGQRgiEseI-L6D_1jKg-of)
A lot of overhead is added to achieve this output method. Captures are not preserved from one individual match to the next, thus to avoid incorrectly splitting the last number, the regex must look all the way back to the start, then parse forward from there, for each individual match. There's no variable-length lookbehind in PCRE2, so it is emulated using recursion.
[Answer]
# [Haskell](https://www.haskell.org/), 62 bytes
```
f s=[[a..b]|a<-[1..],b<-[a..a+length s],([a..b]>>=show)==s]!!0
```
[Try it online!](https://tio.run/##JYrRCoMgGEZf5S92UayJvw6bMHuDPYHIMFYzZhYZdLN3d8JuPg7nfM7Gz@B9SiNEpbUlpDdfe79oJMQ0fYas7NkP4b07iKap/p@uU9EtR61UNEVB02ynAApmuz6eUK3bFHYy1nCCY9leEUpk/ArtTSJFBCFEC0xyypEzznORMhdKIa9ELNMP "Haskell – Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), ~~10~~ 8 bytes
```
øṖ⌊'ḣtṡ⁼
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLDuOG5luKMiifhuKN04bmh4oG8IiwiIiwiXCI3ODkxMDExXCIiXQ==)
Incredibly slow for some inputs, reasonable for others.
## Explained
```
øṖ⌊'ḣtṡ⁼
øṖ⌊      # All sublists of the input, as numbers
   '     # Keep only those where:
    ḣtṡ  #   The range between the first and last item
       ⁼ #   Exactly equals the original item
```
[Answer]
# [Julia](https://julialang.org), 71 bytes
```
! =length
*(s,a=1,b=a,j=join(a:b))=!j<!s ? s*a*-~b : j!=s ? s*-~a : a:b
```
[Attempt This Online!](https://ato.pxeger.com/run?1=VY-xasMwEIZ3PcXZQ5CNXCQr2HGo0qENnQodOhSCB4UorYxRgux0zIt0aJY8Rh8kb9NTHEIqEJz-__77Tt_HZtdafTgcd_06m5yeI1CtcR_9J0lpx7QSbKk0a1SzsY7q6TJJVNTcRx08QJfqNNsvYQpNpAYh22t8Yttl3M9646G1zoB14I1ehbqjCQE8lhlQ0G1b29OgM_DxAuo0m8UJOXcE33zplr6YXt9tte8MNcmQ9iqldii33rq-ddSCmoG_2BBhFkajqxvP31_nj2_zpynEDExCjFsNax5OvyKXY7iebAYLwSBnIBmMa1JOKsGFuHFLBhMGFQPB8YqaFEVR_h9QFAyKsiZ5JbkUMpcyIIKTY05iTiJDBghSJGKqCjGc38xAJSA4R1Pw6rrCYAY2avXwiz8)
Takes a string as input and returns a range (`2:5 == [2,3,4,5]`).
A brute-force approach that's actually not that bad. `a` is the starting number and `b` the last number. We increment `b` until the list is too long and start over for `a=a+1`
[Answer]
# [R](https://www.r-project.org), 66 bytes
```
\(n)repeat for(i in 1:(T=T+1))if(n==Reduce(paste0,i:T))return(i:T)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72waMHK0rziwtLE4gzbpaUlaboWN51iNPI0i1ILUhNLFNLyizQyFTLzFAytNEJsQ7QNNTUz0zTybG2DUlNKk1M1ChKLS1INdDKtQjSBWkpKi_I0QGyISZthJmtYGhoYGhoaGRpDZRYsgNAA)
[Answer]
# [J](http://jsoftware.com/), 37 bytes
```
0{<((=<@;\"1)#&,<\"1@])".\<@":@+/i.@#
```
[Try it online!](https://tio.run/##TYzBCsIwEETv/YolhSbBNO4mkpqYSlDwJB4815NY1Isf4MfHCGJ7GIaZnbfPzDQfoQ/AQQFCKGo17M/HQ8Z3FKKPaTMwknWjYvF0kUwPMbGQFsuHTnWW1WmnIYIQbWi2StaqbOB7gt8MClHdrvcXjMDJ2BX/p27tCYmmwjnXTcl4i5assXYOeV8gxFlB6MuT/AE "J – Try It Online")
Not much in the way of golfiness (and it could surely be golfed more), but it executes decently fast, solving the test cases effectively instantly.
[Answer]
# [Husk](https://github.com/barbuz/Husk), 10 bytes
```
ḟo=⁰ṁsṁṫḣN
```
[Try it online!](https://tio.run/##yygtzv7//@GO@fm2jxo3PNzZWAzED3eufrhjsd////@VDA0MDQ2NlAA "Husk – Try It Online")
```
      ṁ  N  # map across all integers N & concatenate:
        ḣ   #  range 1..N
       ṫ    #  suffix series: 1..N, 2..N, 3..N, ...
ḟo          # now return the first series 
  =⁰        #  for which the input equals    
    ṁs      #  mapped & concatenated string representations
```
[Answer]
# JavaScript (ES6), 82 bytes
```
f=(S,i=s='')=>(k=s+=S[i++],g=q=>q==S?o:S.match(q)?g(q+k,o.push(k++)):f(S,i))(o=[])
```
[Try it online!](https://tio.run/##bZBBbsIwEEX3PcWIDbY8NXaGOhjJcIgsoyyilIQ0FJOG9vqpXRUk6lryxnrz/f681V/11Hz0l@vz2b8e5rl1rMDeTW655G7HBjcJV5S9EBV2bnS70bli77eFfK@vzZGNfN@xUQzo5eVzOrJBCM63bczgnHlXVnxu/Hnyp4M8@Y61bKEzWi/gdjiH1QpKjZAhEMK6evrD5xurldaLBz5H2CBYBK3C1cmQMSZPPjEGweQJm1lSpCkjimK/bBayKWRTMKOoFtwolbM2yCn1KBceo5hSKa6VvVe547GD/adE3NSLufVPNoUgpfxpP38D "JavaScript (Node.js) – Try It Online")
### Commented
```
f = (                 // f is a recursive function taking:
  S,                  //   S = input string
  i =                 //   i = pointer in S
  s = ''              //   s = current prefix extracted from S
) => (                //
  k = s += S[i++],    // append the next character from S to s,
                      // copy the prefix in k and increment i
  g = q =>            // g is a recursive function taking a string q
    q == S ?          //   if q is equal to S:
      o               //     success: return o[]
    :                 //   else:
      S.match(q) ?    //     if q is found in S (*):
        g(            //       do a recursive call:
          q + k,      //         append k to q (q is coerced to a
                      //         string if it's not already)
          o.push(k++) //         append k to o[] (and increment k)
        )             //       end of recursive call
      :               //     else:
        f(S, i)       //       try again with an additional character
)(o = [])             // initial call to g with s = o = []
```
(\*) This doesn't mean that **q** is correct so far because it can be found in the middle of the string. The purpose of this test is rather to know when to give up.
[Answer]
# [Curry (KiCS2)](https://www-ps.informatik.uni-kiel.de/kics2/index.html) + `:set +first`, 37 bytes
```
f(x#y)=[x..y]
x#y|y-x>0=[x..y]>>=show
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m706ubSoqDI-OzO52GjBgqWlJWm6FjdV0zQqlCs1baMr9PQqY7mA7JpK3Qo7A6iAnZ1tcUZ-OUTxptzEzDwFW4U0BSVzC0tDA0NDJahEtJJVcWqJko6CknZaZlFxiVIs1HwA)
A port of [Fatalize's Brachylog answer](https://codegolf.stackexchange.com/a/249210/9288).
This does not work on PAKCS.
[Answer]
# Python3, 142 bytes:
```
f=lambda x,l=[]:l if''==x else max(w,key=len)if(w:=[f(x[k+1:],l+[int(x[:k+1])])for k,_ in enumerate(x)if l==[]or int(x[:k+1])==l[-1]+1])else w
```
[Try it online!](https://tio.run/##XY1BDoMgFET3PQU7IdoEpLFi8k9CSENTSI2IxtqIp6fooqnd/XnzZ2Zc5@fgeT1OMVpwur8/NAqFA6kah1qbZQABGfcyqNcBL0VnVnDGk9bipQFpcZBdzhpVuFy2fk6ySVoRRewwoa64odYj49@9mfRscEhB5CDVJ/f3H8DJM1Pbua8tcZw23@KMlfySEXL6gmstGGXswKqquh5AKTjljJec/6WFSGlKj4xRsRfGDw)
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 13 bytes
```
ef!-.+T1sMM./
```
[Try it online!](https://tio.run/##K6gsyfj/PzVNUVdPO8Sw2NdXT///fyVzC0tDA0NDJQA "Pyth – Try It Online")
Accepts a string as input.
```
ef!-.+T1sMM./
           ./  String partitions of the input
        sMM    Convert elements to integers
 f    T        Filter for paritions T such that:
    .+           The list of deltas between elements of T...
  !-   1         ...becomes empty when 1s are removed
e              Keep the last remaining partition
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 9 bytes
```
ŒṖḌIİƑ$ƇḢ
```
[Try it online!](https://tio.run/##y0rNyan8///opIc7pz3c0eN5ZMOxiSrH2h/uWPT/cLu3ZuT//4ZGxiY6CuYWloYGhoY6CmZmZuY6CkaWxgbGhsZGxsYgSUtLoKSBAZBhaGAJUgRWCwA "Jelly – Try It Online")
```
ŒṖ           Find every partition of the input's digits,
  Ḍ          and convert each slice in each partition back to an integer.
       Ƈ     Filter to only those which
   I         have forward differences
    İƑ$      which are all their own inverses (i.e. 1).
        Ḣ    Yield the first remaining partition (nontrivial).
```
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 94 bytes
```
f=lambda a,d=2,c=1:(r:=(*range(x:=int(a[:c]),x+d),))*(d*"%d"%r==a)or f(a,d:=d%len(a)+1,c+1//d)
```
[Try it online!](https://tio.run/##XczRCoIwFIDh@55CAvEcHbjjQt3gPEl0sZxWYFOGF/b0y7oI7PaH759fy33yqp1DjAOP9nl1NrHCcSU6JgPBMOTB@lsPq@GHX8CeTXdBsRYOBWIOLj@m7pgGZotTSAbYtGGXjr0HiwWJrqCydBjn8OEDZFSpU4Z4@IWm1SSJdq2u62YXKq2kIlUp9ae13rSU@0ZSf4fxDQ "Python 3.8 (pre-release) – Try It Online")
Nothing too fancy here.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 28 bytes
```
ＦＩＥθ…θ⊕κＦＬθ⊞υＩ…ι⁺⊕ι⊕κΦυ⁼θ⪫ιω
```
[Try it online!](https://tio.run/##bY27CgIxFER7vyLlXVjBVCqWQUFRCP5BiNdNMHtjXopfHzdbWTjdwJwz2qiovXK13n1kIFTKcFFPCD0TH@1QGD@XI@mII1LGGzy6FjYDZ6QhGwhTlyUZKBPXHFdFA4LtmXQlwS9tu3@23UJGSxkO1mWMTbMPRbnUvk/eUlO952Gt682Wrzivy5f7Ag "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
ＦＩＥθ…θ⊕κ
```
Loop over all of the nontrivial prefixes of the input.
```
ＦＬθ⊞υＩ…ι⁺⊕ι⊕κ
```
Create ranges of length 2 up to the length of the input starting at each prefix.
```
Φυ⁼θ⪫ιω
```
Find any ranges whose concatenation equals the original input.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 51 bytes
```
n=>(g=s=>s.match(n.join`,?`)||g(s+[,++i]))(i='')[0]
```
[Try it online!](https://tio.run/##dZBBbsIwEEX3PcUoGxxlamwPOHhhOEgUiSiFEAR2VaOuuHuwK6VVi2tpNtY8zfv/3H12of8Y32@vzr8dpqOdnN2ywQa7Dfza3foTc/zsR7fH3b683wcWqgaramzLko12sSgb0U69d8FfDvziB3ZkDee8kIpWBcwvbsNyCY1EUAiEsGpfMlC9MVJIWfyGaoQNgkGQIo7Mklrr@vmc1gi6zgLKkCBJiih5zoCKVyheoShKyTSqUt7VmOgqxB/X@Js8hcgzUpjveD9MymX@CZZ6XOu5mOceEeLWVy3TAw "JavaScript (Node.js) – Try It Online")
Input an array of characters. Output comma separated numbers as a single string.
It passes all testcases listed here. But I still have no idea if this answer is correct or not. Failed testcases are welcomed and I will try to fix it some how.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 6 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
.œ.Δ¥P
```
[Try it online](https://tio.run/##yy9OTMpM/f9f7@hkvXNTDi0N@P/f3MLS0MDQEAA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfeV/vaOT9c5NObQ04H@tzv9oQyNjEx1zC0tDA0NDHTMzM3MdI0tjA2NDYyNjY6CMpSVQxsBAB0haGhrGAgA).
**Explanation:**
```
.œ      # Get all partitions of the (implicit) input (the partition-list is ordered from
        # longest (all single digits) to shortest (single original integer)) 
  .Δ    # Find the first which is truthy for:
    ¥   #  Pop and push the deltas / forward differences
     P  #  Take the product of that
        #  (only 1 is truthy in 05AB1E)
        # (after which the result is output implicitly)
```
[Answer]
# [Prolog (SWI)](http://www.swi-prolog.org), ~~68~~ 64 bytes
*-4 bytes thanks to Steffan pointing out a golf I somehow missed*
```
A+B:-nth1(X,_,_),between(1,X,Y),numlist(Y,X,B),concat_atom(B,A).
```
[Try it online!](https://tio.run/##bY5BasMwEEX3PsVsjGwyDhpNkKMuCvEZunAowaRBNIbYKrVCju@OQkkaUsEsJL357399h1P4rKZLP8@bRfNSjfFIRYsddiV@@HjxfiwIW9yWOJ6HUz/FYivXpsRDGA/72O1jGIoGN@VynhUZXqlFu4T7yatXeCcEg8AIq12WqXrtSBP9Ba9UjbBGcAikZSih1tr6v0BrEWydCONYM7FhvqmvhJEclhwWNye52Dnpc3g7@slD7AcP4RyzXDknhbR@KiTvqYzWaU0J4x5b/1KprvzsfgA "Prolog (SWI) – Try It Online")
Pretty straightforward.
### Explanation:
```
A+B:-                 % A predicate with an atom A and a list of numbers B
     nth1(X,_,_),       % Find a positive number X
     between(1,X,Y),    % And a number Y between 1 and X
     numlist(Y,X,B),    % Generate the range [Y,X] into B
     concat_atom(B,A).  % The concatenated list should be the same atom as A
```
[Answer]
# Rust, ~~242~~ 235 bytes
```
|t:Vec<u64>|(0..).map(|v|{let mut y=vec![];y.extend(t.iter().scan((v,0),|(a,b),c|Some(if *b*10+c==*a+1{*a=c+*b*10;*b=0;Some(*a)}else{*b=*b*10+c;None})));y.last().unwrap().and(Some(y.into_iter().flatten()))}).flatten().next().unwrap();
```
Tries every initial number till it finds one that completes the sequence. [Playground](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=952da1e61d2cccfaa8139156e8d2b8f5)
Saved 7 bytes by using `let mut y=vec![];y.extend(X)` unstead of `let y:Vec<Option<u64>>=X.collect()`
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 120 bytes
```
lambda s:g(s)[1]
g=lambda s:s and[j+[k]for i in range(-len(s),0)for j in g(s[:i])if{*j[-1:]}<={~-(k:=int(s[i:]))}]or[[]]
```
[Try it online!](https://tio.run/##PY7LDoIwEEX3fsXspCqmQw3QRr6kdoHhYQFL07IxBH8d242bWdxzz83Yz/KaDSut27vqsU/1@9nU4EWfeCJRHfrqH3moTSOHsxxVNzvQoA242vRtkk6tCf0LJREMEQRfCq2I7tbTIFMUartX6zdNRlFpswSqhSJkU7OTUqk9ij6KR8zYDYqSI0WEPM8LyDijDFnGWCCcB0IphMsRj1dvJ70kRIB1cbcLf5D9Bw "Python 3.8 (pre-release) – Try It Online")
[Answer]
# [Raku](https://raku.org/), 44 bytes
```
{+«m/^(\d+?)+<?{1==all $0[1..*]Z-$0}>$/[0]}
```
[Try it online!](https://tio.run/##DcnRCoIwFAbgV/mREZWk52wxG7j5HpmJULtSCruSsSfqLXqxtZvv5ns/11mnZcPOw6ZQ/r5Lfd/fHmV3KNsusLXTPENQz1V1HK4nQdGJuqchps@0oRAjrEPwEGMs4F8rWpbqjOZimJihtW4gjSLFSiqVx5g8RMgaZpf@ "Perl 6 – Try It Online")
The regex match `m/.../` does the heavy lifting here.
* `^` matches the start of the input string or number, as usual.
* `(\d+?)+` matches a sequence of groups of digits, each of minimal length such that the overall match succeeds.
* `<?{ ... }>` is an assertion; the Raku code inside the braces must evaluate to a true value for the match to succeed. Inside the braces, `$0` is a list of the matched digit groups. `$0[1..*] Z- $0` is the tail of the list zipped using subtraction with the list; this is the list of differences between each adjacent pair of digit groups. `1 == all ...` tests that all of them are equal to 1. If the assertion fails, the match backtracks to try a different group of digits.
* `$` matches the end of the input, as usual.
Finally, `[0]` extracts the first matching group--which is a list, since the group was followed by a quantifier--and `+«` converts those match objects to numbers.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 71 bytes
```
f=(s,i,p='',...a)=>p==s?a:s.match(p)&&f(s,-~i,p+i,...a,i)||!p&&f(s,-~i)
```
[Try it online!](https://tio.run/##bZDBTgMhEIbvPsW4h3aJUwpMyxYT9EGMB7Lt6ja1S6Tx1Pjq69DYTSqScIGP4fv/ffgKqf3s42lxHLa7cex8nbDH6OdzlFIG4Z@i9@k5PCb5EU7tex3FbNYxtPhm7KG/UNiL8/k@ThdibIdjGg47eRje6q6utKFVBdclBCyX8KIRDAIhrF7v/vDNxmmldXXDNwgbBIegFW9dPLLWNsUn1iLYpmCNI0WaDFEW@2UNzyaeTWxGWY3dqJRzjuWUupXjwyymVIlr5aYoE54zuH9C5KbW9pq/aAqB@76kH38A "JavaScript (Node.js) – Try It Online")
]