Relacionado.

Dada una cadena ASCII imprimible, divídala en una lista de cadenas no vacías con una nueva subcadena que comienza cada vez que aparece un carácter, que no se ha visto previamente en el mismo caso.

Ejemplos

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

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

"AAA" → ["AAA"]

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

"" → []

Jalea , 4 bytes

QƤĠị

Pruébalo en línea!

Explicación

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

La representación interna de las cadenas, que muestra el enlace TIO, es ligeramente diferente.

Retina , 9 bytes

q1,`.
¶$&

Pruébalo en línea!

Explicación

Haga coincidir cada carácter ( .), descarte las coincidencias repetidas ( q), descarte la primera coincidencia ( 1,) e inserte un salto de línea delante de cada coincidencia ¶$&.

05AB1E , 11 bytes

ÙSk¥sg¸«£õK

Pruébalo en línea!

Explicación

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

¡Gracias a @Digital Trauma por guardar 10 bytes y gracias a @gastropner y @ l4m2 por guardar un byte cada uno!

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

Imprime una nueva línea líder.

Pruébalo en línea!

Sin una nueva línea principal (71 bytes):

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

Pruébalo en línea!

Perl 6 ,  58 52  40 bytes

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

Intentalo

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

Intentalo

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

Pruébelo
(la entrada es una lista de caracteres y la salida es una 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

La salida de classifyes

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

Y .sortsolo lo convierte en:

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

».value quita las llaves

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

J , 7 bytes

~:<;.1]

Pruébalo en línea!

Explicación

¡La oportunidad de Tam tam para brillar!

~: <;.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) , ^{SBCS de} 8 bytes

(≢¨∪\)⊆⊢

Pruébalo en línea!

05AB1E , 8 bytes

Ùvyy¶ì.;

Pruébalo en línea!

Siempre generará 1 nueva línea anterior, que es constante y no indica una división, la alternativa de 10 bytes que no genera una nueva línea anterior es Ùvyy¶ì.;}¦, puede intentarlo aquí . Según Adam, una nueva línea anterior o posterior es aceptable.

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

Después de cada iteración obtenemos:

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

Cual es:

m
i
ssissi
ppi

Haskell , 39 bytes

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

Pruébalo en línea!

Inserta un símbolo de nueva línea antes de cada carácter que aparece por primera vez, lo que resulta en una cadena separada por una nueva línea, con una nueva línea inicial. Anteponer lines.para producir una lista.

Haskell , 55 bytes

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

Pruébalo en línea!

Toma el prefijo repetidamente el primer carácter más los caracteres no únicos que lo siguen.

APL (Dyalog) , 9 bytes

¡Gracias, Erik the Outgolfer por guardar 1 byte!

⊢⊂⍨⍳∘≢∊⍳⍨

Pruébalo en línea!

Explicación:

⍳⍨: Para cada personaje, obtenga el índice de su primera aparición. p.ejmississippi -> 1 2 3 3 2 3 3 2 9 9 2

⍳∘≢: El rango de 1 a la longitud de la entrada.

∊: Afiliación. p.ej1 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

⊢⊂⍨: Particionar la cadena de entrada con nuevas particiones que comienzan en 1s en el vector de arriba

Japt , 11 bytes

‰ r@=iRUbY

¡Pruébelo en línea!

Explicación

Esto fue inspirado por la magia pulpo Urna 's solución 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

Se guardaron 7 bytes: se permitió explícitamente una nueva línea principal (¡Gracias @Shaggy!)

Toma la entrada como una matriz de caracteres. Emite una cadena separada por una nueva línea.

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

Casos de prueba

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

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

Formateado:

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

Pruébalo en línea

La nueva línea inicial en la salida (que solo se imprime si la entrada no está vacía) se puede eliminar a un costo de 5 bytes reemplazando el cuerpo xdel bucle principal (más externo) con .>,[x].

Jalea , 6 bytes

ŒQœṗ⁸Ḋ

Pruébalo en línea!

K4 , 19 bytes

Solución:

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

Ejemplos:

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

Explicación:

8 bytes es solo para manejar ""...

$[#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:])

Pruébalo en línea!

Python 2 , 47 bytes

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

Pruébalo en línea!

Emite una cadena separada por una nueva línea. Apenas supera la versión del programa:

Python 2 , 48 bytes

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

Pruébalo en línea!

Perl, 30 bytes

Incluye +1parap

Dar entrada sin seguir la nueva línea en STDIN. La salida también es sin línea nueva:

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

Si no se preocupan por las nuevas líneas iniciales y finales de este 25( +3por -pya que el código contiene ') también trabaja:

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

JavaScript, 61 54 52 bytes

Toma la entrada como una matriz de caracteres.

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

Intentalo

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

Pruébalo en línea!

Devuelve una lista (posiblemente vacía) de subcadenas.

¡Gracias a Michael M por guardar 7 bytes!

Stax , 8 bytes

ç↓‼►▐NVh

Ejecutar y depurar en línea

La representación ascii del mismo programa es esta.

c{[Ii=}(m

Para cada carácter, se divide cuando el índice del carácter actual es la posición actual.

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 gracias a Emigna

i:::a$1g?!o1po

Pruébalo en línea!

Imprime una nueva línea inicial y final.

Realiza un seguimiento de las letras que ya han aparecido pemitiendo una copia del carácter en ese punto correspondiente en la segunda fila e imprimiendo una nueva línea si el valor obtenido desde esa posición no era 1. Finaliza un error cuando intenta imprimir-1

Haskell, 62 bytes

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

Pruébalo en línea!

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]

Toma la entrada como una lista de caracteres.

Casos de prueba:

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

Pruébalo en línea!

Rojo , 79 bytes

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

Pruébalo en línea!

Sin golf:

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

Pruébalo en línea!

Imprime las subcadenas separadas por nuevas líneas.

Explicación:

line S(for SPLIT) en realidad no se divide, sino que extrae el primer carácter de Ny lo guarda ( .) en Y. En una Fenfermedad, salta a END. La coincidencia solo debe fallar cuando Nes la cadena vacía. Por lo tanto, cuando la entrada está vacía, salta directamente ENDy no genera nada.

S = S Yconcatena Yen S.

SPAN(S)codiciosamente hace coincidir una serie de caracteres Sy los envía ( .) a OUTPUT, estableciendo ( .) Na los REMcaracteres principales de N(si hay alguno). Luego vuelve a saltar 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}

Pruébalo en línea!

Una lambda que acepta una cadena y devuelve una serie de cadenas.

Enfoque: para cada índice, agregue el carácter en ese índice en sla matriz de resultados o en la última cadena de la matriz de resultados. String#indexdevuelve el índice de la primera instancia del argumento.

-2 bytes: Inicialice acomo un argumento splat en lugar de en su propia línea. ¡Gracias, Value Ink !

-1 bytes: Uso c=s[i]... cen lugar de s[i]... s[i]. ¡Gracias, Value Ink !

-4 bytes: usar en .timeslugar 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 gracias a @raznagul (por algo obvio que de alguna manera me extrañé ...)
-3 bytes gracias a @OOBalance (de nuevo por algo obvio que de alguna manera me extrañé ..: S)

Explicación:

Pruébalo en línea.

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)