อินพุตเป็นคำของตัวอักษรตัวพิมพ์เล็กที่ไม่คั่นด้วยช่องว่าง ขึ้นบรรทัดใหม่ในตอนท้ายเป็นตัวเลือก

คำเดียวกันจะต้องส่งออกในเวอร์ชันที่แก้ไข: สำหรับตัวละครแต่ละตัวให้เพิ่มเป็นสองเท่าในครั้งที่สองที่ปรากฏในคำเดิมให้เพิ่มเป็นสามเท่าในครั้งที่สามเป็นต้น

อินพุตตัวอย่าง:

bonobo

ตัวอย่างผลลัพธ์:

bonoobbooo

ใช้กฎ I / O มาตรฐาน รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

การทดสอบโดย @Neil:

tutu -> tuttuu
queue -> queuuee
bookkeeper -> boookkkeeepeeer
repetitive -> repeetittiiveee
uncopyrightables -> uncopyrightables
abracadabra -> abraacaaadaaaabbrraaaaa
mississippi -> misssiisssssssiiipppiiii

เยลลี่ขนาด 4 ไบต์

;\f"

ลองออนไลน์!

มันทำงานอย่างไร

;\f"  Main link. Argument: S (string)

;\    Cumulatively reduce by concatenation.
      This yields the array of all prefixes of S.
  f"  Vectorized filter.
      Keep only occurrences of the nth letter in the nth prefix.

Pyth, 6 ไบต์

ขอบคุณ@Doorknob ที่เลิกใช้ 1 ไบต์

ขอบคุณ@Maltysenสำหรับการปิด 5 ไบต์

s@VQ._

ลองออนไลน์!

มันทำงานอย่างไร

"bonobo"ตัวอย่างเช่นใช้สตริง

._ ทำรายการ: ['b', 'bo', 'bon', 'bono', 'bonob', 'bonobo']

VQ._หมายถึง "ฟังก์ชั่นก่อนหน้านี้ vectorized (นำไปใช้ในแบบคู่ขนาน) มากกว่าQและ._" ซึ่งหมายถึงQ(การประเมินการป้อนข้อมูล) จะได้รับการปฏิบัติเป็นรายการ: ['b', 'o', 'n', 'o', 'b', 'o']แล้วพวกเขาจะถูกจับคู่โดย@เช่นนี้:

     Q      ._         @ (intersect)
0:  'b'     'b'       'b'
1:  'o'     'bo'      'o'
2:  'n'     'bon'     'n'
3:  'o'     'bono'    'oo'
4:  'b'     'bonob'   'bb'
5:  'o'     'bonobo'  'ooo'

ดังนั้นจะผลิต@VQ._['b', 'o', 'n', 'oo', 'bb', 'ooo']

sแล้วร่วมกับพวกเขาทั้งหมดเข้าด้วยกัน, การสร้างสตริงซึ่งเป็นพิมพ์แล้วโดยปริยายออกจะกลายเป็น'bonoobbooo'bonoobbooo

เรติน่า , 34 19 ไบต์

บันทึก 15 ไบต์โดยรับแรงบันดาลใจจากโซลูชันของ isaacg

จำนวนไบต์ถือว่าการเข้ารหัส ISO 8859-1

$`¶
(\D)(?!.*\1¶)

บรรทัดว่างนำหน้าและต่อท้ายมีความสำคัญ

ลองออนไลน์!

คำอธิบาย

$`¶

นี่คือขั้นตอนการแทนที่ซึ่งจับคู่กับ regex ที่ว่างเปล่า (นั่นคือทุกตำแหน่งที่มีความกว้างเป็นศูนย์ในสตริง) และทดแทน$`¶สำหรับมันโดยที่$`คำนำหน้าของการจับคู่และ¶แทรก linefeed สิ่งนี้จะคำนวณคำนำหน้าทั้งหมดและวางไว้ในบรรทัดแยกพร้อมกับอักขระตัวสุดท้ายของคำนำหน้า:

bb
obo
oboo
kbook
kbookk
ebookke
ebookkee
pbookkeep
ebookkeepe
rbookkeeper

จะมี linefeeds ที่นำหน้าและต่อท้าย แต่เราสามารถเพิกเฉยได้

