Given a string of any length which contains only digits from 0 to 9, replace each consecutive run of the digit 0 with its length.
1234500362000440 → 1234523623441123450036200044 → 123452362344000000000000 → 120123456789 → 11234567891234567890 → 1234567891123456789 → 123456789010203004050 → 11121324151The shortest answer in bytes wins as per code-golf rules
try{for(;;)if(!~~$c=fgetc(STDIN))$x++;else{echo$x?:"",$c;$x=0;}}finally{echo$x?$x:"";}
Takes input via STDIN, outputs via STDOUT.
⭆⪪⁻⪫⪪ＳＩ⁰_0_×_²_∨№ι0ι
Try it online! Link is to verbose version of code. Explanation:
Ｓ Input string
⪪ Split on
⁰ Literal integer `0`
Ｉ Cast to string
⪫ Join with
_0_ Literal string `_0_`
⁻ Remove matching substrings
_ Literal string `_`
× Repeated
² Twice
⪪ Split on
_ Literal string `_`
⭆ Map over pieces and join
№ Count of
0 Literal string `0`
ι In current piece
∨ Logical Or
ι Current piece
String separators are only needed between consecutive strings so the code has been tweaked to avoid them to reduce the byte count. ⭆Ｓ∨Ｉι_0_ also works instead of ⪫⪪ＳＩ⁰_0_ for the same byte count.
r(s)=>s.replaceAllMapped(RegExp('0+'),(m)=>'${m.end-m.start}');
String replaceZerosWithTheirConsecutiveCounts(String src) {
return src.replaceAllMapped(
RegExp('0+'),
(Match match) => '${match.end - match.start}',
);
}
'0+'":@#rxapply]
Fairly simple regex solution:
'0+' ":@#rxapply ]
'0+' rxapply ] apply to all relevant patterns in the input
# length
":@ casted to string
' '-.~[:,(1,2~:/\'0'&=)([`(":@#)@.('0'&e.));.1]
Horrendously long non-regex solution. This is the only way I could really think of approaching this, since, afaik, J doesn't have a builtin for grouping according to a boolean matrix or similar.
[:;]<`(<@":@#)@.('0'&e.);.1~1,2~:/\'0'&=
\$\endgroup\$
+.`=$$?`r$@,
`=$ # chunk the input by
$ # itself,
. # now map over each chunk:
? # if
`r$ # its value as an integer is nonzero
@ # return itself
# otherwise
, # return its length
+ # finally, join it all together
StringReplace[string,x:"0"..:>ToString@StringLength@x]
I =INPUT
R I ARB . L SPAN(0) . X REM . I :F(O)
O =O L SIZE(X) :(R)
O OUTPUT =O I
END
I =INPUT ;* read input
R I ;* Match in I:
ARB . L ;* ARBitrary characters (save as Left part of string) up to
SPAN(0) . X ;* 1 or more 0s (save as X)
REM . I ;* REMaining characters (save as I)
:F(O) ;* On no match, goto O
O =O L SIZE(X) :(R) ;* Append L and # of 0s to O and goto R
O OUTPUT =O I ;* Output O and any remaining characters of I that didn't match
END
sm`|vedhdr8
sm`|vedhdr8Q # implicitly add Q to the end
# implicitly assign Q = eval(input())
r8Q # length encode Q
s # concatenate together
m # map over lambda d
` # convert to string
| # short circuiting or
ved # evaluate the second element of d
hd # or take the first element of d
s=io.read("*a")for i=#s,1,-1 do s=s:gsub(("0"):rep(i),i)end print(s)
def f(s):
c=0;r=''
for d in s:
if d=='0':c+=1
else:r+=f'{c if c!=0 else""}'+d;c=0
return r+f'{c if c!=0 else""}'
$=>[chunk&=>[&]|map'g->(`0`=g\0)?->size g->join g|join]
$=>[ ; a function, assign input to &
chunk&=>[&] ; split input into blocks of equal, contiguous chars
| ; then
map'g-> ; map over each block and assign current elt to g
(`0`=g\0)? ; is the first element of g the character `0`?
->size g ; then map g to the length of g
->join g ; otherwise, map g to its joined string
| ; then
join ; join the block of strings and numbers to a string
] ; end function
Solution without using regexp
s=>s.split(0).map(c=>c?(a?a:"")+(a=1,c):(++a,""),a=0).join``+(--a?a:"")
$r='';$_|sls '0+|[1-9]+'-a|% m*|%{$v=$_.value;('$r+=$v','$r+=$_.length')[$v-match"0+"]|iex};$r
Ungolfed
$args|%{
# empty string to append to
$r=''
# '0+|[1-9]+' will match full string but split by zeroes and non-zeroes
$_ | sls '0+|[1-9]+' -a | % m*| %{
# value is the matched string
$v=$_.value
# true = 1; false = 0; shorter than an if statement
# iex will execute the command in quotes
('$r+=$v','$r+=$_.length')[$v-match"0+"] | iex
}
# prints the results
$r
}
ĉᵐ{ᵉĜ#Mĝ}j
Nekomata is still bad at string challenges.
ĉᵐ{ᵉĜ#Mĝ}j
ĉ Split into groups of identical characters
ᵐ{ } For each group:
ᵉ M Max of the following two:
Ĝ Convert string to number
# Length
ĝ Convert number to string
j Join
Using the fact that the length of a positive integer is always less than or equal to the integer itself.
.c.w.n\0.a.s
Filename
\1.rL.w.i.c0.x.t.e.c.-.m.oXX\1.a.c!.x.s\1.+XX\1.a\1.+.a.e
.s.c.w.n\0.a.s
Filename
\1.rL.w.i.c\1.+\1.y.e.d.a.c0.x.e.o.s\1.rXX1.a.c1.z.s\1.+XX0.a.a
\1.r instead of aa.%..c.w.naa.%.a.s.s
Filename
aa.%.t.w.i.c\1.y.m.e.d.a.c0.x.m.e.m.-.t.oXX1.a1.z\1.m.+.tXX.a.a
Filename.
aa.%.t Store 0 to register because it is initialized with null.
.w Loop
.i Push getchar
.c\1.y If EOF
.m.e.d Push register, call subroutine, exit
.a
.c0.x If top is greater than 48
.m.e Push register, call subroutine
.m.-.t Reset register to 0
.o putchar pop
XX1.a Push 49
1.z If pop is NOT 49
\1.m.+.t Increment register
XX.a
.a End loop
Content as subroutine. Different space with filename, when return stack is concatenated to caller's stack.
.c.w If top is not zero
.n print popped value as numeric integer
aa.%.a
.s.s Clean up
import Data.List
r s=concat[case t!!0 of '0'->show$length t;_->t|t<-group s]
awk(gawk-specific)
gawk 'ORS=RT?length(RT):_' RS=0+
1234523623441
123452362344
12
1123456789
1234567891
123456789
11121324151
'ORS=RT?length(RT):$_' RS=0+ you get the digit back, but a trailing one on a new line.
\$\endgroup\$
0s replaced with?11? \$\endgroup\$10as no modifications to the output were also needed, as most answers suggest \$\endgroup\$