[Question]
  [
You task here is very simple:  
Given a positive integer `n` without leading zeroes as input, split it in all possible ways
## Examples
**Input->Output**
```
111  -> {{111}, {1, 11}, {11, 1}, {1, 1, 1}}
123  -> {{123}, {12, 3}, {1, 23}, {1, 2, 3}}  
  
8451 -> {{8451}, {845, 1}, {8, 451}, {84, 51}, {84, 5, 1}, {8, 45, 1}, {8, 4, 51}, {8, 4, 5, 1}}  
10002-> {{10002},{1,2},{10,2},{100,2},{1000,2},{1,0,2},{10,0,2},{100,0,2},{1,0,0,2},{10,0,0,2},{1,0,0,0,2}}
42690-> {{42690}, {4269, 0}, {4, 2690}, {426, 90}, {42, 690}, {426, 9, 0}, {4, 269, 0}, {4, 2, 690}, {42, 69, 0},  {42, 6, 90}, {4, 26, 90}, {42, 6, 9, 0}, {4, 26, 9, 0}, {4, 2, 69, 0}, {4, 2, 6, 90}, {4, 2, 6, 9,  0}}      
```
  
## Rules
Leading zeroes, if they occur, should be removed.  
Duplicate partitions in your final list should also be removed.  
This is `code-golf`. Shortest answer in bytes, wins!
[Sandbox](https://codegolf.meta.stackexchange.com/a/19258/67961)
  
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 8 bytes
```
ṫ{~cịᵐ}ᵘ
```
Convert to string `ṫ` and get all unique `{…}ᵘ` reverse concatenations `~c` mapped to integers `ịᵐ` (to remove leading zeros).
[Try it online!](https://tio.run/##ASUA2v9icmFjaHlsb2cy///huat7fmPhu4vhtZB94bWY//8xMDAwMv9a "Brachylog – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 4 bytes
```
.œïÙ
```
[Try it online!](https://tio.run/##yy9OTMpM/f9f7@jkw@sPz/z/39DAwMAIAA "05AB1E – Try It Online")
---
### Explanation
```
.œ      - Partitions of implicit input 
  ï     - Converted to integers (will remove leading 0s) 
   Ù    - Uniquified
        - Output implicitly
```
[Answer]
# [Python 3](https://docs.python.org/3/), 87 bytes
```
f=lambda s:{(int(s),)}|{a+b for i in range(1,len(s))for a in f(s[:i])for b in f(s[i:])}
```
[Try it online!](https://tio.run/##XZDRboMgFIbveYpzV8hoI9gtnUn7IksvbKobiUUiZlnT@ezuHBSL80K/852fA@ju/Vdr83Gsj015u1xL8MWDG9tzL6QYfh/lywXqtgMDxkJX2s@KK9lUFvuCfEm@5v6jMOcgLlGY4iyG0dxc2/Xg754xajfGVpRAsfP91diCAT7GOgnVj4NjSOy8a0zPN9vTRrAYwB6@cVVnHBfBTivwvdigXUc3qPEeTsARA99lwzElxKiUAtie4MGRpJCA1wGlAhBFQzgwpfOY1vmU1hLyOaQXIDeww/5VTWmiEEeYhx4koJychITSfsJLZuL5PFmW6ek8RPP5dfhk8fuESHJRMkkl3bS/0lQMbK/f3rOwbaCwLZGELCD@AdSzlRBRwsqu0kmRxAhjh4plFq1ZDf43b12mY6YyHfRcPfwB "Python 3 – Try It Online")
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 6 bytes
```
{sMM./
```
[Try it online!](https://tio.run/##K6gsyfj/v7rY11dP//9/JUMDAwMjJQA "Pyth – Try It Online")
## Explanation
```
{sMM./
    ./  # Partitions of implicit input
 sMM    # Convert to integers (to remove leading 0s)
{       # Deduplicate
```
[Answer]
# [R](https://www.r-project.org/), ~~136~~ 126 bytes
*Edit: -10 bytes thanks to Giuseppe*
```
function(s,n=nchar(s))unique(lapply(apply(!combn(rep(1:0,n),n-1),2,which),function(i)as.double(substring(s,c(1,i+1),c(i,n)))))
```
[Try it online!](https://tio.run/##VY5LCgIxEAXP4q4bWzGjK2HOIkkbTUOmJ@aDePoYEQTfonZVvNxLilIv2hbn89xvTbnKqlBIZ@VgMxTEpvJoHqJNKb7gyw2vi1PIPoE5H0iRdGeQJnoG4YD0Kwnasr@uzUUPpblSs@h99BkMyXYoDDL0z/7OgJmOJ@xv "R – Try It Online")
Hmm... I suspect that this mayn't be the shortest way... but so far my attempts at recursive solutions have been *even* longer...
**Commented code:**
```
split_number=
function(s,n=nchar(s))                # s=input number (converted to string), n=digits
 unique(                              # output unique values from...
  lapply(                             # ...looping over all... 
   apply(                             # ...combinations of breakpoints by selecting all...
    !combn(rep(1:0,n),n-1),           # ...combinations of TRUE,FALSE at each position...
     1,which),                        # ...and finding indices,
   function(i)                        # ...then, for each combination of breakpoints...
    as.double(                        # ...get numeric value of...
     substring(s,c(1,i+1),c(i,n))     # ...the substrings of the input number
 )
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~5~~ 4 bytes
```
ŒṖḌQ
```
[Try it online!](https://tio.run/##y0rNyan8///opIc7pz3c0RP4//9/EyMzSwMA "Jelly – Try It Online")
[-1 byte](https://codegolf.stackexchange.com/questions/210321/split-a-number-in-every-possible-way/210324?noredirect=1#comment495778_210324) thanks to [Jonathan Allan](https://codegolf.stackexchange.com/users/53748/jonathan-allan)
## How it works
```
ŒṖḌQ - Main link. Takes an integer as argument (e.g. n = 42690)
ŒṖ   - Get all partitions. Automatically cast to digits  [[4, 2, 6, 9, 0], [4, 2, 6, [9, 0]], [4, 2, [6, 9], 0], [4, 2, [6, 9, 0]], [4, [2, 6], 9, 0], [4, [2, 6], [9, 0]], [4, [2, 6, 9], 0], [4, [2, 6, 9, 0]], [[4, 2], 6, 9, 0], [[4, 2], 6, [9, 0]], [[4, 2], [6, 9], 0], [[4, 2], [6, 9, 0]], [[4, 2, 6], 9, 0], [[4, 2, 6], [9, 0]], [[4, 2, 6, 9], 0], [4, 2, 6, 9, 0]]
  Ḍ  - Convert each list back to digits                  [[4, 2, 6, 9, 0], [4, 2, 6, 90], [4, 2, 69, 0], [4, 2, 690], [4, 26, 9, 0], [4, 26, 90], [4, 269, 0], [4, 2690], [42, 6, 9, 0], [42, 6, 90], [42, 69, 0], [42, 690], [426, 9, 0], [426, 90], [4269, 0], 42690]
   Q - Remove duplicates                                 [[4, 2, 6, 9, 0], [4, 2, 6, 90], [4, 2, 69, 0], [4, 2, 690], [4, 26, 9, 0], [4, 26, 90], [4, 269, 0], [4, 2690], [42, 6, 9, 0], [42, 6, 90], [42, 69, 0], [42, 690], [426, 9, 0], [426, 90], [4269, 0], 42690]
      - Implicit output
```
[Answer]
# [Perl 5](https://www.perl.org/) `-MList::Util=uniq -F`, ~~108~~ ~~96~~ ~~94~~ 90 bytes
```
say uniq map{@b=(sprintf'%b',$_)=~/./g;$_="@F
";s/ /','x pop@b/ge;s/\d+/$&*1/reg}1..2**$#F
```
[Try it online!](https://tio.run/##K0gtyjH9/784sVKhNC@zUCE3saDaIclWo7igKDOvJE1dNUldRyVe07ZOX08/3Vol3lbJwY1LybpYX0FfXUe9QqEgv8AhST89FSgSk6Ktr6KmZahflJpea6inZ6SlpaLs9v@/oYGBgdG//IKSzPy84v@6vqZ6BoYGQNons7jEyiq0JDPHFmT1f103AA "Perl 5 – Try It Online")
[Answer]
# [Scala](http://www.scala-lang.org/), ~~139~~...~~104~~ 94 bytes
```
def f(? :String):Set[_]=Set(?)++(for{< <-1 to?.size-1
x<-f(?take<)
y<-f(?drop<)}yield x+","+y)
```
[Try it online!](https://tio.run/##PY3BboMwDIbveQor2iEWo0pYW20oFdpxh516rKaJFjOxsoCIDzDGs9OIoV7s77f0@feXvM7n5vxNF4b3vHJAPZMrPLy2LYxzQSWUKoP0yF3lvjA9Ep8@Pw5hqQyjSJVNN1qwsQFuso2vfik2ordxkDi/kkUxLKHomtbiNFRUF9BH8lFGAy7vmTwrn8KbY4QDtKGHa6dK5eWDl7j5uf53KzkGC/4gzEkiCrGYRhtcydwpeVrpebu7H7XWycrbZP@iUUzzDQ "Scala – Try It Online")
A recursive method. The input has to be a string.
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 59 bytes
```
\G\d
$&$'¶$`,$&
+%)`^.+¶
m`^,|\b0+\B
O`
m`^(.+)(¶\1)+$
$1
```
[Try it online!](https://tio.run/##K0otycxL/K@qoeGe8D/GPSaFS0VNRf3QNpUEHRU1Lm1VzYQ4Pe1D27i4chPidGpikgy0Y5y4uPwTQHwNPW1NjUPbYgw1tVW4VAz//zc0NOQyNDLmsjAxBTIMDAyMuEyMzCwNAA "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation:
```
\G\d
$&$'¶$`,$&
```
Create copies of the line with all possible proper prefixes of the first number on the line.
```
^.+¶
```
If there were any such prefixes, delete the original line.
```
+%)`
```
Repeat until no more prefixes can be generated.
```
m`^,|\b0+\B
```
Remove the leading separator and also leading zeros of any numbers.
```
O`
m`^(.+)(¶\1)+$
$1
```
Sort and deduplicate the results.
For the Retina 1 port, the biggest saving comes from deduplication, which is basically a built-in in Retina 1. The newlines aren't included in the deduplication, so another stage is needed to filter out blank lines, but it's still a saving of 14 bytes. Another 3 bytes can be saved by using `$"` which is a shorthand for `$'¶$``. I also tried using an `L` stage to avoid leaving the original line but then a conditional is required to end the loop which means that the byte count ends up unchanged.
[Answer]
# [Python 3](https://docs.python.org/3/), 81 bytes
```
f=lambda g:{(int(g),)}|{b+(int(g[i:]),)for i in range(1,len(g))for b in f(g[:i])}
```
[Try it online!](https://tio.run/##XZDBboMwDIbveQrfmmhpRUJXdUjti0w9UBW6SDSNAE2rOp6d2QmhYRzg8@8vjoV79F93m49jfWjK2/lSwrV4cmN7fhVSDL/P81uoPk1xwqS@t2DAWGhLe624kk1lUfX5mfIa1cKcxDCam7u3PXSPjjFqN8ZWZGCw6fqLsQUDfIx1EqofBwdvbDrXmJ6v1seVYFHAHr7xVGscFz4NJ/A9pz52LW1b485OwAGF77LhaAkxKqUA1kd4ciQpJOD2oJQHopgQDkzpPNo6D7aWkE@SnoGyge237yrYRF5HmIbuJWAYMgkJpf2EZyfwtE@WZTrsQzTtr/0ni98XRJJzJBMr6ab9RUzFwLZ695H5az35a4kkZB7xD2A8pRIiSlikCzspEo0wdqiYZ9GZxeB/85ZlOiaU6aDX6eEP "Python 3 – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 47 bytes
```
⊞υ⟦Ｓ⟧≔⟦⟧θＦυ«≔⊟ιη¿ηＦＬη⊞υ⁺ι⟦Ｉ…η⊕κ✂η⊕κ⟧¿¬№θι⊞θι»Ｉθ
```
[Try it online!](https://tio.run/##bY@9CsIwFIVn@xR3vBciVFcn6SSIFDqWDiXGJhiTtkkEEZ893opujofz83Gk7mfpe5tznYLGJKA9uDHFJs7GDUgd7Yp9CGZw2HYCJpYXPwMmgmex@jq1H9GQAM3uylwANcEndVRuiJolwW@@timgYUzVh4jVQ1pVae5rAQcnZ3VTLqozXol4sLFGqj9WRwtJ2aBgwZ08L/nkIk4CDP1oH7ErXkXNXzixACdu5rwpy3Kb13f7Bg "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
⊞υ⟦Ｓ⟧
```
Start a breadth first search with the input number.
```
≔⟦⟧θ
```
Start with no results.
```
Ｆυ«
```
Loop over the candidates.
```
≔⊟ιη
```
Get the current suffix.
```
¿ηＦＬη
```
If the suffix is not empty then loop over all of its proper suffixes...
```
⊞υ⁺ι⟦Ｉ…η⊕κ✂η⊕κ⟧
```
... push the next candidate, which is the prefixes so far, the current prefix cast to integer, and the current suffix.
```
¿¬№θι⊞θι
```
But if it is empty and the resulting split is unique then push it to the results.
```
»Ｉθ
```
Print all the results. (This uses Charcoal's default output, whereby lists are double-spaced as their entries are printed on separate lines.)
[Answer]
# [J](http://jsoftware.com/), 36 29 bytes
```
[:~.]<@("./.~+/\)"#.2#:@i.@^#
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/o63q9GJtHDSU9PT16rT1YzSVlPWMlK0cMvUc4pT/a3JxpSZn5CukKagbGhmrIzgGBgZGCK6JkZmlgfp/AA "J – Try It Online")
*-7 bytes thank to xash!*
Explanation later.
[Answer]
# [Raku](https://github.com/nxadm/rakudo-pkg), 38 bytes
```
{unique +<<m:ex/^(.+)+$/>>[0],:as(~*)}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/ujQvs7A0VUHbxibXKrVCP05DT1tTW0Xfzi7aIFbHKrFYo05Ls/Z/cWKlgh5QQ1p@kUJOZl5q8X9DQ0MuQyNjLgsTUyDDwMDAiMvEyMzSAAA "Perl 6 – Try It Online")
[Answer]
# Mathematica 106 bytes
```
Union@Table[FromDigits/@#~TakeList~i,{i,Join@@Permutations/@IntegerPartitions@Length@#}]&@IntegerDigits@#&
```
[Try it online](https://tio.run/##NYwxC8IwEEZ/TKBTodFduEEEpUOGOoUMp1zTQ3OB9Jyk/euxKK7fe@9LqBMlVL5jHQ/1KpwFBrw9yZ9KTkeOrHMHZh3wQT3PunL75vaSWQAclfTSLc6yOWdRilQcFuXvBD1J1AnMEpo//R2CaaorLOpHv7PW7kOoHw)
[Answer]
# JavaScript (ES6), 88 bytes
Expects a string. Returns a Set of comma-separated strings.
```
f=([c,...a],o='',S=new Set)=>c?f(a,o+c,o?f(a,o+[,c],S):S):S.add(o.replace(/\d+/g,n=>+n))
```
[Try it online!](https://tio.run/##bcpBCsIwEIXhvaeQbprQMU1qFRVSD9Fl7SJMkqKUTGmLHj8quJLAW/x8vId5mgXn@7TuAlkXo9esQxBCmB5I5zm0OrjXtnUr1w1ePTNABQL9qgPsoeWX74SxlpGY3TQadKy82aIcIOimCJxHpLDQ6MRIA/MsU0plnG/@tdon9FQfkmcpZZXwujqe5cfjGw "JavaScript (Node.js) – Try It Online")
### How?
It's important to note that `Set.prototype.add()` returns the set itself. And because the recursion always ends with `S.add(...)`, each call to `f` returns `S`.
### Commented
*NB: alternate slash symbols used in the regular expression to prevent the syntax highlighting from being broken*
```
f = (                // f is a recursive function taking:
  [c,                //   c   = next digit character
      ...a],         //   a[] = array of remaining digits
  o = '',            //   o   = output string
  S = new Set        //   S   = set of solutions
) =>                 //
  c ?                // if c is defined:
    f(               //   do a recursive call:
      a,             //     pass a[]
      o + c,         //     append c to o
      o ?            //     if o is non-empty:
        f(           //       do another recursive call
          a,         //         pass a[]
          o + [, c], //         append a comma followed by c to o
          S          //         pass S
        )            //       end of recursive call (returns S)
      :              //     else:
        S            //       just pass S as the 3rd argument
    )                //   end of recursive call (returns S)
  :                  // else:
    S.add(           //   add to the set S:
      o.replace(     //     the string o with ...
        ∕\d+∕g,      //       ... all numeric strings
        n => +n      //       coerced to integers to remove leading zeros
                     //       (and coerced back to strings)
      )              //     end of replace()
    )                //   end of add() (returns S)
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 18 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
ã
cU à f_¬¥NÃ®mnÃâ
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=4wpjVSDgIGZfrKVOw65tbsPi&input=IjEwMDQiCi1R)
* Saved 1 thanks to @Shaggy !
```
    ã                  - substrings of input
      cUã)             - concatenated to substrings of input(repeated)
          à            - combinations
            f_¬¥N      - take combinatons if == input when joined
           ®mn  - deduplicates ( @Shaggy ® )
                    Ãâ    - implicitly returns unique elements
```
[Answer]
# [K (ngn/k)](https://bitbucket.org/ngn/k), ~~32~~ 25 bytes
-4 bytes from not de-listing first result
-3 bytes from @ngn's improvements
```
{?.''(&'+1,!1_2&$x)_\:$x}
```
[Try it online!](https://tio.run/##y9bNS8/7/z/NqtpeT11dQ01d21BH0TDeSE2lQjM@xkqlovZ/mrqhoaGCoZGxgoWJKZBhYGBgpGBiZGZp8B8A "K (ngn/k) – Try It Online")
* `&'+1,!1_2&$x` returns the subset of the (power set of indices of the input) that begin with 0. The original power set index generation code was taken from [@JohnE's answer on a different question](https://codegolf.stackexchange.com/a/51634/98547), and includes improvements from @ngn's comments on this answer.
* `(...)_\:$x` `cut`s the stringified-input on each of the specified indices
* `?.''` converts each slice to integers, taking the `distinct` elements
[Answer]
# [Ruby](https://www.ruby-lang.org/), 127 bytes
```
->(n,f=->(s){s.size.times.map{|i|([f.(s[0...i])].flatten(i>1?1:0).map{|j|[j.flatten<<s[i..-1]]})}.flatten(2)}){f.(n.to_i.to_s)}
```
[Try it online!](https://tio.run/##PUzbCsIgGL7fU/wMBgruR@1ARa0HEYkVGzmaSdpFTZ99raJuvgPf4XY/Pka3G8uKWNbuJvJ08OjNs8Fg@sZjX7shmkhUi8QrjohGU43tpQ6hscRUYi82nH57XVTdL9puvTKIpdA60fQfSJroMH1ZDNeDeYOnaVRCCJYJOWPZar54S865ZNlcLtecZfnkPjLX2NSnMwwQbQR3D57khYOygsLlUICyDJyyWlNI4ws "Ruby – Try It Online")
**Explanation**
1. first lambda takes a number and a function as parameters
2. second parameter defaults to the lambda that computes the partition
3. the second lambda is called with the number stripped of leading zeroes
4. computation starts with a map for each split point in the number
5. recursively call lambda for the substring before the split point
6. append the substring after the split point to each resulting partition array
judicious array creation [] and applications of flatten in the code ensure exactly one level of array nesting in the result.
[Answer]
# [Perl 5](https://www.perl.org/), 87 bytes
```
sub f{$_=pop;/(.)(.+)/?do{my$s=$1;map s/@_\d+/0+$&/ger,map{("$s $_",$s.$_)}f(1,$2)}:$_}
```
[Try it online!](https://tio.run/##nVLLbsIwELzzFaPIbW3hkjhQRIlC8wO99QYoosJUtIREMZUaRfl2ajsvUDk1h93x7MzsHpLJ/PB0Pqvvd@xKEodZmgUuHTE6GjL3ZZuWSUFUSESQbDIoN4pX26HrDcm9@yFzrsmSOkSBxA4nakRiVu2o4MRn1ZzE1flbSbxJdZrPX9Nc4qShChfTYJAUiMwrpANgKYQAwgWWjkYOhyPQdA2atwbrNbdqf9yq/bGd@qg7/LZr4l/q2eRJ1GqDzFj3@oYZOgY9MDNt7D@r6xytErW0vcnzPL@@ySCHmyNM9ZrW9QbA9us9WtzLe13L4Zo0uNk@8afPnt1ukbnPANQIFxxaBMtd77fzC1MHMb2w4YYPXTCudlzG4ZYTbWKD@5jGvF6DBYNdmlP7d7HSBiQFJftjxon8yVgYkThoaNxpJoh0KSMzrEIq2I@Qfi/4SE9BpEu5sxnsr4SYTcdNIkPHKPC4gDP6TPdH@sDxwFWan@iXLJSJYqy27VW8lTI7FHRlaI6VuYT3WVpXnX8B "Perl 5 – Try It Online")
Ungolfed:
```
sub f {
  $_ = pop;                     # set $_ to input (last arg)
  if( /(.)(.+)/ ) {             # if input two or more digits, split
                                # into start digit and rest
    my $s = $1;                 # store start digit
    return
      map s/@_\d+/0+$&/ger,     # no @_ => 1st recursive level => trim leading 0s
                                # 0+$& means int(digits matched)
      map { ("$s $_", "$s$_") } # return "start+space+rest" and "start+rest"...
      f(1, $2)                  # ...for every result of rest
                                # (1 marks recursive level below first)
  }
  else {
    return $_                   # if just one digit, return that
  }
}
```
# [Perl 5](https://www.perl.org/) -MList::Util, 68 bytes
...which is further golfed from the answer from @xcali
```
say uniq map"@F
"=~s| |$_/=2;','x($_%2)|reg=~s|\d+|$&*1|reg,1..2**@F
```
[Try it online!](https://tio.run/##K0gtyjH9/784sVKhNC@zUCE3sUDJwY1LybauuEahRiVe39bIWl1HvUJDJV7VSLOmKDUdJBOTol2joqZlCOLrGOrpGWlpObj9/29oYGBg9C@/oCQzP6/4v66vqZ6BoQGQ9sksLrGyCi3JzLEFWfJf1w0A "Perl 5 – Try It Online")
[Answer]
# [Husk](https://github.com/barbuz/Husk), 14 bytes
```
ummdf(=d¹Σ)ṖQd
```
[Try it online!](https://tio.run/##yygtzv7/vzQ3NyVNwzbl0M5zizUf7pwWmPL//39DA0MA "Husk – Try It Online")
[Answer]
# [Pip](https://github.com/dloscutoff/pip) `-p`, 44 bytes
```
YaUQ({(a|>0)RMx}M({y=aRMs?a^sx}M(PMaJs)))RMx
```
Probably my craziest Pip answer. There's definitely a shorter method, but I decided to roll with this.
-p pretty prints the final list for easier verification. Takes a very long time with 5 digit numbers.
[Try it online!](https://tio.run/##K8gs@G@tEBqoUV1pmxjkW2wfnVhTUxxbUeurEeCb6FWsCeQFlRdr/o9MBCnSSKyxM9AM8gXJw3QkxhUjlGuCJP///29oZPxftwAA "Pip – Try It Online")
## Explanation
```
YaUQ({(a|>0)RMx}M({y=aRMs?a^sx}M(PMaJs)))RMx a → first command line argument
Ya                                           Yank a into variable y
                                 PMaJs       join each element of a with a space, get permutations
                  {y=aRMs?a^sx}M             filter out the permutations that are not in order
     {(a|>0)RMx}M                            Strip leading zeros and empty strings in each split
                                         RMx remove empty strings from the whole result
  UQ                                         print the unique splits
```
]