Schreiben Sie ein Programm , das eine Reihe von Nicht-Leerzeichen geht durch (Sie können davon ausgehen , dass sie Ziffern 0zu 9, aber nichts in der Art , wie sie verarbeitet werden sollen , hängt von dieser) und fügt Räume nach folgenden Regeln.

1. Das aktuelle Token sei die leere Zeichenfolge, und die zuvor ausgegebenen Token seien eine leere Menge.
2. Durchlaufen Sie die Zeichen der Zeichenfolge. Fügen Sie für jedes Zeichen zuerst das Zeichen an das aktuelle Token an. Wenn sich das aktuelle Token nicht bereits in der Gruppe der zuvor ausgegebenen Token befindet, fügen Sie das aktuelle Token zu dieser Gruppe hinzu und lassen Sie das neue aktuelle Token die leere Zeichenfolge sein.
3. Wenn Sie das Ende der Zeichenfolge erreichen und das aktuelle Token leer ist, geben Sie die zuvor ausgegebenen Token in der Reihenfolge ihrer Ausgabe aus, getrennt durch ein Leerzeichen. Andernfalls geben Sie die ursprüngliche Zeichenfolge wörtlich aus.

Eingang

Die Eingabe in die STDIN sollte eine Folge von Ziffern sein.

Ausgabe

Das Programm sollte das Ergebnis wie in Schritt 3 angegeben drucken.

Proben

Beispieleingaben

2015
10101010
4815162342
101010101010
3455121372425
123456789101112131415
314159265358979323846264338327950288419716939937

Beispielausgaben

2 0 1 5
10101010
4 8 1 5 16 2 3 42
1 0 10 101 01 010
3 4 5 51 2 1 37 24 25
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
3 1 4 15 9 2 6 5 35 8 97 93 23 84 62 64 33 83 27 95 0 28 841 971 69 39 937

Dies ist Codegolf, daher gelten Standard-CG-Regeln. Kürzestes Programm in Bytes gewinnt.

(Bitte fordern Sie Klarstellungen in den Kommentaren an. Ich bin noch neu darin. Danke!)

Pyth, 22 Bytes

 faW!}=+kTYY~kdz?tkzsY

Führender Raum ist wichtig.

Retina , 68 61 Bytes

+`\b(\w+?)(?<!\b\1 .*)(\w+)$
$1 $2
(?=.* (.+)$(?<=\b\1 .+)) 
<empty>

<empty>ist eine leere Zeile. Beachten Sie das nachfolgende Leerzeichen in Zeile 3. Sie können den obigen Code aus einer einzelnen Datei mit dem -sFlag ausführen .

Erläuterung

+`\b(\w+?)(?<!\b\1 .*)(\w+)$
$1 $2

In diesem ersten Schritt werden die Regeln 1 bis 6 implementiert. Es handelt sich um eine reguläre Ersetzung, die wiederholt angewendet wird, bis sich die Zeichenfolge nicht mehr ändert (wofür +ist die vorgesehen). In jedem Schritt fügen wir der Zeichenfolge ein einzelnes Leerzeichen von links nach rechts hinzu (gemäß den Regeln der Herausforderung). Der reguläre Ausdruck entspricht der kürzesten Zeichenfolge, die nicht im bereits verarbeiteten Teil der Zeichenfolge enthalten ist. Wir stellen sicher, dass wir ein Präfix der verbleibenden Zeichenfolge mit der Wortgrenze betrachten \bund überprüfen, ob wir das Ende der Zeichenfolge erreichen können, ohne Leerzeichen mit zu übergeben (\w+)$. Letzteres stellt auch sicher, dass wir nur einen Austausch pro Schritt durchführen.

(?=.* (.+)$(?<=\b\1 .+)) 
<empty>

Dies entspricht jedem Leerzeichen (das sich am Ende des regulären Ausdrucks befindet), vorausgesetzt, das letzte Segment der Zeichenfolge ist dasselbe wie jedes andere Segment in der Zeichenfolge und ersetzt sie durch die leere Zeichenfolge. Das heißt, wir machen den ersten Schritt rückgängig, wenn er zu einem ungültigen Endsegment geführt hat, und implementieren Regel 7.

Pyth, 24 23 Bytes

VzI!}=+kNYaY~k"";?kzjdY

Probieren Sie es hier aus .

VzI!}=+kNYaY~k"";?kzjdY    Implicit: z=input(), k='', Y=[], d=' '
Vz              ;          For N in z:
     =+kN                    Append N to k
  I!}    Y                   Is the above not in Y?
          aY k               Append k to Y
            ~k""             After append, reset k to ''
                 ?k        Is k truthy (i.e. not '')
                   z       Print original input
                    jdY    Otherwise print Y joined on spaces

Danke an @FryAmTheEggman für das Speichern eines Bytes: o)

Python 3, 92 Bytes

i,n,*o=input(),""
for c in i:n+=c;o,n=[o+[n],o,"",n][n in o::2]
print([" ".join(o),i][n>""])

Grundsätzlich eine stark golfene Version von @Willems Lösung.

Python 3, 100 99 Bytes

o=[];n="";i=input()
for c in i:
 n+=c
 if not n in o:o.append(n);n=""
print(i if n else" ".join(o))

Brachylog , 91 Bytes

