Ecrire un programme qui passe par une chaîne de caractères non-blancs (vous pouvez supposer qu'ils sont des chiffres 0à 9, mais rien dans la façon dont ils doivent être traités en dépend) et ajoute des espaces selon les règles suivantes.

1. Soit le jeton actuel la chaîne vide et les jetons précédemment émis un ensemble vide.
2. Parcourez les caractères de la chaîne. Pour chaque personnage, ajoutez d'abord le personnage au jeton actuel. Ensuite, si le jeton actuel n'est pas déjà dans l'ensemble des jetons précédemment émis, ajoutez le jeton actuel à cet ensemble et laissez le nouveau jeton actuel être la chaîne vide.
3. Si lorsque vous atteignez la fin de la chaîne, le jeton actuel est vide, sortez les jetons précédemment émis par ordre d'émission, séparés par un caractère espace. Sinon, affichez la chaîne originale textuellement.

Contribution

L'entrée du STDIN doit être une séquence de chiffres.

Sortie

Le programme doit imprimer le résultat comme spécifié à l'étape 3.

Échantillons

Exemples d'entrées

2015
10101010
4815162342
101010101010
3455121372425
123456789101112131415
314159265358979323846264338327950288419716939937

Exemples de sorties

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

C'est du golf de code, donc les règles CG standard s'appliquent. Le programme le plus court en octets gagne.

(Veuillez demander des éclaircissements dans les commentaires. Je ne suis pas encore au courant. Merci!)

Pyth, 22 octets

 faW!}=+kTYY~kdz?tkzsY

L'espace de tête est important.

Rétine , 68 61 octets

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

<empty>est une ligne vide. Notez l'espace de fin sur la ligne 3. Vous pouvez exécuter le code ci-dessus à partir d'un seul fichier avec l' -sindicateur.

Explication

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

Cette première étape implémente les règles 1 à 6. Il s'agit d'une substitution d'expression régulière qui est appliquée à plusieurs reprises jusqu'à ce que la chaîne cesse de changer (c'est à cela que +sert). À chaque étape, nous ajoutons un seul espace dans la chaîne de gauche à droite (en suivant les règles du défi). L'expression régulière correspond à la chaîne de chiffres la plus courte qui n'apparaît pas dans la partie déjà traitée de la chaîne. Nous nous assurons que nous regardons un préfixe de la chaîne restante avec le mot limite \bet vérifions que nous pouvons atteindre la fin de la chaîne sans passer d'espaces avec (\w+)$. Ce dernier garantit également que nous n'effectuons qu'un seul remplacement par étape.

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

Cela correspond à n'importe quel espace (qui se trouve à la fin de l'expression régulière), à ​​condition que le dernier segment de la chaîne soit le même que tout autre segment de la chaîne, et les remplace par la chaîne vide. Autrement dit, nous annulons la première étape si elle aboutissait à un segment final non valide, mettant en œuvre la règle 7.

Pyth, 24 23 octets

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

Essayez-le ici .

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

Merci à @FryAmTheEggman d'avoir enregistré un octet: o)

Python 3, 92 octets

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

Fondamentalement, une version très golfée de la solution de @ Willem.

Python 3, 100 99 octets

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 octets

:_:_{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&)}

Cela m'a fait réaliser qu'il y a beaucoup de choses sur la syntaxe que je dois changer ...

Explication

:_:_              § 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 octets

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

Testez-le ici.

Explication

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

Mon format de sortie n'est pas exactement le même que celui des échantillons de sortie dans la quête (il y a un espace de tête). Je ne vois pas cela comme un défaut, car le format de sortie n'est pas spécifié (juste Le programme devrait imprimer le numéro après le numéro ... )

Testez l'exécution de l'extrait ci-dessous dans un navigateur compatible EcmaScript 6. Développé avec Firefox, testé et fonctionnant sur le dernier 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 octets

(Marquez un extra parce que nous avons besoin d'un -rdrapeau)

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

La boucle interne teste une séquence répétée et ajoute des caractères selon les besoins jusqu'à ce qu'un numéro unique apparaisse après le séparateur _. La boucle extérieure se déplace_ .

Version étendue et annotée:

#!/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 octets

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

Utilise l'indicateur de ligne de commande -p(ou plsi votre entrée a une nouvelle ligne de fin). Exploite plusieurs traits des dictionnaires Ruby Hash: vous pouvez muter en toute sécurité la chaîne que vous avez utilisée pour définir une clé sans que cela change la clé (ce qui ne fonctionne pas pour les autres types mutables), .keysretourne les clés dans l'ordre dans lequel elles ont été insérées et l' []||=opérateur fournit un moyen concis de ramifier si une clé donnée est déjà là.

Haskell, 105 octets

f le fait.

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 octets

Défi cool, beaucoup de plaisir!

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