จากคำนำหน้าแต่ละคำเหล่านี้เราต้องการเก็บอักขระที่เท่ากับอักขระตัวสุดท้าย เพื่อที่เราจะใช้เวทีแทนที่อื่น:

(\D)(?!.*\1¶)

สิ่งนี้ตรงกับทุกสิ่งที่เราไม่ต้องการเก็บไว้และแทนที่ด้วยสิ่งใด เราจับคู่อักขระใด ๆ (โดยใช้\Dเนื่องจากเรารู้ว่าจะไม่มีตัวเลขในอินพุต) จากนั้นตรวจสอบให้แน่ใจว่าไม่มีสำเนาของตัวละครนั้นอีกที่ท้ายบรรทัด

Python ขนาด 56 ไบต์

ฉันดูเหมือนจะติดอยู่กับสองคำตอบที่มีความยาวเท่ากัน:

f=lambda x,*y:x and-~y.count(x[0])*x[0]+f(x[1:],x[0],*y)
f=lambda x,y=0:x[y:]and-~x[:y].count(x[y])*x[y]+f(x,y+1)

แก้ไข: ดูคำตอบของ @ pacholikสำหรับวิธี Python ที่สั้นกว่าและเป็นทางเลือก

Haskell, 39 ไบต์

f""=""
f x=f(init x)++filter(==last x)x

ตัวอย่างการใช้งาน: ->f "bonobo""bonoobbooo"

ที่แตกต่างกันมากพอจาก@ คำตอบดาเมียน สร้างสตริงจากด้านขวาด้วยการแยกทั้งหมดที่เกิดขึ้นของตัวละครตัวสุดท้ายจากสตริงและการเตรียมการเรียกซ้ำด้วยทั้งหมดยกเว้นตัวอักษรตัวสุดท้าย

> <> , 27 ไบต์

