Input adalah kata dari huruf kecil yang tidak dipisahkan oleh spasi. Baris baru di bagian akhir adalah opsional.

Kata yang sama harus berupa keluaran dalam versi yang dimodifikasi: Untuk setiap karakter, gandakan itu saat kedua kali muncul dalam kata aslinya, lipat tiga kali untuk yang ketiga kali, dll.

Input contoh:

bonobo

Contoh output:

bonoobbooo

Aturan I / O standar berlaku. Kode terpendek dalam byte menang.

Tes disediakan oleh @Neil:

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

Jelly , 4 byte

;\f"

Cobalah online!

Bagaimana itu bekerja

;\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 byte

Terima kasih kepada @Doorknob untuk melepas 1 byte.

Terima kasih kepada @Maltysen untuk melepas 5 byte.

s@VQ._

Cobalah online!

Bagaimana itu bekerja

Misalnya, ambil senarnya "bonobo".

._ membuat daftar: ['b', 'bo', 'bon', 'bono', 'bonob', 'bonobo']

VQ._berarti "fungsi sebelumnya di-vectorized (diterapkan secara paralel) berulang Qdan ._", yang berarti Q(input dievaluasi) akan diperlakukan sebagai daftar:, ['b', 'o', 'n', 'o', 'b', 'o']dan kemudian mereka akan dipasangkan dengan @seperti ini:

     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'

Karena itu, @VQ._akan menghasilkan ['b', 'o', 'n', 'oo', 'bb', 'ooo'].

The skemudian bergabung dengan mereka semua bersama-sama, menciptakan string 'bonoobbooo', yang kemudian secara implisit dicetak menjadi bonoobbooo.

Retina , 34 19 byte

Disimpan 15 byte dengan mengambil beberapa inspirasi dari solusi isaacg.

Hitungan byte mengasumsikan penyandian ISO 8859-1.

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

Baris kosong yang mengarah dan tertinggal signifikan.

Cobalah online!

Penjelasan

