Output with the same length as the code

Question

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 code-golf, so the shortest valid answer – measured in bytes – wins.

Leaderboard

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>

Answer 1

C (modern Linux), 19 bytes

main(){puts('s');}

When compiled and run, this prints:

Segmentation fault

Answer 2

Excel, 11 bytes

Norwegian language version:

=SMÅ(13^9)

English language version (12 bytes):

=LOWER(17^9)

Generates n-digit number and converts to text by converting to lowercase.

Answer 3

Labyrinth, 4 bytes

!!>@

Try it online!

Prints 0000

Explanation

!   Print an implicit 0 from the stack.
!   Print an implicit 0 from the stack.
>   Rotate the source code right by one cell, so the code now becomes

    @!!>

    The IP is moved along, so it's now at the end of the line, which is 
    a dead end. So the IP turns around and starts moving left.
!   Print an implicit 0 from the stack.
!   Print an implicit 0 from the stack.
@   Terminate the program.

Answer 4

Bash (builtins only), 8 bytes

{e,,}cho

Prints cho cho and a newline.

Answer 5

Retina, 2 bytes

no

Try it online!

Prints 0 and a linefeed.

There are a lot of 2-byte solutions, but I believe this is optimal. Retina by default always prints a trailing newline and getting rid of it takes too many bytes. So we'd have to find a 1-byte program that leaves the empty input unchanged. I believe the only program which does this is the program containing a single linefeed, which is therefore equal to the output and hence not permitted by the challenge.

The next simplest thing to do is to live with Retina outputting a single digit (the number of matches of some regex against the empty input), and we can do that with a lot of failing (or matching) 2-byte patterns.

Answer 6

Mathematica, 2 bytes

4!

factorial

24

Answer 7

C, 20 bytes

f(){printf("%20d");}

Outputs some number, padded with spaces to a length of 20. (What number? Whatever happens to come next in memory.)

Some sample runs on my system:

llama@llama:...code/c/ppcg121056samelen$ ./a.out 
           -666605944
llama@llama:...code/c/ppcg121056samelen$ ./a.out 
          -1391039592
llama@llama:...code/c/ppcg121056samelen$ ./a.out 
           1727404696
llama@llama:...code/c/ppcg121056samelen$ ./a.out 
             10717352
llama@llama:...code/c/ppcg121056samelen$ ./a.out 
           1485936232

It's a shame that the output can't be arbitrary bytes, because that would have allowed this 19 byte solution:

f(){write(1,f,19);}

which outputs 19 bytes of junk, starting at f's address.

Answer 8

Bash on Linux, 6

uname

(followed by a newline)

Outputs Linux followed by a newline.

Answer 9

Javascript ES6, 9 bytes

Using Template Strings

_=>`${_}`

f=

_=>`${_}`

console.log(f());
console.log(typeof f());

Answer 10

Pyramid Scheme, 74 43 42 bytes

Saved 31 bytes thanks to Khuldraeseth na'Barya! Saved 1 byte thanks to JoKing's redesigned solution!

  ^
 /^\
^---^
-^ ^-
 -^-
 /2\
/ 8 \
-----

Try it online! Outputs the 41-digit number 28^28 = 33145523113253374862572728253364605812736, followed by a trailing newline.

---

Old version

  ^
 / \
/out\
-----^
    /^\
   ^---^
  /1\ /9\
 /606\---
/51015\
-------

Try it online!

Outputs 71277303925397560663333806233294794013421332605135474842607729452115234375 = 160651015 ** 9, or about 10⁷⁴.

Answer 11

Python 2, 9 bytes

print 1e5

The displayed output contains a trailing newline.

Try it online!

Answer 12

Python 2, 9 bytes

print{+1}

This prints set([1]) and a linefeed.

Try it online!

Answer 13

brainfuck, 25 bytes

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

Try it online! Note: Requires an implementation with 8-bit unsigned cells

Output:

