输入是不由空格分隔的小写字母单词。最后的换行符是可选的。
必须以修改后的版本输出相同的单词：对于每个字符，第二次在原始单词中出现时将其翻倍，第三次出现中以此类推。
输入示例：
bonobo
输出示例：
bonoobbooo
适用标准I / O规则。以字节为单位的最短代码获胜。
@Neil提供的测试：
tutu -> tuttuu
queue -> queuuee
bookkeeper -> boookkkeeepeeer
repetitive -> repeetittiiveee
uncopyrightables -> uncopyrightables
abracadabra -> abraacaaadaaaabbrraaaaa
mississippi -> misssiisssssssiiipppiiii
Answers:
;\f"
;\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.
感谢@Doorknob腾出 1个字节。
感谢@Maltysen腾出 5个字节。
s@VQ._
例如，使用字符串"bonobo"。
._ 列出： ['b', 'bo', 'bon', 'bono', 'bonob', 'bonobo']
VQ._表示“前面的函数在Q和上向量化（并行应用）._”，这意味着Q（被评估的输入）将被视为list ['b', 'o', 'n', 'o', 'b', 'o']：，然后将它们配对，@如下所示：
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'
因此，@VQ._会产生['b', 'o', 'n', 'oo', 'bb', 'ooo']。
在s随后加入他们一起，创建一个字符串'bonoobbooo'，然后将其隐含打印出来，成为bonoobbooo。
VQ仅表示for N in Q当它不在函数内部时。在这种情况下，实际发生的情况是@V该@函数在其后两个参数Q和上向量化（并行应用）._。文档中缺少此内容，因此我将对其进行修复。
通过从isaacg的解决方案中获得启发，节省了15个字节。
字节数假定为ISO 8859-1编码。
$`¶
(\D)(?!.*\1¶)
开头和结尾的空行很重要。
$`¶
这是一个替换阶段，它匹配空的正则表达式（即字符串中的每个零宽度位置）并替换$`¶它，其中$`match是前缀，并¶插入换行符。基本上，这将计算所有前缀，并将它们与该前缀的最后一个字符放在单独的行上：
bb
obo
oboo
kbook
kbookk
ebookke
ebookkee
pbookkeep
ebookkeepe
rbookkeeper
会有一些前导和尾随换行符，但是我们可以忽略它们。
我们希望从每个前缀中保留与最后一个字符相同的字符。为此，我们使用另一个替换阶段：
(\D)(?!.*\1¶)
这符合我们的一切不希望保留，并用什么来替换它。我们匹配任何字符（使用，\D因为我们知道输入中不会有数字），然后确保该行的末尾没有该字符的另一个副本。
我似乎被两个长度相同的答案所困扰：
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)编辑：请参阅@pacholik的答案，以获取更短的替代Python方法。
+1具有足够高的优先级的增量，因此不需要括号
f""=""
f x=f(init x)++filter(==last x)x
用法示例：f "bonobo"-> "bonoobbooo"。
与@Damien的答案足够不同。通过从字符串中提取所有出现的最后一个字符并在除最后一个字符之外的所有字符之前进行递归调用，从右侧构建字符串。
>i:0g1+:\
:{-1v!?:<}o
/p${/
需要正式的解释程序，该解释程序在尝试打印代码点-1时会错误退出。在线尝试！
该代码一次读取一个输入的字符，并将代码箱的第一行用作大数组，该数组存储到目前为止每个字符的可见次数（> <>将非程序单元初始化为0）。第二行是用于多次输出char的循环。
另外，这是一个可以完全退出的版本（37个字节，未正确打高尔夫球）：
>i:0(?;:0g1+:\
}o:{-1v!?: <
v p${<
chr(-1)。动画解释器非常适合可视化，但是不幸的是，与官方解释器的某些差异有点令人讨厌：/
tt!=RsY"
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
<#; "#: ={},>
}=}(.);("@
另一种协同合作与@MartinBüttner，究竟是谁做了大部分的几乎所有高尔夫的这一个。通过改进算法，我们设法将程序大小减少了很多！
快速的Labrinth入门：
迷宫是一种基于堆栈的2D语言。有两个堆栈，一个是主堆栈，另一个是辅助堆栈，从空堆栈弹出会产生零。
在每个结点处，指令指针有多个向下移动的路径，将检查主堆栈的顶部以查看下一步的位置。负数是左转，零是正数，正数是右转。
就内存选项而言，任意精度整数的两个堆栈没有太大的灵活性。为了执行计数，该程序实际上使用两个堆栈作为磁带，将值从一个堆栈移动到另一个堆栈，类似于将存储指针左右移动一个单元。但是，这并不完全相同，因为我们需要在向上拖动一个循环计数器。
首先，<and >在任一端都弹出一个偏移量，然后向左或向右旋转偏移量的代码行。这种机制用于使代码循环运行- <弹出一个零并向左旋转当前行，将IP置于代码的右侧，>弹出另一个零并向后固定该行。
相对于上图，这是每次迭代发生的情况：
[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
def f(s):*s,x=s;return s and f(s)+x+x*s.count(x)or x
f=lambda s:s and f(s[:-1])+s[-1]*s.count(s[-1])
$b=@{};-join([char[]]$args[0]|%{"$_"*++$b[$_]})
构造一个空的哈希表，并将其存储在中$b。这是我们所看到的字母的“计数器”。然后$args[0]，我们接受输入，将其转换为字符数组，然后通过循环发送。每次迭代时，我们都会获取当前字符"$_"并将其乘以给定值处的预递增计数器，这将使第一次出现的次数乘以1，第二次出现的次数2以此类推。我们用a封装它，-join这样就输出了一个单词。
通过使用哈希表而不是数组，感谢TessellatingHeckler节省了5个字节，因此我们不需要通过递减ASCII字符97来达到适当的索引。之所以起作用，是因为.Add()如果哈希索引是可变的，则如果哈希索引不存在，则预增加哈希索引会在后台隐式调用。
PS C:\Tools\Scripts\golfing> .\stretch-the-word.ps1 tessellatingheckler
tessseelllattingheeeckllleeeer
∊,\∩¨⊢
叉子（3列）的顶部（2列）有4个功能：
┌──┴──┐
∊ ┌───┼─┐
\ ¨ ⊢
┌─┘ ┌─┘
, ∩
⊢给定字符串的第一个（对–不操作），给出'bonobo'
然后,\（串联扫描）在字符串上，给出'b' 'bo' 'bon' 'bono' 'bonob' 'bonobo'
两个与（给定为右和左参数）一起分叉∩¨（交叉点的每个），即('b'∩'b') ('bo'∩'o') ('bon'∩'n') ('bono'∩'o') ('bonob'∩'b') ('bonobo'∩'o')，这是'b' 'o' 'n' 'oo' 'bb' 'ooo'
最后，将∊（enlist）应用于结果以使其平坦化，得到'bonoobbooo'
码：
$vy«Dy¢y×?
说明：
$ # 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
使用CP-1252编码。在线尝试！
q:A,{)A<_)--}/
说明：
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
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()}这使用映射为输入中的每个字符存储一个字符串。对于每个字符，该字符串将从映射中删除，与该字符连接，再插入到映射中，并附加到输出中。
我本来想get(...)代替使用remove(...)，但是借阅检查器让我改变了主意。
不幸的是，Mathcad的字符串处理不是特别好，因此我将输入字符串转换为向量，然后使用（字符代码索引）向量来跟踪遇到字符的次数，并添加了结果向量的次数。最后，将结果向量转换回字符串。很遗憾，很宽大。
请注意，Mathcad使用2D“白板”界面，混合了普通文本和运算符。操作员通常通过工具栏或键盘快捷键输入；例如，ctl-＃输入for循环运算符，该运算符包括关键字for，元素的符号和分别用于迭代变量，范围和主体表达式的3个空“占位符”。键入[在变量名进入数组索引模式后，键入'输入匹配的括号（主要是...，根据周围表达式中的其他内容，会有例外）
q=>q.replace(/./g,a=>x[a]=(x[a]||'')+a,x=[])
旧答案
Javascript ES6 46字节
q=>(x=[...q]).map(a=>x[a]=(x[a]||'')+a).join``
//thanks user81655 for -1 byte
x输入数组->q=>(x=[...q]).map(a=>x[a]=(x[a]||'')+a).join``
for(;$C=$argn[$X++];)echo str_repeat($C,++$$C);
像这样运行：
echo abracadabra | php -nR 'for(;$C=$argn[$X++];)echo str_repeat($C,++$$C); echo"\n";'
null转换int为字符串偏移量的类型来保存字节，因为无论如何字符串偏移量都强制转换为int$argn代替$argv（thx Titus）保存了3个字节$argn与with -R一起使用可节省三个字节。
-n应该和您的操作相同-d error_reporting：n代表no config file，默认配置中的通知已关闭；因此-nr（分别-nR）就足够了。
BEGIN{FS=""}{for(i=1;i<=NF;i++){a[$i]++;for(j=0;j<a[$i];j++)printf $i}}
想法是将出现的字符的计数存储在关联数组中，并打印该计数次数的字符。
def s(w,o=[],n=""):
for x in w:o+=x;n+=x*o.count(x)
return n
def stretch(word):
occurrences = []
newWord = ""
for w in word:
occurrences.append(w)
newWord += w * occurrences.count(w)
return newWord