Menulis sebuah program yang berjalan melalui string karakter non-spasi (Anda mungkin menganggap bahwa mereka adalah digit 0ke 9, tapi tidak dalam cara mereka untuk diproses tergantung pada ini) dan menambah ruang sesuai dengan aturan berikut.

1. Biarkan token saat ini menjadi string kosong, dan token yang dipancarkan sebelumnya menjadi set kosong.
2. Iterasi melalui karakter string. Untuk setiap karakter, pertama tambahkan karakter ke token saat ini. Kemudian jika token saat ini belum ada di set token yang dipancarkan sebelumnya, tambahkan token saat ini ke set itu dan biarkan token saat ini menjadi string kosong.
3. Jika ketika Anda mencapai akhir string token saat ini kosong, output token yang dipancarkan sebelumnya dalam urutan emisi, dipisahkan oleh karakter spasi. Kalau tidak, output string asli kata demi kata.

Memasukkan

Input ke STDIN harus berupa urutan digit.

Keluaran

Program harus mencetak hasilnya seperti yang ditentukan pada langkah 3.

Sampel

Input sampel

2015
10101010
4815162342
101010101010
3455121372425
123456789101112131415
314159265358979323846264338327950288419716939937

Output sampel

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

Ini adalah kode golf, jadi aturan standar CG berlaku. Program terpendek dalam byte menang.

(Silakan minta klarifikasi dalam komentar. Saya masih baru dalam hal ini. Terima kasih!)

Pyth, 22 byte

 faW!}=+kTYY~kdz?tkzsY

Ruang utama adalah penting.

Retina , 68 61 byte

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

<empty>adalah baris kosong. Perhatikan spasi tambahan pada baris 3. Anda dapat menjalankan kode di atas dari satu file dengan -sflag.

Penjelasan

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

Langkah pertama ini menerapkan aturan 1 hingga 6. Ini adalah pengganti regex yang diterapkan berulang kali hingga string berhenti berubah (untuk itulah +gunanya). Di setiap langkah kami menambahkan satu spasi ke string dari kiri ke kanan (mengikuti aturan tantangan). Regex cocok dengan string digit terpendek yang belum muncul di bagian string yang sudah diproses. Kami memastikan bahwa kami melihat awalan string yang tersisa dengan batas kata \bdan memeriksa bahwa kami dapat mencapai akhir string tanpa melewati spasi (\w+)$. Yang terakhir juga memastikan bahwa kami hanya melakukan satu penggantian per langkah.

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

Ini cocok dengan ruang apa pun (yang berada di akhir regex), asalkan segmen terakhir dari string adalah sama dengan segmen lainnya di string, dan menggantinya dengan string kosong. Yaitu, kami membatalkan langkah pertama jika menghasilkan segmen akhir yang tidak valid, menerapkan aturan 7.

Pyth, 24 23 byte

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

Cobalah di sini .

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

Terima kasih kepada @FryAmTheEggman karena telah menyimpan byte: o)

Python 3, 92 byte

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

Pada dasarnya versi berat dari solusi @ Willem.

Python 3, 100 99 byte

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 byte

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

Ini membuat saya sadar bahwa ada banyak hal tentang sintaks yang perlu saya ubah ...

Penjelasan

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

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

Uji di sini.

Penjelasan

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

Format output saya tidak persis sama dengan sampel output di questioin (ada ruang terkemuka). Saya tidak melihat itu sebagai cacat, karena format output tidak ditentukan (hanya Program harus mencetak nomor setelah nomor ... )

Tes menjalankan cuplikan di bawah ini di peramban yang mendukung EcmaScript 6. Dikembangkan dengan Firefox, diuji dan dijalankan di Chrome terbaru.

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

(Skor satu ekstra karena kami memerlukan -rbendera)

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

Loop dalam menguji urutan berulang dan menambahkan karakter yang diperlukan sampai nomor unik muncul setelah pemisah _. Loop luar bergerak _bersama.

Versi diperluas, beranotasi:

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

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

Menggunakan bendera baris perintah -p(atau pljika input Anda memiliki baris tambahan). Mengeksploitasi beberapa sifat kamus Ruby Hash: Anda dapat dengan aman mengubah string yang Anda gunakan untuk mendefinisikan kunci tanpa itu mengubah kunci (yang tidak bekerja untuk jenis bisa berubah lainnya), .keysmengembalikan kunci dalam urutan mereka dimasukkan, dan []||=operator menyediakan cara singkat untuk bercabang pada apakah kunci yang diberikan sudah ada di sana.

Haskell, 105 byte

f melakukannya.

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 byte

Tantangan keren, sangat menyenangkan!

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