Relacionado.

Dada uma sequência ASCII imprimível, divida-a em uma lista de seqüências não vazias com uma nova sub-sequência iniciando sempre que um caractere, que não foi visto anteriormente no mesmo caso, ocorre.

Exemplos

"mississippi" → ["m","i","ssissi","ppi"]

"P P & C G" → ["P"," P ","& ","C ","G"]

"AAA" → ["AAA"]

"Adam" → ["A","d","a","m"]

"" → []

Gelatina , 4 bytes

QƤĠị

Experimente online!

Explicação

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"]

A representação interna das seqüências de caracteres, que o link TIO exibe, é um pouco diferente.

Retina , 9 bytes

q1,`.
¶$&

Experimente online!

Explicação

Combine cada caractere ( .), descarte as correspondências repetidas ( q), descarte a primeira correspondência ( 1,) e insira um avanço de linha na frente de cada correspondência ¶$&.

05AB1E , 11 bytes

ÙSk¥sg¸«£õK

Experimente online!

Explicação

Ù             # 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 "" -> [])

C,  75   65  63 bytes

Agradecemos ao @Digital Trauma por salvar 10 bytes e obrigado a @gastropner e @ l4m2 por salvar um byte cada!

f(char*s){for(int l[128]={};*s;putchar(*s++))l[*s]++||puts(l);}

Imprime uma nova linha principal.

Experimente online!

Sem uma nova linha principal (71 bytes):

f(char*s){int l[128]={};for(l[*s]=1;*s;putchar(*s++))l[*s]++||puts(l);}

Experimente online!

Perl 6 ,  58 52  40 bytes

{$/={};.comb.classify({$+=!$/{$_}++}).sort».value».join}

Tente

*.comb.classify({$+=!(%){$_}++}).sort».value».join

Tente

*.classify({$+=!(%){$_}++}).sort».value

Experimente
(entrada é uma lista de caracteres e saída é uma lista de listas de caracteres)

Expandido:

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

A saída de classifyé

{ # Hash
  1 => ['m'],
  2 => ['i'],
  3 => ['s','s','i','s','s','i'],
  4 => ['p','p','i'],
}

E .sortapenas transforma em:

[
  1 => ['m'],
  2 => ['i'],
  3 => ['s','s','i','s','s','i'],
  4 => ['p','p','i'],
]

».value remove as chaves

[
  ['m'],
  ['i'],
  ['s','s','i','s','s','i'],
  ['p','p','i'],
]

J , 7 bytes

~:<;.1]

Experimente online!

Explicação

A chance da peneira de Nub brilhar!

~: <;.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

APL (Dyalog Unicode) , 8 bytes ^SBCS

(≢¨∪\)⊆⊢

Experimente online!

05AB1E , 8 bytes

Ùvyy¶ì.;

Experimente online!

Sempre produzirá 1 nova linha anterior, que é constante e não indica uma divisão, a alternativa de 10 bytes que não gera uma nova linha anterior é Ùvyy¶ì.;}¦, você pode tentar isso aqui . Segundo Adam, uma nova linha anterior ou posterior é aceitável.

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']

Após cada iteração, obtemos:

['\nmississippi'] > ['\nm\nississippi'] > ['\nm\ni\nssissippi'] > ['\nm\ni\nssissi\nppi']

Qual é:

m
i
ssissi
ppi

Haskell , 39 bytes

foldl(\s c->s++['\n'|all(/=c)s]++[c])""

Experimente online!

Insere um símbolo de nova linha antes de cada caractere que aparece pela primeira vez, resultando em uma sequência separada por nova linha, com uma nova linha inicial. Anexar lines.para produzir uma lista.

Haskell , 55 bytes

(""%)
_%[]=[]
p%s|(a,b)<-span(`elem`s!!0:p)s=a:(a++p)%b

Experimente online!

Pega o prefixo repetidamente no primeiro caractere mais os caracteres não exclusivos que o seguem.

APL (Dyalog) , 9 bytes

Obrigado, Erik, o Outgolfer, por economizar 1 byte!

⊢⊂⍨⍳∘≢∊⍳⍨

Experimente online!

Explicação:

⍳⍨: Para cada caractere, obtenha o índice de sua primeira ocorrência. por exemplomississippi -> 1 2 3 3 2 3 3 2 9 9 2

⍳∘≢: O intervalo de 1 ao comprimento da entrada.

∊: Assinatura. por exemplo1 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

⊢⊂⍨: Particione a sequência de entrada com novas partições começando em 1s no vetor acima

Japonês , 11 bytes

‰ r@=iRUbY

Teste online!

Explicação

Isto foi inspirado por Magia Octopus Urna 's solução 05AB1E .

‰ 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.

JavaScript (ES6), 37 bytes

Economizou 7 bytes: uma nova linha principal foi explicitamente permitida (Obrigado @Shaggy!)

Recebe a entrada como uma matriz de caracteres. Gera uma sequência separada por nova linha.

s=>s.map(c=>s[c]=s[c]?c:`
`+c).join``

Casos de teste

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

brainfuck, 66 bytes

,[>+[<[>+<<-<+>>-]>[>]<<[[+]++++++++++.>>>]<]<[>+<-]>>>[>>]<<-.>,]

Formatado:

,
[
  >+
  [
    <[>+< <-<+>>-]
    >[>]
    <<[[+]++++++++++.>>>]
    <
  ]
  <[>+<-]
  >>>[>>]
  <<-.>,
]

Experimente online

A nova linha principal na saída (que é impressa apenas se a entrada não estiver vazia) pode ser removida ao custo de 5 bytes, substituindo o corpo xdo loop principal (mais externo) por .>,[x].

Gelatina , 6 bytes

ŒQœṗ⁸Ḋ

Experimente online!

K4 , 19 bytes

Solução:

$[#x;(*:'.=x)_;,]x:

Exemplos:

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:""
,[""]

Explicação:

8 bytes é apenas para lidar com ""...

$[#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, "" => [""]

Python 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:])

Experimente online!

Python 2 , 47 bytes

lambda s:reduce(lambda r,c:r+'\n'[c in r:]+c,s)

Experimente online!

Gera uma sequência separada por nova linha. Mal bate a versão do programa:

Python 2 , 48 bytes

r=''
for c in input():r+='\n'[c in r:]+c
print r

Experimente online!

Perl, 30 bytes

Inclui +1parap

Dê entrada sem rastrear nova linha no STDIN. A saída também é sem nova linha à direita:

echo -n adam | perl -pE 's%.%$v{$&}+++!pos?$&:$/.$&%eg'; echo

Se você não se preocupam esquerda e à direita newlines este 25( +3para -pporque o código contém ') também funciona:

#!/usr/bin/perl -p
s%%$/x!$v{$'&~v0}++%eg

JavaScript, 61 54 52 bytes

Recebe a entrada como uma matriz de caracteres.

s=>s.map(x=>a[x]?a[y]+=x:a[x]=a[++y]=x,a=[],y=-1)&&a

Tente

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>

R , 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))

Experimente online!

Retorna uma lista (possivelmente vazia) de substrings.

Agradecimentos a Michael M por economizar 7 bytes!

Stax , 8 bytes

ç↓‼►▐NVh

Executar e depurar online

A representação ascii do mesmo programa é essa.

c{[Ii=}(m

Para cada caractere, ele é dividido quando o índice do caractere atual é a posição atual.

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

> <> , 22 17 14 bytes

-1 byte graças a Emigna

i:::a$1g?!o1po

Experimente online!

Imprime uma nova linha inicial e final.

Ele rastreia quais letras já apareceram, pcitando uma cópia do caractere no local correspondente na segunda linha e imprimindo uma nova linha se o valor buscado nessa posição não for 1. Termina com um erro ao tentar imprimir-1

Haskell, 62 bytes

r#c|any(elem c)r=init r++[last r++[c]]|1<2=r++[[c]]
foldl(#)[]

Experimente online!

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]

Recebe a entrada como uma lista de caracteres.

Casos de teste:

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([...'']));

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;
}

Experimente online!

Vermelho , 79 bytes

func[s][foreach c next unique/case append s"^@"[print copy/part s s: find s c]]

Experimente 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
    ]
] 

SNOBOL4 (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

Experimente online!

Imprime as substrings separadas por novas linhas.

Explicação:

A linha S(for SPLIT) não é dividida, mas extrai o primeiro caractere de Ne salva ( .) em Y. Na Fdoença, ele pula para END. A correspondência só deve falhar quando Né a string vazia. Assim, quando a entrada está vazia, ela salta diretamente para ENDe não produz nada.

S = S Yconcatena Yem S.

SPAN(S)corresponde avidamente a uma série de caracteres Se a envia ( .) para OUTPUT, definindo ( .) Npara os REMcaracteres finais de N(se houver algum). Então ele volta para S.

PowerShell, 73 bytes

{$r=@();$h=@{};[char[]]$ARGS[0]|%{if(!($h[$_]++)){$r+=""};$r[-1]+=$_};$r}

Uso

PS> & {$r=@();$h=@{};[char[]]$ARGS[0]|%{if(!($h[$_]++)){$r+=""};$r[-1]+=$_};$r} "mississipi" | ConvertTo-Json -Compress
["m","i","ssissi","pi"]

Ruby , 65 62 58 bytes

->s,*a{s.size.times{|i|(i==s.index(c=s[i])?a:a[-1])<<c}
a}

Experimente online!

Um lambda aceitando uma string e retornando uma matriz de strings.

Abordagem: para cada índice, acrescente o caractere nesse índice sà matriz de resultados ou à última sequência da matriz de resultados. String#indexretorna o índice da primeira instância do argumento.

-2 bytes: inicialize acomo um argumento de splat em vez de em sua própria linha. Obrigado, Value Ink !

-1 byte: Use c=s[i]... cem vez de s[i]... s[i]. Obrigado, Value Ink !

-4 bytes: use em .timesvez de.map

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 graças a @raznagul (por algo óbvio, de alguma forma, senti falta de mim ..)
-3 bytes graças a @OOBalance (novamente por algo óbvio, de alguma forma, senti falta de mim mesmo ..: S)

Explicação:

Experimente online.

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)