[Question]
  [
[Related.](https://codegolf.stackexchange.com/questions/42580/shorter-than-a-split-second)
Given a printable ASCII string, split it into a list of non-empty strings with a new sub-string beginning every time a character, which has not previously been seen in the same case, occurs.
### Examples
```
"mississippi" → ["m","i","ssissi","ppi"]
"P P & C G" → ["P"," P ","& ","C ","G"]
"AAA" → ["AAA"]
"Adam" → ["A","d","a","m"]
"" → []
```
---
**Anecdote**: The result will have between 0 and 95 elements. The 95th sub-string will necessarily continue until the end because at that point, all printable ASCII characters have begun a sub-string, so every additional character will have occurred before and thus cannot cause a new sub-string to begin.
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 bytes
```
QƤĠị
```
[Try it online!](https://tio.run/##y0rNyan8/z/w2JIjCx7u7v5/uP3opIc7Z/z/r5SbWVwMQgUFmUoA "Jelly – Try It Online")
## Explanation
```
QƤĠị  Input is a string, say s = "adam"
 Ƥ    For each prefix of s: ["a","ad","ada","adam"]
Q     remove duplicates: ["a","ad","ad","adm"]
  Ġ   Group indices by equal values: [[1],[2,3],[4]]
   ị  Index into s: ["a","da","m"]
```
The internal representation of the strings, which the TIO link displays, is slightly different.
[Answer]
## [Retina](https://github.com/m-ender/retina/wiki/The-Language), 9 bytes
```
q1,`.
¶$&
```
[Try it online!](https://tio.run/##K0otycxLNPz/v9BQJ0GP69A2FbX//3Mzi4tBqKAgEwA "Retina – Try It Online")
### Explanation
Match each character (`.`), discard repeated matches (`q`), discard the first match (`1,`), and insert a linefeed in front of each match `¶$&`.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 11 bytes
```
ÙSk¥sg¸«£õK
```
[Try it online!](https://tio.run/##MzBNTDJM/f//8Mzg7ENLi9MP7Ti0@tDiw1u9//9XAoIAhQAFNQVnBXcQBwA "05AB1E – Try It Online")
**Explanation**
```
Ù             # remove duplicates in input
 S            # split to a list of characters
  k           # get the (first) index of each character in the input
   ¥          # calculate delta's
    sg¸«      # append the length of the input
        £     # split the list into pieces of these sizes
         õK   # remove empty string (for the special case "" -> [])
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 8 bytes[SBCS](https://github.com/abrudz/SBCS)
```
(≢¨∪\)⊆⊢
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG9qZv6jtgkG/9OApMajzkWHVjzqWBWj@air7VHXov//S4DC1Y96twJlioDMtEe9u6zU0xIzc9SBLKB40aPuFvX8bPVaLvXczOJiECooyFQv0Tm0Qj1XXUE9E4ghwkAGSIZLPUAhQEFNwVnBHaIqACgBFAGSaiDCGUS4A5U5OjoCFTzqagKzgPyUxFyIDjCLS129RMHgUe8WkAp1AA "APL (Dyalog Unicode) – Try It Online")
[Answer]
# C, ~~75~~ ~~65~~ 63 bytes
*Thanks to @Digital Trauma for saving 10 bytes and thanks to both @gastropner and @l4m2 for saving a byte each!*
```
f(char*s){for(int l[128]={};*s;putchar(*s++))l[*s]++||puts(l);}
```
Prints a leading newline.
[Try it online!](https://tio.run/##S9ZNT07@/z9NIzkjsUirWLM6Lb9IIzOvRCEn2tDIIta2utZaq9i6oLQEJK@hVaytramZE61VHKutXVMDFC7WyNG0rv0P0pGbmJmnoclVzaUABGkaSrmZxcUgVFCQqaRpDVarBGTApAMUAhTUFJwV3LFJOjo6YhVOSczFJg5i1v4HAA)
**Without a leading newline (71 bytes):**
```
f(char*s){int l[128]={};for(l[*s]=1;*s;putchar(*s++))l[*s]++||puts(l);}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9NIzkjsUirWLM6M69EISfa0Mgi1ra61jotv0gjJ1qrONbW0Fqr2LqgtASkTkOrWFtbUxMsoa1dUwMULtbI0bSu/Q/SnZuYmaehyVXNpQAEaRpKuZnFxSBUUJCppGkNVqsUkwdkwhQEKAQoqCk4K7hjl3Z0dMQhkZKYi10GxKz9DwA)
[Answer]
# [Perl 6](https://perl6.org), ~~58 52~~ 40 bytes
```
{$/={};.comb.classify({$+=!$/{$_}++}).sort».value».join}
```
[Try it](https://tio.run/##K0gtyjH7X1qcqlBmppdszcWVW6mglpyfkqpg@79aRd@2utZaLzk/N0kvOSexuDgzrVKjWkXbVlFFv1olvlZbu1ZTrzi/qOTQbr2yxJzSVCCdlZ@ZV/u/OLFSAWSKhlJuJlAbEBUUZCpp6hUArbPmgsuqBygEKKgpOCu4q2PIKTk6OiphEU1JzMUiDBP6DwA "Perl 6 – Try It Online")
```
*.comb.classify({$+=!(%){$_}++}).sort».value».join
```
[Try it](https://tio.run/##K0gtyjH7X1qcqlBmppdszcWVW6mglpyfkqpg@19LLzk/N0kvOSexuDgzrVKjWkXbVlFDVbNaJb5WW7tWU684v6jk0G69ssSc0lQgnZWfmfffmqs4sVIBZIKGUm4mUCMQFRRkKmnqFQCtQpJVD1AIUFBTcFZwV8eQU3J0dFTCIpqSmItFGCb0HwA "Perl 6 – Try It Online")
```
*.classify({$+=!(%){$_}++}).sort».value
```
[Try it](https://tio.run/##TY5BasMwEEX3OsWv6jp2XbTMxmRhsug20AMExZapEssSGilgXJ8su17MFYG2gVnMe/BnvlN@2K6RFK5b0daMmQl5j936KtpBEul@Kuas2j0VL@WcHZeqWkpB1ofvm7jKIaq1Zs9fMPKioAOUJK08gkU6@QY5dvd97JSncKdPBRuDi4FRPKHT5AY5ocBH8MgIJWYGUFIZidaak8j79Ops9Shc6soWxn5D3OhUMI1zmtd/enPAATn2eN/8S940DX/ETppH5vX6Aw "Perl 6 – Try It Online")  
(input is a list of characters, and output is a list of lists of characters)
## Expanded:
```
*                   # parameter for WhateverCode lambda
  .classify(        # classify that list
    {
        $           # anonymous scalar state variable (accumulator)
      +=            # increment it if:
        !           # Bool invert the following
          (
            %       # anonymous hash state variable
          ){ $_ }++ # look to see if the character was seen already
    }
  ).sort\           # sort the Pairs by key (makes the order correct)
  ».value           # get the value from each Pair
```
---
The output from `classify` is
```
{ # Hash
  1 => ['m'],
  2 => ['i'],
  3 => ['s','s','i','s','s','i'],
  4 => ['p','p','i'],
}
```
And `.sort` just turns it into:
```
[
  1 => ['m'],
  2 => ['i'],
  3 => ['s','s','i','s','s','i'],
  4 => ['p','p','i'],
]
```
`».value` removes the keys
```
[
  ['m'],
  ['i'],
  ['s','s','i','s','s','i'],
  ['p','p','i'],
]
```
[Answer]
# [J](http://jsoftware.com/), 7 bytes
```
~:<;.1]
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/66xsrPUMY/9rcqUmZ@QrpCmo52YWF4NQQUGmOlwwQCFAQU3BWcEdIeTo6IjESUnMRfDU/wMA "J – Try It Online")
# Explanation
Nub sieve's chance to shine!
```
~: <;.1 ]
        ]  Input
~:         Nub sieve (1 if the character is the first instance in string)
    ;.1    Split input on 1s in nub sieve
   <       And box each
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
```
Ùvyy¶ì.;
```
[Try it online!](https://tio.run/##MzBNTDJM/f//8MyyyspD2w6v0bP@/z83s7gYhAoKMgE "05AB1E – Try It Online")
---
Always will output 1 preceding newline, which is constant and not indicative of a split, the 10-byte alternative that does not output a preceding newline is `Ùvyy¶ì.;}¦`, you [can try that here](https://tio.run/##MzBNTDJM/f//8MyyyspD2w6v0bOuPbTs///czOJiECooyAQA "05AB1E – Try It Online"). According to Adam a preceding or trailing newline is acceptable.
---
```
Input      = mississippi                               | Stack
-----------#-------------------------------------------+----------------------------------
Ù          # Push unique letters of first input.       | ['misp']
 v         # Iterate through each unique letter.       | []
  yy       # Push 2 copies of the letter (or yD)       | ['m','m']
    ¶      # Push a newline char.                      | ['m','m','\n']
     ì     # Prepended to the letter.                  | ['m','\nm']
      .;   # Replace first instance with '\n + letter' | ['\nmississippi']
```
**After each iteration we get:**
```
['\nmississippi'] > ['\nm\nississippi'] > ['\nm\ni\nssissippi'] > ['\nm\ni\nssissi\nppi']
```
**Which is:**
```
m
i
ssissi
ppi
```
[Answer]
# [Haskell](https://www.haskell.org/), 39 bytes
```
foldl(\s c->s++['\n'|all(/=c)s]++[c])""
```
[Try it online!](https://tio.run/##ZclBCsIwEEDRvacYhkJbSvEEEXIO00WYGA1O0sHp0rM72m2Fv3r/EfV5Y7bsguWVEw9BgeaLTtO1D61/R@bh7GjU5Se0jIhWY2ngIK0nAJBXaRt0kAFrUd0TKXhYPsX6Z94fCe1DmeNdbSaRLw "Haskell – Try It Online")
Inserts a newline symbol before every character that appears for the first time, resulting in a newline-separated string, with a leading newline. Prepend `lines.` to produce a list.
---
**[Haskell](https://www.haskell.org/), 55 bytes**
```
(""%)
_%[]=[]
p%s|(a,b)<-span(`elem`s!!0:p)s=a:(a++p)%b
```
[Try it online!](https://tio.run/##ZclBDsIgEEDRPaeYEkkgtYnrRhacozZ22oISgU4cl55djNua/NX7d@SHT6kGe6laSmXEVQ2jHUZBit8aj7M5d0xY9OSTzxM3zaknwxZ7jW1LRs01YyxgYd0EANAzlhccIIDMkfkXUZS75VbMf@bcnmT9LCHhjWu3EH0B "Haskell – Try It Online")
Repeatedly takes the prefix the first character plus the non-unique characters that follow it.
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 9 bytes
Thanks, Erik the Outgolfer for saving 1 byte!
```
⊢⊂⍨⍳∘≢∊⍳⍨
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qLdP/VHfVOdIdfXixJwSdfVH3S1AfrCrXqizrwuQ2zYhKb9CIT9PQbfYNjczBSjStTg1LzEpJzXY0ScEpLp3jbrC/zSgwkddix51NT3qXfGod/OjjhmPOhc96ugCsXtX/P@fpqCem1lcDEIFBZnqXEB@gEKAgpqCs4I7mOfo6AihUxJzwQx1AA "APL (Dyalog) – Try It Online")
# Explanation:
`⍳⍨`: For each character, get the index of its first occurrence. e.g `mississippi -> 1 2 3 3 2 3 3 2 9 9 2`
`⍳∘≢`: The range from 1 to the length of the input.
`∊`: Membership. e.g `1 2 3 4 5 6 7 8 9 10 11∊1 2 3 3 2 3 3 2 9 9 2 -> 1 1 1 0 0 0 0 0 1 0 0`
`⊢⊂⍨`: Partition the input string with new partitions starting at `1`s in the vector above
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 11 bytes
```
¬â r@=iRUbY
```
[Test it online!](https://ethproductions.github.io/japt/?v=1.4.5&code=rOIgckA9aVJVYlk=&input=J21pc3Npc3NpcHBpJw==)
### Explanation
This was inspired by [Magic Octopus Urn](https://codegolf.stackexchange.com/users/59376/magic-octopus-urn)'s [05AB1E solution](https://codegolf.stackexchange.com/a/156291/42545).
```
¬â r@=iRUbY    Implicit: U = input string
¬â             Split U into chars, and keep only the first occurrence of each.
   r@          Reduce; for each char Y in this string...
        UbY      Find the first index of Y in U.
      iR         Insert a newline at this index in U.
     =           Set U to the result.
               As reduce returns the result of the last function call, this gives the
               value of U after the final replacement, which is implicitly printed.
```
[Answer]
# JavaScript (ES6), 37 bytes
*Saved 7 bytes: a leading newline was explicitly allowed (Thanks @Shaggy!)*
Takes input as an array of characters. Outputs a newline-separated string.
```
s=>s.map(c=>s[c]=s[c]?c:`
`+c).join``
```
### Test cases
```
let f =
s=>s.map(c=>s[c]=s[c]?c:`
`+c).join``
;[
  [..."mississippi"],
  [..."P P & C G"],
  [..."AAA"],
  [..."Adam"],
  [...""]    
]
.forEach(s => console.log('{' + f(s) + '}\n'))
```
[Answer]
## brainfuck, 66 bytes
```
,[>+[<[>+<<-<+>>-]>[>]<<[[+]++++++++++.>>>]<]<[>+<-]>>>[>>]<<-.>,]
```
Formatted:
```
,
[
  >+
  [
    <[>+< <-<+>>-]
    >[>]
    <<[[+]++++++++++.>>>]
    <
  ]
  <[>+<-]
  >>>[>>]
  <<-.>,
]
```
[Try it online](https://tio.run/##PcpRCoAwDAPQA3XbCUIuUvqhglBEGQ7PXzs/DCEf4a334tf@bEdEUYoiB6gQshqVBqiKyZ9G5mmfS8E0E9XGYhGnjzHbu78)
The leading newline in the output (which is only printed if the input is non-empty) can be removed at the cost of 5 bytes by replacing the body `x` of the main (outermost) loop with `.>,[x]`.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
ŒQœṗ⁸Ḋ
```
[Try it online!](https://tio.run/##y0rNyan8///opMCjkx/unP6occfDHV3/D7cfnfRw54z//5VyM4uLQaigIFMJAA "Jelly – Try It Online")
[Answer]
# [K4](http://kx.com/download/), 19 bytes
**Solution:**
```
$[#x;(*:'.=x)_;,]x:
```
**Examples:**
```
q)k)$[#x;(*:'.=x)_;,]x:"mississippi"
,"m"
,"i"
"ssissi"
"ppi"
q)k)$[#x;(*:'.=x)_;,]x:"P P & C G"
,"P"
" P "
"& "
"C "
,"G"
q)k)$[#x;(*:'.=x)_;,]x:"AAA"
"AAA"
q)k)$[#x;(*:'.=x)_;,]x:"Adam"
,"A"
,"d"
,"a"
,"m"
q)k)$[#x;(*:'.=x)_;,]x:""
,[""]
```
**Explanation:**
8 bytes is just to handle `""`...
```
$[#x;(*:'.=x)_;,]x: / the solution
                 x: / save input as variable x
$[  ;         ; ]   / $[condition;true;false]
  #x                / length of x ("" has length 0, i.e. false)
             _      / cut right at left indices
     (      )       / do together
          =x        / group x into key/value (char!indices)
         .          / return value (get indices)
      *:'           / first (*:) each
               ,    / enlist, "" => [""]
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~81~~ 74 bytes
```
def f(s):d=sorted(map(s.find,set(s)));print map(lambda a,b:s[a:b],d,d[1:])
```
[Try it online!](https://tio.run/##LY29CsMwEIP3PsXhobHBFNrRIUPI0DV7CMThbGqof8jd0qd3Y1oQkuBDqHz4ldOjVnQevCRlcKB8sEMZbZF08yGhJscnUqovR0gMjbxt3NGC1buhxZp91ahxuZtVVXbEwyJiIGoqJQgtZpjhChM8zz6OY3O08QyxXnw@gCEkaEvz@9h4673k/2XX1S8 "Python 2 – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 47 bytes
```
lambda s:reduce(lambda r,c:r+'\n'[c in r:]+c,s)
```
[Try it online!](https://tio.run/##VU09D8IgFJzlV7ww2DZlciTpQBxcu7cdkI9IIpS8h4O/HotxMbncx3B3@V0ee7pUP631qePdaiCJzr6M638ZhZE4dmvqFgMhAcptNIKGWhwVggkWHgNRQ86BCz7DDGe4wu3wSqnGVsdD@MaY3xGozXzbkp0yhlTA9zQIaCf1b@0D "Python 2 – Try It Online")
Outputs a newline-separated string. Barely beats the program version:
**[Python 2](https://docs.python.org/2/), 48 bytes**
```
r=''
for c in input():r+='\n'[c in r:]+c
print r
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v8hWXZ0rLb9IIVkhMw@ICkpLNDStirRt1WPy1KPBgkVWsdrJXAVFmXklCkX//yvlZhYXg1BBQaYSAA "Python 2 – Try It Online")
[Answer]
# Perl, 30 bytes
Includes `+1` for `p`
Give input without trailing newline on STDIN. Output is also without trailing newline:
```
echo -n adam | perl -pE 's%.%$v{$&}+++!pos?$&:$/.$&%eg'; echo
```
If you don't care about leading and trailing newlines this `25` (`+3` for `-p` because the code contains `'`) also works:
```
#!/usr/bin/perl -p
s%%$/x!$v{$'&~v0}++%eg
```
[Answer]
# JavaScript, ~~61~~ ~~54~~ 52 bytes
Takes input as an array of characters.
```
s=>s.map(x=>a[x]?a[y]+=x:a[x]=a[++y]=x,a=[],y=-1)&&a
```
---
## Try it
```
o.innerText=JSON.stringify((f=
s=>s.map(x=>a[x]?a[y]+=x:a[x]=a[++y]=x,a=[],y=-1)&&a
)([...i.value=""]));oninput=_=>o.innerText=JSON.stringify(f([...i.value]))
```
```
<input id=i><pre id=o></pre>
```
[Answer]
# [R](https://www.r-project.org/), ~~94~~ 87 bytes
```
function(s,n=nchar(s),g=substring)g(s,d<-which(!duplicated(g(s,1:n,1:n))),c(d[-1]-1,n))
```
[Try it online!](https://tio.run/##FYkxDsMgDAC/kmSyJRhYq@QlVYbEFLCUOgiD@nwapLvhdKWHabU9NKHKt4Aa2YTSUUDRxE3bqbWwRIzP8qv9JaYEs2/5Yjrqx8MY7iVDRDQE/m3dbp15sgdYvqw6yJkX7H8 "R – Try It Online")
Returns a (possibly empty) list of substrings.
*Thanks to Michael M for saving 7 bytes!*
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 8 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
ç↓‼►▐NVh
```
[Run and debug online](https://staxlang.xyz/#c=%C3%A7%E2%86%93%E2%80%BC%E2%96%BA%E2%96%90NVh&i=mississippi%0A%0AP+P+%26+C+G%0A%0AAAA%0A%0AAdam%0A&a=1&m=1)
The ascii representation of the same program is this.
```
c{[Ii=}(m
```
For each character, it splits when the index of the current character is the current position.
```
c            copy the input
 {    }(     split the string when the result of the enclosed block is truthy
  [          duplicate the input string under the top of the stack
   I         get the character index of the current character
    i=       is it equal to the iteration index?
        m    print each substring
```
[Answer]
# [><>](https://esolangs.org/wiki/Fish), ~~22 17~~ 14 bytes
*-1 byte thanks to Emigna*
```
i:::a$1g?!o1po
```
[Try it online!](https://tio.run/##S8sszvj/P9PKyipRxTDdXjHfsCD////czOJiECooyAQA "><> – Try It Online")
Prints a leading and trailing newline. 
It keeps track of which letters have already appeared by `p`utting a copy of the character at that corresponding spot on the second row, and printing a newline if the value fetched from that position was not 1. Ends in an error when it tries to print `-1`
[Answer]
## Haskell, 62 bytes
```
r#c|any(elem c)r=init r++[last r++[c]]|1<2=r++[[c]]
foldl(#)[]
```
[Try it online!](https://tio.run/##ZYk7DsIwEAX7nGLlUCSKUkCNC58juFj5AyvWjmWnQcrZMbLSBekV82ZeWN6OuXr5qH5ly0M/LrrLvdkxfgbHLoAZs6RIG@RpWhjLAUbr/Xq/ycbt1IAUQYJdOwBImeIGF/AgApXSlhKJU1IWw59T6qxE/RrP@Cx1Nin9AA "Haskell – Try It Online")
[Answer]
# JavaScript (ES6), 68 bytes
```
s=>s.map(c=>o[c]?t+=c:(t&&m.push(t),t=o[c]=c),t='',o=m=[])&&[...m,t]
```
Takes input as a list of characters.
**Test cases:**
```
let f=
s=>s.map(c=>o[c]?t+=c:(t&&m.push(t),t=o[c]=c),t='',o=m=[])&&[...m,t]
console.log(f([...'mississippi']));
console.log(f([...'P P & C G']));
console.log(f([...'AAA']));
console.log(f([...'Adam']));
console.log(f([...'']));
```
[Answer]
# PHP, 317 bytes
```
function SplitOnFirstUnique($s){
    $len = strlen($s); 
    $output = [];
    $newstring = '';
    for ($i=0; $i < $len ; $i++) { 
        $newstring = $newstring.$s[$i];
        if(!in_array($s[$i] , $output  )){
            $output[] = $newstring;
            $newstring = '';
        }
    }
    return $output;
}
```
[Try it online!](https://tio.run/##bU7LCsIwELz3K9YSMEER71G8efUgnoqISKsLul03CSLit9eE@EB0CGEzMzsZPnA3mfGBCxYkvxG95CP6Bc1RnF8RnkOtyxM6lw4zlsbYrgm089gS/DErZ24FRKhjTTAF5yUOibaQ@TZ4Dj5K1dpmhupLtCHtI9nvZ7JpBbTC6diCQpjkuDQPBgZuOepn@fMYKVcpfH6QgI3uIW22IturziIM32XAPFu/Y7NQrb9S7bfnX@@Ee/G5pfZB6JVni3vXPQA "PHP – Try It Online")
[Answer]
# [Red](http://www.red-lang.org), 79 bytes
```
func[s][foreach c next unique/case append s"^@"[print copy/part s s: find s c]]
```
[Try it online!](https://tio.run/##dcqxCsIwFIXhPU9x6OAm3TtZHFyLa4gQkhvM0PSa20Kl5NmjRXDr4Wz/l8nXO3loo0JXw5KcFqPDlMm6JxwSrTOWFF8Ltc4KwTJT8pDmcWk055hmuInfLds8QyAdQtw7nDE1YBujyH7mWNTPb@f/ivqSAQNOuOJ2BPq@P0zejketqPoB "Red – Try It Online")
## Ungolfed:
```
f: func [s] [
    b: next unique/case append s "^@"  ; append `null` to the end of the string, than
                                       ; find the unique characters and 
                                       ; store all except the first to b  
    foreach c b [                      ; for each character in b
        print copy/part s s: find s c  ; print the part of the string to
                                       ; where the character is found and
                                       ; set the beginning of the string to that position
    ]
] 
```
[Answer]
# [SNOBOL4 (CSNOBOL4)](http://www.snobol4.org/csnobol4/), ~~115~~ ~~91~~ 77 bytes
```
	N =INPUT
S	N LEN(1) . Y	:F(END)
	S =S Y
	N SPAN(S) . OUTPUT REM . N	:(S)
END
```
[Try it online!](https://tio.run/##K87LT8rPMfn/n9NPwdbTLyA0hCsYyPRx9dMw1FTQU4jktHLTcPVz0eTiDFawDVaI5ALKBgc4@mkEg6T9Q0OAWhSCXH2BHD9OK6AoF1D1//@5mcXFIFRQkAkA "SNOBOL4 (CSNOBOL4) – Try It Online")
Prints the substrings separated by newlines.
Explanation:
line `S` (for `SPLIT`) doesn't actually split, but instead extracts the first character of `N` and saves it (`.`) to `Y`. On `F`ailure, it jumps to `END`. The match should only fail when `N` is the empty string. Thus, when the input is empty, it jumps directly to `END` and outputs nothing.
`S = S Y` concatenates `Y` onto `S`.
`SPAN(S)` greedily matches a run of characters in `S`, and sends it (`.`) to `OUTPUT`, setting (`.`) `N` to the `REM`aining characters of `N` (if there are any). Then it jumps back to `S`.
[Answer]
# PowerShell, 73 bytes
```
{$r=@();$h=@{};[char[]]$ARGS[0]|%{if(!($h[$_]++)){$r+=""};$r[-1]+=$_};$r}
```
## Usage
```
PS> & {$r=@();$h=@{};[char[]]$ARGS[0]|%{if(!($h[$_]++)){$r+=""};$r[-1]+=$_};$r} "mississipi" | ConvertTo-Json -Compress
["m","i","ssissi","pi"]
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~65~~ ~~62~~ 58 bytes
```
->s,*a{s.size.times{|i|(i==s.index(c=s[i])?a:a[-1])<<c}
a}
```
[Try it online!](https://tio.run/##RY/NasMwEITveopFh8QujmivIWowOeTquxFla8lUELvCK0N@nGd3V0nrgnY1mvlWSMP4eZlbPW/eqXjBW/aqlCJF/upy1WG4TX7KvNakfG/dOWs01d7ke9xivXkz@W7X3AXe5@gofjRIjkBDLQBq2XmitELwskhnWUhW8umySIExRYLXFVSwggMc1wmtOGWD@yq1Q2rHP1aWZfm4MO2LZ7F7moxaLuTqljhFxggjxP9DlcPmC@w3TL4PYyzAnYNrorMTjwyOxlPkv7T1IzXshcH3cUn0wsMeZBaQKAcJW9Yt@hPrNPKLC9fbef4B)
A lambda accepting a string and returning an array of strings.
Approach: For each index, either append the character at that index in `s` to the result array, or to the last string in the result array. `String#index` returns the index of the first instance of the argument.
-2 bytes: Initialize `a` as a splat argument instead of on its own line. *Thanks, [Value Ink](https://codegolf.stackexchange.com/users/52194/value-ink)!*
-1 byte: Use `c=s[i]`...`c` instead of `s[i]`...`s[i]`. *Thanks, [Value Ink](https://codegolf.stackexchange.com/users/52194/value-ink)!*
-4 bytes: Use `.times` instead of `.map`
[Answer]
# Java 8, ~~193~~ ~~169~~ ~~155~~ 151 bytes
```
s->{for(int l=s.length(),i=0,j;i<l;i++)if(s.indexOf(s.charAt(i))==i){for(j=i;++j<l&&s.indexOf(s.charAt(j))!=j;);System.out.println(s.substring(i,j));}}
```
-14 bytes thanks to *@raznagul* (for something obvious I somehow missed myself..)  
-3 bytes thanks to *@O.O.Balance* (again for something obvious I somehow missed myself.. :S)
**Explanation:**
[Try it online.](https://tio.run/##jZE/b4MwEMX3foorA7IFQd0dV0IdOjWNlLHqYAwk5xqDOBO1ivjs1BDGDEh3kv/87vk92air2rVd5Uz5M2mriOBDobs9AaDzVV8rXcFh3gJcWyxBs5Pv0Z2BuAinY@hQ5JVHDQdwIGGi3eutbnsWFMBKymzlzv7CeIryJTUC91ZgknCsGWXoyur3c17pi@pzz5BzKZEvAkaiSBKzt3H8gDScP0sjuDj9ka@arB181gVv3roA0VDQ4pRhGkgxjpO4m@2Gwgazq@clVRMyr8G@vhW/53WZZlGDRHN1HUZLYoAHz603y8QRjhDDG7xv5PM830qWqtmIbsTUdsXCKlg7Wr9@nP4B)
```
s->{                    // Method with String parameter and no return-type
  for(int l=s.length(), //  The length of the input-String
          i=0,j;        //  Index integers
      i<l;i++)          //  Loop `i` from 0 to `l` (exclusive)
    if(s.indexOf(s.charAt(i))==i){
                        //   If the character at index `i` hasn't occurred yet:
      for(j=i;++j<l     //    Inner loop `j` from `i` to `l` (exclusive),
          &&s.indexOf(s.charAt(j))!=j;);
                        //     as long as the character at index `j` has already occurred
      System.out.println(//    Print:
        s.substring(i,j));}}
                        //     The substring of the input from index `i` to `j` (exclusive)
```
]