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

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

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

• For the bonus, does the output have to be exactly n * program length bytes, or is that a minimum? – xnor Oct 2 '15 at 23:19
• It has to be exact – Daniel M. Oct 2 '15 at 23:20
• Looks like the code snippet has to be modified to handle negative scores. – El'endia Starman Oct 2 '15 at 23:49
• A bonus of -25 is basically mandatory for some languages, since it lets them achieve a negative score. In the future, I'd suggest using a percent bonus, or just making the bonus the question if you really want answers to go for it. Or, just don't have a bonus. – xnor Oct 2 '15 at 23:58
• For "no input is provided", do we assume the empty string is passed in? I can't see how one would deal with the user never typing in an input and the program just waiting. – xnor Oct 2 '15 at 23:59

# 05AB1E, 7 - 25 = -18 bytes

Saved a byte thanks to Okx.

YI7*ð×?


Try it online!

Explanation

Y       # push 2
I      # push input
7*    # multiply top of stack with 6 (program length)
ð×  # repeat <space> that many times
? # print top of stack

• Save 1 byte by using YI7*Xs×. There is no need to reverse the stack. – Okx Jan 26 '17 at 9:11
• @Okx: Good catch. Thanks! – Emigna Jan 26 '17 at 9:32
• Your current code will print the correct amount of spaces and then a newline :/ – Okx Jan 26 '17 at 12:29
• @Okx: True. I'm too used to trailing newlines being acceptable. Fixed now :) – Emigna Jan 26 '17 at 12:40
• @Okx: The Y is there to handle empty input (which should default to 2). – Emigna Feb 22 '17 at 19:04

# Java, 90 bytes

class T{public static void main(String[]a){for(int i:new int[90])System.out.print("##");}}


# Fission, 7 6 bytes

'#ORR"


This is a variation on a standard Fission quine. With two R's it creates two atoms and reads through the program twice.

Outputs ''##OORRRR##

Try it online!

-1 byte thanks to Jo King

• Why do you need the _? '#ORR" seems to work fine – Jo King Apr 13 '18 at 8:34
• @Joking It outputs ## at the end instead of "". – KSmarts Apr 16 '18 at 15:31
• And? That’s still twice the bytes. It doesn’t need to be quine-like – Jo King Apr 16 '18 at 21:41
• @JoKing Ah, I didn't re-read the challenge well. Updated. – KSmarts Apr 17 '18 at 13:27
• Or just ORR". – jimmy23013 Apr 17 '18 at 15:03

# Befunge-98, 12 - 25 = -13 bytes

j& 6*1-k.@>2


Try it online!

Prints the correct amount of 0s, each with a trailing space.

### How It Works:

j  No effect
& Gets input. If no input, reflect
>2 If it reflected put two 2s on the stack
j  Use one of the 2s to jump past the &
6*1- Multiply by 6 (length/2) and subtract 1 because it prints an extra 0 later
k.@ Print that many 0s and end the program


# Attache, 11 bytes

10^20|Print


Try it online!

outer:
ld b, 14
inner:
rst $38 djnz inner dec a jr nz, outer halt  # Python 3, 26 25 Bytes lambda n=2:print(n*26*'-')  Improved thanks to @JoKing # Come Here, 39 bytes CALL"9999999999999"iTELLi i i i i iNEXT  # 8088 machine code, IBM PC DOS, 35 bytes Unassembled listing:  _LOOP: AC LODSB ; load byte [SI] into AL, increment SI 8A F0 MOV DH, AL ; save original byte in DH B9 0204 MOV CX, 0204H ; set up nibble counter and shift count D2 C0 ROL AL, CL ; reverse nibbles (display high order first) _NIB: 24 0F AND AL, 0FH ; mask low nibble 3C 0A CMP AL, 0AH ; is < 10? 72 02 JC _ASC ; if so, is a numeric digit 04 07 ADD AL, 07H ; otherwise adjust for A-F hex ASCII _ASC: 04 30 ADD AL, '0' ; ASCII convert B4 0E MOV AH, 0EH ; BIOS output char function CD 10 INT 10H ; display char 8A C6 MOV AL, DH ; restore original nibble to AL FE CD DEC CH ; decrement nibble counter 75 EC JNZ _NIB ; if > 0, repeat 81 FE 0123 CMP SI, OFFSET _EF ; is SI < last byte? 7C DE JL _LOOP ; if so, keep looping C3 RET ; return to DOS _EF EQU$               ; get program size


This is a complete IBM PC DOS executable that displays itself as ASCII hex, so will always output as twice the program size.

Output

# Husk, 13 bytes - 25 = -12

R'A*13→←↓ΘN←


(Both TIO links use capital xi instead of A because it looks cooler, but since I just realized that output has to be ASCII and xi isn't exactly ASCII although it is one byte in Husk's code page, the "canonical" program here uses A instead.)

I tried to come up with a well-thought-out and enlightening explanation of why Husk's overload resolution for built-ins doesn't support distinguishing type signatures by number of arguments alone, but I couldn't quite get it right and it took long enough just to write the solution. Suffice it to say, it doesn't, so I had to get a bit creative.

