Data una stringa, il tuo compito è comprimerlo in una struttura a zig-zag come descritto di seguito.

Piegare in uno zigzag

Prenderemo la stringa "Mississippi"come esempio:

1. Innanzitutto, genera il prefisso più lungo composto solo da caratteri univoci:

   Mis
   

2. Quando si raggiunge il primo carattere duplicato C , ignorarlo e generare il prefisso più lungo costituito da caratteri univoci della stringa rimanente ( issippi) in verticale, sotto la prima occorrenza di C :

   Mis
     i
     s
   

3. Ripetere il processo, alternando la continuazione orizzontale e verticale. Ma ora fai attenzione (al passaggio 1) per continuare a emettere in orizzontale dall'ultima occorrenza del carattere duplicato, che non è necessariamente l'ultimo, come in questo caso:

   Mis
     i
     sip
   -----
   Mis
     i
     sip
       i
   

Regole

• La stringa conterrà solo caratteri ASCII stampabili, ma non conterrà alcun tipo di spazio bianco.
• Puoi competere in qualsiasi linguaggio di programmazione e prendere input e fornire output attraverso qualsiasi metodo standard e in qualsiasi formato ragionevole ¹ , tenendo presente che queste scappatoie sono vietate per impostazione predefinita. Questo è code-golf , quindi vince l'invio più breve (in byte) per ogni lingua .
• ¹ Input: String / Elenco di caratteri / qualunque altra cosa la tua lingua usi per rappresentare le stringhe. Output: stringa multilinea, elenco di stringhe che rappresentano linee o elenco di elenchi di caratteri / stringhe di lunghezza 1, ma, se possibile, includi una versione stampata del codice nella tua risposta.
• Per quanto riguarda gli spazi aggiuntivi, l'output può contenere:
  • Newline leader / finali
  • Spazi finali su ogni riga / alla fine
  • Un numero consistente di spazi iniziali su ogni riga
• Devi iniziare a produrre in orizzontale, potresti non iniziare in verticale.

Casi test

ingressi:

"Perfetto"
"Mississippi"
"stranezze"
"Trivialities"
"Cthulhu"
"PPCG"
"POpOpOpOpOpOp"
"ABCCCE"
"ABCCCECCEEEEC"
"Abcdcebffg"
"ABCA"
"AAAAAAAA"

Uscite corrispondenti:

Perf
 c
 t

Mis
  io
  sorso
    io

od
 ies
 t

Triv
  un'
  l
  ies
  t

Cthul
  u

P
C
sol

pO 
Opo
pop
 p

ABC
  C
  E

ABC
  CCE
  E CE

abcd
  e
  B
  fg

abc

UN
aa
 UN

Wolfram Language (Mathematica) , 143 byte

{#}//.{q___,a_,r___,a_,Longest@s___}:>{q}~f@{a,r}~{{s}}//.{q_~f@a_~s_}/;s~FreeQ~f:>(PadLeft@{q~Join~#,##2}&)@@PadRight@Join[{a},s]/. 0->" "&

Provalo online!

Contiene 0xF8FF, che corrisponde \[Transpose]all'operatore.

Uff, è stato difficile trasformare il risultato in una stringa. Ottenere ogni ramo non è così difficile:#//.{q___,a_,r___,a_,Longest@s___}:>{q,a,{r},{s}}&

Python 2 , 131 byte

X=Y=y=0
s=input()
o=()
l={}
for i in s:o+=[' ']*len(s),;exec('l[i]=X,Y','y^=1;X,Y=l[i];l={}')[i in l];o[Y][X]=i;X+=y<1;Y+=y
print o

Provalo online!

-1 grazie a Lynn .

Stampa come una tupla di elenchi di stringhe di lunghezza 1. Stampa piuttosto stampata .

Python 2 , 184 176 175 168 byte

^{-5 byte grazie a Mr. Xcoder}

def f(x):i,k=[p for p in enumerate(map(x.find,x+"z"))if cmp(*p)][0];return[x[:i]+' '*len(x)]+[' '*k+''.join(d)+i*' 'for d in zip(*f(x[i+1:]))]if x[len(set(x)):]else[x,]

Provalo online!

CJam , 81 byte

{_,_S*a*a\+{__L#){V!:V;L#)LM:L;=~:U;:T}{[TU]a+L+:L}?;U@_U=T4$tt\;TV!+:T;UV+:U;}*}

Provalo online!