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/


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)
  • 3
    \$\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\$ – Peter Cordes Aug 3 '19 at 1:49
  • 4
    \$\begingroup\$ @PeterCordes I do not care if it modifies the same object or builds a new one. \$\endgroup\$ – AJFaraday Aug 3 '19 at 5:08
  • 2
    \$\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\$ – Peter Cordes Aug 3 '19 at 5:16
  • \$\begingroup\$ Can the string be empty? \$\endgroup\$ – cschultz2048 Aug 6 '19 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 '19 at 22:36

187 Answers 187

3 4 5 6

Unlambda, 11 bytes


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`|`@|.)


Ly, 7 bytes


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... 

V (vim), 5 bytes


Try it online!

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


V (vim), 5 bytes


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


Try it online!

  • \$\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 at 15:33

<>^v, 29 bytes

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


.—""?§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)


SM83, 8 bytes

Input string pointer in de, output string pointer in hl

1A 13 23 B7 C8 23 18 F8
    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

A0A0, 165 bytes




The program consists of three loops right after one another. The first loop does the following:

I1           ; take character input, store in V0
  A6         ; append this line to the line six below
    V0       ; operand, holds input
      P0     ; prints input
        G6   ; jumps to six lines below
          C6 ; removes all instructions on the six lines below

We duplicate the operand and print instructions a little lower, so we can print it twice. We then jump to there and the last C6 is to get rid of any other instructions that we didn't need afterwards.

The second loop is empty and is constructed from the first loop. The loop is also partially executed so we can enter the loop at the same place each time. This loop will print the character a second time. Because there is a nice G6 instruction inside the copied instructions that will also be executed, we use that as a way to escape from the infinite loop. This is because six lines below is yet another loop.

G-10     ; jumps 10 lines up, back to the first loop
    G1   ; no-op
      G1 ; no-op

This is a simple infinite loop (also partially executed) that takes us back to the first loop. It's padded with no-ops, since the loops needs at least three instructions. Because the first loop contains a C6, any redundant instructions in the second loop will be removed once we get back to the first loop.


Pxem, filename: 17 bytes.

\001 is such a byte of binary.


How it works

Since this program is simple, here is verbose explaination.

# while stack is empty or popped value is not zero; do
# NOTE stack is initially empty
  # if not empty; then pop to output its character; fi
  # if not empty; then pop to output its character; fi
  # getchar and push its codepoint value
  # NOTE EOF is -1
  # if not empty; then duplicate; fi
  # if not empty; then duplicate; fi
  # push one
  # if stack has two or more items; then pop twice and push their sum; fi
# done
# NOTE reaching to end of filename implicitily terminates the program

Try it online!

3 4 5 6

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.