$`¶

Ini adalah tahap penggantian yang cocok dengan regex kosong (yaitu setiap posisi nol-lebar dalam string) dan menggantinya $`¶, di mana $`awalan pertandingan dan ¶memasukkan baris baris. Ini pada dasarnya menghitung semua awalan dan menempatkannya pada baris yang terpisah bersama dengan karakter terakhir dari awalan itu:

bb
obo
oboo
kbook
kbookk
ebookke
ebookkee
pbookkeep
ebookkeepe
rbookkeeper

Akan ada beberapa baris baris terkemuka dan akhir, tetapi kita bisa mengabaikannya.

Dari masing-masing awalan ini kami ingin mempertahankan karakter yang sama dengan karakter terakhir. Untuk itu kami menggunakan tahap penggantian lain:

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

Ini cocok dengan semua yang kami tidak ingin simpan dan gantikan dengan apa-apa. Kami cocok dengan karakter apa pun (menggunakan \Dkarena kami tahu tidak akan ada digit di input) dan kemudian memastikan bahwa tidak ada salinan karakter yang lain di akhir baris.

Python, 56 byte

Saya sepertinya terjebak dengan dua jawaban dengan panjang yang sama:

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)

Sunting: Lihat jawaban @ pacholik untuk pendekatan Python alternatif yang lebih pendek.

Haskell, 39 byte

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

Contoh penggunaan: f "bonobo"-> "bonoobbooo".

Cukup berbeda dari jawaban @ Damien . Bangun string dari kanan dengan mengekstraksi semua kemunculan karakter terakhir dari string dan mengawali panggilan rekursif dengan semua kecuali karakter terakhir.

> <> , 27 byte

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

Membutuhkan juru bahasa resmi yang keluar dengan kesalahan ketika mencoba untuk mencetak kode titik -1. Cobalah online!

Kode membaca input satu karakter sekaligus dan menggunakan baris pertama codebox sebagai array besar yang menyimpan berapa kali masing-masing karakter terlihat sejauh ini (> <> menginisialisasi sel non-program menjadi 0). Baris kedua adalah loop untuk menghasilkan char beberapa kali.

Atau, inilah versi yang keluar dengan bersih (37 byte, tidak di-golf dengan benar):

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

JavaScript (ES6), 48 45 byte

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

Sunting: Disimpan 3 byte berkat @ user81655.

Haskell, 50 42 41 byte

Disimpan 8 byte berkat Lynn

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

MATL , 8 byte

tt!=RsY"

Cobalah online! Atau verifikasi semua kasus uji sekaligus .

Penjelasan

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

Labirin , 54 25 byte

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

Collab lain dengan @ MartinBüttner, yang benar-benar melakukan sebagian besar hampir semua golf untuk yang satu ini. Dengan pembenahan algoritma, kami telah berhasil mengurangi ukuran program dengan cukup banyak!

Cobalah online!

Penjelasan

Primer Labrinth cepat:

• Labyrinth adalah bahasa 2D berbasis stack. Ada dua tumpukan, tumpukan utama dan tambahan, dan muncul dari tumpukan kosong menghasilkan nol.

• Di setiap persimpangan, di mana ada beberapa jalur untuk penunjuk instruksi bergerak ke bawah, bagian atas tumpukan utama diperiksa untuk melihat ke mana harus pergi berikutnya. Negatif belok kiri, nol lurus ke depan dan positif belok kanan.

Dua tumpukan bilangan bulat presisi sewenang-wenang tidak banyak fleksibilitas dalam hal opsi memori. Untuk melakukan penghitungan, program ini sebenarnya menggunakan dua tumpukan sebagai rekaman, dengan menggeser nilai dari satu tumpukan ke tumpukan lainnya seperti memindahkan penunjuk memori ke kiri / kanan oleh sel. Itu tidak persis sama dengan itu, karena kita perlu menyeret penghitung lingkaran dengan kami di atas.

Pertama, tombol <dan >di kedua ujung pop offset dan memutar baris kode yang diimbangi oleh salah satu kiri atau kanan. Mekanisme ini digunakan untuk membuat kode berjalan dalam satu lingkaran - <muncul nol dan memutar baris saat ini ke kiri, menempatkan IP di sebelah kanan kode, dan >muncul nol lagi dan memperbaiki baris kembali.

Inilah yang terjadi setiap iterasi, sehubungan dengan diagram di atas:

[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 byte kode, +1 untuk -p)

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

Pemakaian:

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

Pyth, 7 byte

s@Led._

Suite uji

Test suite berkat DenkerAffe

Penjelasan:

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 byte

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

Buat hashtable kosong, simpan di $b. Ini adalah "counter" kami dari surat-surat apa yang telah kami lihat. Kami kemudian mengambil input $args[0], melemparkannya sebagai char-array, dan mengirimkannya melalui loop. Setiap iterasi, kita mengambil karakter saat ini "$_"dan mengalikannya dengan penghitung pre-incremented pada nilai yang diberikan, yang akan membuat kejadian pertama dikalikan dengan 1, yang kedua dengan 2dan seterusnya. Kami merangkum bahwa dengan -joinjadi itu semua kata menjadi output.

Disimpan 5 byte berkat TessellatingHeckler dengan menggunakan hashtable alih-alih array, jadi kami tidak perlu mengurangi karakter ASCII dengan 97mencapai indeks yang sesuai. Ini berfungsi karena pra-penambahan indeks hash secara implisit memanggil .Add()di latar belakang jika indeks itu tidak ada, karena hashtable bisa berubah.

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

Dyalog APL , 6 byte

∊,\∩¨⊢

TryAPL!

4 fungsi adalah puncak (2-kereta) dari garpu (3-kereta):

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

Pertama ⊢(kanan - no-op) pada string yang diberikan, memberi'bonobo'

Kemudian ,\(scan concatenation) pada string, memberi'b' 'bo' 'bon' 'bono' 'bonob' 'bonobo'

Keduanya bercabang bersama dengan (diberikan sebagai argumen kanan dan kiri untuk) ∩¨(masing-masing persimpangan), yaitu ('b'∩'b') ('bo'∩'o') ('bon'∩'n') ('bono'∩'o') ('bonob'∩'b') ('bonobo'∩'o'), yaitu'b' 'o' 'n' 'oo' 'bb' 'ooo'

Akhirnya, ∊(minta) diterapkan pada hasil untuk meratakannya, memberi'bonoobbooo'

Hei, setidaknya itu cocok dengan Pyth ! Jelas Jelly lebih pendek karena ini adalah versi golf J, yang pada gilirannya adalah dialek 2-karakter-per-fungsi lanjutan dari APL.

Pyth, 11 byte

s.e*b/<Qhkb

Coba di sini!

Penjelasan

se * b / <Qhkb # Q = input

 .e # memetakan input lebih dengan b sebagai nilai dan k sebagai indeks (Q ditambahkan pada bagian akhir secara tidak sengaja)
      <Qhk # ambil k + 1 karakter pertama dari Q
     / b # hitung kejadian b di sana
   * b # ulangi b itu berkali-kali
s # gabung daftar yang dihasilkan menjadi satu string

J, 11 byte

#~+/@(={:)\

Ini adalah kata kerja monadik. Coba di sini. Pemakaian:

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

Penjelasan

#~+/@(={:)\
     (   )\  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 byte

Kode:

$vy«Dy¢y×?

Penjelasan:

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

Menggunakan pengkodean CP-1252 . Cobalah online!

CJam, 14

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

Cobalah online

Penjelasan:

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 byte

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

> <> , 52 byte

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

Ini menumpuk setiap huruf yang dibaca, mencetaknya sekali dan sekali lagi untuk setiap huruf yang sama dalam tumpukan.
Ia menggunakan &register, karena harus menangani 3 variabel pada stack (huruf baca saat ini, posisi di stack, huruf pada posisi ini) sangat merepotkan.

Anda bisa mencobanya di sini !

Rust, 176 Bytes

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()}

Ini menggunakan peta untuk menyimpan string untuk setiap karakter dalam input. Untuk setiap karakter, string akan dihapus dari peta, digabungkan dengan karakter, dimasukkan kembali ke peta dan ditambahkan ke output.

Saya lebih suka menggunakan get(...)daripada remove(...), tetapi pemeriksa pinjaman membuat saya berubah pikiran.

Mathcad, 66 byte

Sayangnya, Mathcad tidak memiliki penanganan string yang sangat baik, jadi saya telah mengonversi string input ke vektor dan kemudian menggunakan vektor (kode karakter yang diindeks) untuk melacak berapa kali karakter ditemui, menambahkan karakter yang beberapa kali ke vektor hasil. Akhirnya, vektor hasil dikonversi kembali ke string. Sayangnya, cukup panjang.

Perhatikan bahwa Mathcad menggunakan antarmuka "papan tulis" 2D, dengan campuran teks dan operator normal; operator biasanya dimasukkan melalui toolbar atau pintasan keyboard; misalnya, ctl- memasuki operator for loop, yang terdiri dari kata kunci untuk, elemen-simbol dan 3 "placeholder" kosong untuk masing-masing variabel iterasi, rentang, dan ekspresi tubuh. Mengetik [setelah nama variabel memasuki mode indeks larik, Mengetik 'memasuki sepasang tanda kurung yang cocok ( kebanyakan ... ada pengecualian tergantung pada apa lagi yang ada di ekspresi sekitarnya )

Javascript ES6 44 byte

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

jawaban lama

Javascript ES6 46 byte

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

//thanks user81655 for -1 byte

Julia, 38 35 byte

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

I / O berasal dari array karakter. Cobalah online!

Bagaimana itu bekerja

Kami (kembali) mendefinisikan operator monadik ! untuk tujuan kita.

Kapan ! disebut, itu akan memeriksa apakah argumen s kosong. Jika ya, ia mengembalikan argumennya.

Jika s adalah non-kosong, kita memotong s dengan karakter terakhirnya ( s[end]), yang menghasilkan semua kemunculan karakter itu di s . Hasil ini digabungkan dengan nilai balik dari panggilan rekursif ke ! dengan s minus karakter terakhirnya ( s[1:end-1]) sebagai argumen.

PHP, 54 51 50 47 byte

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

Jalankan seperti ini:

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

Tweaks

• Disimpan 3 byte dengan menggunakan variabel variabel. Mengubah variabel yang digunakan menjadi huruf besar untuk mencegah tabrakan
• Menyimpan byte dengan menghapus tipe cast nullke intuntuk string offset, karena string offset dilemparkan ke int
• Disimpan 3 byte dengan menggunakan $argnbukan $argv(thx Titus)

Mathematica, 57 byte

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

Kami menggunakan c[x]sebagai tabel pencarian seberapa sering karakter xtelah terjadi. Ini bertambah setiap kali itu diambil di x~StringRepeat~++c[x]. Sayangnya, untuk membuat fungsi ini dapat digunakan kembali, kita perlu mengatur ulang tabel pencarian setiap kali Clear@c;c@_=0;, yang cukup mahal.

awk, 72 byte

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

Idenya adalah untuk menyimpan hitungan karakter yang muncul dalam array asosiatif dan mencetak karakter kali ini.

Beam, 32 33 42 byte

Seharusnya ini lebih kecil, tapi saya kehilangan beberapa byte yang menginisialisasi slot memori ke 0. Menukar beberapa arah aliran berhasil menghilangkan banyak ruang kosong.

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

Cobalah di cuplikan ini

Penjelasan umum.

• Atur semua slot memori dari 0-255 ke 0
• Baca dalam nilai ascii input ke dalam balok
• Jika balok 0 berhenti (balok = toko)
• Dapatkan nilai [balok] memori ke dalam toko, tambahkan dan simpan kembali
• Kurangi toko menjadi 0 untuk mencetak karakter balok
• Ulangi

Python, 66 62 byte

Coba di sini

Golf

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

Tidak disatukan

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