title: Output with the same length as the code

text:
# Question
Title: 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.

### 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
# C (modern Linux), 19 bytes

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

```

When compiled and run, this prints:

```
Segmentation fault

```
> 229 votes

# Answer
## 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.
> 95 votes

# Answer
# Bash (builtins only), 8 bytes

```
{e,,}cho

```

Prints `cho cho` and a newline.
> 69 votes

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

```
> 62 votes

# Answer
## 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.
> 44 votes

# Answer
## Mathematica, 2 bytes

```
4!

```

factorial

> 24
> 37 votes

# Answer
## 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.
> 32 votes

# Answer
# Bash on Linux, 6

```
uname

```

(followed by a newline)

Outputs `Linux` followed by a newline.
> 31 votes

# Answer
# Javascript ES6, 9 bytes

Using Template Strings

```
_=>`${_}`

```

```
f=

_=>`${_}`

console.log(f());
console.log(typeof f());
```
> 27 votes

# Answer
# 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 1074.
> 26 votes

# Answer
# Python 2, 9 bytes

```
print{+1}

```

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

Try it online!
> 24 votes

# Answer
# Python 2, 9 bytes

```
print 1e5

```

The displayed output contains a trailing newline.

Try it online!
> 23 votes

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

```
> 19 votes

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

```
> 17 votes

# Answer
# 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.
> 16 votes

# Answer
# 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.
> 16 votes

# Answer
# 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.
> 15 votes

# Answer
# 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***
> 14 votes

# Answer
# 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`.
> 12 votes

# Answer
# 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
> 12 votes

# Answer
# 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.
> 10 votes

# Answer
## Batch, 12 bytes

```
@echo %OS%

```

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

```
Windows_NT

```
> 10 votes

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

```
> 10 votes

# Answer
# /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.
> 9 votes

# Answer
Well, uh...

# Mornington Crescent, 1731 bytes

```
Take Northern Line to Stockwell
Take Victoria Line to Seven Sisters
Take Victoria Line to Green Park
Take Piccadilly Line to Green Park
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Russell Square
Take Piccadilly Line to King's Cross St. Pancras
Take Metropolitan Line to King's Cross St. Pancras
Take Hammersmith & City Line to King's Cross St. Pancras
Take Hammersmith & City Line to King's Cross St. Pancras
Take Hammersmith & City Line to King's Cross St. Pancras
Take Hammersmith & City Line to King's Cross St. Pancras
Take Hammersmith & City Line to King's Cross St. Pancras
Take Hammersmith & City Line to King's Cross St. Pancras
Take Hammersmith & City Line to King's Cross St. Pancras
Take Hammersmith & City Line to King's Cross St. Pancras
Take Circle Line to King's Cross St. Pancras
Take Circle Line to King's Cross St. Pancras
Take Circle Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent

```

Prints out the value of `7^2048`, which is `1731` digits long. Try it online! Verify that it's actually `1731` digits long!
> 9 votes

# Answer
# ///, 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.
> 8 votes

# Answer
## Befunge, 2 bytes

```
.@

```

Try it online!

Prints `0` with a trailing space. Also works in Befunge 98.
> 8 votes

# Answer
# R, 7 bytes

```
mode(T)

```

Prints "logical"
> 8 votes

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

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

# Answer
# Charcoal, 2 bytes

```
→¹

```

Try it online!

Prints a length-1 horizontal line of `-` to the right, and a newline.
> 7 votes

# Answer
# Ruby, ~~5 4~~ 3 bytes

Crossed out 4 is still 4 ;(

```
p$*

```

Prints `[]` (empty array) then a newline

Try it online!
> 7 votes

# Answer
# Cubix, ~~6~~ 4 bytes

```
@"Ou

```

Try it online

Cubified

```
  @
" O u .
  .

```

This pushes the string `Ou.` to the stack, `O`utputs the top character (`.`) as a character code (46), does a `u`-turn to the right, `O`utputs again, and exits with `@`.
> 7 votes

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

```
> 7 votes

# Answer
# APL, 2 bytes

```
-1

```

Prints `¯1` (the `-` is the Minus monad, whereas `¯` is the High minus negative indicator).
> 7 votes

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

# Answer
## 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 :)\]
> 7 votes

# Answer
# 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())
```
> 6 votes

# Answer
## QBasic 4.5, 1 byte

```
?

```

This prints nothing. Followed by a newline.
> 6 votes

# Answer
# \>\<\>, 4 bytes

```
"on;

```

Try it online!

Outputs `;110`
> 6 votes

# Answer
# bash, 48 bytes

```
bash bash bash bash bash bash! bash! bash! bash!

```

Output:

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

```
> 6 votes

# Answer
# , ~~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!
> 6 votes

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

```
> 5 votes

# Answer
# 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())
```
> 5 votes

# Answer
# 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 215, `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`**.
> 5 votes

# Answer
# 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.
> 5 votes

# Answer
# dc, 2 bytes

```
Kp

```

