A entrada é uma palavra de letras minúsculas não separadas por espaço em branco. Uma nova linha no final é opcional.

A mesma palavra deve ser impressa em uma versão modificada: para cada caractere, duplique na segunda vez que aparece na palavra original, triplique na terceira vez, etc.

Exemplo de entrada:

bonobo

Exemplo de saída:

bonoobbooo

Aplicam-se as regras de E / S padrão. O código mais curto em bytes vence.

Testes fornecidos por @Neil:

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

Gelatina , 4 bytes

;\f"

Experimente online!

Como funciona

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

Pitão, 6 bytes

Agradecemos a @Doorknob por tirar 1 byte.

Obrigado a @Maltysen por descolar 5 bytes.

s@VQ._

Experimente online!

Como funciona

Por exemplo, pegue a string "bonobo".

._ faz uma lista: ['b', 'bo', 'bon', 'bono', 'bonob', 'bonobo']

VQ._significa "a função anterior vetorizada (aplicada em paralelo) sobre Qe ._", o que significa Q(a entrada avaliada) será tratada como uma lista: ['b', 'o', 'n', 'o', 'b', 'o']e, em seguida, elas serão emparelhadas da @seguinte maneira:

     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'

Portanto, @VQ._irá produzir ['b', 'o', 'n', 'oo', 'bb', 'ooo'].

O sentão une todos eles, criando uma string 'bonoobbooo', que é impressa implicitamente para se tornar bonoobbooo.

Retina , 34 19 bytes

Economizou 15 bytes inspirando-se na solução de isaacg.

A contagem de bytes assume a codificação ISO 8859-1.

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

As linhas vazias à esquerda e à direita são significativas.

Experimente online!

Explicação

