L'entrée est un mot de lettres minuscules non séparées par des espaces. Une nouvelle ligne à la fin est facultative.

Le même mot doit être sorti dans une version modifiée: pour chaque caractère, doublez-le la deuxième fois qu'il apparaît dans le mot d'origine, triplez-le une troisième fois, etc.

Exemple d'entrée:

bonobo

Exemple de sortie:

bonoobbooo

Les règles d'E / S standard s'appliquent. Le code le plus court en octets gagne.

Tests fournis par @Neil:

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

Gelée , 4 octets

;\f"

Essayez-le en ligne!

Comment ça fonctionne

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

Merci à @Doorknob d'avoir enlevé 1 octet.

Merci à @Maltysen d’avoir supprimé 5 octets.

s@VQ._

Essayez-le en ligne!

Comment ça fonctionne

Par exemple, prenez la chaîne "bonobo".

._ fait une liste: ['b', 'bo', 'bon', 'bono', 'bonob', 'bonobo']

VQ._signifie "la fonction précédente vectorisée (appliquée en parallèle) sur Qet ._", ce qui signifie Q(l'entrée évaluée) sera traitée comme une liste:, ['b', 'o', 'n', 'o', 'b', 'o']puis ils seront appariés par ce qui @suit:

     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'

Par conséquent, @VQ._produira ['b', 'o', 'n', 'oo', 'bb', 'ooo'].

Le stout les réunit alors ensemble, créant une chaîne 'bonoobbooo', qui est ensuite implicitement imprimée pour devenir bonoobbooo.

Retina , 34 19 octets

Économisez 15 octets en vous inspirant de la solution isaacg.

Le nombre d'octets suppose un codage ISO 8859-1.

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

Les lignes vides de début et de fin sont significatives.

Essayez-le en ligne!

Explication

$`¶

C'est une étape de remplacement qui correspond à l'expression rationnelle vide (c'est-à-dire chaque position de largeur nulle dans la chaîne) et la remplace $`¶, où $`est le préfixe de la correspondance et ¶insère un saut de ligne. Cela calcule tous les préfixes et les place sur une ligne séparée avec le dernier caractère de ce préfixe:

bb
obo
oboo
kbook
kbookk
ebookke
ebookkee
pbookkeep
ebookkeepe
rbookkeeper

Il y aura des sauts de ligne en tête et en queue, mais nous pouvons les ignorer.

Pour chacun de ces préfixes, nous voulons conserver les caractères égaux au dernier caractère. Pour cela nous utilisons une autre étape de remplacement:

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

Cela correspond à tout ce que nous ne voulons pas conserver et le remplace par un rien. Nous faisons correspondre tout caractère (en utilisant, \Dcar nous savons qu'il n'y aura pas de chiffres dans l'entrée), puis nous nous assurerons qu'il n'y a pas d' autre copie de ce caractère à la fin de la ligne.

Python, 56 octets

Il me semble que je suis coincé avec deux réponses de la même longueur:

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)

Edit: Voir la réponse de @ pacholik pour une approche alternative plus courte en Python.

Haskell, 39 octets

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

Exemple d'utilisation: f "bonobo"-> "bonoobbooo".

Assez différent de la réponse de @ Damien . Construit la chaîne à partir de la droite en extrayant toutes les occurrences du dernier caractère de la chaîne et en ajoutant un appel récursif à tous les caractères sauf le dernier.

> <> , 27 octets

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

Requiert l’interprète officiel qui se termine en essayant d’imprimer le point de code -1. Essayez-le en ligne!

Le code lit l'entrée d'un caractère à la fois et utilise la première ligne de la boîte de code comme un grand tableau qui stocke le nombre de fois que chaque caractère a été vu jusqu'à présent (> <> initialise les cellules non programmées à 0). La deuxième ligne est une boucle permettant de générer plusieurs fois un caractère.

Alternativement, voici une version qui sort proprement (37 octets, pas correctement joué au golf):

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

JavaScript (ES6), 48 45 octets

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

Edit: 3 octets sauvegardés grâce à @ user81655.

Haskell, 50 42 41 octets

Sauvegardé 8 octets grâce à Lynn

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

MATL , 8 octets

tt!=RsY"

Essayez-le en ligne! Ou vérifiez tous les cas de test à la fois .

Explication

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

Labyrinthe , 54 à 25 octets

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

Un autre collab avec @ MartinBüttner, qui a effectivement fait plus la quasi - totalité du golf pour celui - ci. En réaménageant l'algorithme, nous avons réussi à réduire de beaucoup la taille du programme!

Essayez-le en ligne!

Explication

Un rapide apprêt de Labrinth:

• Labyrinth est un langage 2D basé sur des piles. Il y a deux piles, une pile principale et une pile auxiliaire, et le décompression d'une pile vide donne zéro.

• À chaque jonction, où il existe plusieurs chemins pour le pointeur d'instruction à déplacer vers le bas, le haut de la pile principale est vérifié pour voir où aller ensuite. Le négatif est à gauche, le zéro est droit et le positif à droite.

Les deux piles d'entiers de précision arbitraire ne sont pas très flexibles en termes d'options de mémoire. Pour effectuer le comptage, ce programme utilise en fait les deux piles en tant que bande, le déplacement d’une valeur d’une pile à l’autre revenant à déplacer un pointeur de mémoire vers la gauche ou la droite d’une cellule. Ce n’est pas tout à fait la même chose, car nous devons faire glisser un compteur de boucles avec nous vers le haut.

Tout d’abord, les boutons <et >à chaque extrémité créent un décalage et font pivoter la ligne de code qui est décalée d’un côté à l’autre. Ce mécanisme est utilisé pour que le code soit exécuté en boucle: le <zéro s'affiche et la ligne actuelle est pivotée à gauche, en plaçant l'adresse IP à droite du code, puis >un autre zéro et la ligne est corrigée.

Voici ce qui se passe à chaque itération, par rapport au diagramme ci-dessus:

[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 ans

(Code de 16 octets, +1 pour -p)

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

Usage:

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

Pyth, 7 octets

s@Led._

Suite de tests

Suite de test grâce à DenkerAffe

Explication:

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 octets

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

Construit une hashtable vide et la stocke $b. Ceci est notre "compteur" des lettres que nous avons vues. Nous prenons ensuite l’entrée $args[0], la convertissons en tableau de caractères et l’envoyons à travers une boucle. Chaque itération, nous prenons le caractère actuel "$_"et le multiplions par le compteur pré-incrémenté à la valeur donnée, ce qui fera que la première occurrence sera multipliée par 1, la seconde par 2et ainsi de suite. Nous encapsulons cela avec un -joinmot donc tout est en sortie.

5 octets sauvés grâce à TessellatingHeckler en utilisant une table de hachage au lieu d’un tableau, nous n’avions donc pas besoin de décrémenter le caractère ASCII 97pour atteindre l’index approprié. Cela fonctionne car la pré-incrémentation de l'index de hachage appelle implicitement .Add()en arrière-plan si cet index n'existe pas, car les hashtables sont mutables.

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

Dyalog APL , 6 octets

∊,\∩¨⊢

TryAPL!

4 fonctions est un au sommet (2 trains) d'une fourche (3 trains):

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

Premier ⊢(à droite - non-op) sur la chaîne donnée, donnant'bonobo'

Puis ,\(scan de concaténation) sur la chaîne en donnant'b' 'bo' 'bon' 'bono' 'bonob' 'bonobo'

Les deux sont entrelacés avec (donnés comme arguments de droite et de gauche) ∩¨(intersection chaque), c’est ('b'∩'b') ('bo'∩'o') ('bon'∩'n') ('bono'∩'o') ('bonob'∩'b') ('bonobo'∩'o')-à- dire'b' 'o' 'n' 'oo' 'bb' 'ooo'

Enfin, ∊(enlist) est appliqué au résultat pour l’aplatir, en donnant'bonoobbooo'

Hé, au moins ça correspond à Pyth ! De toute évidence, Jelly est plus courte car il s’agit d’une version golf de J, qui est à son tour un dialecte avancé de 2 caractères par fonction d’APL.

Pyth, 11 octets

s.e*b/<Qhkb

Essayez-le ici!

Explication

se * b / <Qhkb # Q = entrée

 .e # mappe sur l'entrée avec b comme valeur et k comme index (Q est ajouté à la fin de manière non explicite)
      <Qhk # prend les k + 1 premiers caractères de Q
     / b # compte les occurrences de b dedans
   * b # répète b que plusieurs fois
s # joindre la liste résultante en une chaîne

J, 11 octets

#~+/@(={:)\

C'est un verbe monadique. Essayez ici. Usage:

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

Explication

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

Code:

$vy«Dy¢y×?

Explication:

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

Utilise le codage CP-1252 . Essayez-le en ligne!

CJam, 14

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

Essayez-le en ligne

Explication:

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 octets

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

> <> , 52 octets

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

Il empile chaque lettre lue, les imprime une fois de plus pour chaque lettre similaire de la pile.
Il utilise le &registre, car devoir gérer 3 variables sur la pile (lettre lue actuelle, position dans la pile, lettre à cette position) est une douleur.

Vous pouvez l'essayer ici !

Rouille, 176 octets

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

Cela utilise une carte pour stocker une chaîne pour chaque caractère de l'entrée. Pour chaque caractère, la chaîne sera supprimée de la carte, concaténée avec le caractère, insérée dans la carte et ajoutée à la sortie.

J'aurais aimé utiliser get(...)au lieu de remove(...), mais le vérificateur d'emprunt m'a fait changer d'avis.

Mathcad, 66 octets

Malheureusement, Mathcad ne gère pas très bien les chaînes. J'ai donc converti la chaîne d'entrée en un vecteur, puis utilisé un vecteur (code de caractère indexé) pour suivre le nombre de fois qu'un caractère est rencontré, en ajoutant le caractère nombre de fois à un vecteur de résultat. Enfin, le vecteur de résultat est reconverti en chaîne. Assez long malheureusement.

Notez que Mathcad utilise une interface "tableau blanc" 2D, combinant du texte normal et des opérateurs; les opérateurs sont normalement entrés via une barre d’outils ou un raccourci clavier; par exemple, ctl- # entre l'opérateur de boucle for, qui comprend le mot clé for, l'élément-of symbol et 3 "espaces réservés" vides pour les expressions de variable d'itération, de plage et de corps, respectivement. Saisie [après que le nom de la variable passe en mode d’index de tableau, Saisie 'entre une paire de parenthèses correspondante (la plupart du temps ... il existe des exceptions qui dépendent de ce qui se trouve dans l’expression environnante )

Javascript ES6 44 octets

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

ancienne réponse

Javascript ES6 46 octets

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

//thanks user81655 for -1 byte

Julia, 38 35 octets

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

I / O est dans le début des tableaux de caractères. Essayez-le en ligne!

Comment ça fonctionne

On (re) définit l'opérateur monadique ! pour nos fins.

Lorsque ! est appelé, il vérifie si son argument s est vide. Si c'est le cas, il retourne son argument.

Si s n'est pas vide, nous intersectons s avec son dernier caractère ( s[end]), ce qui donne toutes les occurrences de ce caractère dans s . Ce résultat est concaténé avec la valeur de retour d'un appel récursif à ! avec s moins son dernier caractère ( s[1:end-1]) comme argument.

PHP, 54 51 50 47 octets

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

Courez comme ça:

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

Tweaks

• Sauvegardé 3 octets en utilisant des variables variables. Changement des variables utilisées en majuscules pour éviter les collisions
• Enregistré un octet en supprimant le transtypage nulldansint de chaîne de décalage, en tant que chaîne de décalage est coulé à toute façon int
• Sauvegardé 3 octets en utilisant à la $argnplace de $argv(merci Titus)

Mathematica, 57 octets

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

Nous utilisons c[x]comme table de correspondance la fréquence à laquelle un personnage xs'est déjà produit. Ceci est incrémenté chaque fois qu'il est récupéré dans x~StringRepeat~++c[x]. Malheureusement, pour rendre la fonction réutilisable, nous devons réinitialiser la table de consultation à chaque fois Clear@c;c@_=0;, ce qui est assez coûteux.

awk, 72 octets

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

L'idée est de stocker le nombre de caractères apparaissant dans un tableau associatif et d'imprimer le caractère multiplié par le nombre de caractères.

Poutre, 32 33 42 octets

Cela aurait dû être plus petit, mais j'ai perdu quelques octets lors de l'initialisation des emplacements de mémoire sur 0. L'échange de certaines directions de flux a permis d'éliminer beaucoup d'espace vide.

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

Essayez-le dans cet extrait

Explication générale

• Définissez tous les emplacements de mémoire de 0 à 255 à 0
• Lire la valeur d'entrée ascii dans le faisceau
• Si le faisceau est à 0 arrêt (beam = store)
• Récupère la valeur de mémoire [faisceau] dans le magasin, incrémente-la et sauvegarde-la
• Décrémentez le magasin à 0 en imprimant le caractère de faisceau
• Répéter

Python, 66 62 octets

Essayez-le ici

Golfé

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