:_:_{h:0<|bhN,?hh:NrcH,?hB(l1,-1=A;BbA),?rhL:I(mH:Ar:[L]c:1&;:[H]:\"~w \"w,L:[H]c:_:Ar:1&)}

Dadurch wurde mir klar, dass es eine Menge Dinge an der Syntax gibt, die ich ändern muss ...

Erläuterung

:_:_              § Creates a list [Input,[],[]] 
{...}             § Define a new predicate between the brackets and call it with the previous list as input
h:0<              § If the head of the input is negative, stop
|                 § Else
bhN,              § Second element of Input is called N
?hh:NrcH,         § N concatenated with the first element of Input is H
?hB(l1,-1=A;BbA), § Remaining digits A are either -1 if there's only one digit left or all the digits but the head otherwise
?rhL:I            § List of used integers is called L
(
   mH:Ar:[L]c:1&  § If H is already in L, call the predicate with input [A,H,L]
   ;              § Else
   :[H]:\"~w \"w, § Print H followed by a space
   L:[H]c:_:Ar:1& § Call the predicate with input [A,[],M] where M is L with H appended to it
)

CJam, 26 Bytes

LLq{+_a2$&{a+L}|}/:X+X!S**

Teste es hier.

Erläuterung

L        e# Push an empty array to keep track if the previous segments.
L        e# Push an empty array to build the current segment.
q{       e# For each character in the input...
  +      e#   Add it to the current segment.
  _a2$&  e#   Duplicate and check if it's already in the segment list.
  {      e#   If not...
    a+L  e#     Add it to the list and push a new empty array for the next segment.
  }|
}/
:X+      e# Store the trailing segment in X and add it's *characters* to the list.
         e# For valid splittings, this trailing segment will be empty, so that the
         e# list remains unchanged.
X!       e# Push X again and take the logical NOT.
S*       e# Get that many spaces, i.e. 1 for valid segments and 0 otherwise.
*        e# Join the list with this string between elements.

JavaScript (ES6), 109

Mein Ausgabeformat stimmt nicht genau mit den Ausgabebeispielen in der Questioin überein (es gibt ein führendes Leerzeichen). Ich sehe das nicht als Fehler, da das Ausgabeformat nicht spezifiziert ist (nur das Programm sollte die Nummer nach der Nummer ausgeben ... )

Testen Sie das folgende Snippet in einem EcmaScript 6-kompatiblen Browser. Entwickelt mit Firefox, getestet und lauffähig auf dem neuesten Chrome.

/* Test: redirect console.log */ console.log=x=>O.innerHTML+=x+'\n';

F=s=>{for(z=s,b=l=o=' ';s[+l];)~o.search(b+(n=s.slice(0,++l)+b))||(s=s.slice(l),o+=n,l=0);console.log(s?z:o)}

/* Test cases */
test = [
  '2015',
,'10101010'
,'4815162342'
,'101010101010'
,'3455121372425'
,'123456789101112131415'
,'11312123133'
,'314159265358979323846264338327950288419716939937']

test.forEach(t=>{console.log('\n'+t);F(t)})

<pre id=O></pre>

GNU sed, 83 77 73 71 Bytes

(Erziele ein Extra, weil wir eine -rFlagge benötigen )

h
s/./&_/
:
/(\b[^ ]+).*\b\1_/{
s/_(.)/\1_/
t
g
}
s/_(.)/ \1_/
t
s/_//

Die innere Schleife prüft auf eine wiederholte Sequenz und fügt nach Bedarf Zeichen hinzu, bis nach dem Trennzeichen eine eindeutige Nummer angezeigt wird _. Die äußere Schleife bewegt sich_ entlang.

Erweiterte, kommentierte Version:

#!/bin/sed -rf

# Stash original in hold space
h

# Add separator
s/./&_/

:
# If current candidate is a duplicate, ...
/(\b[^ ]+).*\b\1_/{
#  ...then attempt to lengthen it ...
s/_(.)/\1_/
# ... and repeat if we succeeded, ...
t
# ... otherwise, restore original string
g
}
# Insert a space, and move our separator along
s/_(.)/ \1_/
t

# Remove the separator if we still have it
s/_//

Ruby, 57 + 1 = 58 Bytes

s=''
l={}
$_.chars{|c|l[s<<c]||=s=''}
l[s]||$_=l.keys*' '

Verwendet das Befehlszeilenflag -p(oder plwenn Ihre Eingabe eine nachgestellte Newline enthält). Nutzt mehrere Merkmale von Ruby Hash-Wörterbüchern aus: Sie können die Zeichenfolge, die Sie zum Definieren eines Schlüssels verwendet haben, sicher ändern, ohne den Schlüssel zu ändern (was bei anderen veränderbaren Typen nicht funktioniert). Sie geben .keysdie Schlüssel in der Reihenfolge zurück, in der sie eingefügt wurden, und den []||=Operator bietet eine knappe Möglichkeit, um zu verzweigen, ob ein bestimmter Schlüssel bereits vorhanden ist.

Haskell, 105 Bytes

f macht es.

e""s""=unwords s
e t s""=concat s++t
e t s(c:r)|t&c`elem`s=e(t&c)s r|0<1=e""(s&(t&c))r
a&b=a++[b]
f=e""[]

PHP - 148 Bytes

Coole Herausforderung, viel Spaß!

$x=fgets(STDIN);$w=array();$k='';$l='';for($i=0;$i<strlen($x);$i++){$k.=$x[$i];if(!isset($w[$k])){$l.=$k.' ';$w[$k]=1;$k='';}}echo strlen($k)?$x:$l;