Try it online!

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

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

```
> 5 votes

# Answer
# 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.
> 5 votes

# Answer
## 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).
> 5 votes

# Answer
# 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.
> 5 votes

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

```
> 5 votes

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

```
> 5 votes

# Answer
# 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.
> 5 votes

# Answer
## 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?
> 4 votes

# Answer
# 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!
> 4 votes

# Answer
# C# (Visual C# Interactive Compiler), 14 bytes

```
_=>new[]{1}+""

```

Found interesting way to shave some bytes. Outputs: `System.Int32[]`

Try it online!

First way: 23 bytes

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

```

Creates a new string consisting of 23 `@` characters
> 4 votes

# Answer
# GNU Make, ~~24~~ 21 bytes

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

```

returns

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

```

Complete makefile:

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

```
> 4 votes

# Answer
# 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)
> 4 votes

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

```
> 4 votes

# Answer
## 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.
> 4 votes

# Answer
# \>\<\>, 3 bytes

```
"nh

```

Try It Online

Prints "104" and exits with an error.
> 4 votes

# Answer
# 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`)
> 4 votes

# Answer
# AWK, ~~19~~ 16 bytes

```
END{print 69**8}

```

Try it online!

*Thanks to Jo King for the pointer that cut 3 chars...*

AWK is a bit of a pain for this one since the minimum code required to run without any input and print something is `END{print }`. So this one just prints a number that's enough digits to match the program size less one, since the `print` adds a linefeed. The output is `513798374428641\n`.
> 4 votes

# Answer
# Python 3, ~~13~~ 12 bytes

```
print(2**-9)

```

Try it here!

**Output:**

```
0.001953125

```

---

**Old:**

```
print([1]*4);

```

Try it here!

**Output:**

```
[1, 1, 1, 1]

```

-1 Thanks to aeh5040! With this, the unneeded semi-colon could be removed as the output is 11 bytes + white space

~~A list printed in python would have the length of 2 + 3 for each extra element plus the new-line, thus with \*n we can have any multiple of 2+3n. A semi-colon is added because unfortunately print adds a new-line character, and I've yet to find a better solution~~
> 4 votes

# Answer
# Desmos, 2 bytes

```
4!

```

Outputs

```
24

```
> 4 votes

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

```
> 3 votes

# Answer
# PHP, ~~216~~ ~~68~~ 7 bytes

```
<?=1e6;

```

Try it online!

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

# Answer
## Powershell, 3 bytes

```
1E2

```

Prints `100`
> 3 votes

# Answer
## 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.
> 3 votes

# Answer
# Octave, 7 bytes

```
[['']]'