>i:0g1+:\
:{-1v!?:<}o
/p${/

ต้องใช้ล่ามอย่างเป็นทางการซึ่งออกมาพร้อมกับข้อผิดพลาดเมื่อพยายามพิมพ์รหัสจุด -1 ลองออนไลน์!

รหัสอ่านอินพุตถ่านหนึ่งตัวในแต่ละครั้งและใช้แถวแรกของโค้ดบ็อกซ์เป็นอาร์เรย์ขนาดใหญ่ซึ่งเก็บจำนวนครั้งที่ถ่านแต่ละตัวถูกมองเห็นแล้ว (> <> เริ่มต้นเซลล์ที่ไม่ใช่โปรแกรมเป็น 0) แถวที่สองเป็นลูปสำหรับเอาท์พุทถ่านหลายครั้ง

หรือนี่คือรุ่นที่ออกให้หมดจด (37 ไบต์ไม่ได้เล่นกอล์ฟอย่างถูกต้อง):

>i:0(?;:0g1+:\
}o:{-1v!?:   <
v  p${<

JavaScript (ES6), 48 45 ไบต์

s=>s.replace(n=/./g,c=>c.repeat(n[c]=-~n[c]))

แก้ไข: บันทึกแล้ว 3 ไบต์ด้วย @ user81655

Haskell, 50 42 41 ไบต์

บันทึก 8 ไบต์ต้องขอขอบคุณ Lynn

f t=[c|(i,c)<-zip[1..]t,x<-take i t,c==x]

MATL , 8 ไบต์

tt!=RsY"

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมดในครั้งเดียว

คำอธิบาย

t    % take input string implictly. Duplicate
t!   % duplicate and transpose into a column
=    % test for equality with broadcast. Gives an NxN array, where N is
     % input string length
R    % upper triangular part: set entries below the diagonal to 0
s    % sum of each column. For each postion in the input, gives how many
     % times that letter has appeared up to that position
Y"   % replicate elements (run-length decoding). Display implicitly

เขาวงกต , 54 25 ไบต์

<#; "#: ={},>
 }=}(.);("@

ร่วมงานกับ @ MartinBüttnerที่ไม่จริงอีกส่วนใหญ่เกือบทั้งหมดของการเล่นกอล์ฟสำหรับคนนี้ ด้วยการปรับปรุงอัลกอริทึมเราจึงสามารถลดขนาดโปรแกรมลงได้เล็กน้อย!

ลองออนไลน์!

คำอธิบาย

ไพรเมอร์ Labrinth ด่วน:

• เขาวงกตเป็นภาษา 2D ตามสแต็ค มีสแต็กสองสแต็กหลักและสแต็กเสริมและการ popping จากสแต็กเปล่าให้ผลเป็นศูนย์

• ที่แต่ละทางแยกที่มีหลายเส้นทางสำหรับตัวชี้คำสั่งเพื่อเลื่อนลงด้านบนของสแต็กหลักจะถูกตรวจสอบเพื่อดูว่าจะไปที่ไหนต่อไป ลบคือเลี้ยวซ้ายศูนย์ตรงไปข้างหน้าและบวกคือเลี้ยวขวา

จำนวนเต็มสองจำนวนที่มีความแม่นยำตามอำเภอใจไม่มากนักในแง่ของตัวเลือกหน่วยความจำ ในการนับจำนวนจริงโปรแกรมนี้ใช้สองสแต็คเป็นเทปโดยเลื่อนค่าจากสแต็กหนึ่งไปยังอีกอันหนึ่งคล้ายกับการย้ายตัวชี้หน่วยความจำไปทางซ้าย / ขวาโดยเซลล์ มันไม่ได้เป็นอย่างนั้นเหมือนกันเนื่องจากเราจำเป็นต้องลากตัวนับลูปกับเราขณะที่ขึ้น

ก่อนอื่น, <และ>ที่ปลายทั้งสองข้างจะมีออฟเซ็ตและหมุนแถวของโค้ดที่ออฟเซ็ตไปทางซ้ายหรือขวา กลไกนี้ใช้ในการทำให้โค้ดทำงานในลูป - <pops เป็นศูนย์และหมุนแถวปัจจุบันไปทางซ้ายวาง IP ที่ด้านขวาของรหัสและ>จะปรากฏที่ศูนย์อื่นและแก้ไขแถวกลับ

นี่คือสิ่งที่เกิดขึ้นแต่ละการวนซ้ำในความสัมพันธ์กับแผนภาพด้านบน:

[Section 1]
,}    Read char of input and shift to aux - the char will be used as a counter
      to determine how many elements to shift

[Section 2 - shift loop]
{     Shift counter from aux
"     No-op at a junction: turn left to [Section 3] if char was EOF (-1), otherwise
      turn right
(     Decrement counter; go forward to [Section 4] if zero, otherwise turn right
=     Swap tops of main and aux - we've pulled a value from aux and moved the
      decremented counter to aux, ready for the next loop iteration

[Section 3]
@     Terminate

[Section 4]
;     Pop the zeroed counter
)     Increment the top of the main stack, updating the count of the number of times
      we've seen the read char
:     Copy the count, to determine how many chars to output

[Section 5 - output loop]
#.    Output (number of elements on stack) as a char
(     Decrement the count of how many chars to output; go forward to [Section 6]
      if zero, otherwise turn right
"     No-op

[Section 6]
}     Shift the zeroed counter to aux

[Section 7a]
This section is meant to shift one element at a time from main to aux until the main
stack is empty, but the first iteration actually traverses the loop the wrong way!

Suppose the stack state is [... a b c | 0 d e ...].

=     Swap tops of main and aux               [... a b 0 | c d e ...]
}     Move top of main to aux                 [... a b | 0 c d e ...]
#;    Push stack depth and pop it (no-op)
=     Swap tops of main and aux               [... a 0 | b c d e ...]
      Top is 0 at a junction - can't move
      forwards so we bounce back
;     Pop the top 0                           [... a | b c d e ... ]

The net result is that we've shifted two chars from main to aux and popped the
extraneous zero. From here the loop is traversed anticlockwise as intended.

[Section 7b - unshift loop]

#     Push stack depth; if zero, move forward to the <, else turn left
}=    Move to aux and swap main and aux, thus moving the char below (stack depth)
      to aux
;     Pop the stack depth

Perl, 17

(รหัส 16 ไบต์ +1 สำหรับ -p)

s/./${$&}.=$&/ge

การใช้งาน:

perl -pe 's/./${$&}.=$&/ge' <<< 'bonobo'
bonoobbooo

Pyth, 7 ไบต์

s@Led._

ชุดทดสอบ

ชุดทดสอบต้องขอบคุณ DenkerAffe

คำอธิบาย:

