จงเขียนโปรแกรมที่ต้องผ่านสายอักขระที่ไม่ใช่ช่องว่างที่ (คุณอาจคิดว่าพวกเขาจะมีตัวเลข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 มันเป็นการทดแทน regex ซึ่งจะถูกนำมาใช้ซ้ำ ๆ จนกระทั่งสตริงหยุดการเปลี่ยนแปลง (นั่นคือสิ่งที่+มีไว้สำหรับ) ในแต่ละขั้นตอนเราเพิ่มช่องว่างเดียวในสตริงจากซ้ายไปขวา (ตามกฎของการท้าทาย) regex ตรงกับสตริงตัวเลขที่สั้นที่สุดซึ่งไม่ได้ปรากฏในส่วนที่ประมวลผลแล้วของสตริง เรามั่นใจว่าเรากำลังมองหาที่คำนำหน้าของสตริงที่เหลืออยู่กับขอบเขตคำว่าและการตรวจสอบว่าเราสามารถไปถึงจุดสิ้นสุดของสตริงโดยไม่ต้องผ่านช่องว่างด้วย\b (\w+)$หลังยังช่วยให้มั่นใจว่าเราจะทำการทดแทนเพียงหนึ่งครั้งต่อขั้นตอน

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

สิ่งนี้ตรงกับพื้นที่ใด ๆ (ซึ่งอยู่ท้ายสุดของ regex) โดยมีเงื่อนไขว่าเซกเมนต์สุดท้ายของสตริงนั้นเหมือนกับเซกเมนต์อื่น ๆ ในสตริงและแทนที่ด้วยสตริงว่าง นั่นคือเราจะยกเลิกขั้นตอนแรกหากทำให้ส่วนสุดท้ายไม่ถูกต้องโดยใช้กฎ 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

รูปแบบผลลัพธ์ของฉันไม่เหมือนกับตัวอย่างผลลัพธ์ใน questioin (มีพื้นที่นำ) ฉันไม่เห็นว่าเป็นข้อบกพร่องเนื่องจากไม่ได้ระบุรูปแบบเอาท์พุท (เฉพาะโปรแกรมควรพิมพ์หมายเลขหลังหมายเลข ... )

ทดสอบการเรียกใช้ตัวอย่างข้อมูลด้านล่างในเบราว์เซอร์ที่สอดคล้องกับ 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ถ้าอินพุตของคุณมีบรรทัดใหม่ต่อท้าย) ใช้ประโยชน์จากหลายลักษณะของทับทิมพจนานุกรมแฮ: คุณสามารถกลายพันธุ์สายที่คุณใช้ในการกำหนดคีย์โดยไม่ได้มีการเปลี่ยนแปลงที่สำคัญ (ซึ่งไม่ทำงานชนิดไม่แน่นอนอื่น ๆ ) .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;