```

Try it online!
> 3 votes

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

```
toString(<sub>10</sub>^(3
```

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

# Answer
## 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.
> 3 votes

# Answer
# Klein 110, ~~7~~ 5 bytes

*Thanks to Martin Ender for saving two bytes!*

```
1.
2@

```

Try it online!

If we unfold the topology here we get

```
1.122@

```

This outputs `1 1 2 2` with a trailing newline.
> 3 votes

# Answer
# Somme, 2 bytes

```
:.

```

Try it online!

Outputs `42`. Explanation:

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

```
> 3 votes

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

```
> 3 votes

# Answer
# OCaml, 22 bytes

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

```

Outputs

```
Exception: Not_found.

```

It search for `""` (empty string) in the empty list `[]`
> 3 votes

# Answer
# Ruby, 3 bytes

```
p""

```

Prints this, plus a newline

```
""

```

Here's another 3 byte one:

```
p:a

```

Prints this, plus a newline

```
:a

```
> 3 votes

# Answer
# 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.
> 3 votes

# Answer
# charcoal, 1

Try it online!

## Explanation:

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

```
> 3 votes

# Answer
## \>\<\>, 11 bytes

```
01+:b=?;:n!

```

Prints numbers from 1-10 (12345678910)
> 3 votes

# Answer
## 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.
> 3 votes

# Answer
# 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.
> 3 votes

# Answer
## **Python 3, 13 bytes**

```
print("a"*13)

```

Outputs "aaaaaaaaaaaaa"
> 3 votes

# Answer
# C#, 84 bytes

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

```

Try Online
> 3 votes

# Answer
# Bash, 6 bytes

```
(arch)

```

Try it online!

The architecture needs to be `x86_64`
> 3 votes

# Answer
# Lean Mean Bean Machine, 28 bytes

```
 /O
)O4
?7/
 *
_~
 o
~ :
  u

```

Try it Online!

Outputs 27 `1`s followed by a trailing newline.

Unfortunately I had to fix a bug in LMBM with the `o` peg for this answer to work. The link above links to the entire LMBM interpreter, with the fix, contained in TIO's header/footer, with the LMBM code in the code section.

## Explanation

The code is a loop. Here's the setup:

```
 /O
 O4
 7/
 *
 ~

```

This creates 2 marbles, sets one to 4 and the other to 7, then multiplies them into a single marble with a value of 28. Finally the `~` pushes the marble up to the top of that column, where the top `/` pushes it into the loop.

```
)
?

_
 o
~ :
  u

```

This is the loop. `?` is a conditional that sets the marble's spin to right if its value is truthy (non-zero), and 0 otherwise.

`)` decrements the marble's value. We do this *before* the conditional to account for LMBM's trailing newline.

`_` pushes the marble in the direction of its spin. This is the exit condition for the loop. If the marble's value was not truthy, ie 0, this pushes the marble to the left, out of bounds. Out of bounds marbles are automatically destroyed. When all marbles are destroyed, the program terminates.

`o` is a split. It splits the marble, pushing one copy left and the other right. The left marble hits ~, which pushes it back up to the top of the loop.

The right marble hits `:`, which sets its value to its spin (1 for right, 0 for left), then it falls into `u`, which prints the marble's value and destroys it.
> 3 votes

# Answer
# `experimental-type-lang` (63 bytes)

Here's a solution in a weird (and not very good) language I made:

```
type R<E,C>=C extends63?E:R<[...E,32],[...C,_]>;[51224,R<[],0>]

```

Output:

```
0> "                                                               "

```

I'm not counting the `0>`  output prefix and quotes as part of the program output in this case (the quotes appear whenever the output is a string, and the output prefix is added for every evaluated expression), but if I wanted to count that I could just adjust the value `63` to be the desired output string length.

### Explanation

Here's an expanded version:

```
type Loop<Result = [], Counter = 0> = Counter extends 63
    ? Result
    : Loop<[...Result, 32], [...Counter, _]>;

// The evaluated expression
[51224, Loop<>];

```

In this language, strings are arrays where the first item is a magic number indicating to the evaluator that it should be displayed as a string, and the second item is an array of character codes. The `Loop` function (called a `type` because I wanted to make the syntax resemble the TypeScript type system) is responsible for generating this array of characters. It does this by recursively calling itself, adding `32` (the code for a space) to a result array with the spread operator, until a counter reaches the desired output length. In `experimental-type-lang`, numbers are just arrays of "items" (represented by a `_`) with the length being the numerical value; because there is no language-level add operator and importing the `Add` type from the standard library would take too many characters, I increment the counter by spreading it into an array and adding an `_`.
> 3 votes

# Answer
# Python 2, 11 bytes

```
print 4**16

```

Beep boop.
> 2 votes

# Answer
# Cjam, 1 byte

```
N

```

## Explanation

```
N e#Push '\n' and implicit print

```
> 2 votes

# Answer
## 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())
```
> 2 votes

# Answer
## 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$.
> 2 votes

# Answer
# 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
> 2 votes

# Answer
# , 6 bytes

```
echo!4

```

Try it online!

Output:

```
24

```

Notice the three spaces on the second line.
> 2 votes

# Answer
# 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`)
> 2 votes

# Answer
# 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
> 2 votes

# Answer
# SQLite, 32 bytes

```
.width 31
.mode column
SELECT"";

```

Try it online!

Outputs 31 spaces and a newline.
> 2 votes

# Answer
# Brain-Flak, 12 bytes

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

```

Try it online!

This prints

```
-1
-1
-1
-1

```
> 2 votes

# Answer
# 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.
> 2 votes

# Answer
# Haskell, 16 bytes

```
main=print[0..6]

```

Try it online! Output:

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

```

(Note the trailing newline.)
> 2 votes

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

```
> 2 votes

# Answer
# 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`.
> 2 votes

# Answer
# Forth, 6 bytes

```
1e3 f.

```

**Try it online**

### Output:

```
1000.

```

Note the trailing space.
> 2 votes

# Answer
# Python 3 REPL, 3 bytes

```
1e0

```

Prints `1.0`.

If trailing newline counts,

```
5*2

```

Prints `10`, then a trailing newline.
> 2 votes

# Answer
# 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!
> 2 votes

# Answer
# 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
> 2 votes

# Answer
## 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.
> 2 votes

# Answer
# , 3 characters, 1 byte

Seen as individual characters:

```
**7**23

```

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 `**7**23`), 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.
> 2 votes

# Answer
# 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::*`
> 2 votes

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

```
> 2 votes

# Answer
# 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!
> 2 votes

# Answer
# ZX Spectrum BASIC, 1 byte

```
PRINT

```

(which is 1 byte) prints a single newline.
> 2 votes

# Answer
# 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 :)
> 2 votes

# Answer
# Microscript, 1 byte

```
E

```

Prints 100=1. `e` will also work, printing 20=1.
> 2 votes

# Answer
# 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.
> 2 votes

# Answer
# SmileBASIC 3, 3 bytes

```
?@A

```

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

# Answer
## MarioLANG, 1 byte

`:`

Output the numeric value from current memory cell, which is `0`
> 2 votes

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

```
> 2 votes

# Answer
# JavaScript, 35 bytes

Source:

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

```

Output:

```
function String() { [native code] }