s@Led._
     ._    All prefixes, implicitly applied to the input.
 @L        Filter each prefix for characters equal to
   ed      the last character of the prefix
s          Concatenate and implicitly print.

Python 3, 52

def f(s):*s,x=s;return s and f(s)+x+x*s.count(x)or x

PowerShell v2 +, 52 47 ไบต์

$b=@{};-join([char[]]$args[0]|%{"$_"*++$b[$_]})

โครงสร้าง Hashtable $bว่างเก็บไว้ใน นี่คือ "ตัวนับ" ของเราสำหรับตัวอักษรที่เราเห็น จากนั้นเราก็รับอินพุต$args[0], ส่งมันเป็น char-array, และส่งมันผ่านลูป การวนซ้ำแต่ละครั้งเราใช้อักขระปัจจุบัน"$_"และคูณมันด้วยตัวนับที่เพิ่มขึ้นล่วงหน้าตามค่าที่กำหนดซึ่งจะทำให้การเกิดครั้งแรกถูกคูณด้วย1ตัวที่สองตาม2ลำดับ เราแค็ปซูลนั้นด้วย-joinคำทั้งหมดที่มีอยู่

บันทึก 5 ไบต์ด้วยTessellatingHecklerโดยใช้ hashtable แทนที่จะเป็นอาร์เรย์ดังนั้นเราจึงไม่จำเป็นต้องลดอักขระ ASCII ด้วย97การเข้าถึงดัชนีที่เหมาะสม ใช้งานได้เนื่องจากมีการเพิ่มดัชนีแฮชล่วงหน้า.Add()ในพื้นหลังหากดัชนีนั้นไม่มีอยู่เนื่องจาก hashtables ไม่แน่นอน

PS C:\Tools\Scripts\golfing> .\stretch-the-word.ps1 tessellatingheckler
tessseelllattingheeeckllleeeer

Dyalog APLขนาด 6 ไบต์

∊,\∩¨⊢

TryAPL!

4 ฟังก์ชั่นเป็นบน (2 รถไฟ) ของส้อม (3 รถไฟ):

┌──┴──┐  
∊ ┌───┼─┐
  \   ¨ ⊢
┌─┘ ┌─┘  
,   ∩    

ครั้งแรก⊢(ขวา - no-op) บนสตริงที่กำหนดให้'bonobo'

จากนั้น,\(การต่อข้อมูลสแกน) บนสตริงให้'b' 'bo' 'bon' 'bono' 'bonob' 'bonobo'

ทั้งสองถูกแยกเข้าด้วยกันด้วย (ให้เป็นอาร์กิวเมนต์ด้านขวาและซ้าย) ∩¨(จุดตัดแต่ละอัน) ('b'∩'b') ('bo'∩'o') ('bon'∩'n') ('bono'∩'o') ('bonob'∩'b') ('bonobo'∩'o')ซึ่งก็คือ'b' 'o' 'n' 'oo' 'bb' 'ooo'

ในที่สุด∊(เกณฑ์) จะถูกนำไปใช้กับผลลัพธ์เพื่อทำให้แบน'bonoobbooo'

เฮ้อย่างน้อยก็ตรงกับPyth ! เห็นได้ชัดว่าเจลลี่นั้นสั้นกว่าเนื่องจากเป็นเวอร์ชั่นกอล์ฟของ J ซึ่งจะเป็นภาษาถิ่น 2 ตัวอักษรต่อฟังก์ชันขั้นสูงของ APL

Pyth, 11 ไบต์

s.e*b/<Qhkb

ลองที่นี่!

คำอธิบาย

se * b / <Qhkb # Q = อินพุต

 .e # map เหนืออินพุตด้วย b เป็นค่าและ k as index (Q รับต่อท้ายท้ายโดยปริยาย)
      <Qhk # ใช้ k + 1 chars แรกของ Q
     / b # นับการเกิดขึ้นของ b ในนั้น
   * b # ทำซ้ำ b หลายครั้ง
s # เข้าร่วมรายการผลลัพธ์เป็นหนึ่งสตริง

J, 11 ไบต์

#~+/@(={:)\

นี่คือคำกริยา monadic ลองที่นี่ การใช้งาน:

   f =: #~+/@(={:)\
   f 'tutu'
