85
\$\begingroup\$

Super simple challenge today, or is it?

I feel like we've heard a fair bit about double speak recently, well let's define it in a codable way...

Double speak is when each and every character in a string of text is immediately repeated. For example:

"DDoouubbllee  ssppeeaakk!!"

The Rules

  • Write code which accepts one argument, a string.
  • It will modify this string, duplicating every character.
  • Then it will return the double speak version of the string.
  • It's code golf, try to achieve this in the smallest number of bytes.
  • Please include a link to an online interpreter for your code.
  • Input strings will only contain characters in the printable ASCII range. Reference: http://www.asciitable.com/mobile/

Leaderboards

Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.

var QUESTION_ID=188988;
var OVERRIDE_USER=53748;
var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;function answersUrl(d){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+d+"&pagesize=100&order=asc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(d,e){return"https://api.stackexchange.com/2.2/answers/"+e.join(";")+"/comments?page="+d+"&pagesize=100&order=asc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(d){answers.push.apply(answers,d.items),answers_hash=[],answer_ids=[],d.items.forEach(function(e){e.comments=[];var f=+e.share_link.match(/\d+/);answer_ids.push(f),answers_hash[f]=e}),d.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(d){d.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),d.has_more?getComments():more_answers?getAnswers():process()}})}getAnswers();var SCORE_REG=function(){var d=String.raw`h\d`,e=String.raw`\-?\d+\.?\d*`,f=String.raw`[^\n<>]*`,g=String.raw`<s>${f}</s>|<strike>${f}</strike>|<del>${f}</del>`,h=String.raw`[^\n\d<>]*`,j=String.raw`<[^\n<>]+>`;return new RegExp(String.raw`<${d}>`+String.raw`\s*([^\n,]*[^\s,]),.*?`+String.raw`(${e})`+String.raw`(?=`+String.raw`${h}`+String.raw`(?:(?:${g}|${j})${h})*`+String.raw`</${d}>`+String.raw`)`)}(),OVERRIDE_REG=/^Override\s*header:\s*/i;function getAuthorName(d){return d.owner.display_name}function process(){var d=[];answers.forEach(function(n){var o=n.body;n.comments.forEach(function(q){OVERRIDE_REG.test(q.body)&&(o="<h1>"+q.body.replace(OVERRIDE_REG,"")+"</h1>")});var p=o.match(SCORE_REG);p&&d.push({user:getAuthorName(n),size:+p[2],language:p[1],link:n.share_link})}),d.sort(function(n,o){var p=n.size,q=o.size;return p-q});var e={},f=1,g=null,h=1;d.forEach(function(n){n.size!=g&&(h=f),g=n.size,++f;var o=jQuery("#answer-template").html();o=o.replace("{{PLACE}}",h+".").replace("{{NAME}}",n.user).replace("{{LANGUAGE}}",n.language).replace("{{SIZE}}",n.size).replace("{{LINK}}",n.link),o=jQuery(o),jQuery("#answers").append(o);var p=n.language;p=jQuery("<i>"+n.language+"</i>").text().toLowerCase(),e[p]=e[p]||{lang:n.language,user:n.user,size:n.size,link:n.link,uniq:p}});var j=[];for(var k in e)e.hasOwnProperty(k)&&j.push(e[k]);j.sort(function(n,o){return n.uniq>o.uniq?1:n.uniq<o.uniq?-1:0});for(var l=0;l<j.length;++l){var m=jQuery("#language-template").html(),k=j[l];m=m.replace("{{LANGUAGE}}",k.lang).replace("{{NAME}}",k.user).replace("{{SIZE}}",k.size).replace("{{LINK}}",k.link),m=jQuery(m),jQuery("#languages").append(m)}}
body{text-align:left!important}#answer-list{padding:10px;float:left}#language-list{padding:10px;float:left}table thead{font-weight:700}table td{padding:5px}
 <script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/primary.css?v=f52df912b654"> <div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table> 

To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:

# Language Name, [Other information] N bytes

where N is the size of your submission. Other information may include flags set and if you've improved your score (usually a struck out number like <s>M</s>). N should be the right-most number in this heading, and everything before the first , is the name of the language you've used. The language name and the word bytes may be links.

For example:

# [><>](http://esolangs.org/wiki/Fish), <s>162</s> 121 [bytes](https://esolangs.org/wiki/Fish#Instructions)
\$\endgroup\$
10
  • 5
    \$\begingroup\$ It will modify this string. Are you intentionally requiring pass-by-reference and modify in-place? And then return a copy or reference to that modified string? If so, languages like asm or C would need to accept an explicit-length string (pointer + length) where the length is either the current string length (with the buffer being twice that size), or it's the total size and you need to duplicate the low half. Thus you need to start from the end and work backwards, or allocate scratch space and then copy back. But there are answers in C and 8086 asm that totally violate all that. \$\endgroup\$ Aug 3, 2019 at 1:49
  • 5
    \$\begingroup\$ @PeterCordes I do not care if it modifies the same object or builds a new one. \$\endgroup\$
    – AJFaraday
    Aug 3, 2019 at 5:08
  • 4
    \$\begingroup\$ I'd suggest wording it as "modify (or produce a modified copy) of the string" to explicitly allow answers that do or don't modify in-place. Simplifying the wording to "return a string that's twice as long, with each character repeated" would be nice but then it's not clear if void foo(char *c, size_t len) is legal that takes one input/output buffer and a length, and doesn't have any return value, just a side-effect on the object it has a pointer to. \$\endgroup\$ Aug 3, 2019 at 5:16
  • \$\begingroup\$ Can the string be empty? \$\endgroup\$ Aug 6, 2019 at 19:58
  • 1
    \$\begingroup\$ @cschultz2048 it says the string will only contain printable ascii characters, so that implies that they’ll always be populated. I’d expect that any code for this challenge would leave an empty string empty... anyway, I don’t think it’s a test case that I’d use for this. \$\endgroup\$
    – AJFaraday
    Aug 6, 2019 at 22:36

212 Answers 212

1
4 5 6
7
8
1
\$\begingroup\$

Brain-Flak, 26 bytes

{(({}<>))<>}<>{({}<>)<>}<>

Pretty simple, and my first Brain-Flak answer :D

(Note: this requires the -a and -ac flags for ascii I/O)

How it works

{  Begins a loop that will run for every character of input
(({}<>))   Pops the top element of the stack and pushes two copies of it to the second stack
<>  Go back to the first stack
}   End loop
<>   Go to the second stack
{({}<>)<>}   Reverse the second stack and puts it onto the first
<>  Go to the first stack do it outputs it

Try it Online!

\$\endgroup\$
1
\$\begingroup\$

C (clang), 60 50 bytes

gets(s);while(s[(int)i])putchar(s[(int)(i+=0.5)]);

Try it online!

Saved 10 bytes Thanks to Peter Cordes

\$\endgroup\$
5
  • \$\begingroup\$ This snippet depends on declarations and initializers (like float i = -0.5) outside the block you're counting. You need to count all the bytes of your code for a whole function or block that can be used on its own without dependencies on other parts of the source code. e.g. a whole function + any global variables it uses. \$\endgroup\$ Aug 3, 2019 at 2:49
  • \$\begingroup\$ Interesting idea, though, to use float increments to half-step. putchar would be shorter than printf("%c", and also !=0 is implicit in while(s[(int]i]). I think ISO C guarantees that \0 has integer value 0, and I'm sure that it's guaranteed to be the only "false" character value so a strlen like while(*s++) is a safe. \$\endgroup\$ Aug 3, 2019 at 2:51
  • \$\begingroup\$ Congratulations on your first answer! I remember when I first started, it was a bit complicated to figure out what should be counted and what shouldn't be counted (I'm still not sure sometimes). From this meta post, a function is also a valid submission, in which case we can abuse a bunch of things in C to get this 51-byte answer. It's not pretty though \$\endgroup\$
    – maxb
    Aug 6, 2019 at 9:16
  • \$\begingroup\$ Thanks guys for the comments, still learning so please forgive any mistakes and thanks for the ideas Peter would definitely try implementing them. \$\endgroup\$
    – Loki
    Aug 7, 2019 at 11:25
  • 1
    \$\begingroup\$ Building on @maxb 41 bytes \$\endgroup\$
    – ceilingcat
    Aug 19, 2019 at 5:32
1
\$\begingroup\$

Q'Nial7, 28 bytes

d is OP N{link cols mix N N}

result:

     d 'Double Speak!'
DDoouubbllee  SSppeeaakk!!

Explanation, using detailed picture mode:

     set "decor                 %turn on decoration of atoms and empty arrays,
                                %gives a picture that distinguishes all atoms                                  
"decor                                                                          
     set "diagram                                                               
"diagram                        %set default display mode to diagram,
                                %give full boxed picture of results                                 
     N:='Double Speak!'         %define string N                                       
+--+--+--+--+--+--+--+--+--+--+--+--+--+                                        
|`D|`o|`u|`b|`l|`e|` |`S|`p|`e|`a|`k|`!|                                        
+--+--+--+--+--+--+--+--+--+--+--+--+--+                                        
     mix N N                    %nesting restructuring: create table of items
                                %from list of items, the list being N N                                       
+--+--+--+--+--+--+--+--+--+--+--+--+--+                                        
|`D|`o|`u|`b|`l|`e|` |`S|`p|`e|`a|`k|`!|                                        
+--+--+--+--+--+--+--+--+--+--+--+--+--+                                        
|`D|`o|`u|`b|`l|`e|` |`S|`p|`e|`a|`k|`!|                                        
+--+--+--+--+--+--+--+--+--+--+--+--+--+                                        
     cols mix N N               %nesting restructuring: list of columns
                                %of the table                                       
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+
||`D|`D|||`o|`o|||`u|`u|||`b|`b|||`l|`l|||`e|`e|||` |` |||`S|`S|||`p|`p|||`e|`e|
|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
                                                                                
+-------+-------+-------+                                                       
|+--+--+|+--+--+|+--+--+|                                                       
||`a|`a|||`k|`k|||`!|`!||                                                       
|+--+--+|+--+--+|+--+--+|                                                       
+-------+-------+-------+                                                       
     link cols mix N N          %construction op: items of the first item of N
                                %are followed by the items of the second item of N, etc.                                       
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ 
|`D|`D|`o|`o|`u|`u|`b|`b|`l|`l|`e|`e|` |` |`S|`S|`p|`p|`e|`e|`a|`a|`k|`k|`!|`!| 
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ 
\$\endgroup\$
1
\$\begingroup\$

Forget, 61 55 bytes

I created this language when I was bored one day. I released it the same day as this challenge was posted. I can guarantee this was not designed specifically for this challenge.

in;cleanse;out;out;pop;hasin;in;cleanse;out;out;pop;end

-6 bytes by terminating on EOF
There's no TIO (yet). The interpreter is available here There's a TIO now
Explanation:

in - reads a character from standard input and pushes a pointer to the stack

cleanse - unpoisons the pointer on top of the stack

out - prints the value stored at the address on top of the stack as a character

out - see above

pop - removes the value from the stack to avoid memory leaks

hasin - while characters are available on standard input...

(the body of the loop is the same as before it)

end marks the end of the loop

The only way this program can error is if the interpreter forgets the value stored at the address on the stack and the program attempts to use it.

\$\endgroup\$
1
\$\begingroup\$

Aceto: 5 bytes

,dppO

Doesn't work on TIO, because it hangs indefinitely. Buffering might prevent you from seeing the result, run with -F to immediately flush all output.

\$\endgroup\$
1
\$\begingroup\$

Go, 110 bytes

func main(){for j:=0;j<len(os.Args[1]);j++{fmt.Printf("%c%c",os.Args[1][j],os.Args[1][j])};fmt.Printf("\n");}

Try It on Jdoodle!

\$\endgroup\$
1
\$\begingroup\$

C#, 104 bytes

public class P{public static void Main(string[]a){foreach(char c in a[0])System.Console.Write(c+""+c);}}

Try Online

\$\endgroup\$
1
\$\begingroup\$

Clojure, 25 bytes

(fn[s](apply str(map #(str % %)s)))
\$\endgroup\$
1
\$\begingroup\$

[sed], 13 bytes

sed 's/\(.\)/&&/g'  <<< "Double speak"

Try it online!

\$\endgroup\$
4
  • 2
    \$\begingroup\$ 1) Please use a properly formatted heading line for your answer so the leaderboard script can parse it. 2) The quotes around the code are necessary only when specified in command line due to the shell's own parsing rules, they not need to appear in the answer and even less to get counted. 3) As possible please add TIO links to your answers so people can try them out easier and see how input is supposed to get passed to the code. \$\endgroup\$
    – manatwork
    Nov 11, 2019 at 10:54
  • 2
    \$\begingroup\$ Just as information (its existence doesn't invalidate your solution), Leo Tenenbaum's sed solution is shorter. ☹ \$\endgroup\$
    – manatwork
    Nov 11, 2019 at 10:56
  • \$\begingroup\$ @manatwork: Oh sorry, I visually "grepped" through the StackExchange posts, but didn't see sed. \$\endgroup\$
    – stephanmg
    Nov 11, 2019 at 11:03
  • \$\begingroup\$ Yes, capture group is not needed, so @LeoTenenBaums's solution is better. \$\endgroup\$
    – stephanmg
    Nov 11, 2019 at 11:14
1
\$\begingroup\$

[awk], 24 bytes

awk '$0=gensub(/./,"&&","g")' <<< "Double speak"

Try it online!

\$\endgroup\$
8
  • 1
    \$\begingroup\$ I guess you accidentally pasted an older code version since you still debugged it. That would explain that \n. \$\endgroup\$
    – manatwork
    Nov 11, 2019 at 11:00
  • 1
    \$\begingroup\$ You could shorten it by learning from Leo Tenenbaum's sed solution and avoid using a capture group: $0=gensub(/./,"&&","g"). \$\endgroup\$
    – manatwork
    Nov 11, 2019 at 11:03
  • 2
    \$\begingroup\$ Super late to the party... but I think gsub(".","&&") will work too. Meaning just that, the assignment to $0 is implicit. \$\endgroup\$
    – cnamejj
    Apr 16, 2021 at 10:26
  • 1
    \$\begingroup\$ FWIW, I'm using GNU AWK if that makes the difference. \$\endgroup\$
    – cnamejj
    Apr 16, 2021 at 18:57
  • 1
    \$\begingroup\$ Yeah that's a GNU extension. \$\endgroup\$
    – stephanmg
    Apr 16, 2021 at 19:09
1
\$\begingroup\$

Bash, 45 bytes

while IFS= read -n1 c;do printf %s"$c$c";done 

Try it online!

\$\endgroup\$
2
  • \$\begingroup\$ Yeah I removed this part. Btw. I'm not sure if it's a valid solution, because the string is not modified but a copy is printed. \$\endgroup\$
    – stephanmg
    Nov 11, 2019 at 11:45
  • \$\begingroup\$ @JoKing: You are probably right. \$\endgroup\$
    – stephanmg
    Nov 11, 2019 at 11:57
1
\$\begingroup\$

Binary Lambda Calculus, 10 bytes

8446 0016 c25b 3fdf 9ade

This program was on this page and was known as a ``stuttering'' program.

\$\endgroup\$
1
\$\begingroup\$

GolfScript, 9 bytes

Great if this hasn't been posted yet.

[{.}/]''+

Try it online!

\$\endgroup\$
1
\$\begingroup\$

@, 8 bytes

¤ōōč

Explanation

¤    Forever
   č Read a character
 ōō  Output twice
\$\endgroup\$
1
\$\begingroup\$

Pyth, 5 bytes

sm*2d
s      Concatenate
  *2d  lambda d: d*2
 m     Mapped over
     Q Input (implicit

Try it online!

\$\endgroup\$
1
  • \$\begingroup\$ 3 byter here, but theres a 2 byte solution for pyth here \$\endgroup\$
    – frank
    Dec 2, 2019 at 22:38
1
\$\begingroup\$

Add++, -i 8 bytes

L,dzbFBJ

Try it online!

This creates a lambda (L) that:

  • duplicates the input string (d)
  • zips the two strings together (z)
  • flattens that list (bF)
  • and joins it together (BJ)

Finally, the -i flag auto executes the lambda.

\$\endgroup\$
1
\$\begingroup\$

Pip, 4 bytes

aWVa

Try it online!

A pip answer without loops.

\$\endgroup\$
1
\$\begingroup\$

Canvas, 3 bytes

21*

Try it here!

\$\endgroup\$
1
\$\begingroup\$

Lua, 31 bytes

print(((...):gsub(".","%1%1")))

Try it online!

Explanation

... is the multi-return formatted version of the arg table. We encase it in parentheses here so that it only returns one value (the first).

gsub() is the global substitution function, it takes a pattern and returns a string with every instance of it replaced according to the second parameter.

"." is a pattern matching any single character.

"%1%1" is a pattern which is used as the second parameter to gsub. %1 means the first case, which is the whole match in this instance, so it repeated the entire match twice.

\$\endgroup\$
1
\$\begingroup\$

Python 3, 31 bytes

lambda s:"".join(c*2for c in s)

-4 bytes thank you to Redwolf Programs for suggesting lambda method.

Try it online!

\$\endgroup\$
1
  • \$\begingroup\$ Hi! Taking input by assuming a variable contains it isn't allowed, but you can use a lambda (and if you do, there's no need for a print!). \$\endgroup\$ Jan 29, 2021 at 15:32
1
\$\begingroup\$

VBScript, 88 bytes

s=wscript.arguments(0):k=""
for i=0 to len(s)-1
n=mid(s,i+1,1)
k=k&n&n&" "
next
msgbox k

First argument as the string

\$\endgroup\$
1
\$\begingroup\$

Duocentehexaquinquagesimal, 3 bytes

6÷V

Try it online!

\$\endgroup\$
1
\$\begingroup\$

Unlambda, 11 bytes

``ci`c`|`@|

Try it online!

On its own, `|`@| is an identity function with a side effect of reading a char from the input and printing it twice. `ci is a call-with-cc trickery that ends up applying its argument to itself, hence `c`|`@| is the same with the above-mentioned side effect; all in all, this will set up a loop.

(The solution is memory inefficient, as each iteration will create a new continuation, hence the space used will be linear or quadratic in the length of the input, depending on the implementation. This can be fixed at the expense of adding two more characters: ``ci`d`c`|`@|.)

\$\endgroup\$
1
\$\begingroup\$

Ly, 7 bytes

ir[:oo]

Try it online!

Oddly enough, this turned out to be similar to the Brainfuck answer someone else posted...

i        - reads in a line, adds each character to the stack as a codepoint
 r       - reverse the stack
  [   ]  - a "loop while stack not empty" construct
   :     - duplicate the top of the stack
    o    - pop the top of the stack and print codepoint as char
      o  - again... 
\$\endgroup\$
1
\$\begingroup\$

V (vim), 5 bytes

òylpl

Try it online!

òylpl
ò       " loop until error
 yl     " yank character under cursor
   p    " paste it
    l   " move right

Alt:

V (vim), 5 bytes

òälll

Try it online!

ä{motion} is a synonym for y{motion}P which is almost what we want but pastes backwards rather than forwards, so we need another l here, tying the vim-ier first solution.

Equivalent vim version:

Vim, 11 bytes

qqylpl@qq@q

Try it online!

\$\endgroup\$
1
  • \$\begingroup\$ Another 5 byte V: Ó./&&. Ironically, this can be ported perfectly to vim and also ties your vim solution haha: :s/./&&/g<cr> \$\endgroup\$
    – DJMcMayhem
    Apr 20, 2021 at 15:33
1
\$\begingroup\$

<>^v, 29 bytes

.—""?§0 27 0«0 82!=0_~~?(___|

Explanation

.—""?§0 27 0«0 82!=0_~~?(___|

.                             Input string, push to stack
 —                            (not a minus) Reverse the string
  ""                          Push empty string to stack
    ?                         Swap top two elements
     §                        Split top of stack (now the user input) with second element of stack (`""`)
      0                       Push 0
        27                    Push 27
           0                  Push 0
            «                 Goto ; redirects program to the `|`
                            | Reverses instruction pointer direction, now going left
                           _  Pop stack
                          _   Pop stack (again)
                         _    For the third time, pop the stack
                        )     Decrement top of stack
                       ?      Swap top two elements
                      ~       Print top of stack without newline
                     ~        Print top of stack without newline (again, for the double character)
                    _         Pop stack
                   0          Push 0
                  =           Execute next instruction only if top two elements of the stack are equal
                 !            Exit, executed only if the top two elements of the stack are equal
               82             Push 28 (pointer is going left, so literal 82 -> value 28
             0                Push 0
            «                 Goto _
                          _   (Loop goes on, go back to the first "Pop stack")

It first reverses the string, then splits it into characters. Then it goes into a loop reverse-iterating the characters and printing them twice, popping them at the same time, each time decrementing the "characters left" counter which is at the top of the stack, and exits when "characters left" is 0.

Mostly inspired by this other answer I made

run online (> is the prompt, cannot remove it)

\$\endgroup\$
1
\$\begingroup\$

SM83, 8 bytes

Input string pointer in de, output string pointer in hl

1A 13 23 B7 C8 23 18 F8
dbl:
    ld a,(de)               // 1A       read
    inc de                  // 13       and increment
    ld (hl+),a              // 23       write and increment
    or a                    // B7       cheap test for zero
    ret z                   // C8       return if zero
    ld (hl+),a              // 23       write and increment again
    jr dbl                  // 18 F8    loop
\$\endgroup\$
1
\$\begingroup\$

Pxem, filename: 17 bytes.

\001 is such a byte of binary.

.w.o.o.i.c.c\001.+.a

How it works

Since this program is simple, here is verbose explaination.

XX.z
# while stack is empty or popped value is not zero; do
# NOTE stack is initially empty
.a.wXX.z
  # if not empty; then pop to output its character; fi
  # if not empty; then pop to output its character; fi
  .a.o.oXX.z
  # getchar and push its codepoint value
  # NOTE EOF is -1
  .a.iXX.z
  # if not empty; then duplicate; fi
  # if not empty; then duplicate; fi
  .a.c.cXX.z
  # push one
  # if stack has two or more items; then pop twice and push their sum; fi
  .a\001.+XX.z
# done
# NOTE reaching to end of filename implicitily terminates the program
.a.a

Try it online!

\$\endgroup\$
1
\$\begingroup\$

Arduino, 113 bytes

#define S Serial
int c;void setup(){S.begin(300);}void loop(){if(S.available()){S.write(c=S.read());S.write(c);}}

Pretty simple. If there are unread characters from the serial input, write them twice.

Explanation:

#define S Serial /* This abbreviation is worth it if it's used more than twice */

int c;

void setup() {
  S.begin(300); // begin serial communications
}

void loop() {
  if (S.available()) { // if there are bytes to be read
    S.write(
      c = S.read() // read, store, and write it
    );
    S.write(c); // write the stored value
  }
}
\$\endgroup\$
1
\$\begingroup\$

K (ngn/k), 11 bytes

{,/{x,x}'x}

Try it online!

Quick.

Explanation:

{,/{x,x}'x}       Main program.
         x        For each character in the string...
   {x,x}          Duplicate the character twice
 ,/               Then join each duplicated character together
\$\endgroup\$
1
4 5 6
7
8

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.