```
> 2 votes

# Answer
# 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?
> 2 votes

# Answer
# 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)
> 2 votes

# Answer
# Python 3 REPL, 11 bytes

```
str(...)[:]

```

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

This prints:

```
'Ellipsis'

```
> 2 votes

# Answer
# 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.
> 2 votes

# Answer
# 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.
> 2 votes

# Answer
# Javascript (ES6), 5 bytes

```
!1+''

```

outputs the string `"false"`.
> 2 votes

# Answer
# , 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.
> 2 votes

# Answer
# brainfuck, ~~15~~ 32 bytes

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

```

Try it online!

Illegal version (no ascii), 15 bytes

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

```

Try it online!
> 2 votes

# Answer
# brainfuck, 24 bytes

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

```

Try it online!

Prints 24 `U`s.

### Explanation:

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

```
> 2 votes

# Answer
# 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
> 2 votes

# Answer
# 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.
> 2 votes

# Answer
# Actually, 2 bytes

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

```
1╤

```

Try it online!
> 2 votes

# Answer
# 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 .
> 2 votes

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

```
> 2 votes

# Answer
# 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
> 2 votes

# Answer
# MAWP, 13 bytes

```
43W2M[84W;1A]

```

Prints 14 space characters.

Try it!
> 2 votes

# Answer
# MAWP, 1 bytes

```
:

```

Try it!

Prints the 1 thats already on stack
> 2 votes

# Answer
# 05AB1E, 1 byte

```
,

```

Try it online!

```
,  # output top of stack (nothing) with trailing newline

```
> 2 votes

# Answer
# Rust, 30 28 bytes

```
fn main(){print!("{:28}",0)}

```

Try it online!

Prints zero, padded with enough spaces so that it is 28 bytes long.
> 2 votes

# Answer
# Red, 32 bytes

```
i: 1 until[prin i: i + 1 i > 20]

```

Try it online!

Sets `i` to 1, then increments `i` and prints it without trailing newlines until `i` is greater than 20. This prints the numbers `[2..21]` without delimiters, an output 32 characters long.
> 2 votes

# Answer
# tinylisp, 3 bytes

```
(q(

```

Try it online!

### Explanation

After parenthesis autocompletion, the code is `(q())`. The `q` macro prevents evaluation of its argument, which in this case is the empty list `()`. So the program outputs `()`, with a trailing newline.
> 2 votes

# Answer
# JavaScript REPL, 2 bytes

```
~0

```

So, apparently there is a limit to how small your submissions can be. Typing words here so I can submit. \\$\\$
> 2 votes

# Answer
# Ruby 3, 6 bytes

```
p ?c*3

```

**Try it online!**

Prints `"ccc"` with a trailing newline to get a 6-byte response.
> 2 votes

# Answer
# Halfwit, 1 byte

```
><

```

Try It Online!

The compressed integer 0, which currently prints `0n`.*

\*I'm going to change this soon

Other interesting approaches:

# Halfwit `-A`, 2 bytes

```
4+

```

Try It Online!

The `-A` flag turns characters into bytes. `4` is a predetermined constant `[0, 1]` and `+` is a NOP here.

# Halfwit `-A`, 3 bytes

```
>;<M>f

```

Try It Online!

This is **M**apping 3 (`>;<`) (converted to a range 1, 2, 3 on map) to 8 (`>f`), which then gets turned into characters and output.
> 2 votes

# Answer
# Aheui (esotope), 30 bytes

```
받발땨희빠챠뎌뱧볗멍

```

Try it online!

Prints 15 copies of `-1`.

# Aheui (esotope), 30 bytes

```
밤발땨희빠챠명뱧뼈더

```

Try it online!

Prints `191817161514131211109876543210`, i.e. a countdown from 19 to 0 without spaces.

### How these work

Aheui is a 2D language with Hangul characters. Each Hangul character consists of an *initial consonant*, a *vowel*, and an optional *final consonant*. In Aheui, the initial consonant defines the instruction, the vowel defines the next movement, and the final consonant provides an argument to the instruction (when necessary).

Aheui comes with multiple stacks and a queue, but the programs above are simple enough that they only operate on a single stack.

Relevant consonants:

* Initial consonant ㅂ: Pushes a constant or a value from stdin.
    + Final consonant ㄷ, ㄹ, ㅁ: Pushes 3, 5, 4 respectively.
    + ㅎ: Reads a UTF-8 character from stdin and pushes its value. On EOF, pushes -1.
* Initial consonant ㄷ, ㄸ: Pops two values and pushes the sum and product respectively.
* ㅃ: Duplicates the top value.
* ㅁ: Pops a value, and prints as integer if the final consonant is ㅇ.
* ㅊ: Pops a value. If it is 0, the next movement is reversed.
* ㅎ: Halts the program.

Relevant vowels:

* ㅏ, ㅓ, ㅗ, ㅜ: Move in the direction of the short stroke by 1 cell.
* ㅑ, ㅕ, ㅛ, ㅠ: Move in the same direction, but by 2 cells (jumping over a cell).