'tuttuu'

คำอธิบาย

#~+/@(={:)\
     (   )\  For each non-empty prefix:
       {:      Take last element,
      =        compare for equality to the others and itself
  +/@          and take sum (number of matches).
#~           Replicate original elements wrt the resulting array.

05AB1E , 10 ไบต์

รหัส:

$vy«Dy¢y×?

คำอธิบาย:

$           # Push the number 1 and input
 v          # Map over the input string
  y«        # Concat the letter to the previous string (initial 1)
    D       # Duplicate this string
     y¢     # Count the occurences of the current character in the string
       y×   # Multiply this number with the current character
         ?  # Pop and print without a newline

ใช้การเข้ารหัสCP-1252 ลองออนไลน์!

CJam, 14

q:A,{)A<_)--}/

ลองออนไลน์

คำอธิบาย:

q:A      read the input and store in A
,        get the string length
{…}/     for each number from 0 to length-1
  )      increment the number
  A<     get the prefix of A with that length
  _      duplicate it
  )      separate the last character
  -      remove it from the rest of the prefix
  -      remove all the remaining characters (different from the last one)
          from the prefix

Perl 6, 37 ไบต์

{.split('').map({$_ x++%.{$_}}).join}

> <> , 52 ไบต์

i:0(?;&l:?!v1-$:&:&=?\}70.>
6f+0.00o:&~/         \:o

มันซ้อนตัวอักษรทุกตัวที่อ่านพิมพ์ครั้งแล้วครั้งเล่าสำหรับตัวอักษรที่คล้ายกันทั้งหมดในสแต็ค
มันใช้&รีจิสเตอร์เนื่องจากต้องจัดการกับตัวแปร 3 ตัวบนสแต็ค (จดหมายอ่านปัจจุบันตำแหน่งในสแต็กตัวอักษรที่ตำแหน่งนี้) เป็นความเจ็บปวด

คุณสามารถลองได้ที่นี่ !

สนิม 176 ไบต์

fn s(w:&str)->String{let mut m=std::collections::HashMap::new();w.chars().map(|c|{let mut s=m.remove(&c).unwrap_or(String::new());s.push(c);m.insert(c,s.clone());s}).collect()}

สิ่งนี้ใช้แผนที่เพื่อเก็บสตริงสำหรับอักขระทุกตัวในอินพุต สำหรับตัวละครแต่ละตัวสตริงจะถูกลบออกจากแผนที่เชื่อมต่อกับตัวละครแทรกกลับเข้าไปในแผนที่และผนวกเข้ากับเอาท์พุท

ฉันอยากจะใช้get(...)แทนremove(...)แต่ตัวตรวจสอบการยืมทำให้ฉันเปลี่ยนใจ

Mathcad, 66 ไบต์

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

โปรดทราบว่า Mathcad ใช้อินเทอร์เฟซแบบ "กระดานไวท์บอร์ด" แบบ 2D พร้อมการผสมผสานระหว่างข้อความและตัวดำเนินการปกติ โดยปกติผู้ปฏิบัติงานจะถูกป้อนผ่านแถบเครื่องมือหรือแป้นพิมพ์ลัด ตัวอย่างเช่น ctl- # ป้อนสำหรับตัวดำเนินการลูปซึ่งประกอบด้วยคำสำคัญสำหรับองค์ประกอบของสัญลักษณ์และ "ตัวยึด" ที่ว่างเปล่า 3 ตัวสำหรับตัวแปรการวนซ้ำช่วงและนิพจน์ตามลำดับ การพิมพ์ [หลังจากชื่อตัวแปรเข้าสู่โหมดดัชนีอาร์เรย์การพิมพ์ 'จะเข้าสู่วงเล็บที่จับคู่ ( ส่วนใหญ่ ... มีข้อยกเว้นขึ้นอยู่กับสิ่งอื่นที่อยู่ในนิพจน์โดยรอบ )

Javascript ES6 44 ไบต์

q=>q.replace(/./g,a=>x[a]=(x[a]||'')+a,x=[])

คำตอบเก่า

Javascript ES6 46 ไบต์

q=>(x=[...q]).map(a=>x[a]=(x[a]||'')+a).join``

//thanks user81655 for -1 byte

Julia, 38 35 ไบต์

