给定一个非空的小写ASCII字母a-z字符串，请输出该字符串，并且该字母的每个连续“游程”都要加长该字母的一个副本。
例如，dddogg（3 d “S，1 o，2 g “S）打开到ddddooggg（4 d “S，2 o “S，3 g “S）。
这是代码高尔夫球：以字节为单位的最短答案将获胜。
aabbcccc-> aaabbbccccc 门铃-> ddooorrbbeelll uuuuuuuuuuz-> uuuuuuuuuuzz q-> qq xyxyxy-> xxyyxxyyxxyy xxxyyy-> xxxxyyyy
Answers:
.¡€ĆJ
说明：
Example input: "dddogg"
.¡ Split into chunks of consecutive equal elements
stack: [['ddd', 'o', 'gg']]
€ For each...
Ć Enclose; append the first character to the end of the string
stack: [['dddd', 'oo', 'ggg']]
J Join array elements into one string
stack: ['ddddooggg']
Implicitly output top element in stack: "ddddooggg"
附件是一个非常新的内置函数。这是我第一次使用它。很方便 ;）
γ€ĆJ
.¡γ在最新更新中已被替换。
dddd是执行“包围”之后的解释中的堆栈上数组的第一个元素。
Ć什么？
xx -> xxxx什么时候应该xx -> xxx...？
r9hMMr8
测试套件。
r9hMMr8 example input: "xxyx"
r8 run-length encoding
[[2, "x"], [1, "y"], [1, "x"]]
hMM apply h to each item
this takes advantage of the overloading
of h, which adds 1 to numbers and
takes the first element of arrays;
since string is array of characters in
Python, h is invariant on them
[[3, "x"], [2, "y"], [2, "x"]]
r9 run-length decoding
xxxyyxx
/kf.>o./
@i$QowD\
/.../
@...\
这是一个用于程序的框架，该程序完全在Ordinal模式下运行，并且基本上是线性的（可以编写简单的循环，并且在该程序中使用了一个循环，但是在这里使用其他分支控制流比较棘手）。指令指针在代码中从左到右沿对角线上下反弹，然后在最后由两个镜像移动一个单元格，然后从右向左移动，执行它在第一次迭代中跳过的单元格。线性化的形式（忽略镜子）基本上如下所示：
ifQ>w.Doo.$k@
让我们来看一下：
i Read all input as a string and push it to the stack.
f Split the string into runs of equal characters and push those
onto the stack.
Q Reverse the stack, so that the first run is on top.
> Ensure that the horizontal component of the IP's movement is east.
This doesn't do anything now, but we'll need it after each loop
iteration.
w Push the current IP address to the return address stack. This marks
the beginning of the main loop.
. Duplicate the current run.
D Deduplicate the characters in that run so we just get the character
the run is made up of.
o Output the character.
o Output the run.
. Duplicate the next run. When we've processed all runs, this will
duplicate an implicit empty string at the bottom of the stack instead.
$ If the string is non-empty (i.e. there's another run to process),
execute the next command otherwise skip it.
k Pop an address from the return address stack and jump there. Note that
the return address stack stores no information about the IP's direction,
so after this, the IP will move northwest from the w. That's the wrong
direction though, but the > sets the horizontal component of the IP's
direction to east now, so that the IP passes over the w again and can
now execute the next iteration in the correct direction.
@ Terminate the program.
ḅ{t,?}ᵐc
Example input: "doorbell"
ḅ Blocks: ["d","oo","r","b","e","ll"]
{ }ᵐ Map: ["dd","ooo","rr","bb","ee","lll"]
t Tail: "d" | "o" | "r" | "b" | "e" | "l"
,? Prepend to input: "dd" | "ooo" | "rr" | "bb" | "ee" | "lll"
c Concatenate: "ddooorrbbeelll"
7个字节的代码，-P标志+1 。
ó¥ ®+Zg
这使用了ó我昨天刚刚添加的（falsy分区）内置函数：
ó¥ ® +Zg
ó== mZ{Z+Zg}
ó== // Split the input into runs of equal chars.
mZ{ } // Replace each item Z in this array with
Z+Zg // Z, concatenated with the first char of Z.
-P // Join the resulting array back into a string.
// Implicit: output result of last expression
s=>s.replace(/(.)\1*/g,"$1$&")
f=
s=>s.replace(/(.)\1*/g,"$1$&")
i.addEventListener("input",_=>o.innerText=f(i.value))
console.log(f("aabbcccc")) // aaabbbccccc
console.log(f("doorbell")) // ddooorrbbeelll
console.log(f("uuuuuuuuuz")) // uuuuuuuuuuzz
console.log(f("q")) // qq
console.log(f("xyxyxy")) // xxyyxxyyxxyy
console.log(f("xxxyyy")) // xxxxyyyy<input id=i><pre id=o>,[.[->->+<<]>[[-]>.<],]
, read the first input character
[ main loop to be run for each input character
. output the character once
[->->+<<] subtract from previous character (initially 0), and create a copy of this character
>[ if different from previous character:
[-] zero out cell used for difference (so this doesn't loop)
>.< output character again from copy
]
, read another input character
]
{S:g/)>(.)$0*/$0/}{ # bare block lambda with implicit parameter ｢$_｣
S # replace and return
:global # all occurrences
/
)> # don't actually remove anything after this
(.) # match a character
$0* # followed by any number of the same character
/$0/ # replace with the character (before the match)
}le`1af.+e~
说明：
e# Input: doorbell
l e# Read line: | "doorbell"
e` e# Run-length encode: | [[1 'd] [2 'o] [1 'r] [1 'b] [1 'e] [2 'l]]
1a e# Push [1]: | [[1 'd] [2 'o] [1 'r] [1 'b] [1 'e] [2 'l]] [1]
f.+ e# Vectorized add to each: | [[2 'd] [3 'o] [2 'r] [2 'b] [2 'e] [3 'l]]
e~ e# Run-length decode: | "ddooorrbbeelll"
e# Implicit output: ddooorrbbeelll
n2\׿
n2\׿ Main link. Argument: s (string)
n2\ Reduce all overlapping slices of length two by non-equal.
For input "doorbell", this returns [1, 0, 1, 1, 1, 1, 0].
× Multiply the characters of s by the Booleans in the resulting array. This is
essentially a bug, but integer-by-string multiplication works as in Python.
For input "doorbell", this returns ['d', '', 'o', 'r', 'b', 'e', '', 'l'].
Note that the last character is always left unchanged, as the Boolean array
has one fewer element than s.
ż Zip the result with s, yielding an array of pairs.
For input "doorbell", this returns [['d', 'd'], [[], 'o'], ['o', 'o'],
['r', 'r'], ['b', 'b'], ['e', 'e'], [[], 'l'], ['l', 'l']].
(implicit) Print the flattened result.
s/(.)\1*/\1&/g
s/((.)\2*)/\1\2/g
感谢Martin Ender 在Mathematica中找到了正确的方法来节省13个字节！
##&[#,##]&@@@Split@#&
使用字符数组作为输入和输出格式的纯函数。Split将列表分成相等的字符。##&[#,##]&是一个返回一系列参数的函数：第一个参数被输入，然后是所有参数（因此特别重复第一个）；@@@它将（）应用于列表的每个子Split列表。
##&[#,##]&@@@Split@#&吧？（未经测试。）
Gather如果有多个相同字符的运行实际上是行不通的（但幸运的Split是反正短了一个字节）
Split）您的第一个评论的构想很棒！
String f(String s){return s.replaceAll("((.)\\2*)","$1$2");}正则表达式
( ) group
(.) a character
\\2* optional repetition详细
import java.util.*;
import java.lang.*;
import java.io.*;
class H
{
public static String f(String s)
{
return s.replaceAll("((.)\\2*)","$1$2");
}
public static void main(String[] args)
{
f("dddogg");
}
}Matcher和Pattern？您可以像这样将其打高尔夫球至60个字节：String f(String s){return s.replaceAll("((.)\\2*)","$1$2");}
,.[.>,[[->+>+<<]<[->>-<<]>>[[-]>.<]]>]
,. print the "doubling" of the first char of input
[ this main loop runs on every char
. print it "normally" (the not-doubling)
>, read the next char
[ judiciously placed "loop" to prevent printing NULs
[->+>+<<] copy new char at position p to p+1 and p+2
<[->>-<<]>> subtract old char from p+1 - zero if same, nonzero otherwise
[ if it *is* different (nonzero)...
[-] clear it
>.< print the char (at p+2 now) again
]
]
> the new char is now the old char
]
甚至在发布此答案之前，都要感谢马丁·恩德（Martin Ender）打了两个字节。他比您想像的还要强大。
I4&.h%?-$OO!
I Input a character and push its unicode value
4&. Push 4 more copies of this value to the stack
(they will be needed for the following operations)
h% Try to compute n%(n+1), exits with an error if n==-1
which happens on EOF
? Push a copy of what's currently on the tape.
In the first iteration this will push -1, in following
iterations it will push the previous character.
-$O If the two topmost values on the stack are different
output the third one. This will output one more copy of
any new character encountered.
O Output this character.
! Store this character on the tape.
Execution loops back to the beginning of the line.