The two-cell movements allow simple loops to be encoded in a single line, and each character encoding both the instruction and the movement allows more flexible arrangement of code fragments.

```
받발땨희빠챠뎌뱧볗멍
받발땨
push 3; push 5; mul (i.e. push 15); enter loop with this loop counter
  빠챠
  if the current loop counter is 0, direct to 희 and halt
  뱧 멍 볗 뎌
  push -1, print, push -1, add

밤발땨희빠챠명뱧뼈더
밤발땨
push 4; push 5; mul (i.e. push 20); enter loop
  빠챠 (same as the other program)
  뱧 더 뼈 명
  push -1, add, dup, print

```

More info can be found in the language spec.
> 2 votes

# Answer
# ForWhile 6 bytes

`6(48#)`

prints 6 zeros

`5(9#)`

would print 5 tabs (but tab is not an allowed character)

online interpreter

# Explanation

```
6(   \ start for-loop with 6 iterations
48#  \ print 0
)    \ end for-loop

```
> 2 votes

# Answer
# Julia 1.0, 6 bytes

```
@show^

```

Try it online!

Prints `^ = ^` followed by a newline.
> 2 votes

# Answer
# Electra, ~~18~~ 15 bytes

```
NONO<??
ONO---o

```

Prints 15 zeros
> 2 votes

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

```
> 1 votes

# Answer
# PHP, 17 bytes

```
<?php echo 9**17;

```

Because I wanted to beat Mayube's answer ;)

Try it online!
> 1 votes

# Answer
# 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!
> 1 votes

# Answer
# brainfuck, 33 bytes

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

```

Try it online!

Output:

```
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

```

I could do it in `32` bytes but I decided this is better.
> 1 votes

# Answer
# brainfuck, 30 bytes

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

```

Outputs 30 `#`s.

Try it online!
> 1 votes

# Answer
# 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
}()

```
> 1 votes

# Answer
# 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.
> 1 votes

# Answer
# Actually, 1 byte

```
ε

```

Try it online!

Prints the empty string (and a trailing newline).
> 1 votes

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

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

```

Try it online!

Output:

```
aaaaaaaaaaaaaaaaaaaaaaaaaaaa

```
> 1 votes

# Answer
# 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*
> 1 votes

# Answer
# 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.
> 1 votes

# Answer
# T-SQL, ~~21~~ 15 bytes

```
print space(15)

```

**Try it online**

### Output:

```

```
> 1 votes

# Answer
# WinDBG, 7 bytes

```
??1;$$$

```

Outputs:

```
int 0n1

```

How it works:

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

```
> 1 votes

# Answer
# 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.
> 1 votes

# Answer
## Java, 70 bytes

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

```

Prints 69 spaces and a zero.
> 1 votes

# Answer
# Scala, 9 bytes

```
()=>"x"*9

```

This is a function which returns "xxxxxxxxx".

Try it online
> 1 votes

# Answer
# , 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!
> 1 votes

# Answer
# 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)
> 1 votes

# Answer
# braingasm, 1 byte

Prints `0` (without newline):

```
:

```
> 1 votes

# Answer
# PARI/GP, 2 bytes

```
4!

```

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

# Answer
# Batch - 6 Bytes

```
xcopy^

```

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

```
More?

```

(With a trailing space)
> 1 votes

# Answer
# 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!
> 1 votes

# Answer
# Pyke, 1 byte

```
k

```

Try it online!

Pushes the empty string and then prints it with a newline
> 1 votes

# Answer
## 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.
> 1 votes

# Answer
# 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).
> 1 votes

# Answer
# 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.
> 1 votes

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

```
> 1 votes

# Answer
# 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`
> 1 votes

# Answer
# Add++, 2 bytes

Noncompeting as language postdates challenge.

```
O

```

Try it online!

Outputs a `0` with a trailing newline.
> 1 votes

# Answer
# 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
> 1 votes

# Answer
# 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.
> 1 votes

# Answer
# 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.
> 1 votes

# Answer
# GolfScript, 1 byte

```
#

```

Prints a new line character

Try it online!
> 1 votes

# Answer
## C#, 12 bytes

```
()=>1e11+"";

```

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

# Answer
# 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, `,`.
> 1 votes

# Answer
# PowerShell, 5 bytes

```
$true

```

Output (including trailing linefeed):

```
True

```

Try it online!
> 1 votes

# Answer
# 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!
> 1 votes

# Answer
# Python 3, 10 bytes

```
print(1e6)

```

Try it online!
> 1 votes

# Answer
# Common Lisp REPL, 2 bytes

```
'a

```

returns `a` followed by a newline
> 1 votes

# Answer
# 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`)
> 1 votes

# Answer
# 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.
> 1 votes

# Answer
# Recursiva, 2 bytes

```
L(

```

Try it online!

It outputs `26`.

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

```
> 1 votes

# Answer
# SmileBASIC, 3 bytes

```
?#Y

