Dane wejściowe to słowo pisane małymi literami, które nie są oddzielone spacjami. Nowa linia na końcu jest opcjonalna.

To samo słowo musi być wyprowadzone w zmodyfikowanej wersji: Dla każdego znaku dwukrotnie go za drugim razem, gdy pojawia się w oryginalnym słowie, potrój go za trzecim razem itp.

Przykładowe dane wejściowe:

bonobo

Przykładowe dane wyjściowe:

bonoobbooo

Obowiązują standardowe zasady we / wy. Najkrótszy kod w bajtach wygrywa.

Testy dostarczone przez @Neil:

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

Galaretka , 4 bajty

;\f"

Wypróbuj online!

Jak to działa

;\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 bajtów

Dzięki @Doorknob za zdjęcie 1 bajtu.

Dzięki @Maltysen za zdjęcie 5 bajtów.

s@VQ._

Wypróbuj online!

Jak to działa

Na przykład weź ciąg "bonobo".

._ tworzy listę: ['b', 'bo', 'bon', 'bono', 'bonob', 'bonobo']

VQ._oznacza „poprzednią funkcję wektoryzowaną (zastosowaną równolegle) nad Qi ._”, co oznacza Q(dane wejściowe ocenione) będą traktowane jako lista: ['b', 'o', 'n', 'o', 'b', 'o']a następnie zostaną sparowane w @następujący sposób:

     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'

W związku z tym, @VQ._będzie produkować ['b', 'o', 'n', 'oo', 'bb', 'ooo'].

sNastępnie łączy je w całość, tworząc łańcuch 'bonoobbooo', który następnie jest domyślnie drukowany stać bonoobbooo.

Retina , 34 19 bajtów

Zaoszczędź 15 bajtów, czerpiąc inspirację z rozwiązania isaacg.

Liczba bajtów zakłada kodowanie ISO 8859-1.

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

Znaczące są wiodące i końcowe puste linie.

Wypróbuj online!

Wyjaśnienie

