Boşluk olmayan karakter dizesi geçer bir program yazın (eğer onlar rakam olduğunu kabul edebilir 0üzere 9, ancak bunlar işlenecek olan şekilde hiçbir şey buna bağlıdır) ve aşağıdaki kurallara göre boşluk ekler.

1. Geçerli jetonun boş dize olmasına izin verin ve önceden verilen jetonlar boş bir küme olsun.
2. Dizenin karakterlerini yineleyin. Her karakter için, önce karakteri geçerli tokene ekleyin. Ardından, geçerli belirteç önceden yayınlanmış belirteçlerin kümesinde değilse, geçerli belirteci bu kümeye ekleyin ve yeni geçerli belirtecin boş dize olmasına izin verin.
3. Dizenin sonuna ulaştığınızda geçerli belirteç boşsa, daha önce yayımlanan belirteçleri emisyon sırasına, boşluk karakteriyle ayırarak çıkarın. Aksi takdirde orijinal dize verbatim çıktı.

Giriş

STDIN girişi, bir rakam dizisi olmalıdır.

Çıktı

Program sonucu 3. adımda belirtilen şekilde yazdırmalıdır.

Numuneler

Örnek girişler

2015
10101010
4815162342
101010101010
3455121372425
123456789101112131415
314159265358979323846264338327950288419716939937

Örnek çıktılar

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

Bu kod golf, yani standart CG kuralları geçerlidir. Bayt cinsinden en kısa program kazanır.

(Lütfen yorumlarda açıklama talebinde bulunun. Bu konuda hala yeniyim. Teşekkürler!)

Pyth, 22 bayt

 faW!}=+kTYY~kdz?tkzsY

Önde gelen alan önemlidir.

Retina , 68 61 bayt

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

<empty>boş bir satır. Satır 3'deki sondaki boşluğa dikkat edin. Yukarıdaki kodu -sbayraklı tek bir dosyadan çalıştırabilirsiniz .

açıklama

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

Bu ilk adım 1 ila 6 arasındaki kuralları uygular. Dizenin değişmesi duruncaya kadar tekrar tekrar uygulanan bir regex ikamesidir (bunun +içindir). Her adımda dizgiye soldan sağa tek bir boşluk ekleriz (meydan okuma kurallarına uyarak). Düzenli ifade, dizenin önceden işlenmiş bölümünde görünmeyen en kısa basamak dizesiyle eşleşir. Sınır kelimesiyle kalan dizgenin önekine baktığımızdan ve dizgenin \bsonuna boşluk bırakmadan ulaşabileceğimizi kontrol ettiğimizi garanti ediyoruz (\w+)$. İkincisi ayrıca her adımda yalnızca bir değiştirme gerçekleştirmemizi sağlar.

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

Bu, dizenin son bölümünün dizedeki diğer bölümlerle aynı olması ve boş dizeyle değiştirilmeleri koşuluyla (regex'in sonunda olan) herhangi bir boşlukla eşleşir. Yani, kural 7'yi uygulayarak geçersiz bir son bölümle sonuçlandıysa ilk adımı geri alırız.

Pyth, 24 23 bayt

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

Burada dene .

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

Bayt kaydetmek için @FryAmTheEggman teşekkürler: o)

Python 3, 92 bayt

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

Temel olarak @ Willem'in çözümünün ağır bir golf oyunu.

Python 3, 100 99 bayt

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 bayt

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

Bu, farkına varmam gereken sözdizimi hakkında birçok şeyin olduğunu anlamamı sağladı.

açıklama

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

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

Burada test et.

açıklama

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

Çıkış formatım, questioin'deki çıkış örnekleriyle tam olarak aynı değil (öncü bir boşluk var). Çıktı formatı belirtilmediğinden, kusur olarak görmüyorum (sadece program numaradan sonra numarayı basmalıdır ... )

Aşağıdaki pasajı EcmaScript 6 uyumlu bir tarayıcıda çalıştırmayı test edin. Firefox ile geliştirildi, en son Chrome'da test edildi ve çalışıyor.

/* 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 bayt

( -rBayrağa ihtiyacımız olduğu için bir puan daha kazanın)

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

İç döngü, tekrarlanan bir diziyi test eder ve ayırıcıdan sonra benzersiz bir sayı görünene kadar gereken karakterleri ekler _. Dış döngü _boyunca hareket eder .

Genişletilmiş, açıklamalı sürüm:

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

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

Komut satırı bayrağını kullanır -p(veya plgirişinizde izleyen bir yeni satır varsa). Ruby Hash sözlüklerinin çeşitli özelliklerini kullanır: bir anahtarı tanımlamak için kullandığınız dizeyi, anahtarı değiştirmeden (diğer değişken türler için çalışmaz), .keysanahtarları girdikleri sırayla ve []||=operatöre geri döndürmeden güvenle değiştirebilirsiniz. Verilen bir anahtarın zaten orada olup olmadığına dair kısa bir dallanma yolu sağlar.

Haskell, 105 bayt

f yapar.

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 bayt

Harika bir meydan okuma, çok eğlenceli!

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