Die Eingabe ist ein Wort aus Kleinbuchstaben, die nicht durch Leerzeichen getrennt sind. Eine neue Zeile am Ende ist optional.

Das gleiche Wort muss in einer modifizierten Version ausgegeben werden: Verdoppeln Sie es für jedes Zeichen, wenn es das zweite Mal im Originalwort vorkommt, verdreifachen Sie es das dritte Mal usw.

Beispiel Eingabe:

bonobo

Beispielausgabe:

bonoobbooo

Es gelten die Standard-E / A-Regeln. Der kürzeste Code in Bytes gewinnt.

Von @Neil bereitgestellte Tests:

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

Gelee , 4 Bytes

;\f"

Probieren Sie es online!

Wie es funktioniert

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

Vielen Dank an @Doorknob für das Abheben von 1 Byte.

Danke an @Maltysen für die 5 Bytes.

s@VQ._

Probieren Sie es online!

Wie es funktioniert

Nehmen Sie zum Beispiel die Zeichenfolge "bonobo".

._ macht eine Liste: ['b', 'bo', 'bon', 'bono', 'bonob', 'bonobo']

VQ._bedeutet "die vorhergehende Funktion vektorisiert (parallel angewendet) über Qund ._", was bedeutet, dass Q(die ausgewertete Eingabe) als Liste behandelt wird: ['b', 'o', 'n', 'o', 'b', 'o']und dann werden sie wie folgt gepaart @:

     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'

Daher @VQ._wird produzieren ['b', 'o', 'n', 'oo', 'bb', 'ooo'].

Das sfügt sie dann alle zusammen und erzeugt einen String 'bonoobbooo', der dann implizit ausgedruckt wird, um zu werden bonoobbooo.

Retina , 34 19 Bytes

Einsparung von 15 Byte durch Anregung durch die isaacg-Lösung.

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

Die führenden und nachfolgenden Leerzeilen sind signifikant.

Probieren Sie es online!

Erläuterung

