[Question]
  [
In this challenge, you should write a program or function which takes no input and prints or returns a string with the same number of bytes as the program itself. There are a few rules:
* You may only output bytes in the printable ASCII range (0x20 to 0x7E, inclusive), or newlines (0x0A or 0x0D).
* Your code must not be a quine, so the code and the output must differ in at least one byte.
* Your code must be at least one byte long.
* If your output contains trailing newlines, those are part of the byte count.
* If your code requires non-standard command-line flags, count them as usual (i.e. by adding the difference to a standard invocation of your language's implementation to the byte count), and the output's length must match your solution's score. E.g. if your program is `ab` and requires the non-standard flag `-n` (we'll assume it can't be combined with standard flags, so it's 3 bytes), you should output 5 bytes in total.
* The output doesn't always have to be the same, as long as you can show that every possible output satisfies the above requirements.
* Usual quine rules *don't* apply. You may read the source code or its size, but I doubt this will be shorter than hardcoding it in most languages.
You may write a [program or a function](https://codegolf.meta.stackexchange.com/q/2419) and use any of the [standard methods](https://codegolf.meta.stackexchange.com/q/2447) 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](https://codegolf.meta.stackexchange.com/q/2028), but note that [these loopholes](https://codegolf.meta.stackexchange.com/q/1061/) are forbidden by default.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest valid answer – measured in *bytes* – wins.
### Leaderboard
```
var QUESTION_ID=121056,OVERRIDE_USER=8478;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){var F=function(a){return a.lang.replace(/<\/?a.*?>/g,"").toLowerCase()},el=F(e),sl=F(s);return el>sl?1:el<sl?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
```
```
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>
```
  
[Answer]
# C (modern Linux), 19 bytes
```
main(){puts('s');}
```
When compiled and run, this prints:
```
Segmentation fault
```
[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.
[Answer]
# Bash (builtins only), 8 bytes
```
{e,,}cho
```
Prints `cho cho` and a newline.
[Answer]
## [Labyrinth](https://github.com/m-ender/labyrinth), 4 bytes
```
!!>@
```
[Try it online!](https://tio.run/nexus/labyrinth#@6@oaOfw/z8A "Labyrinth – TIO Nexus")
Prints `0000`
### Explanation
```
!   Print an implicit 0 from the stack.
!   Print an implicit 0 from the stack.
>   Rotate the source code right by one cell, so the code now becomes
    @!!>
    The IP is moved along, so it's now at the end of the line, which is 
    a dead end. So the IP turns around and starts moving left.
!   Print an implicit 0 from the stack.
!   Print an implicit 0 from the stack.
@   Terminate the program.
```
[Answer]
## [Retina](https://github.com/m-ender/retina), 2 bytes
```
no
```
[Try it online!](https://tio.run/nexus/retina#@5@X//8/AA "Retina – TIO Nexus")
Prints `0` and a linefeed.
There are a lot of 2-byte solutions, but I believe this is optimal. Retina by default always prints a trailing newline and getting rid of it takes too many bytes. So we'd have to find a 1-byte program that leaves the empty input unchanged. I believe the only program which does this is the program containing a single linefeed, which is therefore equal to the output and hence not permitted by the challenge.
The next simplest thing to do is to live with Retina outputting a single digit (the number of matches of some regex against the empty input), and we can do that with a lot of failing (or matching) 2-byte patterns.
[Answer]
## Mathematica, 2 bytes
```
4!
```
factorial 
> 
> 24
> 
> 
> 
[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.
[Answer]
# Bash on Linux, 6
```
uname
```
(followed by a newline)
Outputs `Linux` followed by a newline.
[Answer]
# Javascript ES6, 9 bytes
Using Template Strings
```
_=>`${_}`
```
```
f=
_=>`${_}`
console.log(f());
console.log(typeof f());
```
[Answer]
# [Pyramid Scheme](https://github.com/ConorOBrien-Foxx/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!](https://tio.run/##K6gsSszNTNEtTs5IzU39/19BIY5LQT8uhitOV1c3jks3TiFOl0tBF0ToG8Vw6StYKMRw6YLA//8A "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!](https://tio.run/nexus/pyramid-scheme#@6@gEMeloK8Qw6WfX1oSw6ULAkARINCPiwHRcVABfcMYBX1LoJC@mYFZDFCQS9/U0MDQFKpHV/f/fwA "Pyramid Scheme – TIO Nexus")
Outputs `71277303925397560663333806233294794013421332605135474842607729452115234375` = `160651015 ** 9`, or about 1074.
[Answer]
# [Python 2](https://docs.python.org/2/), 9 bytes
```
print{+1}
```
This prints `set([1])` and a linefeed.
[Try it online!](https://tio.run/nexus/python2#@19QlJlXUq1tWPv/PwA "Python 2 – TIO Nexus")
[Answer]
# [Python 2](https://docs.python.org/2/), 9 bytes
```
print 1e5
```
The displayed output contains a trailing newline.
[Try it online!](https://tio.run/nexus/python2#@19QlJlXomCYavr/PwA "Python 2 – TIO Nexus")
[Answer]
# [brainfuck](https://github.com/TryItOnline/tio-transpilers), 25 bytes
```
--[-->+<]+++++[->-.....<]
```
[Try it online!](https://tio.run/nexus/brainfuck#@6@rG62ra6dtE6sNAtG6drp6IGAT@/8/AA "brainfuck – TIO Nexus") *Note: Requires an implementation with 8-bit unsigned cells*
Output: 
```
~~~~~}}}}}|||||{{{{{zzzzz
```
---
## Explanation
```
--[         254
 -->+<]      /2 = 127 into the second cell
+++++[      Five times
 ->-.....<]  Print the second cell - 1 five times
```
[Answer]
# C (Ideone), 14 bytes
```
f(){warn(0);}
```
[On Ideone](http://ideone.com/8hesZH), which names its executable `prog`, this outputs the following with a trailing newline.
```
prog: Success
```
# C (GCC), 15 bytes
```
f(){warn(00);}
```
Because GCC writes an executable named `a.out` by default (in the absence of additional flags that would cost bytes), this outputs the following with a trailing newline.
```
a.out: Success
```
[Answer]
# [Self-modifying Brainfuck](https://soulsphere.org/hacks/smbf/), 5 bytes
```
<[.<]
```
[Try it online!](https://tio.run/nexus/smbf#@28TrWcT@/8/AA "Self-modifying Brainfuck – TIO Nexus")
Output:
```
]<.[<
```
---
## Explanation:
Really simple, prints the source in reverse. In SMBF, the content of the program is stored on the tape, to the left of the initial position of the pointer. Gliding left and printing will output the source code backwards.
Since reading source is allowed in this challenge, this should definitely be within the rules.
[Answer]
# [Basic Arithmetic Calculator](https://i.stack.imgur.com/SH8cv.jpg), 2 bytes
`1``=`
prints `1.`, or:
```
    |
    |
    |  .
```
on those silly seven-segment displays.
To reproduce, pick up any random calculator; they all have this programming language installed somehow.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~18~~ 17 bytes
```
f(){puts('@C');}
```
Note that there's an STX byte (**0x02**) between `@` and `C`.
[Try it online!](https://tio.run/##S9ZNT07@/z9NQ7O6oLSkWEPdgclZXdO69n9mXolCbmJmnoYmVzUXJ1Demqv2PwA "C (gcc) – TIO Nexus")
### 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  [[email protected]](/cdn-cgi/l/email-protection)...@.....
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  [[email protected]](/cdn-cgi/l/email-protection).......
00000180: 44 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00  D...............
00000190: 50 e5 74 64 04 00 00 00 b0 05 00 00 00 00 00 00  P.td............
000001a0: b0 05 40 00 00 00 00 00 b0 05 40 00 00 00 00 00  ..@.......@.....
000001b0: 3c 00 00 00 00 00 00 00 3c 00 00 00 00 00 00 00  <.......<.......
000001c0: 04 00 00 00 00 00 00 00 51 e5 74 64 06 00 00 00  ........Q.td....
000001d0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
000001e0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
000001f0: 00 00 00 00 00 00 00 00 10 00 00 00 00 00 00 00  ................
00000200: 52 e5 74 64 04 00 00 00 08 0e 00 00 00 00 00 00  R.td............
00000210: 08 0e 60 00 00 00 00 00 08 0e 60 00 00 00 00 00  ..`.......`.....
00000220: f8 01 00 00 00 00 00 00 f8 01 00 00 00 00 00 00  ................
00000230: 01 00 00 00 00 00 00 00 2f 6c 69 62 36 34 2f 6c  ......../lib64/l
00000240: 64 2d 6c 69 6e 75 78 2d 78 38 36 2d 36 34 2e 73  d-linux-x86-64.s
00000250: 6f 2e 32 00 04 00 00 00 10 00 00 00 01 00 00 00  o.2.............
00000260: 47 4e 55 00 00 00 00 00 02 00 00 00 06 00 00 00  GNU.............
00000270: 20 00 00 00 04 00 00 00 14 00 00 00 03 00 00 00   ...............
```
Using, e.g., `main(int c, char**v){f();}` instead changes some bytes, but not the offset of the string `/lib64/ld-linux-x86-64.so.2`, which we'll use to produce output.
The offset of said string is **0x238** and it is 27 bytes long. We only want to print 17 bytes (and the last one will be a newline if we use `puts`), so we add **11** to the offset to get **0x243**, the offset of `inux-x86-64.so.2`. Adding **0x400000** and **0x243** gives **0x400243**, the memory location of `inux-x86-64.so.2`.
To obtain this memory address, we can use multi-character character constants, which exhibit implementation-defined behavior. **0x400243** is **(64)(2)(67)** in base 256 and gcc's multi-character character constants use big-endian byte order, so `'@\2C'` yields the memory address of the desired string.
Finally, `puts` prints the (null-terminated) sting at that memory location and a trailing newline, creating 17 bytes of output.
[Answer]
# Fourier, ~~26~~ ~~22~~ 20 bytes
```
5^(`na`&i)` Batman!`
```
[**Try it on FourIDE!**](https://beta-decay.github.io/editor/?code=NV4oYG5hYCZpKWAgQmF0bWFuIWA)
Outputs:
```
nananananana Batman!
```
---
For proper capitalisation, it's 4 extra bytes:
```
`N`7^(`an`i^~i)`a Batman!`
```
[**Try it on FourIDE!**](https://beta-decay.github.io/editor/?code=YE5gN14oYGFuYGlefmkpYGEgQmF0bWFuIWA)
```
Nanananananananana Batman!
```
---
***[R.I.P. Adam West](http://www.bbc.co.uk/news/entertainment-arts-40246650)***
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 1 byte
```
w
```
[Try it online!](https://tio.run/nexus/brachylog2#@1/@/z8A "Brachylog – TIO Nexus")
### Explanation
`w` is the built-in "write". Here, it will write the Input. Since the Input is a free variable, `w` will label it as an integer before printing. The first integer it tries is `0`.
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), 11 bytes
```
o->1e8-1+""
```
[Try it online!](https://tio.run/##LYxBi8IwEIXv/opHoJCiDXhb2NWjN/Hgcd1D2qY1NSbBmQhl8bd3s7UwMMO873uDfuoqROOH9jbFVDvboHGaCEdtPX5XwPIl1pzXM9gW95zJMz@s779/oB89lTMKDLlPJbZOdck3bINXh@X4OtWDaXjz9vbosJtCtd@aj2q7FmL61z/nkjcBwg6d0jG6UfrkXLmkI7G5q5BYxcxxJ8VFFHQRkEWLemRDZeHFBpRHOeN7vspyll@r1/QH "Java (OpenJDK 8) – Try It Online")
Output:
> 
> 
> ```
> 9.9999999E7
> 
> ```
> 
> 
Just a tad more elaborate than the obvious answer, `()->"".format("%23s",0)`.
## Saves
* 18 -> 16 bytes: More advantageous combination of rounding and power of 10, thanks to PunPun1000
* 16 -> 13 bytes: better formula, thanks to JollyJoker
* 13 -> 11 bytes: improved formula, thanks to Kevin Cruijssen
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 1 byte
```
õ
```
Outputs a single newline. `õ` pushes an empty string, and it is implicitly outputted with a newline.
[Try it online!](https://tio.run/nexus/05ab1e#@3946///AA "05AB1E – TIO Nexus")
Some other 2 byte solutions, for your viewing pleasure (the output is in the brackets, and all output has a trailing newline):
```
X, (1)
Y, (2)
¾, (0)
¼, (1)
¶, (newline)
ð, (space)
Î, (0)
```
There are way more 2 byte solutions though.
[Answer]
## Batch, 12 bytes
```
@echo %OS%
```
Byte count includes trailing newline for both script and output, which is
```
Windows_NT
```
[Answer]
## [Hexagony](https://github.com/m-ender/hexagony), 3 bytes
```
o!@
```
[Try it online!](https://tio.run/nexus/hexagony#@5@v6PD/PwA "Hexagony – TIO Nexus")
Prints `111`.
Unfolded:
```
 o !
@ . .
 . .
```
But the code is really just run in the order `o!@`.
```
o   Set the memory edge to 111, the code point of 'o'.
!   Print this value as a decimal integer.
@   Terminate the program.
```
[Answer]
# [V](https://github.com/DJMcMayhem/V)/vim, 1 byte
```
o
```
This prints a single newline.
[Try it online!](https://tio.run/nexus/v#@5///z8A "V – TIO Nexus")
There are a bunch of variants on this that would work too. For example,
```
O
```
in vim, and
```
Ä
ä
ï
Ï
```
in V.
There are also many many many three byte solutions. For example:
```
3ii
i³i
¬ac
```
These are all specific to V.
[Answer]
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!](https://tio.run/##7ZXNigJBDITvPkVOetKHcA4K/iCOeA9tWMP0JJqOik@vjX97WBYVZGFhzvUVyaWqajVh@XKVbjBKgcRPpwVWBFM1X5MJjFkIXKF0DdWBYmxd9CUHV2P81mlPAiUnJ0u/MAOjzMzQqisw4xBwxTEe30Hmu5TyH1Bud2jUYA3WYJ/BRrkLOgkK05Ry4Hs5hxIMb3GekJtuNLKjvGgZYl3nOqjZ19CGgv3YGP@jsWALkf4A7qNUT4QfyzR5jFg@ch@xMw) [Verify that it's actually `1731` digits long!](https://tio.run/##K6gsycjPM/r/v6AoM69EISc1T6O4pEjDXEvLyMDEQlPz/38A)
[Answer]
# [///](https://esolangs.org/wiki////), 12 bytes
```
/a/bcd/aaaa/
```
[Try it online!](https://tio.run/nexus/slashes#@6@fqJ@UnKKfCAT6//8DAA "/// – TIO Nexus")
This prints `bcdbcdbcdbcd`, and because this is 12 bytes, I've added a [harmless](https://codegolf.stackexchange.com/a/120425/44874) `/` to the end of the code to pad it out.
[Answer]
## [Befunge](https://github.com/catseye/Befunge-93), 2 bytes
```
.@
```
[Try it online!](https://tio.run/nexus/befunge#@6/n8P8/AA "Befunge-98 – TIO Nexus")
Prints `0` with a trailing space. [Also works in Befunge 98.](https://tio.run/nexus/befunge-98#@6/n8P8/AA "Befunge – TIO Nexus")
[Answer]
# R, 7 bytes
```
mode(T)
```
Prints "logical"
[Answer]
# [MATL](https://github.com/lmendo/MATL), 2 bytes
```
H
```
There is a trailing newline.
[Try it online!](https://tio.run/nexus/matl#@@/B9f8/AA "MATL – TIO Nexus")
### Explanation
Clipboard H contains number `2` by default. `H` pushes that content to the stack, which gets implicitly displayed with a trailing newline.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 2 bytes
```
→¹
```
[Try it online!](https://tio.run/nexus/charcoal#@/@obdKhnf//AwA "Charcoal – TIO Nexus")
Prints a length-1 horizontal line of `-` to the right, and a newline.
]