The first part functions the same with and without an input:

R           Repeat
'A         capital A (could be any character)
13      (thirteen
*         times
→      (one plus
←      the first element of
whatever expression we get to the right of this))
R           times.


The rest of the program handles the defaulting behavior, by exploiting ↓'s possession of overloads for using either a function or a number to drop a prefix from a list.

Explained with an input:

   N     The infinite list of the natural numbers
Θ      with a zero tacked on to the beginning
↓       with the first
(input
←     minus one)
↓       elements removed.


Without an input:

   N     The infinite list of all natural numbers
Θ      with a zero tacked on to the beginning
↓       without the largest prefix every element of which
←    is not equal to 1.


A version which elects to not take the bonus:

# Husk, 2 bytes

←.


Try it online!

Husk assumes that, in the absence of any digits on the left of the radix point, a single 0 is meant, and in the absence of any on the right, a single 5 is meant. So, it is possible to write 0.5 as just .. 0.5, as a string, is three bytes long (and so is 1/2, which is what actually gets printed), so to add a byte, subtract 1 for -0.5 (although what we actually print is -1/2).

←     Subtract 1 from
.    0.5.


A longer and sillier no-input version:

# Husk, 3 bytes

ss"


Try it online!

Prints "\"\"".

s      The string representation of
s     the string representation of
"    the empty string.


A version which must take input, having no valid type if it doesn't take an input, and thus neither does nor doesn't take the bonus, failing to comply with the challenge at all:

# Husk, 4 bytes (invalid but here anyways, would be -21 with bonus)

*s"¨


Try it online!

Prints n copies of "\"".

 s      The string representation of
"     the string containing
¨    a single "
*       repeated n times.


# Excel Formula, 23 - 25 = -2 bytes

=REPT("A",MAX(A1,2)*23)


However, this doesn't work for A1 (n) = 1(!)

## Version supporting N=1, 28 - 25 = 3 bytes

=REPT("A",(A1=0)*56+(A1*28))


# TinCan, 122 bytes

# 62367, A, &                          #
# -256, A, -1                          #
# 0, A, 1                              #


Outputs 244 'a's.

aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa


Try it online!

Explanation:

Lines have a minimum length of 40 characters in TinCan, and there is only one instruction, so 40 bytes would be the shortest feasible TinCan program other than an empty file.

TinCan's interpreter is written in PHP and uses the PHP chr function to output the character value of each number on the stack when the program ends. This also works for values outside the range of 0 to 255, using bitwise and with 255 to get the result.

For this program, I multiplied the length of the program (122 bytes) times two, minus one for the positive case, times 256 and added (256 - 97), 97 being the ASCII value of 'a'. This gives 62367.

The loop then generates a sequence of values starting at -62367 and counting upwards by 256 each iteration. Each value in sequence when processed by chr produces another 'a'. When the variable A becomes positive, the program exits and prints 244 'a's.

With the fixed line length, golfing this down would require removing one whole instruction, which I don't believe is possible. But I'd be happy to be proven wrong!

# Aheui (esotope), 87 bytes

삭밦밢따밥다사바바바바바바우a
샥ㅇ뱟ㅇ탸ㅇ뺘소처희ㅇㅇ아멍a


Try it online!

output is 174 bytes of 0. Aheui program is written in Korean, so one character is 3 bytes, and question said measured in byte, so 174. Trailing a is for making program to proper bytes.

# How does this work?

