# Output with the same length as the code

In this challenge, you should write a program or function which takes no input and prints or returns a string with the same number of bytes as the program itself. There are a few rules:

• You may only output bytes in the printable ASCII range (0x20 to 0x7E, inclusive), or newlines (0x0A or 0x0D).
• Your code must not be a quine, so the code and the output must differ in at least one byte.
• Your code must be at least one byte long.
• If your output contains trailing newlines, those are part of the byte count.
• If your code requires non-standard command-line flags, count them as usual (i.e. by adding the difference to a standard invocation of your language's implementation to the byte count), and the output's length must match your solution's score. E.g. if your program is ab and requires the non-standard flag -n (we'll assume it can't be combined with standard flags, so it's 3 bytes), you should output 5 bytes in total.
• The output doesn't always have to be the same, as long as you can show that every possible output satisfies the above requirements.
• Usual quine rules don't apply. You may read the source code or its size, but I doubt this will be shorter than hardcoding it in most languages.

You may write a program or a function and use any of the standard methods of providing output. Note that if you print the result, you may choose to print it either to the standard output or the standard error stream, but only one of them counts.

You may use any programming language, but note that these loopholes are forbidden by default.

This is , so the shortest valid answer – measured in bytes – wins.

var QUESTION_ID=121056,OVERRIDE_USER=8478;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){var F=function(a){return a.lang.replace(/<\/?a.*?>/g,"").toLowerCase()},el=F(e),sl=F(s);return el>sl?1:el<sl?-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>

• – Martin Ender May 17 '17 at 11:19
• "Your code must not be a quine" but... but... it's tagged quine – Okx May 17 '17 at 11:21
• @Okx Because it's a generalised quine, i.e. the required output depends on the source code. – Martin Ender May 17 '17 at 11:22
• @MartinEnder You should probably disallow output by exit code, which is a default. If you allow it nearly every one byte program in nearly every language is allowed. One user has already done this – Post Rock Garf Hunter May 17 '17 at 22:37
• @WheatWizard output by exit code is not a string, so it doesn't apply here. – Martin Ender May 18 '17 at 4:29

# Common Lisp, 5 bytes

1e+01


in the Common Lisp REPL it produces 10.0 plus linefeed, for a total of 5 bytes.

Thanks to @MartinEnder for noting an error in the previous 4 bytes version!

# SmileBASIC, 3 bytes

?#Y


Output:

128

#Y is a constant used for checking the (Y) button, and has a value of 128.

• I wonder if ? is acceptable since it prints a blank line. (Of course it's impossible to actually verify if the console writes a linefeed.) – snail_ Apr 20 '18 at 3:47

# x86 .COM opcode, 9 Bytes

0100 B409          MOV     AH,09
0102 BAFF00        MOV     DX,00FF
0105 CD21          INT     21
0107 C3            RET
0108 24            DB      '$'  # Pascal (FPC), 22 bytes begin write('':22)end.  Try it online! :22 pads the write value to be at least 22 characters in length. Here, the write value is an empty string, so this prints 22 spaces. # Flobnar, 9 8 bytes *<*@ 9*<  Try it online! Outputs 43046721, which is 98. This uses the -d flag to output in decimal. Thanks to Esolanging Fruit for this solution # Z80Golf, 5 3 bytes 00000000: 3e76 34 >v4  Try it online! The output is vvv. Yay for ASCII-printable machine code! ### Disassembly start: ld a,$76 ; 3e 76
inc (hl)  ; 34


Uses the same concept as the 5-byte one: edit the running code on the fly, and abuse stack underflow.

The program initially loads 'v' to register a, and increments the value at the memory address (hl), which is $0000 where the code $3e is located. Then the code becomes:

  ccf      ; 3f ; Complement carry flag, effective no-op in this program
halt     ; 76
inc (hl) ; 34


So the halt is uncovered right away. The stack underflow magic takes the next job; putchar's ret returns to $763f, $0034, and $0000 in the order, and three vs are printed in the process. Now pc is back at the start of the program. ccf is no-op, halt is executed, and the program terminates. ## A variation, 4 bytes 00000000: 3e76 343b >v4;  Try it online! The output is vvvv. ### Disassembly start: ld a,$76 ; 3e 76
inc (hl)  ; 34
dec sp    ; 3b


The added dec sp makes things slightly more convoluted; the stack is arranged so that putchar is run 4 times instead of 3. Without the instruction, the return addresses are $763f -$3b34 - $0000; with it, the addresses are $3e00 - $3476 -$003b - 0000. Leaving this solution here, in case someone finds the "stack misalignment" technique useful. ## Previous solution, 5 bytes 00000000: 2e0a 3e76 34 ..>v4  Try it online! ### Disassembly start: ld l,0a  ; 2e 0a
ld a, $76 ; 3e 76 inc (hl) ; 34  The second instruction sets up the character to print, which is 'v'. The rest increases the value at the memory address $000a.

The output is vvvvv. Too bad it's not in uppercase (and it's not six v's), otherwise I'd reference the game VVVVVV.

### How it works

For no-input challenges, underflowing the stack into the code is a standard technique in Z80Golf. It is done by letting the PC flow beyond the end of the code, so that putchar at address $8000 is reached, a char is printed, and ret is executed. • When the code section is run the first time, the instruction at memory $000a becomes ld bc, $0000 (opcode$01 $00$00). Pretty much no-op, since all registers are zeroed when the program starts. putchar is reached and v is printed once. Then it returns to $0a2e. • putchar is run again, v is printed, and the next return address is $763e.
• Same thing again, return to $0034. • Same thing again, finally return to $0000, the start of the code.
• The code is run again; the instruction at memory $000a is now ld (bc), a (opcode$02). a is $76, so the value is written to memory $0000. After putchar is reached this time, return to $0000 again, and PC meets the new instruction $76 which is... halt! The program ends.

# MathGolf, 1 byte

!


Try it online!

For MathGolf, there is an implicit pop if nothing is on the stack and nothing is in the input. The operator will pop the default value for the type it's requesting, which is either 0, [] or "". That means that a lot of operators will pop implicit zeros from the empty stack, and transform them either into 0 or 1. There are 15 1-byte programs which satisfy the criteria of this challenge, most of them output 0. The rest output 1.

## Output 0

*: 0
+: 0
,: 0
-: 0
.: 0
<: 0
>: 0
f: 0
i: 0
w: 0
x: 0


## Output 1

!: 1
#: 1
): 1
=: 1

• Doesn't ! output 1 as well by default? I remember using that in the How high can you count challenge. Also, your code contains *, but your TIO is ¶. – Kevin Cruijssen Dec 6 '18 at 12:04
• You're absolutely correct. I created a script to search for all possible correct answers, ! must have gotten lost somewhere. My first thought was ¶, but that's not printable ascii. I'll update the answer once I've looked for more possible correct answers. – maxb Dec 6 '18 at 12:06

# PowerShell, 4 bytes

1..2


Try it online!

Output includes a trailing newline!

• You could to try ,1 or +1. Output includes a trailing newline! – mazzy Dec 9 '18 at 7:04
• Thanks @mazzy, however I think that this method has already been used in this answer. – Gabriel Mills Dec 9 '18 at 15:21

## Perl612 7 bytes

say |^6


Prints the number from 0-5 and a newline for 7 bytes. Suggested by Jo King.

Original

.say for ^7

• Nice. I'll have that :D (With attribution of course). – Scimon Proctor Jul 29 '19 at 13:34

# Alchemist, 9 bytes

_->9Out__


Try it online!

Uses up the initial _ atom to output the number of _ atoms remaining (0) nine times.

# brainfuck, 24 bytes

-[>+<---]++++++[->....<]


Try it online!

Prints 24 Us.

### Explanation:

-[>+<---]    # Generate a U
++++++[      # Loop 6 time
->....<]     # Printing U 4 times each


# Keg, 2 bytes

Q.


Outputs 81, which is the ascii value of Q

Try it Online!

• I thought ! would be shorter, but the implicit output has a trailing newline :( – Jo King Aug 10 '19 at 9:55
• It also has 3 trailing spaces for some reason – EdgyNerd Aug 10 '19 at 10:01

# T-SQL, 21 15 bytes

print space(15)


Try it online

### Output:

               
• Looks like a space is a valid output, so PRINT SPACE(15) would save you some bytes. – BradC Aug 14 '19 at 15:12
• Nice! Thanks... – mbomb007 Aug 14 '19 at 15:16

# Pyramid Scheme, 32 bytes

^ ^ ^
-^-^-
^-^-
-^-^
^-^-
- -



Try it online!

Outputs 16 zeroes and newlines. I can find a lot of alternative 32 byters with varying amounts of extra padding, but the closest I can come to something shorter is this 27 byte program that outputs 26 bytes

## Keg, 2 bytes




Note that there is a 0x01 here. Try It Online!

# AsciiDots, 8 bytes

.v.
(*\$#


This starts with two dots, then duplicates them both, and then outputs all of their values. Might be golf able down to 6 bytes

Try it online!

# Actually, 2 bytes

Not winning of course, but I find it relatively interesting. (outputs 10)

1╤


Try it online!

# Keg, 1 byte (SBCS)

🄂


Try it online!

Now before you say "Hang on a second, that's 2 bytes: a 1 and a ,", it isn't. Unicode has these really nice symbols where they have a number and a comma combined. It push'n'prints the number 1, the length of the program.

Just don't go pasting this into programs like IDLE and tkinter... they don't particularly like 🄂.

• I don't see that character in the codepage for the language. What byte value does it have? – Jo King Oct 14 '19 at 0:49
• @JoKing 248. You don't see it because otherwise I couldn't use IDLE to edit Keg.py (as mentioned in my answer 🄂 isn't very much supported) – Jono 2906 Oct 14 '19 at 1:38
• Perhaps move the code page to its own file, since you shouldn't have to edit it much? – Jo King Oct 14 '19 at 1:47
• @JoKing I've been trying to implement the code page using Mego's golflang-encoding repository to no avail. – Jono 2906 Oct 14 '19 at 1:54

# Go, 22 bytes

func f(){print(0., f)}


On my machine, this prints

+0.000000e+0000x477c88


But the compiler could conceivably allocate f at an address other than 6 hex digits. If you don't like an implementation detail like that, the next best thing is the 26-byte

func f(){print(0.,1<<34)}


which prints

+0.000000e+00017179869184


# Ohm, 5 bytes

αvssL


## Explanation

αvssL
αv    push 'aeiou'
ss  convert to string two times (NOP)
L print without newline


# Pip, 4 bytes

L2P1


Try it online!

This prints 1\n1\n, at 4 bytes including the newlines.

# Minimal-2D, 72 bytes

/D+++++++++L
R/D          /LR/>>D     /LR
R->++>+++<</UU   R->..</UU


Try it online!

Outputs 72 6s. This is BF in a 2D layout.