93
\$\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\$
9
  • 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
  • 6
    \$\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
  • 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
  • \$\begingroup\$ Does this answer your question? Stretching Words Because when you make the two operands in any submission to that challenge equal, programs will obey the behavior described in this challenge. An example of this behavior is here. \$\endgroup\$
    – user85052
    Jan 2, 2020 at 12:29

245 Answers 245

1
5 6 7
8
9
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\$

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\$

Python, 31 bytes

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

Gives out an actual string instead of a list of characters.

Try it online!

\$\endgroup\$
1
  • \$\begingroup\$ Hey there, welcome to Code Golf! Unfortunately, someone else came up with this method independently to you: codegolf.stackexchange.com/a/250051. Still, nice answer! \$\endgroup\$
    – lyxal
    Sep 11, 2022 at 11:01
1
\$\begingroup\$

Knight (v2.0-alpha), 22 bytes

;=sP W;O+*[s 2'\'=s]sN

Try it online!

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

Raku, 16 bytes

{[~] .comb Xx 2}

Try it online!

Since the task expressly asked for a function, we're counting the curly braces that turn this expression into one; without them, it will just operate on the current topic $_, so depending on the surrounding code you don't necessarily need them.

~ is the string concatenation operator. Wrapping [...] around it changes it from an infix operator to a prefix function, so everything after it will be joined together into one big string at the end.

.method with no explicit invocant calls the method on the current topic, which here is the unnamed argument to the function. The .comb method splits a string into a sequence of characters (really one-character strings).

str x num repeats the string the given number of times.

X<operator> performs an outer join of its operands and applies the given operator to each pair of items in the result. In this case the right operand is the scalar 2, which just gets paired up with each element in the sequence on the left. So l Xx 2 could also be written, albeit with more bytes, as l »x»2 or l.map: *x 2.

All of the whitespace in the solution is required, unfortunately.

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

Scratch, 122 bytes

define(s
set[i v]to(1
set[r v]to(
repeat(length of(s
set[r v]to(join(r)(join(letter(i)of(s))(letter(i)of(s
change[i v]by(1

Outputs by modifying a global variable, r, which is automatically displayed (Consensus).

Try it on Scratch

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

Thunno J, \$ 3 \log_{256}(96) \approx \$ 2.47 bytes

e2*

Attempt This Online!

e is map, and 2* doubles. The J flag joins the resulting list.

Note: eZI and .ZI would also work for the same bytecount.

\$\endgroup\$
1
5 6 7
8
9

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

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