~~~~~}}}}}|||||{{{{{zzzzz

---

Explanation

--[         254
 -->+<]      /2 = 127 into the second cell
+++++[      Five times
 ->-.....<]  Print the second cell - 1 five times

Answer 14

C (Ideone), 14 bytes

f(){warn(0);}

On Ideone, which names its executable prog, this outputs the following with a trailing newline.

prog: Success

C (GCC), 15 bytes

f(){warn(00);}

Because GCC writes an executable named a.out by default (in the absence of additional flags that would cost bytes), this outputs the following with a trailing newline.

a.out: Success

Answer 15

C (gcc), 18 17 bytes

f(){puts('@C');}

Note that there's an STX byte (0x02) between @ and C.

Try it online!

Portability

This has been tested with gcc 6.3.1 and clang 3.9.1 on Fedora 25, gcc 4.8.4 on Ubuntu 14.04.4, and gcc 4.8.3 on openSUSE 13.2, where it prints the following output.

inux-x86-64.so.2

I expect this to produce the same output with all versions of gcc, as long as it compiles to an executable of the following type.

ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2

Different platforms will require a different memory address and possibly a different order for the bytes in the multi-character character constant.

For example, replacing @\2C with @\2\4 prints exec/ld-elf.so.1 and a newline on FreeBSD 11 with clang 3.8.0.

Offline verification

$ printf "%b\n" "f(){puts('@\2C');}main(){f();}" > quine.c
$ gcc -w -o quine quine.c
$ ./quine
inux-x86-64.so.2
$ ./quine | wc -c
17

How it works

By default, ld uses 0x400000 as the base address of the text segment, meaning that we can find the ELF's content starting at memory address 0x400000.

The first 640 bytes of the ELF are largely independent of the actual source code. For example, if the declaration of f is followed by main(){f();} and nothing else, they look as follows.

00000000: 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00  .ELF............
00000010: 02 00 3e 00 01 00 00 00 00 04 40 00 00 00 00 00  ..>.......@.....
00000020: 40 00 00 00 00 00 00 00 e8 19 00 00 00 00 00 00  @...............
00000030: 00 00 00 00 40 00 38 00 09 00 40 00 1e 00 1b 00  ....@.8...@.....
00000040: 06 00 00 00 05 00 00 00 40 00 00 00 00 00 00 00  ........@.......
00000050: 40 00 40 00 00 00 00 00 40 00 40 00 00 00 00 00  @.@.....@.@.....
00000060: f8 01 00 00 00 00 00 00 f8 01 00 00 00 00 00 00  ................
00000070: 08 00 00 00 00 00 00 00 03 00 00 00 04 00 00 00  ................
00000080: 38 02 00 00 00 00 00 00 38 02 40 00 00 00 00 00  8.......8.@.....
00000090: 38 02 40 00 00 00 00 00 1c 00 00 00 00 00 00 00  8.@.............
000000a0: 1c 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00  ................
000000b0: 01 00 00 00 05 00 00 00 00 00 00 00 00 00 00 00  ................
000000c0: 00 00 40 00 00 00 00 00 00 00 40 00 00 00 00 00  ..@.......@.....
000000d0: 04 07 00 00 00 00 00 00 04 07 00 00 00 00 00 00  ................
000000e0: 00 00 20 00 00 00 00 00 01 00 00 00 06 00 00 00  .. .............
000000f0: 08 0e 00 00 00 00 00 00 08 0e 60 00 00 00 00 00  ..........`.....
00000100: 08 0e 60 00 00 00 00 00 1c 02 00 00 00 00 00 00  ..`.............
00000110: 20 02 00 00 00 00 00 00 00 00 20 00 00 00 00 00   ......... .....
00000120: 02 00 00 00 06 00 00 00 20 0e 00 00 00 00 00 00  ........ .......
00000130: 20 0e 60 00 00 00 00 00 20 0e 60 00 00 00 00 00   .`..... .`.....
00000140: d0 01 00 00 00 00 00 00 d0 01 00 00 00 00 00 00  ................
00000150: 08 00 00 00 00 00 00 00 04 00 00 00 04 00 00 00  ................
00000160: 54 02 00 00 00 00 00 00 54 02 40 00 00 00 00 00  T.......T.@.....
00000170: 54 02 40 00 00 00 00 00 44 00 00 00 00 00 00 00  T.@.....D.......
00000180: 44 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00  D...............
00000190: 50 e5 74 64 04 00 00 00 b0 05 00 00 00 00 00 00  P.td............
000001a0: b0 05 40 00 00 00 00 00 b0 05 40 00 00 00 00 00  ..@.......@.....
000001b0: 3c 00 00 00 00 00 00 00 3c 00 00 00 00 00 00 00  <.......<.......
000001c0: 04 00 00 00 00 00 00 00 51 e5 74 64 06 00 00 00  ........Q.td....
000001d0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
000001e0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
000001f0: 00 00 00 00 00 00 00 00 10 00 00 00 00 00 00 00  ................
00000200: 52 e5 74 64 04 00 00 00 08 0e 00 00 00 00 00 00  R.td............
00000210: 08 0e 60 00 00 00 00 00 08 0e 60 00 00 00 00 00  ..`.......`.....
00000220: f8 01 00 00 00 00 00 00 f8 01 00 00 00 00 00 00  ................
00000230: 01 00 00 00 00 00 00 00 2f 6c 69 62 36 34 2f 6c  ......../lib64/l
00000240: 64 2d 6c 69 6e 75 78 2d 78 38 36 2d 36 34 2e 73  d-linux-x86-64.s
00000250: 6f 2e 32 00 04 00 00 00 10 00 00 00 01 00 00 00  o.2.............
00000260: 47 4e 55 00 00 00 00 00 02 00 00 00 06 00 00 00  GNU.............
00000270: 20 00 00 00 04 00 00 00 14 00 00 00 03 00 00 00   ...............

Using, e.g., main(int c, char**v){f();} instead changes some bytes, but not the offset of the string /lib64/ld-linux-x86-64.so.2, which we'll use to produce output.

The offset of said string is 0x238 and it is 27 bytes long. We only want to print 17 bytes (and the last one will be a newline if we use puts), so we add 11 to the offset to get 0x243, the offset of inux-x86-64.so.2. Adding 0x400000 and 0x243 gives 0x400243, the memory location of inux-x86-64.so.2.

To obtain this memory address, we can use multi-character character constants, which exhibit implementation-defined behavior. 0x400243 is (64)(2)(67) in base 256 and gcc's multi-character character constants use big-endian byte order, so '@\2C' yields the memory address of the desired string.

Finally, puts prints the (null-terminated) sting at that memory location and a trailing newline, creating 17 bytes of output.

Answer 16

Fourier, 26 22 20 bytes

5^(`na`&i)` Batman!`

Try it on FourIDE!

Outputs:

nananananana Batman!

---

For proper capitalisation, it's 4 extra bytes:

`N`7^(`an`i^~i)`a Batman!`

Try it on FourIDE!

Nanananananananana Batman!

---

_{R.I.P. Adam West}

Answer 17

Self-modifying Brainfuck, 5 bytes

<[.<]

Try it online!

Output:

]<.[<

---

Explanation:

Really simple, prints the source in reverse. In SMBF, the content of the program is stored on the tape, to the left of the initial position of the pointer. Gliding left and printing will output the source code backwards.

Since reading source is allowed in this challenge, this should definitely be within the rules.

Answer 18

Basic Arithmetic Calculator, 2 bytes

1=

prints 1., or:

    |
    |
    |  .

on those silly seven-segment displays.

To reproduce, pick up any random calculator; they all have this programming language installed somehow.

Answer 19

Brachylog, 1 byte

w

Try it online!

Explanation

w is the built-in "write". Here, it will write the Input. Since the Input is a free variable, w will label it as an integer before printing. The first integer it tries is 0.

Answer 20

Java (OpenJDK 8), 11 bytes

o->1e8-1+""

Try it online!

Output:

9.9999999E7

Just a tad more elaborate than the obvious answer, ()->"".format("%23s",0).

Saves

• 18 -> 16 bytes: More advantageous combination of rounding and power of 10, thanks to PunPun1000
• 16 -> 13 bytes: better formula, thanks to JollyJoker
• 13 -> 11 bytes: improved formula, thanks to Kevin Cruijssen

Answer 21

05AB1E, 1 byte

õ

Outputs a single newline. õ pushes an empty string, and it is implicitly outputted with a newline.

Try it online!

Some other 2 byte solutions, for your viewing pleasure (the output is in the brackets, and all output has a trailing newline):

X, (1)
Y, (2)
¾, (0)
¼, (1)
¶, (newline)
ð, (space)
Î, (0)

There are way more 2 byte solutions though.

Answer 22

V/vim, 1 byte

o

This prints a single newline.

Try it online!

There are a bunch of variants on this that would work too. For example,

O

in vim, and

Ä
ä
ï
Ï

in V.

There are also many many many three byte solutions. For example:

3ii
i³i
¬ac

These are all specific to V.

Answer 23

Batch, 12 bytes

@echo %OS%

Byte count includes trailing newline for both script and output, which is

Windows_NT

Answer 24

Hexagony, 3 bytes

o!@

Try it online!

Prints 111.

Unfolded:

 o !
@ . .
 . .

But the code is really just run in the order o!@.

o   Set the memory edge to 111, the code point of 'o'.
!   Print this value as a decimal integer.
@   Terminate the program.

Answer 25

///, 12 bytes

/a/bcd/aaaa/

Try it online!

This prints bcdbcdbcdbcd, and because this is 12 bytes, I've added a harmless / to the end of the code to pad it out.

Answer 26

R, 7 bytes

mode(T)

Prints "logical"

Answer 27

MATL, 2 bytes

H

There is a trailing newline.

Try it online!

Explanation

Clipboard H contains number 2 by default. H pushes that content to the stack, which gets implicitly displayed with a trailing newline.

Answer 28

Jelly, 1 byte

V

Quite a few Jelly one byters - this is one - it evaluates the left argument which, when nothing is provided as input, defaults to zero which in turn evaluates to zero and the result is implicitly printed, a 0.

Try it online!

In fact, of the 256 bytes in the code-page there are only 95 that do not currently produce a different one byte output within the specified range when run as a full program; these are (as code-page characters in byte order):

¡¢£¦©½¿€ÇÑÞßçıȷñ÷þ"#&',-./0123456789:;?@IMRTVZ\`dmpstxyz{}~°³⁴⁵⁹ƓƈɠḶỌṬḊĖİĿṄȮṖṘẆẊṃọṣṭḃḟḣŀṁṗṡẋż’“

Notes:

• Most of the 1-byte programs print a 0 (no-ops / yielding a list with a single zero in, which prints a 0), most others print a 1 (0=0 and the like)

• Ọ is the one program which does yield a different byte, but one which is out of range as per the specification - it produces the null-byte (casts the 0 to character)

• ⁶ produces a space (a literal)

• ⁷ produces a line feed (a literal)

• Some bytes that do work now may not do so in the future - there are a fair few bytes being reserved (I believe) for niladic values which, when assigned, are almost certainly not going to produce one-byte output.

Answer 29

Charcoal, 2 bytes

→¹

Try it online!

Prints a length-1 horizontal line of - to the right, and a newline.

Answer 30

Cubix, 6 4 bytes

@"Ou

Try it online

Cubified

  @
" O u .
  .

This pushes the string Ou. to the stack, Outputs the top character (.) as a character code (46), does a u-turn to the right, Outputs again, and exits with @.

Answer 31

Befunge, 2 bytes

.@

Try it online!

Prints 0 with a trailing space. Also works in Befunge 98.

Answer 32

C#, 22 16 bytes

()=>$"{1L<<50}";

-6 bytes thanks to Orjan Johansen, using long instead of int.

Outputs

1125899906842624

Alternately, if you allow an arbitrary parameter to be passed into the lambda:

C#, 21 15 bytes

_=>$"{1L<<49}";

Outputs

562949953421312

Answer 33

NodeJS REPL, 4 bytes

Did someone say REPLs are languages?

*;;;

→ ..._

(the underscore is actually a space character).

For anyone not familiar with the Node REPL, it thinks my program isn't complete, so it's prompting for the rest of the line.

Answer 34

Excel, 7 bytes

=9^7&""

Produces a 7 digit number and then appends empty string

Uses general idea from pajonk in their answer [although obviously not the language trick :)]

Answer 35

bash, 48 bytes

bash bash bash bash bash bash! bash! bash! bash!

Output:

/bin/bash: /bin/bash: cannot execute binary file

Answer 36

JavaScript (ES6), 9 bytes

_=>""+1E8

Returns 1 * 10^8, or 100000000.

If I can return a number instead of a string, _=>1E5 is 6 bytes.

f=
_=>""+1E8

console.log(f())

Answer 37

QBasic 4.5, 1 byte

?

This prints nothing. Followed by a newline.

Answer 38

Ruby, 5 4 3 bytes

_{Crossed out 4 is still 4 ;(}

p$*

Prints [] (empty array) then a newline

Try it online!

Answer 39

C (modern Linux), 19 bytes

main(){raise(11);}

Output (with newline):

Segmentation fault 

How it works:

SIGSEGV is defined as 11 in /usr/include/asm-generic/signal.h. Therefore, raise(11) raises SIGSEGV, and when SIGSEGV is raised on Linux, all execution stops and Segmentation fault is printed.

20 bytes

main(){raise(2*2);}

Output (with newline):

Illegal instruction 

22 bytes

main(){raise(2*3-1);}

Output (with newline):

Trace/breakpoint trap

22 bytes

main(){raise(5*2+5);} 

Output (with newline):

User defined signal 1 

22 bytes

main(){raise(1?26:0);}

Output (with newline):

Virtual timer expired 

24 bytes

main(){raise(12*(1+1));}

Output (with newline):

CPU time limit exceeded 

25 bytes

main(){raise(5*5?5*5:0);}

Output (with newline):

File size limit exceeded 

25 bytes

main(){printf(raise(8));}

Output (with newline):

Floating point exception 

Answer 40

><>, 4 bytes

"on;

Try it online!

Outputs ;110

Answer 41

Python 3, 53 bytes

s='s=%r;print("0"*~-len(s%%s))';print("0"*~-len(s%s))

Try it online!

This must be the most quine-like answer ever.

Answer 42

Alice, 5 bytes

g/@O

Try it online!

Prints:

103
g

Explanation

This was quite fun to figure out. :)

g   Pop two implicit zeros from the stack and retrieve the code point at that
    location in the code. That's the 'g' itself, so we're pushing 103.
/   Reflect to SE. Switch to Ordinal. The IP bounces diagonally up and down
    through the code.
O   Implicitly convert the 103 to "103" and print it with a trailing linefeed.
    Bounce off the top right corner and move back.
/   Reflect to W/ Switch to Cardinal.
g   Push 103 again.
    The IP wraps back to the last column
O   Interpret the 103 as a code point and print the corresponding character.
    This prints 'g'.   
@   Terminate the program.

Answer 43

APL, 2 bytes

-1

Prints ¯1 _{(the - is the Minus monad, whereas ¯ is the High minus negative indicator)}.

Answer 44

Perl 5, 9 bytes

print$"x9

Prints 9 spaces, no newline.

Explanation

$" contains a " " by default. x9 uses the repetition operator to "multiply" the string by 9.

Answer 45

Powershell, 38 bytes

Just for fun, an answer that returns different output each time it's called.

[System.Guid]::NewGuid().ToString("B")

Prints a GUID surrounded with braces ("B"), such as:

{24cc14a3-ada4-4fcd-8a08-ec419b00f22d}

Answer 46

R, 3 2 bytes

-T

Outputs:

-1

Old 3 byte answers:

Many examples, such as:

1/0
F/F
3^6

Outputs respectively:

Inf
NaN
729

Try it online!

Answer 47

Python 2, 10 bytes

Try it online

print 9**9

Outputs 10 bytes:

387420489
*newline*

---

There are other 10-byte answers with decimals and power. I like this one for e in the output:

print.3**8

Output:

6.561e-05
*newline*

---

Same 10 bytes, but for division (there are 5 versions):

.1/64 = 0.0015625
.3/64 = 0.0046875
.5/64 = 0.0078125
.7/64 = 0.0109375
.9/64 = 0.0140625


print.1/64

outputs:

0.0015625
*newline*

Answer 48

JavaScript (ES6), 17 11 bytes

f=_=>"g="+f

---

Try it

f=_=>"g="+f
console.log("Function source: f="+f)
console.log("Function length: "+(""+f).length+" + 2 (for variable assignment) = "+((""+f).length+2))
console.log("Function output: "+f())
console.log("Output length: "+f().length)
console.log("Output type: "+typeof f())

Answer 49

Fourier, 1 byte

o

Try it FourIDE!

_{Note, TIO.run outputs a trailing newline}

Outputs the value of the accumulator, 0.

More interesting programs:

2P15o

Try it on FourIDE!

Outputs 2¹⁵, 32768.

---

4^do

Try it on FourIDE!

Outputs the current year (doesn't work if used before 1000 AD).

---

999**999o

Try it on FourIDE!

Outputs 997002999. The ** is undefined behaviour in Fourier. The way I think it works is A**B = A*A*B.

Answer 50

Bash, 1 byte:

#

It sort of outputs a newline...although I don't know if the program gets credit for that or the Bash interpreter.

I'm a bit dubious that this counts, so:

Bash, 21 bytes

x=12345;echo $x$x$x$x

This is really terrible, I know. Are you allowed to call any standard program with Bash?

Answer 51

Java, 82 bytes

interface M{static void main(String[]a){for(int i=0;i++<82;)System.out.print(1);}}

Output:

1111111111111111111111111111111111111111111111111111111111111111111111111111111111

Try it online!

Answer 52

C#, 23 bytes

()=>new string('@',23);

Creates a new string consisting of 23 @ characters

Answer 53

dc, 2 bytes

Kp

Try it online!

Pushes the current precision on the stack (which is 0) and prints it with a trailing newline.

Answer 54

GNU Make, 24 21 bytes

$(sort $(value $(0)))

returns

$(0))) $(sort $(value

Complete makefile:

X=$(sort $(value $(0)))
$(info $(call X))

Answer 55

Pyth, 1 byte

k

It prints a new line character.

Explanation: k is just a variable initialized to '' (empty string), and by default Pyth prints the values of instructions which do nothing, followed by a new line character. In this case, it prints an empty string and then the new line character.

Test it online! (the online interpreter doesn't show the \n, you will have to install Pyth on your computer to actually see it)

Answer 56

Underload, 6 bytes

()aaaS

Try it online!

Prints ((())).

() pushes an empty string to the stack. a "stringifies" it by wrapping it in (...) so after aaa we get (((()))). S prints that string (without the outermost parentheses, so we get only three pairs).

Answer 57

Taxi, 540 bytes.

62 is waiting at Starchild Numerology.Go to Starchild Numerology:w 1 l 2 r 1 l 1 l 2 l.Pickup a passenger going to The Underground.Go to The Underground:w 1 r 2 r 1 r 2 l.[r]Switch to plan "e" if no one is waiting.Pickup a passenger going to Cyclone.Go to Cyclone:n 3 l 2 l.Pickup a passenger going to The Babelfishery.Pickup a passenger going to The Underground.Go to The Babelfishery:s 1 l 2 r 1 r.Pickup a passenger going to Post Office.Go to Post Office:n 1 l 1 r.Go to Fueler Up:n 1 r 1 l.Go to The Underground:n.Switch to plan "r".[e]

Try it online!

Ungolfed:

62 is waiting at Starchild Numerology.
Go to Starchild Numerology: west 1st left 2nd right 1st left 1st left 2nd left.
Pickup a passenger going to The Underground.
Go to The Underground: west 1st right 2nd right 1st right 2nd left.
[r]
Switch to plan "e" if no one is waiting.
Pickup a passenger going to Cyclone.
Go to Cyclone: north 3rd left 2nd left.
Pickup a passenger going to The Babelfishery.
Pickup a passenger going to The Underground.
Go to The Babelfishery: south 1st left 2nd right 1st right.
Pickup a passenger going to Post Office.
Go to Post Office: north 1st left 1st right.
Go to Fueler Up: north 1st right 1st left.
Go to The Underground: north.
Switch to plan "r".
[e]

It prints the integers 61 through 1 in descending order and with a decimal and 6 trailing zeros:

61.00000060.00000059.00000058.00000057.00000056.00000055.00000054.00000053.00000052.00000051.00000050.00000049.00000048.00000047.00000046.00000045.00000044.00000043.00000042.00000041.00000040.00000039.00000038.00000037.00000036.00000035.00000034.00000033.00000032.00000031.00000030.00000029.00000028.00000027.00000026.00000025.00000024.00000023.00000022.00000021.00000020.00000019.00000018.00000017.00000016.00000015.00000014.00000013.00000012.00000011.00000010.0000009.0000008.0000007.0000006.0000005.0000004.0000003.0000002.0000001.000000

Answer 58

PowerShell, 2 bytes

+1

The upvote program. This give the output of 1 and a trailing newline to get 2 bytes. I am unsure if the operation is adding 1 to nothing or if it is rendering the positive integer of 1. Either way the result is the same.

Answer 59

Pyramid Scheme, 32 bytes

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

Try it online!

Explanation

This may not look like pyramid scheme but it is. Each triangle looks like:

 ^
 -

This performs one of three operations

• If it has 2 args it pairs them together

• If it has 1 arg it returns it

• If it has 0 args it returns 0

So at the bottom we have two zeros, those are linked on the next level. On the next level two different pyramids grab the pair and then those pairs are paired together. This continues all the way up the pyramid. When we get to the top we have:

 ((((0,0),(0,0)),((0,0),(0,0))),(((0,0),(0,0)),((0,0),(0,0))))

Pyramid scheme's implicit output converts this to 16 zeros separated by newlines. That's 32 bytes.

Answer 60

TAESGL, 1 byte

S

Interpreter

Outputs a single space character

Other solutions

"≠        2 bytes, "≠" converted to "!="
«Ā»       3 bytes, decompresses "Ā" which is equal to "the"
SŔ4)      4 bytes, " " repeated 4 times
5ē)ĴT     5 bytes, first 5 Fibonacci numbers joined
G→6,"A    6 bytes, draws a line to the right of "A" for 6 characters

Answer 61

PHP, 216 68 7 bytes

<?=1e6;

Try it online!

Thanks to Jörg I'm beating Okx again :D

Answer 62

Powershell, 3 bytes

1E2

Prints 100

Answer 63

Stack Cats, 1 + 3 = 4 bytes

+

Try it online!

Requires either the -o or -n flag for numeric output. Prints two zeros, with a linefeed each.

Explanation

Stack Cats has a tape of stacks which are all initialised to an infinite wells of zeros, but the starting stack has a -1 on top (which acts as a terminator when input is given). The + command swaps the first and third element on the current stack. So:

-1           0
 0           0
 0     +    -1
 0   ---->   0
 .           .
 .           .
 .           .

At the end of the program, the current stack is printed from top to bottom. Since the -1 is again treated as a terminator, it's not printed itself. Due to the -o flag, the values are printed as decimal integers with trailing linefeeds.

Answer 64

Octave, 7 bytes

[['']]'

Try it online!

Answer 65

TI-Basic (TI-84 Plus CE OS 5.2+), 4 bytes

toString(10^(3

tostring( is a two-byte token, 10^( is a one-byte token. This returns the string "1000" which is 4 bytes long.

Answer 66

Fission, 4 bytes

R"N;

Try it online!

Prints N;R with a trailing linefeed.

The R creates a right-going atom. " toggles string mode which traverses an immediately prints N;R (wrapping at the end of the line). Then N prints a linefeed and ; destroys the atom, terminating the program.

Answer 67

AWK, 21 bytes

BEGIN{printf"%21s",0}

Try it online!

Simply prints:

                    0

The 0 could of course be any digit. No new line is printed, since that would add 2 bytes.

Answer 68

OCaml, 22 bytes

List.find ((=) "") []

Outputs

Exception: Not_found.

It search for "" (empty string) in the empty list []

Answer 69

Ruby, 3 bytes

p""

Prints this, plus a newline

""

Here's another 3 byte one:

p:a

Prints this, plus a newline

:a

Answer 70

R, 7 bytes

stop( )

Prints Error: (with a trailing space)

---

16 bytes (only works in version 3.3.1)

version$nickname

Prints Bug in Your Hair.

Not nearly as good but I like it anyway.

Answer 71

charcoal, 1

⎚

Try it online!

Explanation:

⎚ Clears the empty screen
[implicitly print nothing plus a trailing newline]

Answer 72

><>, 11 bytes

01+:b=?;:n!

Prints numbers from 1-10 (12345678910)

Answer 73

Mathematica, 2 bytes

Code:

.0

Output:

0.

This is the output of Wolfram kernel from command line, and the plaintext output from the front end. If you must argue about the extra number tick added when copying directly from the front end, then 0.0 will do.

Answer 74

Whitespace, 36 bytes

Try it online!

Generates the output "-15-14-13-12-11-10-9-8-7-6-5-4-3-2-1" (36 characters without quotes, no trailing newline)

Explanation

Pushes the number -15 onto the stack (encoded in binary as 01111, with a leading 0 for padding to match the output) then counts toward 0 outputting the current number each iteration.

Starting from a negative number gives an extra byte of output per iteration and also allows me to use a jump while negative instruction to fall through the loop and exit implicitly. That single padding byte in the code is a downer though but solutions without it are longer.

Answer 75

Python 3, 13 bytes

print("a"*13)

Outputs "aaaaaaaaaaaaa"

Answer 76

Python 2, 11 bytes

print 4**16

Beep boop.

Answer 77

Cjam, 1 byte

N

Explanation

N e#Push '\n' and implicit print

Answer 78

JavaScript (ES6), 17 bytes

^{Edit: I overlooked the rules. This is now returning a string, but is much longer than initially intended.}

Returns "Infinity,Infinity".

let f =

_=>`${[1/0,1/0]}`

console.log(f())

Answer 79

QBIC, 8 2 bytes

?z

Prints 10, to which z is auto-initialised.

---

Original brainfart answer

?A+@1234

Explanation:

?       PRINT
A+      A$ (which is undefined, but hold on!), plus
@1234   The string literal 1234, which we now call A$

Outputs 12341234, which is also 8 bytes. We save a byte by putting the string lit at EOF, because we now don't need to use the delimiter. The definition of the literal is moved to the top of the QBasic code by the interpreter, ensuring it existst at the moment of the first call to A$.

Answer 80

C#, 57 49 47 44 bytes

()=>{for(int i=0;i<44;i++)Console.Write(7);}

-8 bytes thanks to Martin

Not 100% on whether lambdas like this are accepted answers, but my previous submission in this format was accepted just fine, so I'm gunna go with it.

Same as the java answer, but better because it's not Java

Answer 81

J, 6 bytes

echo!4

Try it online!

Output:

24
   

Notice the three spaces on the second line.

Answer 82

Deadfish, 1 byte

o

Outputs the accumulator, which is 0 before any action takes place.

_{note: deadfish prints the accumulator as a number, not as a character code, so the output is "0" (0x48)}

Answer 83

SQLite, 32 bytes

.width 31
.mode column
SELECT"";

Try it online!

Outputs 31 spaces and a newline.

Answer 84

Brain-Flak, 12 bytes

(((([()]))))

Try it online!

This prints

-1
-1
-1
-1

Answer 85

Klein, 7 5 + 3 bytes

Uses the 110 topology

1.
2@

If we unfold the topology here we get

1.122@

This outputs 1 1 2 2 with a trailing newline.

Thanks to Martin Ender for saving two bytes!

Answer 86

Somme, 2 bytes

:.

Try it online!

Outputs 42. Explanation:

:.
:    duplicate; no input, so popping from an empty stack pushes `42`
 .   output as a number

Answer 87

Stacked, 9 bytes

$put:+put

Try it online!

Outputs [put put]. $put pushes a function literal to the stack, : duplicates it, + concats the two functions, and put outputs the representation of the top of the stack.

Answer 88

Haskell, 16 bytes

main=print[0..6]

Try it online! Output:

[0,1,2,3,4,5,6]

(Note the trailing newline.)

Answer 89

MSM, 8 bytes

'.;;.;.;

Output:

........

MSM operates on its own source and takes commands from the left and treats the right as a stack. Stack trace:

' . ; ; . ; . ;                  # ' pushes the next char on the stack
    ; ; . ; . ; .                # ; is dup
      ; . ; . ; . .              # dup again
        . ; . ; . . .            # . is concat
          ; . ; . ..             # dup 
            . ; . .. ..          # concat
              ; . ....           # dup
                . .... ....      # concat
                  ........       # MSM stops if there's only one element in the stack

Answer 90

Python 3 REPL, 3 bytes

1e0

Prints 1.0.

If trailing newline counts,

5*2

Prints 10, then a trailing newline.

Answer 91

Bash + coreutils (on 32-bit Linux), 5 bytes

arch
(trailing newline)

Prints

i686
(trailing newline)

---

Old solution:

sed s/e/a $0

Save (without trailing newline) in filename, and run with bash filename.

Prints

sad s/e/a $0

with no newline. Really you could replace any character in the file with a different character, but s/e/a/ makes the output sad. :(

---

Other solution (10 bytes):

sort $0
a=

(no trailing newline)

Prints:

a=
sort $0

Answer 92

TacO, 1 byte

@

Outputs a single newline.

Taco's default behaviour is to print out a newline, for some reason. But, the code needs an entry point, @, to work. So this works.

Try it online!

Answer 93

Japt, 1 byte

Outputs a string containing a single ".

Q

Try it online

---

Or this will output a string containing a single \n.

R

Try it online

Answer 94

7, 3 characters, 1 byte

Seen as individual characters:

723

Or as a hex dump, proving that it runs from a file that's one byte long:

00000000: e9                                       .

Try it online!

Outputs the characters 23 in 7's encoding. This also happens to be a single byte long, and a printable ASCII byte at that:

00000000: 4f                                       O

Explanation

This is a literal that pushes two stack elements: an empty stack element (7 separates stack elements), and 23, 7's print statement. When the end of the program is reached, the top stack element is copied and evalled, meaning that an attempt is made to print 23; because this contains characters that don't exist in 7's encoding (the active versions of the 2 and 3 commands, shown in bold in the explanation), the printed value gets escaped (into 723), and the 7 is interpreted as a request to format the output in the same encoding as the input, with the 23 getting printed.

It can be observed that the leading 7 on the program is entirely pointless, except to make the output and input distinct.

Answer 95

Perl, 8 7 bytes

print$␖

The seventh byte of this program is the control character \x16, which I can't put literally into the writeup. A hexdump of the source is 70 72 69 6e 74 24 16.

Output is something like v5.20.2 on the standard output. The exact output depends on the exact version, but almost always 7 characters in practical situations. There is no newline or whitespace in the source code or output.

Note that running this code also prints a long mandatory warning message to the standard error. If I understand correctly, that message is ignored by the golf rules.

---

One byte longer (but all printable) is this program:

;print**

The semicolon is there to pad the code to the same length as the output. The output is *main::*

Answer 96

Carrot, 4 bytes

.^*3

Prints .... (4 .s).

Try it online!

Explanation

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

Answer 97

Ruby, 16 bytes

puts (1..8).to_a

returns

1
2
3
4
5
6
7
8

Can I use this to enter challenge?
Try it Online!

Answer 98

ZX Spectrum BASIC, 1 byte

PRINT

(which is 1 byte) prints a single newline.

Answer 99

dc (bash command line under Linux), 9 bytes

(inc newlines on both the math expression and the answer)

2 24 ^ p

Prints:

16777216

I wanted to make sure RPN wasn't forgotten about :)

Answer 100

Microscript, 1 byte

E

Prints 10⁰=1. e will also work, printing 2⁰=1.

Answer 101

Forth (gforth), 4 bytes

.S \

Prints <0> (that's <, 0, >, and space). Stack must be empty (for example if gforth was just started)

How it works: .S prints the stack depth enclosed in brackets and then the stack contents seperated with a space. \ is the beginning of a comment, it does nothing.

Forth (gforth), 8 bytes

8 SPACES

Well, it prints 8 spaces. Not much to see here.

Answer 102

SmileBASIC 3, 3 bytes

?@A

Prints the string @A, plus a trailing newline, so output is 3 bytes.

Answer 103

MarioLANG, 1 byte

:

Output the numeric value from current memory cell, which is 0

Answer 104

TI-Basic, 7 bytes

(Ab)using the fact that Done is displayed when nothing is evaluated on the last line. Lowercase letters are two bytes each in TI-Basic.

Repeat 1337:End

Answer 105

HQ9+, 13 bytes

haaaaaaaaaaaa

Prints:

Hello, world!

The instruction "h" in HQ9+ will print "Hello, world!" and any instruction that is not "h" "q" "9" or "+" will be ignored.

You might want to know why this language exists, and why I'm answering this question with it.

Why not?

Answer 106

VBA, 1 Byte

A surprisingly short answer for VBA

Anonymous VBE immediate window function that takes no input and outputs a single linefeed (vbLf) to the immediate window

?

Output

(A single linefeed)

Answer 107

Python 3 REPL, 11 bytes

str(...)[:]

Try it online! The header and the footer emulate a REPL.

This prints:

'Ellipsis'

Answer 108

><>, 3 bytes

"nh

Try It Online

Prints "104" and exits with an error.

Answer 109

Stax, 1 byte

æ

Run and debug online!

Bytes counted in CP437.

Just the packed version of the program 1. Not surprisingly the output is also 1. Since it is packed it is not a quine and is a valid answer.

Answer 110

R, 25 bytes

sprintf("%.23f",runif(1))

Try it online!

Outputs (as a string) a random number between 0 and 1 with 23 decimal places, e.g.

0.84327139146625995635986

This is 25 characters overall, counting the initial 0.

There are shorter R solutions, but I wanted to post one with randomness since the challenge allows it explicitly.

Answer 111

brainfuck, 15 32 bytes

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

Try it online!

Illegal version (no ascii), 15 bytes

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

Try it online!

Answer 112

Zsh, 5 bytes

<<<$-

Prints 569X followed by a newline. Try it online!

The parameter $- outputs the current flags supplied to the shell. By default, it is set to 569X:

• 5: NOTIFY
• 6: BG_NICE
• 9: AUTO_LIST
• X: LIST_TYPES

When unsetting these options, $- is empty.

Answer 113

Dash/Bash/ksh/fish, 5 bytes

umask

Try it online (Dash) | Try it online (Bash) | Try it online (Ksh) | Try it online (Fish)

umask is a builtin in most unix shells, not an external command! It prints the 4-octal-digit umask followed by a newline for a total of 5 bytes. Does not work in Zsh or Tcsh: Zsh will only print one leading zero (e.g.: 02 instead of 0002), and Tcsh will print no leading zeroes (2 instead of 0002)

Answer 114

C#, 84 bytes

public class P{public static void Main(){System.Console.Write(new string('_',84));}}

Try Online

Answer 115

Braingolf, 1 byte

l

Try it online!

Prints 0 (the current length of the stack)

Braingolf, 2 byte

4*

Prints 16. 4 can be replaced by any number n where 3 < n < 10

Explanation:

4*
4   Pushes 4 to the stack
 *  Monadic multiplication, squares the last item on the stack
    Implicit output of the last item on the stack

Answer 116

PHP, 17 bytes

<?php echo 9**17;

Because I wanted to beat Mayube's answer ;)

Try it online!

Answer 117

Go, 60 bytes

I don't know if this is hard in Go or if I'm failing to see something obvious.

import(."fmt"
."strings")
func main(){Print(Repeat("a",60))}

Try it online!

Answer 118

brainfuck, 33 bytes

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

Try it online!

Output:

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

I could do it in 32 bytes but I decided this is better.

Answer 119

brainfuck, 30 bytes

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

Outputs 30 #s.

Try it online!

Answer 120

Brain-Flak, 32 bytes

(((()()()){}){}()){(({})[()])}()

Try it online!

Prints:

0
1
2
3
...
13

Explanation:

# Push 13
(((()()()){}){}())

# While TOS != 0
{

   # Push TOS, TOS - 1
   (({})[()])

# End While and pad with 2 bytes
}()

Answer 121

Bash, 11 bytes

printf %11s

prints:

"           "

(without the quotes)

If the newline counts, then printf "%10s" will print 10 characters plus the newline.

I did consider echo $0 (7) which works when saved with a filename 7 characters long, but I think that falls under the common set of unaccepted answers

Answer 122

Perl 6, 4 bytes

{?1}

Try it

Returns True

Explanation

&prefix:« ? » is a Bool conversion operator

{ and } can be used to create a bare block lambda.

Answer 123

Actually, 1 byte

ε

Try it online!

Prints the empty string (and a trailing newline).

Answer 124

S.I.L.O.S, 28 bytes

i=28
lblb
i-1
print a
if i b

Try it online!

Output:

aaaaaaaaaaaaaaaaaaaaaaaaaaaa

Answer 125

VBA Immediate Window, 9, 2 bytes

?,

Prints a tab followed by a newline according to this answer in meta

Old answer

?space(6)

Entered in the immediate window, space(n) repeats the space character n times, ? is short for Print & Debug. is implicitly prepended in the immediate window. Printing also gives a space after the function and 2 newlines so only 6 spaces needed

Answer 126

Excel, 13 (12/11) bytes

=TEXT(9^13,0)

Genetrate a number, convert to text, simple!

Alternatively: =1=1 evaluates to TRUE (4bytes)

TRUE is boolean not text

Update

Very debateably for 12 and 11 bytes respectively

=TEXT(9^12,0

Leaving off the close bracket evaluates without a fuss

=REPT("a,11

Leaving out a bracket and " still evaluates although you get a "did you mean...?" prompt correcting the formula. I think the 1st is probably fine, the 2nd probably isn't.

Answer 127

brainbool, 1 byte

.

Try it online!

brainbool is like brainfuck, except cells can only contain 0 or 1. Outputting in brainbool always produces an ASCII 0 or 1. All cells start out as 0, so . will output 0.

Answer 128

Forth, 6 bytes

1e3 f.

Try it online

Output:

1000. 

Note the trailing space.

Answer 129

T-SQL, 21 15 bytes

print space(15)

Try it online

Output:

Answer 130

WinDBG, 7 bytes

??1;$$$

Outputs:

int 0n1

How it works:

??1;        Evaluate (and implicit print) 1 as a C++ expression
    $$$     Comment, ignored

Answer 131

shortC, 15 10 8 7 6 bytes

AR"%6d

Output: A random integer x with y spaces before it. y = strlen(itoa(x))

Directly stolen from Doorknob.

Answer 132

Java, 70 bytes

interface M{static void main(String[]a){System.out.format("%70d",0);}}

Prints 69 spaces and a zero.

Answer 133

Scala, 9 bytes

()=>"x"*9

This is a function which returns "xxxxxxxxx".

Try it online

Answer 134

R, 8 9 bytes

cat(8^8)

Prints 16777216 to stdout. cat(F) would have been better, but there isn't a trailing newline on the output. Thanks to @user2390246 for a byte.

Try it online!

Answer 135

Brian & Chuck, 9 bytes

?{-?
	.{?

Try it online!

Prints ?????????.

The first character on the second line is a tab.

Explanation

The tab's code point is 9 and it's just used as a counter to loop the correct number of times.

The program starts by immediately switching to Chuck with ?. The . prints that ?, { currently does nothing and ? switches back to Brian.

We now start the main loop which runs 8 times. { moves the tape head on Chuck back to the first cell, i.e. the tab. - decrements this counter. Once the counter hits zero, ? does nothing and the program ends. But until that happens it switches control back to Chuck. Then . prints another ?, { resets the tape head on Brian to the beginning and ? hands control back to him. This way, the two instances alternate between decrementing the counter on Chuck and printing a ? on Brian.

Answer 136

Frink, 9, 11, 10 bytes

print[13!]

Outputs:

6227020800

Such a ... boring solution, sigh.
*no trailing newlines.
*Although Frink parses unicode exponents {+- 0-9}, print[9⁹] is 11 bytes, not 9.
Frink has a large data file of constants, but I haven't yet found a < 4 char one that outputs < 11 bytes. (constants have units, and frink is very verbose by default)

Answer 137

braingasm, 1 byte

Prints 0 (without newline):

:

Answer 138

PARI/GP, 2 bytes

4!

Prints 24. (This is using the REPL, which is essentially the only way the language is used.)

Answer 139

Batch - 6 Bytes

xcopy^

Not sure if this counts, but the typing this in cmd will give the output:

More? 

(With a trailing space)

Answer 140

Bash + coreutils, 5 bytes

id -u

Technically depends on the user ID, but the default user has id 1000 on all major distros, and unless you set up 9,000+ additional users, all others will also have a four-digit id.

Finally, this works on TIO, so I'd argue it meets our must work in one implementation rule.

Try it online!

Answer 141

Pyke, 1 byte

k

Try it online!

Pushes the empty string and then prints it with a newline

Answer 142

Klein, 3 + 3 = 6 bytes (non-competing)

Non-competing because " was added after this challenge. +3 bytes for the 000 topology flag.

"@.

Try it online!

Prints 64 46 and a trailing linefeed.

Explanation

With the 000 topology the source code just wraps around like in many other fungeoids.

"@."  Push the code points of '@', 64, and '.', 46, to the stack.
@     Terminate the program.

At the end of the program, the stack contents are printed as decimal integers with space-separation and a trailing linefeed.

I also tried for 5 with "@ and a suitable topology that lets the IP traverse more cells before hitting the " again, but the implicit cells (used to pad the code to a square) are ., so we can only ever print 2-digit numbers, and therefore we can't possibly get to 5 bytes of output with this technique.

Answer 143

BotEngine, 5 bytes

TIRES

(Or any other program of the same length which starts with a T)

Prints TRUE, followed by a trailing newline (which apparently counts for this question).

Answer 144

Perl 5, 7 bytes

say$"x6

$" contains a space by default, and x6 duplicates it six times. say prints and adds a newline, so this prints six spaces followed by a newline.

Answer 145

MainRamCounter, 6 bytes

"a"e6R

This is a new language I am currently developing. It is based off of 3 storage spaces: Main (which does comparisons and math), Ram (which stores values), and counter (which is a counter).

Breakdown:

"a"      push 97 to ram
e6       duplicate current ram 6 times
R        output ram as string

Output:

aaaaaa

Answer 146

Chip, 78+3 = 81 bytes

Flag: -w

Code (Try it online!):

g*
,xZ.
`@'|
,xZ<
`@'|
,xZ<
`@'|
,xZ<
`@'`.
,xZ~<
`@','
,xZ^.
`@'t{*
,xZ~'
`@'

Out: @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

This uses a binary counter to halt at the correct time.

---

11+3 = 14 bytes (uses version string)

Flag: -V

Code (anything will do, just need to fill the length):

gibberishes

Out (current interpreter, has trailing newline):
chip.py 0.1.2

---

40+3 = 43 bytes (error message, uses stderr)

Flag: -w

Code (apparently some of this is filler?):

!*T :Hello you! That shirt looks great!;

Out: 1:1 WARN: '!' (33) is not a valid character

Answer 147

JavaScript, 35 bytes

Source:

console.log(([]+[])["constructor"])

Output:

function String() { [native code] }

Answer 148

Add++, 2 bytes

Noncompeting as language postdates challenge.

O

Try it online!

Outputs a 0 with a trailing newline.

Answer 149

Triangular, 9 bytes

9.(,%<>d]

Try it online!

Formats into this triangle:

    9 
   . ( 
  , % < 
 > d ] ÿ

Triangular auto-inserts ÿ wherever there is no source code to fill the smallest triangle.

Without control flow, the program looks like 9(%d]. Explanation:

• 9 - push 9 to the stack
• ( - open loop
• % - print top of stack as integer
• d - decrement top of stack
• ] - jump back to ( if top of stack is truthy

Answer 150

Cubically, 2 bytes

%5

Try it online! Boring. Outputs 45. Also works with %4 (36), %3 (27), and %2 (18).

Cubically, 7 bytes

+5*66%6

Try it online! Outputs 4100625 by adding 45 to the notepad, then squaring it twice.

Cubically, 9 bytes

+5*5555%6

Try it online! Outputs 184528125 by adding 45 to the notepad, then multiplying it by 45 four times.

Answer 151

C#, 53 bytes

Not short, but good enough:

string a="1";for(int i=0;i<53;i++){Console.Write(a);}

Some Facts I can't resist to post:

• Fifty-three is the 16th prime number. It is also an Eisenstein prime, and a Sophie Germain prime.

• 53 cannot be expressed as the sum of any integer and its base-10 digits, making 53 a self number.

• 53 is the smallest prime number that does not divide the order of any sporadic group.

Answer 152

C#, 12 bytes

()=>1e11+"";

It returns 10^11, which is a 1 followed by 11 0-s, so 12 bytes long.

Answer 153

cQuents, 5 bytes

#3::$

Outputs 1,2,3. This works because of the mode, ::. :: prints the sequence up to n, which in this case is hardcoded in as 3. $ prints the current index - it could be replaced with any single digit. So, the interpreter prints out the first three items in the $ sequence, separated by the default delimiter, ,.

Answer 154

PowerShell, 5 bytes

$true

Output (including trailing linefeed):

True

Try it online!

Answer 155

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!

Answer 156

Python 3, 10 bytes

print(1e6)

Try it online!

Answer 157

Common Lisp REPL, 2 bytes

'a

returns a followed by a newline

Answer 158

Cubically, 2 bytes

%5

Try it online!

Prints the sum of all values on face 5. Face 5 is initialized to

555
555
555

so this prints

45

(Other valid answers: %2,%3,%4)

Answer 159

Implicit, 1 byte

#

Pushes the length of the stack to the stack. Implicit output. Try it online!

1 byte alternatives

• ß prints a space.
• ±, $, +, -, *, /, _, and ^ all push 0 if the TIO input box is empty.

Answer 160

Recursiva, 2 bytes

L(

Try it online!

It outputs 26.

L(
L   - Length of
 (  - upper-case alphabet yield

Answer 161

SmileBASIC, 3 bytes

?#Y

Output:

128

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

Answer 162

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

Answer 163

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.

Answer 164

Flobnar, 9 8 bytes

*<*@
9*<

Try it online!

Outputs 43046721, which is 9⁸. This uses the -d flag to output in decimal. Thanks to Esolanging Fruit for this solution

Answer 165

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.

Answer 166

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

Answer 167

PowerShell, 4 bytes

1..2

Try it online!

Output includes a trailing newline!

Answer 168

Perl6 12 7 bytes

say |^6

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

Original

.say for ^7

Answer 169

Alchemist, 9 bytes

_->9Out__

Try it online!

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

Answer 170

brainfuck, 24 bytes

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

Try it online!

Prints 24 Us.

Explanation:

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

Answer 171

Keg, 2 bytes

Q.

Outputs 81, which is the ascii value of Q

Try it Online!

Answer 172

Keg, 2 bytes

2-byte answer:

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

Answer 173

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

Answer 174

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!

Answer 175

Actually, 2 bytes

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

1╤

Try it online!

Answer 176

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 .

Answer 177

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

Answer 178

W, 2 bytes

1_

Explanation

1  % Push 1
 _ % Negate this number
% Therefore outputs -1

Answer 179

naz, 2 bytes

2o

Outputs 00.

Quite similar to my answer for Create output twice the length of the code.

Answer 180

Ohm, 5 bytes

αvssL

Explanation

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

Answer 181

Pip, 4 bytes

L2P1

Try it online!

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

Answer 182

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.

Answer 183

yup, 12 bytes

0e:::::{0##}

Try it online!

Pushes 6 1s, and, while there are 1 on the top of the stack, output a 0 followed by a 1.

Answer 184

Jellyfish, 2 bytes

p0

Try it online!

Prints 0 and a trailing linefeed.

Answer 185

Rexx 15 Bytes

say left("",15)

Try it here

Answer 186

Lua, 10 bytes

print(1e6)

Outputs:

1000000.0

Try it online!

Answer 187

Aceto, 9 1 byte

p

Prints the top value on the stack, an implicit 0.

---

Old solution (9 bytes):

p
¥×
19

Push a 1, push a 9. Multiply the (remaining) stack (by 9; → [1,1,1,1,1,1,1,1,1]).

Implode and print (prints 111111111).

The code is 9 bytes long in UTF-8 because ¥ and × take 2 bytes each.

Answer 188

Javascript, 10 bytes

alert(1e9)

Nodejs repl (maybe breaking rule)

1

Answer 189

J REPL, 2 bytes

+1

This outputs 1, then a newline.

Answer 190

Python 3 REPL, 2 bytes

1#

Prints 1 followed by a newline (\n)

Answer 191

REXX 8 Bytes

say 9**8

Prints 43046721

Answer 192

Python 2, 13 bytes

Code:

print 10**12

Output:

1000000000000

Character Count: 13

Answer 193

shortC on modern Linux

8 bytes

Araise(6

Output (with a newline):

Aborted 

10 bytes

Araise(7);}

Output (with a newline):

Bus error 

11 bytes

Araise(14);}

Output (with a newline):

Alarm clock 

11 btyes

Araise(15);

Output (with a newline):

Terminated 

12 bytes

Araise(16);}

Output (with a newline):

Stack fault 

13 bytes

Araise(29);} 

Output (with a newline):

I/O possible 

24 bytes

main(){raise(9*(1+1+1));

Output (with a newline):

Profiling timer expired 

Answer 194

Bean, 2 bytes

00000000: 253b                                     %;

Explanation

Implicitly prints a 2 followed by a newline. I arbitrarily decided it should output the amount of bytes the program is, but this will work with many single characters in the printable range.

Try it online!

Answer 195

2Col, 2 bytes [non-competing]

=0

Output:

0

Zero, with a trailing newline

Explanation:

    No input, therefore Cell initializes at 0
=0  Set Cell value to 0 and return Cell value
    Implicit: Print return value followed by a newline

Answer 196

JavaScript, 32 bytes

Code: btoa(01234567891011121314151617)

Output: MS4yMzQ1Njc4OTEwMTExMjEzZSsyNA==

console.log(btoa(01234567891011121314151617))
console.log(btoa(01234567891011121314151617).length)
console.log("btoa(01234567891011121314151617)".length)

Answer 197

Check, 3 bytes (Non-competing)

>]p

Output:

[0]

> pushes 0, ] wraps it in an array, and p prints it.

Answer 198

GolfScript, 2 bytes

!#

The output is:

1

Try it online!

Answer 199

j, 3 bytes

i.2

output...

0 1

(3 bytes including space)

Answer 200

j, 2 bytes

!4

    returns 24 (factorial 4)

Answer 201

Tcl/Tk, 18

pack [text .txt 1]

ouputs

unknown option "1"

Answer 202

Google Sheets, ₉ 4 Bytes

Google Sheets spreadsheet formula that takes no input and outputs a string of length 4 (output value := 1024 or 1000) to the spreadsheet cell that holds the formula.

=4^5

Or

=XE3 '' s.t. `x` is an integer in the range 1 To 9

--

Alternatively, 9 Bytes

Google Sheets spreadsheet formula that takes no input and outputs a string of length 9 to the spreadsheet cell that holds the formula.

=Rept(1,9

Answer 203

ArnoldC, 309 bytes

Easy.

IT'S SHOWTIME
HEY CHRISTMAS TREE S
YOU SET US UP 1
HEY CHRISTMAS TREE T
YOU SET US UP 0
STICK AROUND S
GET TO THE CHOPPER T
HERE IS MY INVITATION T
GET UP 1
ENOUGH TALK
TALK TO THE HAND "SS"
GET TO THE CHOPPER S
HERE IS MY INVITATION  103
LET OFF SOME STEAM BENNET T
ENOUGH TALK
CHILL
YOU HAVE BEEN TERMINATED

Note the double space between HERE IS MY INVITATION and 103 to have the good amount.

Golfable.

Try it online!

Answer 204

ROOP, 7 bytes

/rn/
ha

Try it online!

print IVXLCDM

---

The constant rn represents the string containing the Roman numerals.

The h operator terminates the program and prints all existing objects. The a operator is only to reach 7 bytes (there is no constant that has 6 characters).

Answer 205

MY, 1 byte

←

0 is implicitly popped off of the stack, how nice!

Try it online!

Answer 206

GNU sed, 1 byte

Outputs a newline.

;

Try it online!

Answer 207

Aceto, 1 byte

p

Try it online!

Outputs 0

Answer 208

Pushy, 1 byte

_

Try it online!

Outputs a newline and nothing else.

This works not just with an underscore, but any character from: Qq'_"# (because these are all printing based commands, but there is nothing to print).

Answer 209

JsFuck for Firefox 31+ REPL, 604 bytes

[][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]
]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!
![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!
![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]
])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!
![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+
[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]
+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[
!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+
[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]
]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!!
[]]](+(!![]+!![]+!![]+!![]+!![]+!![]+[+[]]+(+[])))
+![]

Answer 210

POSIX bc, 1 Byte

a

output:

0

Explanation: If you type a variable name it prints the value. Variables you haven't yet defined have the value zero.

Answer 211

Red / Rebol 5 bytes

1 > 2

Prints:

false

Answer 212

Attache, 8 bytes

!11|Echo

Try it online!

Other programs

9^8|Echo
!11|Echo
3|Echo//3
$A*10|Echo
Echo[$A*11]
$A*10|Print
Print[$A*11]
Echo//3 <|[]
Print//3 <|3
{_!_[0:1]}!Print

Answer 213

Husk, 2 bytes

s"

Try it online!

Prints "".

Husk, 2 bytes

_1

Try it online!

Prints -1.

Answer 214

C# (Visual C# Interactive Compiler), 6 bytes

_=>9e5

Try it online!

Answer 215

Python 3 only 3 bytes.

Type 01. in Python 3 interpreter and get 1.0 output.

Answer 216

TI-BASIC, 2 bytes

ᴇ1

Prints 10.

ᴇ is this one-byte token.

Answer 217

Python 3, 10 bytes

print(1e6)

Try it online!

Answer 218

C++ (gcc), 60 58 bytes

#include<stdio.h>
int main(){for(int i=29;i--;)puts("x");}

Try it online!

Answer 219

Bash, 12 bytes

yes|head -n6

outputs 6 lines of ys (6 ys, 6 newlines)

Answer 220

Gol><>, 1 byte

h

Surprisingly easy, "h" pops off a number from the stack and prints that number, then ends the program. If there is no number then by default outputs 0.

Try it online!

Answer 221

Ahead, 4 bytes

Prints 0000.

4kO@

4k    4 times
  O   pop stack and print 
   @  end

The empty stack always pops 0.

Try it online!

Answer 222

Javascript (ES6), 5 bytes

!1+''

outputs the string "false".

Answer 223

R, 6 bytes

seq(1)

Try it online!

I think we've covered all the other types of R answer already, but this one counts the print method's [1] and trailing newline. There might be some counting technicalities here.

Answer 224

TinCan, 122 bytes

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

Outputs 122 'a's.

aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

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), minus one for the positive case, times 256 and added (256 - 97), 97 being the ASCII value of 'a'. This gives 31135.

The loop then generates a sequence of values starting at -31135 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 122 '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!

Answer 225

SNOBOL4 (CSNOBOL4), 23 bytes

	OUTPUT =DUPL(1,22)
END

Try it online!

Outputs 22 1s and then a newline.

Answer 226

Runic Enchantments, 2 bytes

m@

Try it online!

One of several possible programs that satisfies the challenge. This one is just the least obvious. Rather than pushing a value literal (a-f) to the stack, instead push the current value of the IP's energy/mana to the stack (which is initially 10).

1 byte solutions are impossible as Runic requires an output byte and a termination byte (both satisfied by @) as well as a Thing-To-Print byte (m).

Answer 227

Underload, 6 bytes

()aaaS

Outputs ((())), since a just puts brackets around the top item of the stack.

Try it Online!

Answer 228

Ohm v2, 1 byte

‰

Try it online!

‱

or

Try it online!

Ohm, 1 byte

º

Try it online!

or

°

Try it online!

Explanation

In Ohm if a component requires an input but no inputs are provided a 0 is implicitly pushed to the stack, so the output is 2⁰ for the first program (in each version) and 10⁰ for the second.

Answer 229

33, 1 byte

o

Prints 0, the default value of the accumulator.

i also works, printing a trailing newline.

Answer 230

8086/8088 machine code, 6 bytes

b8 21 21    mov ax, 2121         Load 0x2121 into AX.
ef ef ef    out [dx], ax (x3)    Output AX (2 bytes) to port [DX], 3 times.

Assumptions:

• The output may be sent to I/O port 0.
• DX is initialized with 0.

Joke answer:

ee    out [dx], al    Output AL (1 byte) to port [DX].

Assumptions:

• The output may be sent to I/O port [DX], whatever that is.
• AL is initialized with an ASCII character.

Answer 231

brainfuck, 36 bytes

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

Try it online!

Answer 232

Python 3, 13 bytes

print('x'*13)

Try it online!

Answer 233

Zsh, 9 bytes

<<<$[9E7]

try it online!

Answer 234

Or, 5 bytes

 fals

This returns false (this should be a five-character constant) onto the stack, which can be used later in the program (or not really, none of the current known instructions in Or access non-top items).

Explanation

From the IRC log:

14:01 < fungot> mroman_: the command to push false is ' f'

Since fungot had not yet presented the full language, all that we know in the current interpreter is that extra instructions do nothing.

 f    Push false onto the stack
  als All of those are recognized as NOPs in the current implementation.

Answer 235

Wren, 2014 bytes

Fn.new{"1"*14}

Try it online!

Explanation

Fn.new{      } // Anonymous function
       "1"*14  // Returning the string "1" repeated 14 times

Answer 236

Python 3, 29 bytes

s='s=%r;print(ss)';print(s%s)

Try it online!

Output

s='s=%r;print(ss)';print(ss)

A more quine-like answer than this answer