编写一个程序，通过非空白字符的字符串去（你可以认为他们是数字0到9，但没有在他们要处理的方式取决于此），并根据以下规则增加了空间。

1. 假设当前标记为空字符串，而先前发出的标记为空集。
2. 遍历字符串的字符。对于每个字符，首先将字符附加到当前标记。然后，如果当前令牌尚未包含在先前发出的令牌集中，则将当前令牌添加到该令牌集中，并将新的当前令牌作为空字符串。
3. 如果到达字符串末尾时当前标记为空，则按发射顺序输出先前发射的标记，并用空格字符分隔。否则，逐字输出原始字符串。

输入值

STDIN的输入应为数字序列。

输出量

程序应按照步骤3中的指定打印结果。

样品

样本输入

2015
10101010
4815162342
101010101010
3455121372425
123456789101112131415
314159265358979323846264338327950288419716939937

样本输出

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

这是代码高尔夫球，因此适用标准CG规则。以字节为单位的最短程序获胜。

（请在评论中要求任何澄清。我对此仍然陌生。谢谢！）

Pyth，22个字节

 faW!}=+kTYY~kdz?tkzsY

领导空间很重要。

视网膜，68 61字节

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

<empty>是一个空行。注意第3行上的尾随空格。您可以从带有-s标志的单个文件中运行以上代码。

说明

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

第一步实现规则1到6。这是一个正则表达式替换，将重复应用该替换，直到字符串停止更改为止（这就是处理的+目的）。在每个步骤中，我们从左至右在字符串中添加一个空格（遵循挑战规则）。正则表达式匹配尚未出现在字符串的已处理部分中的最短的数字字符串。我们确保查看的是带有字边界的剩余字符串的前缀，\b并检查是否可以到达字符串的末尾而不会使用(\w+)$。后者还确保我们每个步骤仅执行一次替换。

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

如果字符串的最后一段与字符串中的其他任何段相同，则它匹配任何空格（在正则表达式的末尾），并用空字符串替换它们。也就是说，如果第一步导致最终段无效，则撤消第一步，并执行规则7。

Pyth， 24 23字节

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

在这里尝试一下。

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

感谢@FryAmTheEggman保存了一个字节：o）

Python 3，92个字节

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

基本上是@Willem解决方案的高球版本。

Python 3中，100个 99字节

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字节

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

这让我意识到我需要更改的语法有很多方面...

说明

:_:_              § 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个字节

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

在这里测试。

说明

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

我的输出格式与问题中的输出样本不完全相同（有一个前导空格）。我不认为这是一个缺陷，因为未指定输出格式（只是程序应该在数字之后打印数字...）

测试在符合EcmaScript 6的浏览器中运行以下代码段的方法。使用Firefox开发，经过测试并在最新的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字节

（因为我们需要-r标记，所以多得分了）

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

内部循环测试是否有重复的序列，并根据需要追加字符，直到在分隔符后出现唯一数字为止_。外循环继续_前进。

扩展的带注释版本：

#!/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字节

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

使用命令行标志-p（或pl如果输入的末尾有换行符）。利用Ruby Hash词典的几个特征：您可以安全地更改用于定义键的字符串，而无需更改键（不适用于其他可变类型），.keys按插入顺序返回键，然后使用[]||=运算符提供一种简单的分支方式来确定给定密钥是否已经存在。

Haskell，105个字节

f 可以。

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字节

挑战很酷，很有趣！

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