Requirements:
Example:
Input: abcde
Output: abbcdde
Winning Criteria:
Standard code golf. Shortest number of bytes in program wins.
Clarification:
For languages with 1-based indexing the output must still match the above, aabccdee is not an acceptable solution.
>,[.,[..,>]<]
Assumes EOF->0. :(
You can try it online!
(Assuming input also continues to give zeroes indefinitely after the first EOF, we can do it in 11 bytes:
,[.,[..>],]
though this eats memory.)
ḤÐe
A full program accepting a string which prints the result
Utilises the fact that the implementation of the double atom, Ḥ, is multiplication by two, and that strings are lists of Python characters. In Python when a character is multiplied by two it becomes a Python string of length two (e.g. 'x'*2=='xx'). Lastly the implicit output of a list composed entirely of characters and strings (or lists thereof) is its content all smashed together.
ḤÐe - Main Link: list of characters e.g. input abcd -> ['a','b','c','d']
Ðe - apply to even indices (1-indexed):
Ḥ - multiply by 2 -> ['a', 'bb', 'c', 'dd']
- implicit, smashing print -> abbcdd
f=lambda s:s and s[:2]+s[1:2]+f(s[2:])
Takes the first two characters, then the second character, then removes the first two characters and recurses.
39 bytes
f=lambda s,c=2:s and s[:c]+f(s[1:],3-c)
Flips between taking the first two or first one character.
Binary:
00000000: b401 cd21 f7d9 78f8 cd29 ebf4 ...!..x..)..
Unassembled:
START:
B4 01 MOV AH, 1 ; DOS read char from STDIN
CD 21 INT 21H ; put char in AL
F7 D9 NEG CX ; toggle CX sign
78 F8 JS START ; if negative, loop to next char
CD 29 INT 29H ; DOS write char to screen again
EB F1 JMP START ; loop until break/^C
A standalone executable DOS program. Input via STDIN (pipe or keyboard interactive), output to STDOUT.
Output:
lambda s:`[c*11for c in s]`[7::10]
lambda s:`sum(zip(s,s,s),())`[7::10]
Slices characters 7, 17, 27… out of a string like this:
('a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd', 'e', 'e', 'e')
012345678901234567890123456789012345678901234567890123456789012345678901234
^ ^ ^ ^ ^ ^ ^
→ abbcdde
xnor's c*11 trick achieves the same thing, but with a string like:
['aaaaaaaaaaa', 'bbbbbbbbbbb', 'ccccccccccc', 'ddddddddddd', 'eeeeeeeeeee']
012345678901234567890123456789012345678901234567890123456789012345678901234
^ ^ ^ ^ ^ ^ ^
→ abbcdde
lambda s:''.join(c*3for c in s)[1::2]
If returning a tuple of characters is OK (which it isn't), lambda s:sum(zip(s,s,s),())[1::2] is a 33-byte solution.
#~1 2$~#
1 2$~# Shape $~ the list 1 2 (repeating it cyclically as needed) until it matches the length # of the input.#~ Use this 1 2 1 2... "mask" to Copy #~ the implicit input elementwise. That is, make 1 copy of the first char, 2 copies of the 2nd char, 1 copy of the third char, etc.By noticing that obviously f [] = [] also fits the pattern f s = s and removing one extra space, we get to
f(a:b:s)=a:b:b:f s
f s=s
from my starting point of
f []=[]
f (a:b:s)=a:b:b:f s
f s=s
Now my answer matches xnor's Haskell answer.
You can try it online!.
@(s)s(1:2/3:end)
Non-integer values are automatically rounded (with a warning) in colon index expressions.
q3e*1>2%
abcde q read input
→ aaabbbcccdddeee 3e* repeat characters x3
→ aabbbcccdddeee 1> drop first
→ a b b c d d e 2% every other char
Esolanging Fruit saved 1 byte: 3f*s → 3e*.
3e* instead of 3f*s?
\$\endgroup\$
Commented
Mar 1, 2020 at 18:57
-m, 4 bytes+pVu
+pVu :Implicitly map each character U at 0-based index V in the implicit input string
+ :Append to U
p :U repeated
Vu : V mod 2 times
:Implicit output of resulting string
As SB Syntax:
define f(n
set[i v]to(1
set[o v]to(
repeat((length of(n))/(2
set[o v]to(join(o)(letter(i)of(n
change[i v]by(1
set[x v]to(letter(i)of(n
set[o v]to(join(o)(join(x)(x
change[i v]by(1
Oh boy, here I go Scratching again! This was quite an interesting one to solve, and I quite enjoyed it. Thanks for the challenge.
The output of the function is shown in the top left corner.
Finally, Try it online Scratch!
'"""""'"""'""""'"'""""""""""'"'"'""""""""""
Displayed here in variable-width font, per the traditional tribute to the language name.
Exits with error after printing the correct output.
Explanation:
'"""""'""" while(1)
'"""" do 2 things:
'"'"""""""""" print(read stdin)
'"'"'"""""""""" print(print(read stdin))
Uses the fact that '" both prints and returns its argument, which can thus be directly fed to a 2nd print command.
-2 thanks to mypetition (s[:1]*i can be s[:i] if we swap our order of is)
f=lambda s,i=2:s and s[:i]+f(s[1:],i^3)
A recursive function which accepts a string and returns a string.
Works in Python 2 too.
At each call we return s if it is empty or take the first up-to-i-characters of the given string (s[:i]) where i starts out as 2 and append (+) the result of another call to the function this time using a new s of all but the first character (s[1:]) and a new i found by XOR-ing with three (i^3) - i.e. 2, 1, 2, 1, ...
f=lambda s,i=2:s and s[:i]+f(s[1:],i^3) saves 2 bytes
\$\endgroup\$
Commented
Feb 3, 2020 at 18:36
i entirely, which gives xnors f=lambda s:s and s[:2]+s[1:2]+f(s[2:]).
\$\endgroup\$
Commented
Feb 3, 2020 at 19:11
,[>>+<[<..>->-]>[<<.>+>->]<<<,]
You can try it online or you can check my first submission, that I think is also simpler to understand:
+>+>>,[<<[-<->]<[->>+>>+<<<<]+>>>.>[-<.>]<,<[-<+>]>
Cell layout is
| 1 | aux | mult | inp | mult |
where mult is the number of extra times we have to print the current character. Feel free to drop me a line in the comments with feedback.
,.Ajax,.Page,.Act I:.Scene I:.[Exeunt][Enter Page and Ajax]Ajax:Open mind.Speak thy.Open mind.Speak thy.Speak thy.Let usAct I.
Page reads the input one character at a time, and alternately prints it once or twice. Exits with error after printing the correct output.
edit: make use of & (where operator) which for each index i of an int-list L give gives L[i] copies of i. eg &2 1 3 -> 0 0 1 2 2 2
{x@&(#x)#1 2}
{ } /lambda with implicit arg x
(#x) /count x
#1 2 /takes #x items of 1 2 (eg 3#1 2 -> 1 2 1)
& /&1 2 1 -> 0 1 1 2
x@ /index x
This looks incredibly long, I have no idea if something obvious is slipping under my nose... And already saved 5 bytes thanks to @Jonathan Allan! Check his 43 byte Python 3 answer! but here it is:
lambda s:''.join(c+i%2*c for i,c in enumerate(s))
You can try it online!
enumerate and 2 more by using a generator (dropping the []) - TIO
\$\endgroup\$
Commented
Feb 1, 2020 at 0:03
% being treated as a format instruction: c*(1+i%2)->i%2*c+c (or c+i%2*c)
\$\endgroup\$
Commented
Feb 1, 2020 at 0:15
S =INPUT
S S LEN(1) . L LEN(1) . R REM . S :F(O)
O =O L R R :(S)
O OUTPUT =O S
END
-ir -lp, 4 bytes(,⑩,
# (Implicitly) take an input from the console
( # For every item in the input:
, # Print the first character, popping the stack
⑩ # Print the top of the stack w/o poping
, # Print with popping, effectively doubling the second character
Uses the same regex as @DigitalTrauma.
s=>s.replace(/.(.)/g,"$&$1")
A recursive version.
f=([a,b,...c])=>b?a+b+b+f(c):[a]
,[.<[>.>]>>,]
Handles odd and even length strings correctly. This takes an input and prints it once before checking if the previous cell contains the previous character. If so, it prints again and moves three spaces ahead, otherwise it just moves one cell ahead, and then it gets the next character.
-join($args|% t*y|%{"$_"*(1+$i++%2)})
Takes input $args, transforms it toCharArray, pipes that into a loop. Each iteration, we repeat the character "$_" either 1 or 2 times based on a modulo-index. Those characters/strings are left on the pipeline, gathered up with a -join to turn it back into a single string, and output is implicit.
-2 bytes thanks to Veskah.
-1 byte thanks to mazzy.
_%2 -> %_.)
\$\endgroup\$
€Ðιθ
I/O as a list of characters, which is allowed by default.
I have the feeling 4 bytes might be possible, but I'm unable to find it.
It is possible, by porting @emanresuA's Vyxal answer (so make sure to upvote him/her as well).
Explanation:
# (example input = ["a","b","c","d","e"])
€Ð # Triplicate each character (which remains a flattened list)
# → ["a","a","a","b","b","b","c","c","c","d","d","d","e","e","e"]
ι # Uninterleave this list into two parts
# → [["a","a","b","c","c","d","e","e"],["a","b","b","c","d","d","e"]]
θ # Pop and leave just the second part
# → ["a","b","b","c","d","d","e"]
# (which is output implicitly as result)
listen to S
cut S
Y's 1
O's ""
while S
let O be+roll S*Y
let Y be Y-1 or 2
say O
Try it here (Code will need to be pasted in)
1as the first character, for the benefit of languages with1-based indexing? \$\endgroup\$