```

Output:

128

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

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

```
> 1 votes

# Answer
# 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 `v`s 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.
> 1 votes

# Answer
# 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
> 1 votes

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

```
> 1 votes

# Answer
# PowerShell, 4 bytes

```
1..2

```

Try it online!

Output includes a trailing newline!
> 1 votes

# Answer
# Husk, 2 bytes

```
s"

```

Try it online!

Prints `""`.

# Husk, 2 bytes

```
_1

```

Try it online!

Prints `-1`.
> 1 votes

# Answer
# SNOBOL4 (CSNOBOL4), 23 bytes

```
	OUTPUT =DUPL(1,22)
END

```

Try it online!

Outputs 22 `1`s and then a newline.
> 1 votes

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

```
> 1 votes

# Answer
# Alchemist, 9 bytes

```
_->9Out__

```

Try it online!

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

# Answer
# brainfuck, 36 bytes

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

```

Try it online!
> 1 votes

# Answer
# Keg, 2 bytes

```
Q.

```

Outputs 81, which is the ascii value of `Q`

Try it Online!
> 1 votes

# Answer
## Keg, 2 bytes

2-byte answer:

```

```

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

# Answer
# 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!
> 1 votes

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

```
> 1 votes

# Answer
# Wren, ~~20~~14 bytes

```
Fn.new{"1"*14}

```

Try it online!

## Explanation

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

```
> 1 votes

# Answer
# , 2 bytes

```
1_

```

## Explanation

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

```
> 1 votes

# Answer
# naz, 2 bytes

```
2o

```

Outputs `00`.

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

# Answer
# Perl 5, 6 bytes

```
say $~

```

Try it online!

From the Perl documentation:

> `$~` The name of the current report format for the currently selected output channel. The default format name is the same as the filehandle name. For example, the default format name for the STDOUT filehandle is just STDOUT .
> 1 votes

# Answer
# HTML (`w3m -dump`), 4 bytes

```
<s>

```

It outputs

```
[S:

```

Both source code and output contains a trilling new line.
> 1 votes

# Answer
# Swift, 36 bytes

```
print(String(repeating:" ",count:36))

```
> 1 votes

# Answer
# Knight, 2 bytes

```
O0

```

Try it online!

Prints `0`, followed by a newline.
> 1 votes

# Answer
# Pip, 1 byte

```
x

```

Outputs the empty string plus a trailing newline. Try it online!
> 1 votes

# Answer
# JavaScript, 5 bytes

```
f=

x=>!1

console.log(f());
```
> 1 votes

# Answer
# Javascript REPL, 9 bytes

```
`${8**9}`

```

outputs the string

```
134217728

```

```
console.log(`${8**9}`)
```

Well, i like it

# Javascript REPL, 8 Bytes

same approach 1 byte less

```
`${8e7}`

```

outputs the string

```
80000000

```

```
console.log(`${8e7}`)
```
> 1 votes

# Answer
# SNOBOL4 (CSNOBOL4), 19 bytes

```
 output =99 ^ 9
end

```

Outputs:

```
913517247483640899

```

Try it online!
> 1 votes

# Answer
# INTERCAL, 12 bytes

```
DOREADOUT#81

```

Outputs:

```

LXXXI

```

Try it online!
> 1 votes

# Answer
# , 39 bytes

```
3.6003960133602328000000002500100000194

```

Try it online!

How it works:

```
3.              Start of the program.
  6 00 39       Sets cell 00 to 39.
  6 01 33       Sets cell 01 to 33.
  6 02 32       Sets cell 02 to 32.
  8 00          While cell 00 is not zero:
    0 00 00 02  Sets cell 00 as the addition of cells 00 and 02.
    5 00        Gets the value of cell 00 and prints it as UNICODE character.
    1 00 00 01  Sets cell 00 as the subtraction of cells 00 and 01.
  9             End loop.
4               End of the program.

```

I avoided printing ASCII characters below `0x20`, as the rules demanded. Otherwise, if one does not care for the nonprintable ASCII chars, it could be as simple as follows:

## , 27 bytes

```
3.60056 60101 800 500 1000001 9 4

```

Try it online!

Spaces kept for readability. Prints `0x56` to `0x00`.
> 1 votes

# Answer
# Backhand, 1 byte

```
h

```

Try it online!

Immediately halts, printing the top of the stack (if empty, 0) as a number.

# Backhand, 4 bytes

```
v11H

```

Try it online!

Somewhat more interesting one which actually uses Backhand's execution nature. Prints four copies of ASCII 1; the `1`s can be changed to any of `0-9a-f` to print ASCII 0-15 characters.

```
v11H   initial step = 3
v    → reduce step size to 2
  1  → push 1
  1  ← bounce off and push 1
v      reduce step size to 1
 11  → push 1 twice
   H   halt, printing the entire stack as a string

```
> 1 votes

# Answer
# in floop, 2 bytes

```
;;

```

Try it online!

