Viết một chương trình mà đi qua một chuỗi các ký tự không phải khoảng trắng (bạn có thể giả định rằng họ là chữ số 0để 9, nhưng không theo cách chúng được xử lý phụ thuộc vào điều này) và cho biết thêm không gian theo các quy tắc sau đây.

1. Đặt mã thông báo hiện tại là chuỗi trống và mã thông báo được phát ra trước đó là một tập hợp trống.
2. Lặp lại thông qua các ký tự của chuỗi. Đối với mỗi ký tự, trước tiên hãy thêm ký tự vào mã thông báo hiện tại. Sau đó, nếu mã thông báo hiện tại chưa có trong bộ mã thông báo được phát ra trước đó, hãy thêm mã thông báo hiện tại vào bộ đó và để mã thông báo hiện tại mới là chuỗi trống.
3. Nếu khi bạn đến cuối chuỗi, mã thông báo hiện tại trống, hãy xuất mã thông báo được phát ra trước đó theo thứ tự phát xạ, được phân tách bằng ký tự khoảng trắng. Nếu không, xuất nguyên văn chuỗi gốc.

Đầu vào

Đầu vào của STDIN phải là một chuỗi các chữ số.

Đầu ra

Chương trình sẽ in kết quả như được chỉ định trong bước 3.

Mẫu

Đầu vào mẫu

2015
10101010
4815162342
101010101010
3455121372425
123456789101112131415
314159265358979323846264338327950288419716939937

Đầu ra mẫu

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

Đây là mã golf, vì vậy các quy tắc CG tiêu chuẩn được áp dụng. Chương trình ngắn nhất trong byte thắng.

(Vui lòng yêu cầu bất kỳ sự làm rõ nào trong các bình luận. Tôi vẫn chưa quen với điều này. Cảm ơn!)

Bình thường, 22 byte

 faW!}=+kTYY~kdz?tkzsY

Không gian hàng đầu là quan trọng.

Võng mạc , 68 61 byte

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

<empty>là một dòng trống. Lưu ý dấu cách trên dòng 3. Bạn có thể chạy đoạn mã trên từ một tệp duy nhất có -scờ.

Giải trình

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

Bước đầu tiên này thực hiện quy tắc 1 đến 6. Đây là một thay thế regex được áp dụng lặp đi lặp lại cho đến khi chuỗi ngừng thay đổi (đó là những gì +dành cho). Trong mỗi bước, chúng tôi thêm một khoảng trắng vào chuỗi từ trái sang phải (tuân theo các quy tắc của thử thách). Regex khớp với chuỗi chữ số ngắn nhất chưa xuất hiện trong phần đã được xử lý của chuỗi. Chúng tôi đảm bảo rằng chúng tôi đang xem xét một tiền tố của chuỗi còn lại với ranh giới từ \bvà kiểm tra xem chúng tôi có thể đi đến cuối chuỗi mà không vượt qua khoảng trắng với (\w+)$. Cái sau cũng đảm bảo rằng chúng tôi chỉ thực hiện một thay thế cho mỗi bước.

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

Điều này khớp với bất kỳ khoảng trắng nào (nằm ở cuối regex), với điều kiện là đoạn cuối cùng của chuỗi giống với bất kỳ phân đoạn nào khác trong chuỗi và thay thế chúng bằng chuỗi trống. Đó là, chúng tôi hoàn tác bước đầu tiên nếu nó dẫn đến một phân đoạn cuối cùng không hợp lệ, thực hiện quy tắc 7.

Bình thường 24 23 byte

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

Hãy thử nó ở đây .

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

Cảm ơn @FryAmTheEggman vì đã lưu một 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>""])

Về cơ bản là một phiên bản được đánh golf nặng nề của giải pháp @ 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&)}

Điều này khiến tôi nhận ra rằng có rất nhiều điều về cú pháp tôi cần thay đổi ...

Giải trình

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

Kiểm tra nó ở đây.

Giải trình

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

Định dạng đầu ra của tôi không hoàn toàn giống với các mẫu đầu ra trong Questioin (có một khoảng trắng ở đầu). Tôi không thấy đó là một lỗ hổng, vì định dạng đầu ra không được chỉ định (chỉ Chương trình sẽ in số sau số ... )

Kiểm tra chạy đoạn mã dưới đây trong trình duyệt tuân thủ EcmaScript 6. Được phát triển với Firefox, đã thử nghiệm và chạy trên Chrome mới nhất.

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

(Điểm thêm một vì chúng tôi yêu cầu -rcờ)

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

Vòng lặp bên trong kiểm tra một chuỗi lặp lại và nối thêm các ký tự khi cần cho đến khi một số duy nhất xuất hiện sau dấu phân cách _. Các vòng lặp bên ngoài di chuyển _dọc.

Phiên bản mở rộng, chú thích:

#!/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*' '

Sử dụng cờ dòng lệnh -p(hoặc plnếu đầu vào của bạn có dòng mới ở cuối). Khai thác một số đặc điểm của từ điển Ruby Hash: bạn có thể thay đổi chuỗi bạn đã sử dụng để xác định khóa một cách an toàn mà không thay đổi khóa (không hoạt động đối với các loại có thể thay đổi khác), .keystrả về các khóa theo thứ tự chúng được chèn và []||=toán tử cung cấp một cách ngắn gọn để phân nhánh xem một khóa đã cho đã có chưa.

Haskell, 105 byte

f Phải không.

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

Thử thách thú vị, nhiều niềm vui!

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