$`¶

Dies ist eine Ersetzungsstufe, die mit dem leeren regulären Ausdruck (dh jeder Position mit der Breite Null in der Zeichenfolge) übereinstimmt und $`¶diesen ersetzt, wobei $`das Präfix der Übereinstimmung ist und ¶ein Zeilenvorschub eingefügt wird. Dies berechnet im Grunde genommen alle Präfixe und fügt sie zusammen mit dem letzten Zeichen dieses Präfixes in eine separate Zeile ein:

bb
obo
oboo
kbook
kbookk
ebookke
ebookkee
pbookkeep
ebookkeepe
rbookkeeper

Es wird einige führende und nachfolgende Zeilenvorschübe geben, aber wir können sie ignorieren.

Von jedem dieser Präfixe möchten wir die Zeichen behalten, die gleich dem letzten Zeichen sind. Dafür verwenden wir eine andere Ersetzungsstufe:

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

Das passt zu allem, was wir nicht behalten wollen und ersetzt es durch ein Nichts. Wir stimmen mit jedem Zeichen überein (verwenden, \Dda wir wissen, dass die Eingabe keine Ziffern enthält) und stellen dann sicher, dass am Ende der Zeile keine weitere Kopie dieses Zeichens vorhanden ist .

Python, 56 Bytes

Ich habe offenbar zwei Antworten von gleicher Länge:

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)

Bearbeiten: Siehe @ pacholiks Antwort für einen kürzeren, alternativen Python-Ansatz.

Haskell, 39 Bytes

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

Anwendungsbeispiel: f "bonobo"-> "bonoobbooo".

Ganz anders als @ Damiens Antwort . Erstellt die Zeichenfolge von rechts, indem alle Vorkommen des letzten Zeichens aus der Zeichenfolge extrahiert und einem rekursiven Aufruf alle Zeichen bis auf das letzte vorangestellt werden.

> <> 27 Bytes

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

Erfordert den offiziellen Interpreter, der beim Versuch, den Codepunkt -1 zu drucken, mit einem Fehler beendet wird. Probieren Sie es online!

Der Code liest jedes Zeichen einzeln ein und verwendet die erste Zeile der Codebox als großes Array, in dem gespeichert wird, wie oft jedes Zeichen bisher gesehen wurde (> <> initialisiert Nicht-Programmzellen auf 0). Die zweite Zeile ist eine Schleife zum mehrmaligen Ausgeben eines Zeichens.

Alternativ ist hier eine Version, die sauber beendet wird (37 Bytes, nicht richtig golfen):

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

JavaScript (ES6), 48-45 Byte

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

Bearbeiten: 3 Bytes dank @ user81655 gespeichert.

Haskell, 50 42 41 Bytes

8 Bytes dank Lynn gespeichert

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

MATL , 8 Bytes

tt!=RsY"

Probieren Sie es online! Oder überprüfen Sie alle Testfälle auf einmal .

Erläuterung

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

Labyrinth , 54 25 Bytes

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

Eine weitere Zusammenarbeit mit @ MartinBüttner, der eigentlich am meisten getan hat fast alle der Golf für diese ein. Durch die Überarbeitung des Algorithmus ist es uns gelungen, die Programmgröße um einiges zu reduzieren!

Probieren Sie es online!

Erläuterung

Ein kurzer Labrinth-Primer:

• Labyrinth ist eine stapelbasierte 2D-Sprache. Es gibt zwei Stapel, einen Haupt- und einen Hilfsstapel, und das Abspringen von einem leeren Stapel ergibt Null.

• An jeder Kreuzung, an der es mehrere Pfade gibt, auf denen sich der Befehlszeiger nach unten bewegen kann, wird die Oberseite des Hauptstapels überprüft, um festzustellen, wohin er als nächstes gehen soll. Negativ ist links abbiegen, Null ist geradeaus und positiv ist rechts abbiegen.

Die zwei Stapel von Ganzzahlen mit willkürlicher Genauigkeit sind hinsichtlich der Speicheroptionen nicht sehr flexibel. Um die Zählung durchzuführen, verwendet dieses Programm die beiden Stapel tatsächlich als Band, wobei das Verschieben eines Wertes von einem Stapel zum anderen der Bewegung eines Speicherzeigers um eine Zelle nach links / rechts gleicht. Es ist jedoch nicht ganz dasselbe, da wir auf dem Weg nach oben einen Schleifenzähler mitziehen müssen.

Zunächst wird mit <und >an beiden Enden ein Versatz eingefügt, und die Codezeile wird um einen Versatz nach links oder rechts gedreht. Dieser Mechanismus wird verwendet, um den Code in einer Schleife laufen zu lassen - das <Pops eine Null und dreht die aktuelle Zeile nach links, wobei die IP rechts vom Code steht, und das >Pops eine weitere Null und repariert die Zeile zurück.

Folgendes passiert bei jeder Iteration im Zusammenhang mit dem obigen Diagramm:

[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-Code, +1 für -p)

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

Verwendungszweck:

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

Pyth, 7 Bytes

s@Led._

Testsuite

Testsuite dank DenkerAffe

Erläuterung:

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 Bytes

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

Erstellt eine leere Hashtabelle und speichert sie in $b. Dies ist unser "Zähler" für die Buchstaben, die wir gesehen haben. Wir nehmen dann die Eingabe $args[0], wandeln sie in ein Zeichen-Array um und senden sie durch eine Schleife. Bei jeder Iteration nehmen wir das aktuelle Zeichen "$_"und multiplizieren es mit dem vorinkrementierten Zähler mit dem angegebenen Wert, wodurch das erste Vorkommen mit 1, das zweite mit multipliziert wird2 usw. . Wir fassen dies mit einem zusammen, -joinsodass nur ein Wort ausgegeben wird.

Dank TessellatingHeckler konnten 5 Byte mithilfe einer Hashtabelle anstelle eines Arrays eingespart werden, sodass das ASCII-Zeichen nicht um dekrementiert werden musste 97, um den entsprechenden Index zu erreichen. Dies funktioniert, weil vor dem Inkrementieren des Hash-Index implizit .Add()im Hintergrund aufgerufen wird, wenn dieser Index nicht vorhanden ist, da Hash- Tabellen veränderbar sind.

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

Dyalog APL , 6 Bytes

∊,\∩¨⊢

TryAPL!

4 Funktionen ist eine Spitze (2-Zug) einer Gabel (3-Zug):

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

Zuerst ⊢(rechts - ein No-Op) auf der angegebenen Zeichenfolge geben'bonobo'

Dann ,\(Verkettungsscan) auf den String geben'b' 'bo' 'bon' 'bono' 'bonob' 'bonobo'

Die beiden werden zusammen mit (jeweils als rechtes und linkes Argument an gegeben) ∩¨(Schnittmenge) gegabelt , dh ('b'∩'b') ('bo'∩'o') ('bon'∩'n') ('bono'∩'o') ('bonob'∩'b') ('bonobo'∩'o')welches ist'b' 'o' 'n' 'oo' 'bb' 'ooo'

Schließlich wird ∊(enlist) auf das Ergebnis angewendet, um es zu verflachen und zu geben'bonoobbooo'

Hey, zumindest passt es zu Pyth ! Offensichtlich ist Jelly kürzer, da es sich um eine Golfversion von J handelt, bei der es sich wiederum um einen fortgeschrittenen 2-Zeichen-pro-Funktion-Dialekt von APL handelt.

Pyth, 11 Bytes

s.e*b/<Qhkb

Probieren Sie es hier aus!

Erläuterung

se * b / <Qhkb # Q = Eingabe

 .e # map over input mit b als Wert und k als Index (Q wird am Ende implizit angehängt)
      <Qhk # nimm die ersten k + 1 Zeichen von Q
     / b # Zähle Vorkommen von b dort
   * b # Wiederhole b so oft
s # Füge die resultierende Liste zu einer Zeichenkette zusammen

J, 11 Bytes

#~+/@(={:)\

Dies ist ein monadisches Verb. Probieren Sie es hier aus. Verwendungszweck:

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

Erläuterung

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

Code:

$vy«Dy¢y×?

Erläuterung:

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

Verwendet die CP-1252- Codierung. Probieren Sie es online!

CJam, 14

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

Probieren Sie es online aus

Erläuterung:

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 Bytes

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

> <> , 52 Bytes

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

Jeder gelesene Buchstabe wird gestapelt und für jeden ähnlichen Buchstaben im Stapel erneut gedruckt.
Es benutzt das &Register, weil es mühsam ist, mit 3 Variablen auf dem Stapel (aktueller gelesener Brief, Position im Stapel, Buchstabe an dieser Position) umzugehen.

Sie können es hier ausprobieren !

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

Dies verwendet eine Map, um eine Zeichenfolge für jedes Zeichen in der Eingabe zu speichern. Für jedes Zeichen wird die Zeichenfolge aus der Map entfernt, mit dem Zeichen verknüpft, wieder in die Map eingefügt und an die Ausgabe angehängt.

Am liebsten hätte ich get(...)stattdessen verwendet remove(...), aber der Leihscheck hat mich umentschieden.

Mathcad, 66 Bytes

Leider hat Mathcad keine besonders gute Zeichenkettenverarbeitung, daher habe ich die Eingabezeichenkette in einen Vektor konvertiert und dann einen (zeichencodeindizierten) Vektor verwendet, um die Häufigkeit zu verfolgen, mit der ein Zeichen angetroffen wird, wobei das Zeichen hinzugefügt wird Anzahl von Malen zu einem Ergebnisvektor. Schließlich wird der Ergebnisvektor zurück in eine Zeichenfolge konvertiert. Leider ziemlich lang.

Beachten Sie, dass Mathcad eine 2D-Whiteboard-Oberfläche mit einer Mischung aus normalem Text und Operatoren verwendet. Operatoren werden normalerweise über eine Symbolleiste oder eine Tastenkombination eingegeben. Beispielsweise gibt ctl- # den for-Schleifenoperator ein, der das Schlüsselwort für das Symbolelement und 3 leere "Platzhalter" für die Iterationsvariable, den Bereichs- bzw. den Textausdruck enthält. Typing [Wenn ein Variablenname in den Array-Indexmodus wechselt, gibt Typing 'ein übereinstimmendes Klammerpaar ein ( meistens gibt es Ausnahmen, je nachdem, was im umgebenden Ausdruck noch enthalten ist ).

Javascript ES6 44 Bytes

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

alte Antwort

Javascript ES6 46 Bytes

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

//thanks user81655 for -1 byte

Julia, 38 35 Bytes

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

I / O ist in der Form von Zeichenfeldern. Probieren Sie es online!

Wie es funktioniert

Wir definieren den monadischen Operator (neu) ! für unsere Zwecke.

Wann ? aufgerufen wird, prüft es, ob sein Argument s leer ist. Wenn dies der Fall ist, wird das Argument zurückgegeben.

Wenn s nicht leer ist, schneiden wir s mit seinem letzten Zeichen ( s[end]), was alle Vorkommen dieses Zeichens in s ergibt . Dieses Ergebnis wird mit dem Rückgabewert eines rekursiven Aufrufs von ! Verknüpft. mit s minus dem letzten Zeichen ( s[1:end-1]) als Argument.

PHP, 54 51 50 47 Bytes

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

Laufen Sie wie folgt:

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

Optimierungen

• 3 Bytes mit variablen Variablen gespeichert. Die verwendeten Variablen wurden in Großbuchstaben geändert, um Kollisionen zu vermeiden
• Gespeichert ein Byte durch Typumwandlung zu entfernen , nullum intfür String - Offset, als String versetzt ist sowieso int gegossen
• 3 Bytes gespart durch Verwendung von $argnanstelle von $argv(thx Titus)

Mathematica, 57 Bytes

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

Wir verwenden c[x]als Nachschlagetabelle, wie oft Zeichen xbereits vorgekommen sind. Dieser Wert wird jedes Mal erhöht, wenn er abgerufen wird x~StringRepeat~++c[x]. Leider müssen wir die Nachschlagetabelle jedes Mal mit zurücksetzen, um die Funktion wieder verwendbar zu machen Clear@c;c@_=0;, was ziemlich teuer ist.

awk, 72 bytes

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

Die Idee ist, die Anzahl der erscheinenden Zeichen in einem assoziativen Array zu speichern und das Zeichen diesmal auszudrucken.

Strahl, 32 33 42 Bytes

Dies hätte kleiner sein sollen, aber ich habe einige Bytes verloren, die die Speichersteckplätze auf 0 initialisierten. Durch das Auswechseln einiger Flussrichtungen konnte viel leerer Speicherplatz beseitigt werden.

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

Probieren Sie es in diesem Snippet aus

Allgemeine Erklärung.

• Stellen Sie alle Speichersteckplätze von 0 bis 255 auf 0 ein
• Lesen Sie den eingegebenen ASCII-Wert in den Strahl ein
• Wenn beam 0 ist halt (beam = store)
• Holen Sie sich den Speicherwert in den Speicher, erhöhen Sie ihn und speichern Sie ihn zurück
• Dekrementieren Sie den Speicher auf 0, um das Balkenzeichen auszudrucken
• Wiederholen

Python, 66 62 Bytes

Probieren Sie es hier aus

Golf gespielt

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