I seriously doubt it's possible to do anything more complex than this, as in floop's only output method is by halting.
> 1 votes

# Answer
# Vyxal, 1 byte

```
×

```

Try it Online!

Apparently we don't have a Vyxal answer yet. Outputs `*`.
> 1 votes

# Answer
# Desmoslang Assembly, 14 7 8 Bytes

```
[1...8OT

```

Old (14 Bytes):

```
EP+1M-14)14OJT

```
> 1 votes

# Answer
# Ly, 1 byte

```
y

```

Try it online!

Pushes the size of the stack onto the stack, then exits. Entries on the stack are printed as numbers by default. Outputs `0`.
> 1 votes

# Answer
# Rockstar, 8 bytes

Outputs `0.015625`

```
say 1/64

```

Try it (code will need to be pasted in)
> 1 votes

# Answer
# (,) ~~81~~ ~~65~~ 48 Chars or \\$48\log\_{256}(3)\approx\\$ 9.51 Bytes

Thanks to @Leo for -17? chars!

```
(,,(),,(),,((),()()()()()()()(),,,(),,()()()()))

```

(Assuming by same number of bytes you mean same number of chars)
Tio
> 1 votes

# Answer
# Python 3 (PyPy), 13 bytes

```
print('h'*13)

```

Try it online!
> 1 votes

# Answer
# Vyxal, 4 bytes

```
kSĖ

```

There’s a trailing space.

# Click the sus image below to Try It Online!™

## Explanation

```
kSĖ
kS    # Push the character 'ඞ'.
  Ė   # Execute the top of the stack as Vyxal code.
      # Just a space

# When 'ඞ' is run as Vyxal code, it prints the string 'sus' with a newline.

 Created with the help of Luminespire at https://vyxal.github.io/Luminespire

```
> 1 votes

# Answer
# ///, 12 bytes

```
/a/bb/aaaaaa

```

Try it online!

Outputs `bbbbbbbbbbbb`. Explanation:

```
/a/bb/          Replace each a with bb
      aaaaaa    6 a's -> 12 b's (Implicit output)

```

Alternate program, also 12 bytes with same output:

```
/a/bbbbbb/aa

```

Try it online!
> 1 votes

# Answer
# Vyxal, 5 bytes

```
`∞`∞₴

```

## Output

```
\w+w\

```

Yes, I know. Very crazy.

Try it Online!
> 1 votes

# Answer
# Ohm, 5 bytes

```
αvssL

```

## Explanation

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

```
> 0 votes

# Answer
# Pip, 4 bytes

```
L2P1

```

Try it online!

This prints `1\n1\n`, at 4 bytes including the newlines.
> 0 votes

# Answer
# Minimal-2D, 72 bytes

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

```

Try it online!

Outputs 72 `6`s. This is BF in a 2D layout.
> 0 votes

# Answer
# yup, 12 bytes

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

```

Try it online!

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

# Answer
## Jellyfish, 2 bytes

```
p0

```

Try it online!

Prints `0` and a trailing linefeed.
> 0 votes

# Answer
# Rexx 15 Bytes

```
say left("",15)

```

Try it here
> 0 votes

# Answer
# Lua, 10 bytes

```
print(1e6)

```

Outputs:

```
1000000.0

```

Try it online!
> 0 votes

# Answer
# 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.
> 0 votes

# Answer
# Javascript, 10 bytes

```
alert(1e9)

```

## Nodejs repl (maybe breaking rule)

```
1

```
> 0 votes

# Answer
# REPL, 2 bytes

```
+1

```

This outputs 1, then a newline.
> 0 votes

# Answer
# Python 3 REPL, 2 bytes

```
1#

```

Prints `1` followed by a newline (`\n`)
> 0 votes

# Answer
# REXX 8 Bytes

```
say 9**8

```

Prints 43046721
> 0 votes

# Answer
# Python 2, 13 bytes

Code:

```
print 10**12
```

Output:

```
1000000000000
```

Character Count: 13
> 0 votes

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

```
> 0 votes

# Answer
# 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!
> 0 votes

# Answer
# 2Col, 2 bytes

```
=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

```
> 0 votes

# Answer
# JavaScript, 32 bytes

Code: `btoa(01234567891011121314151617)`

Output: `MS4yMzQ1Njc4OTEwMTExMjEzZSsyNA==`

```
console.log(btoa(01234567891011121314151617))
console.log(btoa(01234567891011121314151617).length)
console.log("btoa(01234567891011121314151617)".length)
```
> 0 votes

# Answer
## Check, 3 bytes (Non-competing)

```
>]p

```

Output:

```
[0]

```

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

# Answer
# j, 3 bytes

```
i.2

```

output...

```
0 1

```

(3 bytes including space)
> 0 votes

# Answer
# j, 2 bytes

```
!4

    returns 24 (factorial 4)

```
> 0 votes

# Answer
# Tcl/Tk, 18

```
pack [text .txt 1]

```

ouputs

```
unknown option "1"

```
> 0 votes