!s=[]==s?s:[!s[1:end-1];s∩s[end]]

I / O มาจากอาร์เรย์ของตัวละคร ลองออนไลน์!

มันทำงานอย่างไร

เรา (ใหม่) กำหนดผู้ประกอบการ monadic ! สำหรับวัตถุประสงค์ของเรา

เมื่อไหร่! เรียกว่ามันจะตรวจสอบว่าอาร์กิวเมนต์ของมันว่างเปล่า ถ้าเป็นมันจะส่งคืนอาร์กิวเมนต์ของมัน

หากsเป็นไม่ว่างเปล่าเราตัดsด้วยตัวอักษรสุดท้าย ( s[end]) ซึ่งอัตราผลตอบแทนที่เกิดขึ้นทั้งหมดของตัวละครในการที่s ผลลัพธ์นี้ถูกต่อกันกับค่าส่งคืนของการโทรแบบเรียกซ้ำเพื่อ! ด้วยsลบอักขระตัวสุดท้าย ( s[1:end-1]) เป็นอาร์กิวเมนต์

PHP, 54 51 50 47 ไบต์

for(;$C=$argn[$X++];)echo str_repeat($C,++$$C);

ทำงานแบบนี้:

echo abracadabra | php -nR 'for(;$C=$argn[$X++];)echo str_repeat($C,++$$C); echo"\n";'

การปรับแต่ง

• บันทึก 3 ไบต์โดยใช้ตัวแปรตัวแปร เปลี่ยนตัวแปรที่ใช้เป็นตัวพิมพ์ใหญ่เพื่อป้องกันการชนกัน
• ที่บันทึกไว้ไบต์โดยการเอาประเภทหล่อnullเพื่อintสตริงชดเชยเป็นสตริงชดเชยถูกโยนไป int ล่ะค่ะ
• บันทึก 3 ไบต์โดยใช้$argnแทน$argv(thx Titus)

Mathematica, 57 ไบต์

StringReplace[Clear@c;c@_=0;#,x_:>x~StringRepeat~++c[x]]&

เราใช้c[x]เป็นตารางการค้นหาว่าxมีตัวละครเกิดขึ้นบ่อยแค่ไหน นี่คือการเพิ่มขึ้นทุกครั้งที่ดึงx~StringRepeat~++c[x]มา น่าเสียดายที่การทำให้ฟังก์ชั่นสามารถใช้ซ้ำได้เราจำเป็นต้องรีเซ็ตตารางการค้นหาทุกครั้งด้วยClear@c;c@_=0;ซึ่งค่อนข้างแพง

awk, 72 ไบต์

BEGIN{FS=""}{for(i=1;i<=NF;i++){a[$i]++;for(j=0;j<a[$i];j++)printf $i}}

แนวคิดคือการเก็บจำนวนตัวอักษรที่ปรากฏในอาเรย์แบบเชื่อมโยงและพิมพ์ตัวอักษรจำนวนครั้งนี้

บีม, 32 33 42ไบต์

สิ่งนี้ควรเล็กกว่านี้ แต่ฉันเสียบางไบต์ในการเริ่มต้นสล็อตหน่วยความจำเป็น 0 การสลับทิศทางการไหลเพื่อจัดการพื้นที่ว่างจำนวนมาก

 >+\
vus/
>rnH
  >g'\
(@v's/
^`<

ลองในตัวอย่างนี้

คำอธิบายทั่วไป

• ตั้งค่าสล็อตหน่วยความจำทั้งหมดตั้งแต่ 0-255 ถึง 0
• อ่านค่าอินพุต ascii ลงในลำแสง
• ถ้าคานเป็น 0 หยุด (beam = store)
• นำค่าหน่วยความจำ [ลำแสง] ไปที่ร้านเพิ่มขึ้นและบันทึกกลับ
• ลดการจัดเก็บเป็น 0 พิมพ์อักขระคาน
• ทำซ้ำ

Python, 66 62 ไบต์

ลองที่นี่

แข็งแรงเล่นกอล์ฟ

def s(w,o=[],n=""):
 for x in w:o+=x;n+=x*o.count(x)
 return n

Ungolfed

def stretch(word):
    occurrences = []
    newWord = ""
    for w in word:
        occurrences.append(w)
        newWord += w * occurrences.count(w)
    return newWord