Given a non-empty string of lowercase ASCII letters a-z, output that string with each consecutive “run” of the same letter lengthened by one more copy of that letter.
For example, dddogg (3 d’s, 1 o, 2 g’s) turns into ddddooggg (4 d’s, 2 o’s, 3 g’s).
This is code-golf: the shortest answer in bytes wins.
aabbcccc -> aaabbbccccc doorbell -> ddooorrbbeelll uuuuuuuuuz -> uuuuuuuuuuzz q -> qq xyxyxy -> xxyyxxyyxxyy xxxyyy -> xxxxyyyy
.¡€ĆJ
Explanation:
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"
Try it online or as a test suite.
Enclose is a pretty new builtin; it's the first time I've used it. Very convenient ;)
γ€ĆJ
.¡ has been replaced by γ in the latest update.
dddd for the first element of the array on the stack in the explanation after "enclose" is executed.
\$\endgroup\$
May 7, 2017 at 11:43
Ć?
\$\endgroup\$
May 8, 2017 at 15:12
xx -> xxxx when it should be xx -> xxx...?
\$\endgroup\$
May 8, 2017 at 15:13
(.)\1*
$1$&
Replaces each run of characters with one of the run's characters followed by the run itself.
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
Y'QY"
Consider input 'doorbell'.
Y' % Implicit input. Run-length encoding
% STACK: 'dorbel', [1 2 1 1 1 2]
Q % Increase by 1, element-wise
% STACK: 'dorbel', [2 3 2 2 2 3]
Y" % Run-length decoding. Implicit display
% STACK: 'ddooorrbbeelll'
/kf.>o./
@i$QowD\
/.../
@...\
This is a framework for programs which operate entirely in Ordinal mode and are essentially linear (simple loops can be written, and one is used in this program, but it's trickier to work with otherwise branching control flow here). The instruction pointer bounces diagonally up and down through the code from left to right, then gets shifted by one cell by the two mirrors at the end, and the moves back from right to left, executing the cells it skipped on the first iteration. The linearised form (ignoring the mirrors) then basically looks like this:
ifQ>w.Doo.$k@
Let's go through this:
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"
~ take precedence over metapredicates (or change it to a postfix operation); if you did, you could do this in seven.
\$\endgroup\$
<?=preg_filter('#(.)\1*#',"$1$0",$argn);
Version without Regex
for(;a&$c=$argn[$i++];)echo$c[$c==$l].$l=$c;
7 bytes of code, +1 for the -P flag.
ó¥ ®+Zg
This uses the ó (partition on falsy) built-in that I just added yesterday:
ó¥ ® +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
\~..,}/',\<.-/.<@;$>.${;/${/"$.>$
\ ~ . .
, } / ' ,
\ < . - / .
< @ ; $ > . $
{ ; / $ { /
" $ . > $
. . . .
The pseudo-code is more or less:
char = readchar()
while (char > 0)
print(char)
run_char = char
do
print(char)
char = readchar()
while (run_char == char)
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>
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.
,[.[->->+<<]>[[-]>.<],]
, 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)
}
.¡DÔ‚ø˜J
Explanation:
.¡DÔ‚ø˜J
.¡ Split equal runs of input
D Duplicate
Ô Take connected-uniquified
‚ Pair connected-uniquified equal runs with original equal runs
ø Zip
˜ Deep-flatten (i.e. normal flattening)
J Join elements together
f(a:b:c)=a:[a|a/=b]++f(b:c)
f x=x++x
Usage example: f "aab" -> "aaabb". Try it online!
When the string has at least two chars, bind a to the first char, b to he second and c to the rest of the string. The output is a followed by a if a is not equal to b followed by a recursive call with b:c. If there's only one char, the result is two times this char.
le`1af.+e~
Explanation:
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
->s{s.gsub(/((.)\2*)/){$1+$2}}
⊢é⍨2-0,2=/,
, ravel*
2=/ pair-wise comparison (shows which characters to leave as-is)
0, prepend a zero (indicating that the initial character should be duplicated)
2- subtract that from two (gives 2 for the letters which need to be duplicated, and 1 for the rest)
⊢é⍨ replicate the argument using that (é is just the function /)
⊢ instead of ,.
@set/ps=
@set r=
:g
@if not "%s:~,1%"=="%s:~1,1%" set r=%r%%s:~,1%
@set r=%r%%s:~,1%
@set s=%s:~1%
@if not "%s%"=="" goto g
@echo %r%
Takes input on STDIN.
s/(.)\1*/\1&/g
s/((.)\2*)/\1\2/g
gsub("((.)\\1*)","\\2\\1",scan(,""))
Thanks to Martin Ender for finding the right way to do this in Mathematica, saving 13 bytes!
##&[#,##]&@@@Split@#&
Pure function using an array of characters as both input and output formats. Split separates a list into its runs of equal characters. ##&[#,##]& is a function that returns a sequence of arguments: the first argument it's fed, then all of the arguments (so repeating the first one in particular); this is applied (@@@) to every sublist of the Split list.
##&[#,##]&@@@Split@#&? (Untested.)
\$\endgroup\$
May 6, 2017 at 17:20
Gather doesn't actually work if there are multiple runs of the same character (but luckily Split is a byte shorter anyway)
\$\endgroup\$
May 6, 2017 at 17:53
Split in my heart) Wonderful construction in your first comment!
\$\endgroup\$
May 8, 2017 at 5:17
String f(String s){return s.replaceAll("((.)\\2*)","$1$2");}
Regex
( ) group
(.) a character
\\2* optional repetition
Detailed
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 and Pattern? You can golf it to 60 bytes like this: String f(String s){return s.replaceAll("((.)\\2*)","$1$2");}
\$\endgroup\$
May 8, 2017 at 11:35