삭밦밢따밥다 : to stack ㄱ, then put 58. (28 Korean characters. Aheui cannot put 1 to stack, so I'll subtract 2 instead of 1 when counting loop.)

사바바바바바바우 : to stack (Nothing), put 6 zeros, than move downside.

아멍 : print from current stack till nothing left. if nothing left, move to start of the line.

샥ㅇ뱟ㅇ탸ㅇ뺘소처희 : to stack ㄱ, subtract 2, check if zero, halt if zero, to stack (Nothing) and move to 사바바바바바바우 again.

a : At first, I thought this code would work just fine, but something went wrong. I used online character counter, and I got 29, so I made code with that. But code was 85 bytes and output was 174 bytes. I found the reason of this error : newline character. So I added 2 bytes to my code, than everything works fine. Aheui don't evaluate non-Korean characters, so a is just blank.

# Befunge-93, 25 - 25 = 0 bytes

&+:0\3*+::%+"CG"*:*:.:*.


Try it online!

Uses no control flow instructions! This code is implicitly looped n amount of times.

To get the n as input once and not have it interfere with subsequent iterations, we use Befunge-93's feature of returning -1 for input if the input stream is empty. At the start of each iteration, the top of the stack is the loop counter. It starts off at 0 (the default value on the stack). &+ gets a value from input and adds it to the counter. Conveniently, this sets the counter to the received input on the first iteration, and subtracts 1 on every subsequent iteration, creating a for (i = input();; i--) loop. :0\3*+ computes (counter < 0) * 3 and adds it to the counter. This has the effect of adding 3 if the counter is negative (which happens if there was no input and we want to set n to -1+3=2), and otherwise adding 0 (if the input was positive or this is not the first iteration).

::%+ simply calculates counter % counter and discards the result, so as to halt when the counter reaches 0.

At the end, we output two large numbers by repeatedly squaring the product of two ASCII characters. Note that after each outputted number there is a trailing space.

# C (gcc), 35 - 25 = 10 34 - 25 = 9 bytes

-1 byte thanks to PrincePolka

Input is in the form of number of command-line arguments. No arguments counts as no input.

main(i){printf("%*d",34*--i?:68);}


Try it online!

• main(i){printf("%*d",34*--i?:68);} - 1 byte – PrincePolka Jul 30 '19 at 3:01
• @PrincePolka Cheers! – gastropner Jul 30 '19 at 22:13

# MathGolf, 2 bytes

7!


Outputs 5040, which is 4 bytes.

Try it online!

• Congratulations on your first MathGolf answer! There are also quite a few 1-byte answers, as the bytes A to Z hold values between 11 and 38. Other approaches are Hf (19th fibonacci number) or 7· (push 7 and quadruplicate to 7777). – maxb Aug 6 '19 at 5:26

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

## Keg, 6 2 bytes

(|A,)


It loops 12 times printing 12 A's to the console, which is double the size of the program. There is a control character (0x0C) between the ( and |, which makes this 6 bytes.

Another shorter version:

A


This prints A plus a newline, which contains 2 characters.

Worth a mention(3 bytes):

5/


TIO

• I don't think you have the byte count correct at the top of your answer. (|A,) is 5 bytes. Is there supposed to be a trailing newline? – mbomb007 Jun 6 '19 at 19:18
• There should be a control character between ( and |, which should be 0x0C. – user85052 Jun 7 '19 at 2:08

## W, -22 bytes

The program is 3 bytes long and qualifies for the -25 byte bonus. (Okay. One-digit problem fixed!)

 0M


## Explanation

   % Filler space
M % Map: (implicitly) generate a list from 1 to the input
% There is an implicit 0, so the 0-input
% will produce the output [0, 1], which is
% 6 bytes by default.
M % Map every item in that list ...
0  % .. with the numeric constant 0


# naz, 2 bytes

4o


Outputs 0000.

Explanation

The default value of the register is 0; if the register's value is between 0 and 9 inclusive, use of the o instruction will output that number as an ASCII character.

# Python 3.4, 14 13 bytes

print("a"*26)

• This is only 13 bytes. Which makes your score 41 (13 + 28). You can lose two points by changing 28 to 26. – Zach Gates Oct 3 '15 at 3:31
• Did you think about say()? – Titus Jan 27 '17 at 6:59

## Pyth, 6 bytes

*4"aaa


Explanation:

*4"aaa
-------+------------
"aaa | Print "aaa"
*4     | 4 times


## Pyth, -7 bytes

*.xvw2*2"aaaaaaaaa


Plain and simple.

*.xvw2*2"aaaaaaaaa
-------------------+----------------------
*2"aaaaaaaaa | Print twice the "a"s
*                  | times
.xvw              | try to evaluate input
2             | otherwise, 2

• For the bonus, if no input is provided, it should default to 2. – Dennis Oct 3 '15 at 17:37
• Yup, just noticed that. Fixed. – clap Oct 3 '15 at 17:39

# C#, 63 62 bytes

class P{static void Main(){System.Console.Write(\$"{1,124}");}}


Will print 123 spaces followed by 1.

• How does this work? – LegionMammal978 Dec 29 '15 at 14:20
• @LegionMammal978 in C# 6, @"{1,124}" is the equivalent of string.Format("{0,124}", 1) which means format the number 1 to a string with a minimum length of 124. It uses spaces to pad the value to the minimum length. See composite formatting. – Lucas Trzesniewski Dec 29 '15 at 14:45

# Ruby, 22 bytes - 25 bytes = -3 bytes

c=->n=2{p ?d*21*n}
c[]


The reason the value shows up as 21 bytes in the code itself is that the quotation marks are printed, effectively reducing the number of bytes I need to print by 2 (left paren and right paren).

# ><>, (15 + 3) - 25 = -7

2}f*:?!;1n1-30.


Like torcado's answer, but a one-liner. Takes input via the -v flag, e.g.

py -3 fish.py double.fish -v 5


and outputs 15*<input> ones.

# ><>, 5 bytes

"nn#;


Here's a version without any bonuses. Outputs 5935110110.

# Ruby, 5 bytes

p 1e6


Outputs 1000000.0 and a newline, which is 10 bytes in summary

# GolfScript, 11 - 25 = -14 bytes

~2]0=11*(n*


Given n, outputs n times as many newlines as the length of the code in bytes (= 11). Given no (i.e. empty) input, outputs 22 newlines.

The implementation is very straightforward:

• ~ evals the input,
• 2]0= replaces an empty input with 2,
• 11* multiplies the input number with 11 (the length of the program),
• ( decrements the number by 1 (to account for the automatically inserted trailing newline), and
• n* repeats a newline the given number of times.