$`¶

Jest to etap zastępowania, który pasuje do pustego wyrażenia regularnego (tj. Każdej pozycji o zerowej szerokości w łańcuchu) i zastępuje $`¶go, gdzie $`jest prefiksem dopasowania i ¶wstawia znak linii. To w zasadzie oblicza wszystkie prefiksy i umieszcza je w osobnej linii wraz z ostatnim znakiem tego prefiksu:

bb
obo
oboo
kbook
kbookk
ebookke
ebookkee
pbookkeep
ebookkeepe
rbookkeeper

Będą pewne wiodące i końcowe linie, ale możemy je zignorować.

Z każdego z tych przedrostków chcemy zachować znaki równe ostatniemu znakowi. W tym celu wykorzystujemy kolejny etap wymiany:

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

To pasuje do wszystkiego, czego nie chcemy zachować i zastępuje je niczym. Dopasowujemy dowolny znak (używając, \Dponieważ wiemy, że na wejściu nie będzie cyfr), a następnie upewniamy się, że nie ma innej kopii tego znaku na końcu wiersza.

Python, 56 bajtów

Wydaje mi się, że utknąłem z dwiema odpowiedziami o tej samej długości:

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)

Edycja: Zobacz odpowiedź @ pacholik na krótsze, alternatywne podejście do Pythona.

Haskell, 39 bajtów

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

Przykład użycia: f "bonobo"-> "bonoobbooo".

Wystarczająco różni się od odpowiedzi @ Damiena . Tworzy ciąg od prawej strony, wyodrębniając wszystkie wystąpienia ostatniego znaku z ciągu i przygotowując wywołanie rekurencyjne ze wszystkimi znakami oprócz ostatniego.

> <> , 27 bajtów

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

Wymaga oficjalnego tłumacza, który kończy się błędem podczas próby wydrukowania kodu punktu -1. Wypróbuj online!

Kod odczytuje dane wejściowe jeden znak na raz i używa pierwszego rzędu szafy kodowej jako dużej tablicy, która przechowuje liczbę wyświetleń każdego znaku (> <> inicjuje komórki nieprogramowe na 0). Drugi rząd to pętla wielokrotnego wyprowadzania znaku.

Alternatywnie, oto wersja, która wychodzi czysto (37 bajtów, źle golfowana):

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

JavaScript (ES6), 48 45 bajtów

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

Edycja: Zapisano 3 bajty dzięki @ user81655.

Haskell, 50 42 41 bajtów

Zaoszczędź 8 bajtów dzięki Lynn

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

MATL , 8 bajtów

tt!=RsY"

Wypróbuj online! Lub zweryfikuj wszystkie przypadki testowe jednocześnie .

Wyjaśnienie

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

Labirynt , 54 25 bajtów

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

Innym collab z @ MartinBüttner, kto faktycznie zrobił najbardziej prawie wszystkie gry w golfa dla tego jednego. Przebudowując algorytm, udało nam się znacznie zmniejszyć rozmiar programu!

Wypróbuj online!

Wyjaśnienie

Szybki podkład Labrinth:

• Labirynt to język 2D oparty na stosie. Istnieją dwa stosy, główny i pomocniczy, a wyskakiwanie z pustego stosu daje zero.

• Na każdym skrzyżowaniu, gdzie istnieje wiele ścieżek, w których wskaźnik instrukcji przesuwa się w dół, sprawdzana jest góra głównego stosu, aby zobaczyć, gdzie iść dalej. Negatyw to skręt w lewo, zero to kierunek na wprost, a dodatni to zwrot w prawo.

Dwa stosy liczb całkowitych o dowolnej precyzji nie są zbyt elastyczne pod względem opcji pamięci. Aby wykonać zliczanie, ten program faktycznie używa dwóch stosów jako taśmy, przy czym przesunięcie wartości z jednego stosu na drugi jest podobne do przesunięcia wskaźnika pamięci w lewo / prawo o komórkę. Nie jest to jednak to samo, ponieważ po drodze w górę musimy przeciągnąć licznik pętli.

Po pierwsze, <i >na obu końcach pop offset i obrócić wiersz kodu, który offsetowej z dala od jednego prawej lub lewej strony. Ten mechanizm służy do uruchamiania kodu w pętli -< wyskakuje zero i obraca bieżący wiersz w lewo, umieszczając adres IP po prawej stronie kodu, a >wyskakuje o kolejne zero i naprawia wiersz z powrotem.

Oto, co dzieje się z każdą iteracją, w odniesieniu do powyższego schematu:

[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-bajtowy kod, +1 dla -p)

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

Stosowanie:

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

Pyth, 7 bajtów

s@Led._

Zestaw testowy

Zestaw testowy dzięki DenkerAffe

Wyjaśnienie:

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 bajtów

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

Konstruuje pustą tablicę mieszającą, przechowuje ją $b. To jest nasz „licznik” listów, które widzieliśmy. Następnie pobieramy dane wejściowe $args[0], rzutujemy je jako tablicę znaków i wysyłamy przez pętlę. Przy każdej iteracji bierzemy bieżący znak "$_"i mnożymy go przez wstępnie zwiększony licznik o podanej wartości, co spowoduje, że pierwsze wystąpienie zostanie pomnożone przez 1, drugie przez2 itd. Podsumowujemy to -jointak, że wypisywane jest tylko jedno słowo.

Zaoszczędź 5 bajtów dzięki TessellatingHeckler , używając tablicy hashtowej zamiast tablicy, więc nie musieliśmy zmniejszać znaku ASCII, 97aby osiągnąć odpowiedni indeks. Działa to, ponieważ wstępne zwiększenie indeksu skrótu domyślnie wywołuje .Add()w tle, jeśli ten indeks nie istnieje, ponieważ tabele skrótów można modyfikować.

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

Dyalog APL , 6 bajtów

∊,\∩¨⊢

TryAPL!

4 funkcje są na szczycie (2 pociągi) widelca (3 pociągi):

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

Najpierw ⊢(z prawej - no-op) na danym ciągu, dając'bonobo'

Następnie ,\(skan konkatenacji) na łańcuchu, dając'b' 'bo' 'bon' 'bono' 'bonob' 'bonobo'

Obie są rozwidlone razem z (podanymi jako prawy i lewy argument do) ∩¨(każdy przecięcie), tj. ('b'∩'b') ('bo'∩'o') ('bon'∩'n') ('bono'∩'o') ('bonob'∩'b') ('bonobo'∩'o')Którym jest'b' 'o' 'n' 'oo' 'bb' 'ooo'

Na koniec ∊(wynik) zostaje zastosowany do wyniku, aby go spłaszczyć, dając'bonoobbooo'

Hej, przynajmniej pasuje do Pytha ! Oczywiście Jelly jest krótszy, ponieważ jest golfową wersją J, która z kolei jest zaawansowanym dialektem APL z 2 znakami na funkcję.

Pyth, 11 bajtów

s.e*b/<Qhkb

Wypróbuj tutaj!

Wyjaśnienie

se * b / <Qhkb # Q = wejście

 .e # mapowanie danych wejściowych z b jako wartością i k jako indeksem (Q dołącza się na końcu niejawnie)
      <Qhk # weź pierwsze k + 1 znaków Q
     / b # policz tam wystąpienia b
   * b # powtórz b tyle razy
s # dołącz wynikową listę do jednego ciągu

J, 11 bajtów

#~+/@(={:)\

To jest czasownik monadyczny. Wypróbuj tutaj. Stosowanie:

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

Wyjaśnienie

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

Kod:

$vy«Dy¢y×?

Wyjaśnienie:

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

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

CJam, 14

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

Wypróbuj online

Wyjaśnienie:

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 bajtów

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

> <> , 52 bajty

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

Układa każdą przeczytaną literę, drukuje je raz za razem dla każdej podobnej litery na stosie.
Wykorzystuje &rejestr, ponieważ konieczność obsługi 3 zmiennych na stosie (bieżąca czytana litera, pozycja na stosie, litera w tej pozycji) jest uciążliwa.

Możesz spróbować tutaj !

Rdza, 176 bajtów

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

To używa mapy do przechowywania ciągu dla każdego znaku na wejściu. Dla każdego znaku ciąg zostanie usunięty z mapy, połączony ze znakiem, wstawiony z powrotem do mapy i dołączony do wyniku.

Chciałbym użyć get(...)zamiast remove(...), ale sprawdzanie pożyczek kazało mi zmienić zdanie.

Mathcad, 66 bajtów

Niestety Mathcad nie ma szczególnie dobrej obsługi ciągu, więc przekonwertowałem ciąg wejściowy na wektor, a następnie użyłem wektora (indeksowanego kodem znaków), aby śledzić liczbę napotkanych znaków, dodając znak, że ile razy wektor wynikowy. Na koniec wektor wynikowy jest konwertowany z powrotem na ciąg. Niestety dość długa.

Zauważ, że Mathcad korzysta z interfejsu 2D „tablicy” z mieszanką normalnego tekstu i operatorów; operatory są zwykle wprowadzane za pomocą paska narzędzi lub skrótu klawiaturowego; na przykład, ctl- # wchodzi do operatora pętli for, który zawiera słowo kluczowe symbol elementu-symbol i 3 puste „symbole zastępcze” odpowiednio dla zmiennej iteracji, zakresu i wyrażeń treści. Wpisywanie [po wprowadzeniu nazwy zmiennej do trybu indeksu tablicowego, Wpisanie „wprowadza dopasowaną parę nawiasów ( przeważnie ... są wyjątki w zależności od tego, co jeszcze znajduje się w otaczającym wyrażeniu )

JavaScript ES6 44 bajty

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

stara odpowiedź

JavaScript ES6 46 bajtów

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

//thanks user81655 for -1 byte

Julia, 38 35 bajtów

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

I / O pochodzi z tablic znaków. Wypróbuj online!

Jak to działa

Definiujemy operator monadyczny ! do naszych celów.

Kiedy ! jest wywoływany, sprawdza, czy jego argument s jest pusty. Jeśli tak, zwraca argument.

Jeśli s nie jest puste, przecinamy s jego ostatnim znakiem ( s[end]), co daje wszystkie wystąpienia tego znaku w s . Ten wynik jest łączony z wartością zwrotną wywołania rekurencyjnego do ! ze s minus ostatni znak ( s[1:end-1]) jako argument.

PHP, 54 51 50 47 bajtów

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

Uruchom tak:

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

Poprawki

• Zapisano 3 bajty przy użyciu zmiennych zmiennych. Zmieniono używane zmienne na wielkie litery, aby zapobiec kolizji
• Zapisano bajt, usuwając rzut typu nullna intdla przesunięcia łańcucha, ponieważ przesunięcie łańcucha jest rzutowane na int
• Zapisano 3 bajty, używając $argnzamiast $argv(thx Titus)

Mathematica, 57 bajtów

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

Używamy c[x]jako tabeli przeglądowej tego, jak często postać xjuż występowała. Jest to zwiększane za każdym razem, gdy jest pobierane x~StringRepeat~++c[x]. Niestety, aby funkcja była wielokrotnego użytku, musimy za każdym razem resetować tabelę wyszukiwania Clear@c;c@_=0;, co jest dość kosztowne.

awk, 72 bajty

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

Chodzi o to, aby zapisać liczbę pojawiających się znaków w tablicy asocjacyjnej i wydrukować liczbę razy.

Belka, 32 33 42 bajtów

Powinno to być mniejsze, ale straciłem kilka bajtów inicjujących gniazda pamięci do 0. Zamiana niektórych kierunków przepływu pozwoliła wyeliminować dużo pustej przestrzeni.

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

Wypróbuj w tym fragmencie

Ogólne wyjaśnienie.

• Ustaw wszystkie gniazda pamięci od 0-255 do 0
• Wczytaj wejściową wartość ascii do wiązki
• Jeśli wiązka wynosi 0, zatrzymaj się (wiązka = zapisz)
• Pobierz wartość pamięci [wiązki] do sklepu, zwiększ ją i zapisz
• Zmniejsz wartość sklepu do 0, drukując znak wiązki
• Powtarzać

Python, 66 62 bajtów

Wypróbuj tutaj

Grał w golfa

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

Bez golfa

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