$`¶

Este é um estágio de substituição que corresponde ao regex vazio (ou seja, todas as posições de largura zero na string) e o substitui $`¶, onde $`é o prefixo da correspondência e ¶insere um avanço de linha. Isso basicamente calcula todos os prefixos e os coloca em uma linha separada junto com o último caractere desse prefixo:

bb
obo
oboo
kbook
kbookk
ebookke
ebookkee
pbookkeep
ebookkeepe
rbookkeeper

Haverá alguns feeds de linha iniciais e finais, mas podemos ignorá-los.

De cada um desses prefixos, queremos manter os caracteres iguais ao último caractere. Para isso, usamos outro estágio de substituição:

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

Isso corresponde a tudo o que não queremos manter e o substitui por um nada. Combinamos qualquer caractere (usando \Ddesde que sabemos que não haverá dígitos na entrada) e, em seguida, verifique se não há outra cópia desse caractere no final da linha.

Python, 56 bytes

Eu pareço estar preso com duas respostas do mesmo comprimento:

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: Veja a resposta de @ pacholik para uma abordagem Python mais curta e alternativa.

Haskell, 39 bytes

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

Exemplo de uso: f "bonobo"-> "bonoobbooo".

Diferente o suficiente da resposta de @ Damien . Cria a sequência da direita, extraindo todas as ocorrências do último caractere da sequência e precede uma chamada recursiva com todos, exceto o último caractere.

> <> , 27 bytes

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

Requer o intérprete oficial que sai com erro ao tentar imprimir o ponto de código -1. Experimente online!

O código lê a entrada de um caractere de cada vez e usa a primeira linha do codebox como uma matriz grande que armazena o número de vezes que cada caractere foi visto até o momento (>> <> inicializa as células que não são do programa para 0). A segunda linha é um loop para gerar um char várias vezes.

Como alternativa, aqui está uma versão que sai corretamente (37 bytes, não é adequada para o golfe):

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

JavaScript (ES6), 48 45 bytes

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

Editar: salvou 3 bytes graças a @ user81655.

Haskell, 50 42 41 bytes

Economizou 8 bytes graças a Lynn

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

MATL , 8 bytes

tt!=RsY"

Experimente online! Ou verifique todos os casos de teste de uma só vez .

Explicação

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

Labirinto , 54 25 bytes

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

Outra colaboração com @ MartinBüttner, que realmente fez mais quase todo o golfe para este. Renovando o algoritmo, conseguimos reduzir bastante o tamanho do programa!

Experimente online!

Explicação

Uma rápida cartilha Labrinth:

• Labirinto é uma linguagem 2D baseada em pilha. Existem duas pilhas, uma pilha principal e auxiliar, e o surgimento de uma pilha vazia produz zero.

• Em cada junção, onde há vários caminhos para o ponteiro da instrução se mover para baixo, a parte superior da pilha principal é verificada para ver para onde ir. Negativo é virar à esquerda, zero é reto e positivo é virar à direita.

As duas pilhas de números inteiros de precisão arbitrária não são muita flexibilidade em termos de opções de memória. Para realizar a contagem, esse programa realmente usa as duas pilhas como uma fita, com a mudança de um valor de uma pilha para outra sendo semelhante a mover um ponteiro de memória para a esquerda / direita por uma célula. Não é exatamente o mesmo que isso, pois precisamos arrastar um contador de loop conosco no caminho para cima.

Primeiro, as extremidades <e, >em cada extremidade, exibem um deslocamento e giram a linha de código que é deslocada para um lado esquerdo ou direito. Esse mecanismo é usado para fazer o código rodar em um loop - o valor <é zero e gira a linha atual para a esquerda, colocando o IP à direita do código, e o valor >zero e corrige a linha de volta.

Aqui está o que acontece a cada iteração, em relação ao diagrama acima:

[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

(Código de 16 bytes, +1 para -p)

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

Uso:

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

Pitão, 7 bytes

s@Led._

Suíte de teste

Conjunto de testes graças ao DenkerAffe

Explicação:

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[$_]})

Constrói uma hashtable vazia e a armazena $b. Este é o nosso "contador" das letras que vimos. Em seguida, pegamos a entrada $args[0], a convertemos como uma matriz de caracteres e a enviamos por um loop. A cada iteração, pegamos o caractere atual "$_"e o multiplicamos pelo contador pré-incrementado no valor especificado, o que fará com que a primeira ocorrência seja multiplicada 1e a segunda por2 e assim por diante. Encapsulamos isso com um, -joinentão é tudo uma palavra sendo produzida.

Economizou 5 bytes graças ao TessellatingHeckler usando uma tabela de hash em vez de uma matriz, portanto, não precisamos decrementar o caractere ASCII 97para alcançar o índice apropriado. Isso funciona porque o pré-incremento do índice de hash chama implicitamente .Add()em segundo plano se esse índice não existir, pois as hashtables são mutáveis.

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

Dyalog APL , 6 bytes

∊,\∩¨⊢

TryAPL!

4 funções é o topo (2 trens) de um garfo (3 trens):

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

Primeiro ⊢(à direita - no-op) na sequência especificada, fornecendo'bonobo'

Em seguida ,\(varredura de concatenação) na cadeia, fornecendo'b' 'bo' 'bon' 'bono' 'bonob' 'bonobo'

Os dois são bifurcados junto com (dados como argumentos da direita e da esquerda para) ∩¨(interseção cada), ou seja ('b'∩'b') ('bo'∩'o') ('bon'∩'n') ('bono'∩'o') ('bonob'∩'b') ('bonobo'∩'o'), que é'b' 'o' 'n' 'oo' 'bb' 'ooo'

Finalmente, ∊(alistar) é aplicado ao resultado para achatá-lo, dando'bonoobbooo'

Ei, pelo menos ele combina com Pyth ! Obviamente, o Jelly é mais curto, pois é uma versão de golfe do J, que por sua vez é um dialeto avançado de 2 caracteres por função do APL.

Pitão, 11 bytes

s.e*b/<Qhkb

Experimente aqui!

Explicação

se * b / <Qhkb # Q = entrada

 .e # mapeia a entrada com b como valor e k como índice (Q é anexado no final de forma explícita)
      <Qhk # obtém os primeiros k + 1 caracteres de Q
     / b # conta ocorrências de b lá
   * b # repita b tantas vezes
s # junta a lista resultante em uma sequência

J, 11 bytes

#~+/@(={:)\

Este é um verbo monádico. Experimente aqui. Uso:

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

Explicação

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

Código:

$vy«Dy¢y×?

Explicação:

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

Usa a codificação CP-1252 . Experimente online!

CJam, 14

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

Experimente online

Explicação:

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

Ele empilha todas as letras lidas, as imprime uma e outra vez para cada letra semelhante na pilha.
Ele usa o &registro, porque ter que lidar com três variáveis ​​na pilha (letra de leitura atual, posição na pilha, letra nesta posição) é uma dor.

Você pode tentar aqui !

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

Isso usa um mapa para armazenar uma sequência para cada caractere na entrada. Para cada caractere, a sequência será removida do mapa, concatenada com o caractere, inserida novamente no mapa e anexada à saída.

Eu gostaria de usar em get(...)vez de remove(...), mas o verificador de empréstimos me fez mudar de idéia.

Mathcad, 66 bytes

Infelizmente, o Mathcad não possui um manuseio de seqüência de caracteres particularmente bom, então converti a sequência de entrada em um vetor e, em seguida, usei um vetor (indexado pelo código de caractere) para rastrear o número de vezes que um caractere é encontrado, adicionando o caractere que número de vezes para um vetor de resultado. Finalmente, o vetor resultante é convertido novamente em uma sequência. Muito longo, infelizmente.

Observe que o Mathcad usa uma interface 2D de "quadro branco", com uma mistura de texto e operadores normais; os operadores normalmente são inseridos por meio de uma barra de ferramentas ou atalho de teclado; por exemplo, ctl- # insere o operador for loop, que compreende a palavra-chave for, o elemento-of symbol e 3 "placeholders" vazios para a variável de iteração, intervalo e expressões do corpo, respectivamente. Digitando [depois que um nome de variável entra no modo de índice de matriz, Digitando 'entra em um par parênteses correspondente ( principalmente ... há exceções dependendo do que mais há na expressão circundante )

Javascript ES6 44 bytes

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

resposta antiga

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]]

A E / S está na matriz de caracteres. Experimente online!

Como funciona

Nós (re) definimos o operador monádico ! para nossos propósitos.

Quando ! é chamado, verifica se o argumento s está vazio. Se for, ele retorna seu argumento.

Se s é não vazio, cruzamos s com seu último caractere ( s[end]), que produz todas as ocorrências desse caractere em s . Este resultado é concatenado com o valor de retorno de uma chamada recursiva para ! com s menos seu último caractere ( s[1:end-1]) como argumento.

PHP, 54 51 50 47 bytes

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

Execute assim:

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

Tweaks

• Salva 3 bytes usando variáveis ​​variáveis. Alterou as variáveis ​​usadas para maiúsculas para evitar colisão
• Salva um byte, removendo o tipo de conversão nullpara intpara o deslocamento da string, pois o deslocamento da string é convertido para int de qualquer maneira
• Salva 3 bytes usando em $argnvez de $argv(thx Titus)

Mathematica, 57 bytes

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

Utilizamos c[x]como tabela de pesquisa a frequência com que o personagem xjá ocorreu. Isso é incrementado cada vez que é recuperado x~StringRepeat~++c[x]. Infelizmente, para tornar a função reutilizável, precisamos redefinir a tabela de pesquisa toda vez Clear@c;c@_=0;, o que é bastante caro.

awk, 72 bytes

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

A idéia é armazenar a contagem do caractere que aparece em uma matriz associativa e imprimir o caractere essa contagem vezes.

Largura, 32 33 42 bytes

Isso deveria ter sido menor, mas perdi alguns bytes ao inicializar os slots de memória para 0. A troca de algumas direções de fluxo conseguiu eliminar muito espaço vazio.

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

Experimente neste trecho

Explicação geral.

• Defina todos os slots de memória de 0 a 255 a 0
• Leia o valor ascii de entrada no feixe
• Se o feixe é de 0 parada (feixe = loja)
• Coloque o valor da memória [feixe] na loja, aumente e salve de volta
• Decrescente o armazenamento para 0, imprimindo o caractere do feixe
• Repetir

Python, 66 62 bytes

Experimente aqui

Golfe

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