Create output twice the length of the code

Question

The Challenge

Write a complete program that writes twice as many bytes to standard output as the length of the program.

Rules

• The program must write ASCII characters to the standard output.

• The contents of the output doesn't matter.

• The output, measured in bytes, must be exactly twice the length of the program, also measured in bytes, unless you fulfill the bonus.

• Any trailing newline is included in the output's byte count.

Bonus

Your program can optionally take a number, n, as input. If so, the output must be exactly n * program length bytes. You can assume that n will always be a positive integer. If no input is provided, n must default to 2.

If you do this, you can subtract 25 bytes from your score.

Shortest program wins.

Restrictions

• No standard loopholes.

• The program must be at least 1 byte long.

• No adding unnecessary whitespace to the source code to change its length. Similarly, comments don't count.

• Unless you fulfill the bonus, the program must accept no input. If you do fulfill the bonus, the integer must be the only input.

Lowest score (program length in bytes - bonus) wins.

The shortest answer for each language wins for that language.

Leaderboards

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

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

# Language Name, N bytes

where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:

# Ruby, <s>104</s> <s>101</s> 96 bytes

If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:

# Perl, 43 + 2 (-p flag) = 45 bytes

You can also make the language name a link which will then show up in the leaderboard snippet:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

var QUESTION_ID=59436,OVERRIDE_USER=41505;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\-?\d+/);answer_ids.push(s),answers_hash[s]=e}),e.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(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\-?\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;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="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <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><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><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Answer 1

Brachylog, 10 bytes - 25 = -15

{2|};Ṿj₍jw

Try it online!

         w    Print
     Ṿ        "aeiou"
      j       concatenated with itself
 2            two
{ |}          or whatever else the input is
    ;  ₍      times
        j     concatenated with itself again.

A version without the bonus:

Brachylog, 3 bytes

ẈẈw

Try it online!

Bypasses the ban on unnecessary whitespace by using unnecessary variable unification instead.

  w    Print
 Ẉ     the built-in constant "aeiouy" which is
Ẉ      the built-in constant "aeiouy".

A version without any silly redundancy:

Brachylog, 4 bytes

1j₈w

Try it online!

   w    Print
1       the digit 1 (could be any digit other than 0)
 j      repeated
  ₈     eight times.

Answer 2

Runic Enchantments, 10 bytes -25 = Score: -15

"9q2i{S*$;

Try it online!

Program reads a string literal (effectively its own source), concats a 9, pushes a literal 2, and attempts to read input.

Reading input and there being no input to read causes the next two commands, {S, to be NOP. This leaves the literal 2 on top of the stack. If there was input, the input ends up on top and the literal 2 on the bottom. Non-numerical input has undefined behavior.

Then multiplication between the integer on the top of the stack with the next item (the string) duplicates it n times (Python style). String is exactly the length of the program, being almost a quine, with 9q putting a 9 on the end substituting for the missing " from the beginning. $; prints only the resulting string and terminates (discarding any remaining literal 2 if input was taken).

Answer 3

INTERCAL, 32 bytes

PLEASE,1<-#64DOREADOUT,1DOGIVEUP

Try it online!

Prints 64 null bytes and takes no input. If you like your output printable, the next version is for you:

INTERCAL, 45 bytes

PLEASE,1<-#90DO,1SUB#1<-#4DOREADOUT,1DOGIVEUP

Try it online!

This is one of those rare cases where C-INTERCAL’s “Turing Tape” I/O is actually helpful. Essentially, what it does is for each value in an array, rather than directly print the corresponding character, is subtract the value from the previous value (starting at 0) mod 256, reverse the bits, and then print that, for every value up to the end of the array. So to print a string of a certain length, you just need to READ OUT an array of that size, and to make it more than just a bunch of null bytes, you only need to set the first element of the array and it’ll print a bunch of something else instead: here, setting the first value to 4 prints 90 question marks, since 0 - 4 mod 256 ≡ 252 = 0b11111100 which is 0b00111111 = 63 backwards, and since every cell in the array after the first has a 0 in it the byte which gets printed never changes on account of that 252 - 0 is still 252.

A version with the bonus which prints null bytes:

INTERCAL, 67 bytes - 25 = 42 (except it can't default to 2)

DOWRITEIN.1DO.2<-#67DO(1530)NEXTPLEASE,1<-:1DOREADOUT,1PLEASEGIVEUP

Try it online!

A version which prints question marks instead:

INTERCAL, 80 bytes - 25 = 55 (except it can't default to 2)

DOWRITEIN.1DO.2<-#80DO(1530)NEXTPLEASE,1<-:1DO,1SUB#1<-#4DOREADOUT,1PLEASEGIVEUP

Try it online!

Uses a call to syslib for multiplication of the input with 80 into :1. (Also note that INTERCAL’s native number input format is the digits of a number spelled out with a trailing newline.)

Answer 4

Boolfuck, 21 bytes

+[[>+>+[<;;;]<]>+>>]>

This program outputs 330 bits (41.25 bytes) which get buffered to 42 bytes. I found it by systematically (but not quite exhaustively) searching through several million possible candidates.

Here is a hexdump of the output:

00000000: fc0f ffe3 ffc7 ffff ff1f fe3f ffff f8ff  ...........?....
00000010: ffff ffff c0ff fe3f ffff ff1f ffff ffff  .......?........
00000020: ff1f ffff ffff ffff fe00                 ..........

Try it online!

I also recommend taking a look at this in fatiherikli's Brainfuck visulizer (optimized and with minimal delay of course).

Answer 5

Guile (5)

"oof" outputs $1 = "oof"

Answer 6

Bash, 10 bytes

yes|head -

outputs 10 lines of ys for 20 total bytes output.

Answer 7

MathGolf, 2 bytes

7!

Outputs 5040, which is 4 bytes.

Try it online!

Answer 8

MathGolf, 5 - 25 = -20 bytes

╜2╩[*

Try it online!

Explanation

╜2      If not implicit input, push 2
  ╩[    Push dictionary word "great"
    *   Repeat string

To make it work, I just had to find a word within the top 256 lines of the dictionary which had the same length as the code.

Almost working 3-byter with 25 byte bonus

╜2r

Try it online!

Basically the same as Stan Strum's Pyth answer. If (implicit) input is equal to 0, push 2. Then create a range using either the 2, or the implicit input. The length of the output is the length of the string representation of the array, which is 3 times the length of the array. This only works for input \$\leq 10\$.

Answer 9

Triangular, 10 8 7 bytes

tdC%.`y

Try it online!

Prints odd numbers from 11 to 1 descending, twice each.

Triangular executes as if written in the shape of a triangle. For example, if your program was 123456, the triangle representing your program would be drawn like this:

  1
 2 3
4 5 6

The program executes starting from 1, and has a Southeast direction (I.e., the above would run as 1, 3, 6). This explanation is for its actual execution order, which is why it doesn't visually look the same as the submission.

Ungolfed/Directional

   t
  d C
 % . `
y

-------------------------------------------------------------------

t             - If ToS != 0, set direction to SouthEast
 C            - Push 12
  `           - Set direction to NorthWest (This means we hit "t" with ToS > 0)
   d          - Decrement the top value of the stack
    %y        - Print the top value of the stack, then change direction to NorthEast if ToS != 0

---

Previous Version (8 bytes):

Dn,%d./<

Answer 10

GolfScript, 18 - 25 = -7

.!35 n*{~18*(n*}if

Try it online!

Prints \$input * 6 - 1\$ newlines if there is an input else 35 newlines, plus one trailing newline.

                if           If
.!                           input is empty:
  35 n*                      35 newlines
       {       }             Else:
        ~18*(n*              18 * input - 1 newlines
                             Trailing newline

Answer 11

GolfScript, 13-25 = -12 bytes

.~13*(25if n*

Try it online!

Explanation

        if     # If
.              # Input is not a null string:
 ~             # Evaluate the input
  13*(25
           n*

Answer 12

Flurry, 28 bytes, no bonus

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

Verification

$ echo -n "({<(({})){}{}>})({}){({})}{}" | wc -c
28
$ ./flurry -iin -c "({<(({})){}{}>})({}){({})}{}"
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3
$ ./flurry -iin -c "({<(({})){}{}>})({}){({})}{}"  | wc -c
56

Uses 3 ** 3 = 27, and enables both stack output and return value output so that 3 is printed 27 + 1 times.

(
 {<(({})){}{}>}  Literal 3
)              Push and return 3
({})           Pop, push and return 3; 3 3 -> 27
{({})}         Push&return function
{}             Pop 3; 27 push&return 3 -> push 27 copies of 3 and return 3

---

Flurry, 32 bytes, no bonus

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

Verification

$ echo -n "<(({<({}){}>})({})){}{}>{({})}{}" | wc -c
32
$ ./flurry -inn -c "<(({<({}){}>})({})){}{}>{({})}{}"
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
$ ./flurry -inn -c "<(({<({}){}>})({})){}{}>{({})}{}" | wc -c
64

How it works

In order to increase the output size, it is easiest to push numbers to stack and print them in integer mode. Basically the program follows the structure of n push&return m, where n is the repeat count, push&return is a function that, given an argument, pushes it and returns it unchanged, and m is the number to push. Then the stack contains n copies of m at the end, giving the output size of (length of m + 1) * n.

The second part of the challenge is to generate high enough numbers. Flurry uses Church numerals to represent natural numbers, so multiplication (<abc...> evaluates to a * b * c * ...) and exponentiation (ab evaluates to b**a) is much golfier than number literals (except 1), successor <><<>()>, and addition (which is defined via successor). So I tried various powers and products until I got the solution, where 32 is 4 * 4 * 2.

<
 (
  ({<({}){}>})  Push and return 2
  ({})          Pop 2, push back and return 2
 )            Push and return 2 ** 2 = 4
 {}{}         Pop 4 and Pop 2
>           Product; return 4 * 4 * 2 = 32
{({})}      Function: push&return
{}          Pop from empty stack, which gives I = 1
32 push&return 1 -> Push 1 to stack 32 times and return 1

Answer 13

Factor, 7 bytes

42 2^ .

Try it online!

2^42 is a 13-digit number. . outputs this number plus a newline.

Answer 14

Crystal, 9 bytes

print 5/7

Try it online!

Answer 15

Risky, 1 bytes

*1

Try it online!

(Prints 10, by doing 10 ** 1)

Answer 16

Carrot, 4 bytes

.^*7

Prints ........ (8 .s).

Try it online!

Explanation

.^                        Sets the stack-string to "."
  *7                      Append seven duplicates of the stack-string to itself
                          Implicit output

Answer 17

PHP, 56-25 = 31 bytes

I wanted one where size of the code doesn't matter:

<?=str_repeat(file_get_contents(__FILE__),$n!=''?$n:2)?>

Or a more modern version:

<?=str_repeat(file_get_contents(__FILE__),$argv[1]?:2)?>

Answer 18

Python REPL, 4 Bytes

9**8

\$9^8=43046721\$

Answer 19

C, 47 - 25 = 22 46 - 25 = 21 bytes

x=2;main(){scanf("%d",&x);printf("%*x",x*46);}

Try it online!

Works by printing an uninitialised int, padded to the specified size. Credit to anatolyg's answer.

Answer 20

Python 3, 28 bytes - 25 bonus = 3 bytes

lambda n=2:print(*[9]*14*n,)

Try it online!

Takes in an int as input and outputs [9] (the 9 is an arbitrary one-byte number) times 14, which is the length of the input (28) divided by 2. The star expansion operator * makes print print the contents of [9]*14*n as a space-separated string, which results in 2*14*n-1 characters. With the newline (+1 byte) that becomes 2*14*n=28*n characters printed.

Answer 21

Desmoslang Assembly, 11 - 25 = -14 Bytes

[1...11*IOT

Note that you can't not give input.

Answer 22

><>, 22 bytes

095*>1-:?v;
    ^o*86<

Try it online!

Pushes 0 and 45 (which is subtracted by 1 right after), then outputs a zero that many times.

Answer 23

AArch64 machine code + Linux syscalls, 56 - 25 = 31 bytes

00: 4f03e7c0  movi  v0.16b, #126      // v0 / q0 = '~' * 16
04: ad0003e0  stp   q0, q0, [sp]      // stack   = '~' * 32
08: ad0103e0  stp   q0, q0, [sp, #32] // stack   = '~' * 64
0c: 52800048  mov   w8, #2            // default to 2
10: 71000409  subs  w9, w0, #1        // argc - 1
14: 1a890109  csel  w9, w8, w9, eq    // argc - 1 ?: 2
18: 910003e1  mov   x1, sp            // pointer to '~' * 64
1c: d2800702  mov   x2, #56           // 56 bytes
20: d2800808  mov   x8, #64           // 64 = write()
24: d2800020  mov   x0, #1            // 1 = stdout (loop starts here)
28: d4000001  svc   #0                // syscall, write(stdout, '~' * 64, 56)
2c: 51000529  sub   w9, w9, #1        // loop countdown
30: 35ffffa9  cbnz  w9, 0x24          // loop
34: d65f03c0  ret                     // return result of last syscall

Should be linked as main.

The input is the number of command line arguments.

---

If it needs to be linked as _start and isn't allowed to segfault out:

AArch64 machine code + Linux syscalls, 60 - 25 = 35 bytes

00: 4f03e7c0  movi  v0.16b, #126      // v0 / q0 = '~' * 16
04: ad0003e0  stp   q0, q0, [sp]      // stack   = '~' * 32
08: ad0103e0  stp   q0, q0, [sp, #32] // stack   = '~' * 64
0c: 52800048  mov   w8, #2            // default to 2
10: 71000409  subs  w9, w0, #1        // argc - 1
14: 1a890109  csel  w9, w8, w9, eq    // argc - 1 ?: 2
18: 910003e1  mov   x1, sp            // pointer to '~' * 64
1c: d2800782  mov   x2, #60           // 60 bytes
20: d2800808  mov   x8, #64           // 64 = write()
24: d2800020  mov   x0, #1            // 1 = stdout (loop starts here)
28: d4000001  svc   #0                // syscall, write(stdout, '~' * 64, 60)
2c: 51000529  sub   w9, w9, #1        // loop countdown
30: 35ffffa9  cbnz  w9, 0x24          // loop
34: d2800ba8  mov   x8, #93           // 93 = exit()
38: d4000001  svc   #0                // syscall, exit(result of last syscall)

---

If the input number being the number of command-line arguments doesn't count, here's one with no bonus:

AArch64 machine code + Linux syscalls, 40 bytes

00: 4f03e7c0  movi  v0.16b, #126      // v0 / q0  = '~' * 16
04: ad0003e0  stp   q0, q0, [sp]      // stack    = '~' * 32
08: ad0103e0  stp   q0, q0, [sp, #32] // stack    = '~' * 64
0c: 3d8013e0  str   q0, [sp, #64]     // stack    = '~' * 80
10: 910003e1  mov   x1, sp            // pointer to '~' * 80
14: d2800a02  mov   x2, #80           // 80 bytes
18: d2800808  mov   x8, #64           // 64 = write()
1c: d2800020  mov   x0, #1            // 1 = stdout
20: d4000001  svc   #0                // syscall, write(stdout, '~' * 80, 80)
24: d65f03c0  ret                     // return result of last syscall

---

And for both of the above conditions:

AArch64 machine code + Linux syscalls, 44 bytes

00: 4f03e7c0  movi  v0.16b, #126      // v0 / q0  = '~' * 16
04: ad0003e0  stp   q0, q0, [sp]      // stack    = '~' * 32
08: ad0103e0  stp   q0, q0, [sp, #32] // stack    = '~' * 64
0c: ad0203e0  stp   q0, q0, [sp, #64] // stack    = '~' * 96
10: 910003e1  mov   x1, sp            // pointer to '~' * 96
14: d2800b02  mov   x2, #88           // 88 bytes
18: d2800808  mov   x8, #64           // 64 = write()
1c: d2800020  mov   x0, #1            // 1 = stdout
20: d4000001  svc   #0                // syscall, write(stdout, '~' * 96, 88)
34: d2800ba8  mov   x8, #93           // 93 = exit()
38: d4000001  svc   #0                // syscall, exit(result of last syscall)

Answer 24

><>, 29 + 2 (-v flag) - 25 = 6

l0=?21-:0(?;fe+1-ao:0=f*e+0.~

Takes input on the stack, which I believe is populated through -v on the official interpreter. Prints newlines only.

Answer 25

Microscript, 1

0

Prints the digit 0, followed by a newline.

Answer 26

q (bonus), 27 bytes

1#[;"x"]27*2^first"J"$.z.x;

Answer 27

C#, 104 bytes (79 point with bonus)

class a{static void Main(string[] p){System.Console.Write(new System.String('1',104*int.Parse(p[0])));}}

you can run the program by using an argument for example test.exe 2 prints 208 character '1'

Answer 28

awk, 29 - 25 = 4 bytes

{printf"%0"($0?$0:2)*29"d",0}

Prints the wanted number of zeros.

Answer 29

Befunge-98, 26-25=1

&:#v_v>1.1-v
*d2<2<^_@#:<*

Run it in this interpreter. Apparently, it can't take input.

Befunge-93, 30 - 25 = 5 27-25=2

&:#v_v>1.1-v 
*93<2<^_@#:<*

There is a trailing space on the first line, and this is done because it's shorter to make 27 than it is to make 26 with Befunge-93. This outputs 27*n 1s in a row.

Answer 30

Perl, 10 9 bytes

Uses @primo's suggestion of $=.

print$=x9

$= is a shortcut for $FORMAT_LINES_PER_PAGE, which defaults to 60.

Example:

$ cat doubler.pl
print$=x9
$ perl doubler.pl
606060606060606060