# Answer
# Google Sheets, ~~9~~ 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

```
> 0 votes

# Answer
# 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!
> 0 votes

# Answer
## 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).
> 0 votes

# Answer
# MY, 1 byte

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

Try it online!
> 0 votes

# Answer
# GNU sed, 1 byte

Outputs a newline.

```
;

```

Try it online!
> 0 votes

# Answer
# Aceto, 1 byte

```
p

```

Try it online!

Outputs `0`
> 0 votes

# Answer
# 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).
> 0 votes

# Answer
# JsFuck for Firefox 31+ REPL, 604 bytes

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

```
> 0 votes

# Answer
# 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.
> 0 votes

# Answer
Red / Rebol 5 bytes

```
1 > 2

```

Prints:

```
false

```
> 0 votes

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

```
> 0 votes

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

```
_=>9e5

```

Try it online!
> 0 votes

# Answer
> Python 3 only **3** bytes.

Type **01.** in Python 3 interpreter and get **1.0** output.
> 0 votes

# Answer
# TI-BASIC, 2 bytes

```
ᴇ1

```

Prints `10`.

is this one-byte token.
> 0 votes

# Answer
# Python 3, 10 bytes

```
print(1e6)

```

Try it online!
> 0 votes

# Answer
# C++ (gcc), ~~60~~ 58 bytes

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

```

Try it online!
> 0 votes

# Answer
# Bash, 12 bytes

```
yes|head -n6

```

outputs 6 lines of `y`s (6 `y`s, 6 newlines)
> 0 votes

# Answer
# 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!
> 0 votes

# Answer
# Ahead, 4 bytes

Prints `0000`.

```
4kO@

4k    4 times
  O   pop stack and print
   @  end

```

The empty stack always pops 0.

Try it online!
> 0 votes

# Answer
# , 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.
> 0 votes

# Answer
# 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!
> 0 votes

# Answer
# 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`).
> 0 votes

# Answer
# Underload, 6 bytes

```
()aaaS

```

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

Try it Online!
> 0 votes

# Answer
# 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 20 for the first program (in each version) and 100 for the second.
> 0 votes

# Answer
# 33, 1 byte

```
o

```

Prints `0`, the default value of the accumulator.

`i` also works, printing a trailing newline.
> 0 votes

# Answer
# 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.
> 0 votes

# Answer
# Python 3, 13 bytes

```
print('x'*13)

```

Try it online!
> 0 votes

# Answer
# Zsh, 9 bytes

```
<<<$[9E7]

```

try it online!
> 0 votes

# Answer
# PowerShell, ~~5~~ 4 bytes

```
,0*2

```

Try it online!

-1 and fixing thanks to @ZaelinGoodman
> 0 votes

# Answer
# Deadfish, 1 byte

```
o

```

Outputs 0. In Deadfish~, `c` outputs a NULL byte.
> 0 votes

# Answer
# Scratch, 64 bytes

```
define
set[a v]to[
repeat[4
set[a v]to(join(a)([e ^ v]of[2
say(a

```

Uses scratchblocks syntax.
> 0 votes

# Answer
# Pxem, 0 bytes (content) + 3 bytes (filename).

* Filename: `d.n`
* Content is empty.
* Outputs `100` (if ascii-compatible environment).
> 0 votes

# Answer
# Piet \+ ascii-piet, 20 bytes (14×2=28 codels)

```
eEeEUSABkKnNRTFEqKkk

```

Try Piet online!

Outputs `42949672964294967296`.
> 0 votes

# Answer
# Thunno, 1 byte

```
+

```

Attempt This Online!

Prints \\$0\\$. Also works in Thunno 2: Attempt This Online!

## Thunno, \\$ 2 \log\_{256}(96) \approx \\$ 1.65 bytes

```
Z1

```

Attempt This Online!

Constant for \\$10\\$

Others include:

`aA`, `aB`, `aC`, `aD`, `aE`, `aF`, `aG`, `aH`, `aI`, `aJ`, `aK`, `aL`, `aM`, `aN`, `aO`, `aP`, `aQ`, `aR`

which are constants for \\$10\\$, \\$15\\$, \\$20\\$, ..., \\$95\\$.
> 0 votes

# Answer
# Haskell, 16 bytes

```
main=print$2^48

```

Try it online!
> 0 votes

# Answer
# Python REPL, 4 Bytes

```
9**4

```

# \\$9^4=6561\\$
> 0 votes

# Answer
# GNU `calc`, 2 bytes

```
~3

```

Outputs `-4`, the logical NOT of 3.

There's actually a ridiculous amount of quines in GNU `calc` (any plain number will do the trick), and a *slightly* fewer amount of non-quines that meet this challenge's requirements. This is a short non-quine.
> 0 votes

# Answer
# Swift, 25 bytes

```
for i in 0...11{print(i)}

```

Prints the numbers 0 to 11 with trailing newlines.
> 0 votes

---
Tags: code-golf, self-referential
---