Ovviamente, il golf del codice consiste nel trarre il massimo dal minimo del codice. A chi importa davvero quale sia l'output effettivo?

Mentre abbiamo avuto una sfida per la massima input-to-output rapporto , questo è un invito più finito e deterministico di uscita con una data lunghezza di codice. Ironia della sorte, questa sfida non lo è code-golf .

Regole:

1. Scrivi tre frammenti indipendenti (non programmi / funzioni completi).

2. Gli snippet devono essere nella stessa lingua.

3. Il punteggio è il numero totale di byte emessi.

4. Le uscite possono avere la forma di un risultato, STDOUT, ecc.

5. I frammenti non possono causare alcun errore.

6. Gli snippet possono causare diverse forme di output.

7. I caratteri di nuova riga finali non vengono conteggiati.

8. Il primo frammento deve essere 1 byte o la lunghezza minima che produce almeno 1 byte di output.

9. Il secondo frammento deve essere un byte più lungo di quello.

10. Il terzo frammento deve essere più lungo di due byte rispetto al primo.

gs2, 412 + 5,37 * 10 ⁹⁰² + 10 ^{10 903,1} byte

1. fspinge 1\n2\nFizz\n4\nBuzz\n...\nFizzBuzzcome una 412stringa di byte.

2. fôstampa tutte le sue permutazioni, quindi i 412! * 412personaggi.

3. fôôstampa tutte le permutazioni di quell'elenco di elementi 412!, dove ogni elemento è lungo 412 caratteri, quindi 412 * (412!)!byte.

EDIT: per mettere le cose in prospettiva, questo è almeno

10^{1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000}

byte, sminuendo tutte le altre risposte qui finora.

Pyth, 26 + 1140850688 + (> 4.37 × 10 ^20201781 )

Non ho idea se è possibile calcolare la lunghezza esatta dell'output per il terzo programma. Posso solo dare dei confini. Stamperà qualcosa tra 4.37 × 10^20201781e 1.25 × 10^20201790personaggi.

G
yG
yyG

Questo stampa:

abcdefghijklmnopqrstuvwxyz
['', 'a', 'b', ..., 'abcdefghijklmnopqrstuvwxyz']
[[], [''], ['a'], ['b'], ['c'], ..., ['', 'a', 'b', ..., 'abcdefghijklmnopqrstuvwxyz']]

Il primo stampa l'alfabeto, il secondo tutti i sottoinsiemi dell'alfabeto e il terzo i sottoinsiemi dei sottoinsiemi dell'alfabeto, che è un elenco di lunghezza 2^(2^26) ~= 1.09 × 10^20201781.

Ovviamente nessun computer sarà mai in grado di calcolare questo grande elenco e produrlo.

CJam, 17 + 34 + 72987060245299200000 = 72987060245299200051 byte di output

Per un confronto più semplice, si tratta di circa 7,3 * 10 ¹⁹ .

P
PP
Ke!

stampe:

3.141592653589793
3.1415926535897933.141592653589793
012345678910111213141516171819012345678910111213141516171918012...

Bene, l'ultimo è costituito da tutte le permutazioni di [0 1 2 ... 19]con i numeri schiacciati insieme. Non consiglierei di provarlo ... (Provalo come 4e!per avere un assaggio.)

Provalo qui: Programma 1 , Programma 2 , Versione sana del programma 3 .

Gelatina , 1,2 × 10 ²⁵⁶⁸ byte di output

ȷ
ȷ*
ȷ*!

Calcola 1000 , 1000 ¹⁰⁰⁰ e 1000 ^1000! .

Provalo online: primo programma | secondo programma | terzo programma (modificato)

Ai fini del conteggio dei byte, ȷpuò essere codificato come byte 0xa0 nella versione corrente di Jelly .

Come funziona

In Jelly, ȷpuò essere usato all'interno di letterali numerici come Python e(notazione scientifica). Ad esempio, 3ȷ4restituisce 30000 . Nella notazione scientifica di Jelly, il coefficiente viene impostato automaticamente su 1 e l'esponente su 3 , quindi ȷ, 1ȷ3e 1000tutti restituiscono lo stesso numero.

ȷ      Return 1000.

ȷ      Return 1000.
       Parse the remaining code as a program with input 1000.
 *     Hook; compute 1000 ** 1000.

ȷ      Return 1000.
       Parse the remaining code as a program with input 1000.
  !    Return 1000!.
 *     Fork; compute 1000 ** 1000!.

Esagonia , 1 + 3 + 6 = 10 byte di output

Beh ... non è un punteggio molto impressionante, ma almeno posso affermare che è ottimale. Con un singolo byte è impossibile stampare qualcosa e terminare, quindi iniziamo con due byte:

!@

Il codice spiegato è

 ! @
. . .
 . .

Questo stampa un byte e termina.

Per tre byte di codice, possiamo stampare tre byte di output. Per esempio:

o!@

o spiegato:

 o !
@ . .
 . .

stampe 111. Qualsiasi lettera minuscola da dalle zopere e stampe il suo codice di carattere. Questi sono gli unici 23 modi per stampare 3 byte con 3 byte di codice.

Infine, per quattro byte, ci sono 169 modi per stampare 6 byte. Dal momento che nessuno di loro fa qualcosa di più interessante (ad eccezione del flusso di controllo dispari) della soluzione diretta, presenterò che:

o!!@

non piegato:

 o !
! @ .
 . .

Hai indovinato. Esso stampa 111111.

Come faccio a sapere che sono ottimali? Ho adattato il forcer brutale che ho scritto per il catalogo di macchine per la verità per cercare la massima resa finita in 7000 cicli (non credo che tu possa scrivere un castoro occupato con 4 byte, che funziona per 7000 cicli ma termina ancora in seguito).

Scherzi a parte, 2025409 byte

1 byte:

N

(produce 11.756 byte di output)

2 byte:

Nñ

Produce 153.717 byte di output

3 byte:

9!!

Produce 1.859.936 byte di output

Seriamente non presenta ancora elementi come "tutti i sottoinsiemi" o "tutte le combinazioni", quindi i punteggi relativamente bassi su questo.

Python 3, 1 + 22 + 23 = 56

9
id
abs

Produzione

9
<built-in function id>
<built-in function abs>

Stampa 9 e quindi la definizione di ide abs.

Labirinto , 1 + 2 + 4 = 7 byte

Un altro punteggio basso, che sto pubblicando principalmente perché l'ho dimostrato ottimale per la lingua.

Come Hexagony, Labyrinth non può stampare e terminare con un singolo byte, quindi iniziamo con due byte:

!@

Stampa uno zero e termina.

Per tre byte, non possiamo battere la soluzione ingenua:

!!@

Questo stampa due byte prima di terminare. Ci sono alcune altre opzioni, come la stampa -1con (!@o ~!@o ,!@. Esiste una soluzione piuttosto interessante che utilizza la rotazione del codice sorgente:

!>@

Questo stampa uno zero, quindi sposta la fonte per diventare @!>. A quel punto colpisce un vicolo cieco, si gira ed esegue il! nuovo sulla via del ritorno, prima di terminare.

Per quattro byte, è un po 'più divertente, perché l' unico modo per stampare 4 caratteri è usare il trucco di cui sopra:

!!>@

Stampa due zero, passa a @!!>, stampa altri due zero.

In tutti questi casi, sto ignorando che puoi anche stampare un byte con \o ., perché quelli stamperanno sempre esattamente un byte, mentre !stamperanno almeno uno e potenzialmente diversi.

Bash, 1726 byte

(L'ho risolto ora. Per favore, considera l'upgrade.)

1 byte :"

Uscite:

>

307 byte: id

Uscite:

uid=501(geokavel) gid=20(staff) groups=20(staff),701(com.apple.sharepoint.group.1),12(everyone),61(localaccounts),79(_appserverusr),80(admin),81(_appserveradm),98(_lpadmin),33(_appstore),100(_lpoperator),204(_developer),395(com.apple.access_ftp),398(com.apple.access_screensharing),399(com.apple.access_ssh)

1418 byte: zip (stampa su STDOUT)

Copyright (c) 1990-2008 Info-ZIP - Digitare 'zip "-L"' per la licenza software.
Zip 3.0 (5 luglio 2008). Uso:
zip [-options] [-b path] [-t mmddyyyy] [-n suffixes] [elenco zipfile] [-xi list]
  L'azione predefinita è aggiungere o sostituire le voci del file zip dall'elenco, che
  può includere il nome speciale - per comprimere l'input standard.
  Se il file zip e l'elenco sono omessi, zip comprime stdin in stdout.
  -f aggiornamento: solo i file modificati -u aggiornamento: solo i file modificati o nuovi
  -d cancella le voci nel file zip -m sposta nel file zip (elimina i file del sistema operativo)
  -r ricorre nelle directory -j nomi di directory spazzatura (non registrare)
  -0 memorizza solo -l converti LF in CR LF (-ll CR LF in LF)
  -1 comprimere più velocemente -9 comprimere meglio
  -q operazione silenziosa -v operazione dettagliata / informazioni sulla versione di stampa
  -c aggiungi commenti di una riga -z aggiungi il commento del file zip
  - @ leggi i nomi da stdin -o rende zipfile vecchio come l'ultima voce
  -x esclude i seguenti nomi -i includo solo i seguenti nomi
  -F fix zipfile (-FF provare di più) -D non aggiungere voci di directory
  -A regolare exe autoestraente -J prefisso file zip junk (unzipsfx)
  -T verifica l'integrità del file zip -X eXclude gli attributi del file eXtra
  -y memorizza collegamenti simbolici come collegamento anziché come file di riferimento
  -e crittografa -n non comprime questi suffissi
  -h2 mostra più aiuto

MATL , 313

Viene utilizzata la versione corrente del linguaggio ( 3.1.0 ), che è precedente a questa sfida.

1. Codice (letterale predefinito: produce il numero 2, che è implicitamente stampato):

   H
   

   Uscita (1 byte):

   2
   

2. Codice (produce il numero pi, che è implicitamente stampato con 15 decimali):

   YP
   

   Uscita (17 byte):

   3.141592653589793
   

3. Codice (numeri da 1 a 99, che vengono stampati di default con spazi in mezzo):

    99:
   

   Uscita (295 byte):

   1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
   

Elaborazione, 39 byte

Deterministico

1 byte :

print(X);

Uscite 0.

9 byte :

print(PI);

Uscite 3.1415927

29 byte :

print(P3D);

Uscite processing.opengl.PGraphics3D

Non deterministico,> = 129 byte

> = 32 byte:

print(g);

Uscite processing.awt.PGraphicsJava2D@ + [mem-address]

> = 32 byte:

print( g);

Uscite processing.awt.PGraphicsJava2D@ + [mem-address]

> = 65 byte: (Grazie a @anOKsquirrel per questo suggerimento.)

print(g,g);

Uscite

processing.awt.PGraphicsJava2D@ + [mem-address]
processing.awt.PGraphicsJava2D@ + [mem-address]

JavaScript, 1 + 3 + 18 = 18 22

Non è una risposta molto interessante ma probabilmente il miglior JavaScript è in grado di farlo.

alert(1)
alert(.1)
alert(1/9)

Aggiunti 4 punteggi grazie a @UndefinedFunction !

Output come testo:

1
0.1
0.1111111111111111

Befunge, 2 + 4 + 6 = 12

.@
..@
...@

Qualsiasi frammento inferiore alla lunghezza 2 non può essere emesso o non può terminare il suo output.

In Befunge, .genera il valore superiore dello stack come numero intero, seguito da uno spazio. Uno spazio non è una nuova riga, quindi è incluso nel conteggio. Inoltre, lo stack è "infinitamente" riempito con 0, quindi i programmi emettono (rispettivamente):

0 
0 0 
0 0 0 

SmileBASIC, 1 + 4 + 10 = 15 byte

Programma 1:

Il modo più breve per stampare qualcosa è con? (STAMPA) e un singolo carattere. Può essere un numero o un nome di variabile e non importa poiché hanno tutti la stessa lunghezza.

?1
1

Programma 2:

Ora abbiamo accesso ad alcune altre cose. L'espressione più lunga che può essere fatta sarebbe una delle costanti #Y, #L o #R, che hanno valori 128, 256 e 512, rispettivamente. Tuttavia, invece, utilizzo una virgola in modo che (in questo caso) vengano stampati 3 spazi extra.

?1,
1   

Programma 3:

Con 3 caratteri, puoi scrivere numeri di notazione elettronica:

?1E9
1000000000

HQ9 +, 71304

9

Stampa il testo di 11.884 caratteri di "99 bottiglie di birra"

99

Stampa "99 bottiglie di birra" due volte

999

Stampa "99 bottiglie di birra" tre volte

Japt -Q, output 1.0123378918474279e+150byte

Il numero completo è

1,012,337,891,847,427,807,734,770,805,740,683,255,348,979,141,331,502,541,182,800,555,980,960,810,784,280,906,237,433,006,787,771,597,919,201,659,212,694,207,520,340,705,280,000,000,000,000,000,000,568

byte.

# 1

M

Uscite

{"P":3.141592653589793,"Q":1.618033988749895,"T":6.283185307179586}

Per 67 byte. (Ringraziamo Shaggy)

# 2

LÆ

Uscite

[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null]

che è 501 byte.

(Credito a @Shaggy)

# 3

;Eá

Emette tutte le permutazioni dei 95 caratteri ASCII stampabili nel formato ["...","...","..."...], che è

$1,012,337,891,847,427,807,734,770,805,740,683,255,348,979,141,331,502,541,182,800,555,980,960,810,784,280,906,237,433,006,787,771,597,919,201,659,212,694,207,520,340,705,280,000,000,000,000,000,000,001$ bytes of output.

You can get an infinite amount of output bytes if you use the -F flag in Japt. What it does is that if the last expression of the program evaluates to false, it outputs the value specified in the flag instead. So I guess the score for Japt-F"Insert Super Long String Here" is infinity.

Malbolge, 1 + 2 + 3 = 6 bytes

(=aN
(&a`M
(=a`_L

Try it online: first, second, third

Outputs:

r
ll
xxx

Brute forced. Assumes \0 is not a valid output character

With \0:

cP
cbO
cbaN

Outputs:

\0
\0\0
\0\0\0

scg, 1 + 27 + 188 = 216

First one:

1

Just prints 1, as the stack is outputted at the end of program.

Second:

.d

Prints debug info, which should look like this:

Stack: []
Array Markers: []

Third:

99r

adds 99 to stack, then uses range function. Outputs 01234567891011.... (this is one of those times I wish I implemented the factorial function. I haven't)

Marbelous 1 + 1 + 2 = 4 bytes of output

Marbelous is hamstrung here by having two-byte instructions. Pointless comments or unnecessary whitespace are the only ways to get an odd byte count.

print "A" and terminate:

`A

print "B" and terminate, with an empty EOL comment

`B#

print "CD" and terminate:

`C`D

Mathematica, 6 + 461 + 763 = 1230 1225 618 163 bytes of output

%  (* -> Out[0] *)

?D  (* ->

D[f, x] gives the partial derivative ∂ f/∂ x. 
                                              n        n
D[f, {x, n}] gives the multiple derivative ∂  f/∂ x . 
D[f, x, y, …] differentiates f successively with respect to x, y, ….
D[f, {{x , x , …}}] for a scalar f
        1   2
     gives the vector derivative (∂ f/∂ x , ∂ f/∂ x , …). 
                                             1             2
D[f, {array}] gives a tensor derivative.

*)

?Do (* ->

Do[expr, {i   }] evaluates expr i    times. 
           max                   max
Do[expr, {i, i   }] evaluates expr with the variable i successively taking on the values 1 through i    (in steps of 1). 
              max                                                                                   max
Do[expr, {i, i   , i   }] starts with i = i   . 
              min   max                    min
Do[expr, {i, i   , i   , di}] uses steps di. 
              min   max
Do[expr, {i, {i , i , …}}] uses the successive values i , i , ….
               1   2                                     1   2
Do[expr, {i, i   , i   }, {j, j   , j   }, …] evaluates expr looping over different values of j, etc. for each i. 
              min   max        min   max

*)

Currently, the last two use Information to get documentation about the symbols, which can output many bytes. Note that this was run on the 10.1 command-line MathKernel.

Javascript, 72 bytes

This works in the Mozilla JSShell Javascript command line interpreter.

1 byte: 1

Outputs 1

35 bytes: gc

Outputs

function gc() {
    [native code]
}

36 bytes: run

Outputs

function run() {
    [native code]
}

Octave, 2818417 bytes

e

14 bytes for ans = 2.7183\n

pi

14 bytes for ans = 3.1416\n

doc

Display the entire documentation. 2818389 bytes, counted with dd Try it online! because evalc didn't work.

SmileBASIC 4, 1 + 13 + 15 = 29 bytes

This is going to be similar to 12Me21's SmileBASIC 3 answer, with a couple adjustments.

1

As before, the shortest amount of code to produce some output is 2 bytes: ? (PRINT) and some single-byte expression. The consensus is that PRINT does not produce a newline when it advances to the next line, due to the way the text screen works. So this results in one byte of output.

?1
1

2

With 3 bytes, we can do something different. SB4 introduces INSPECT, aliased as ??, which prints info about a single value. If we give it an empty string, for example, this can produce much more output than SB3 could. This gets us 13 bytes.

??"
STRING: (0)""

3

We have 4 bytes to work with, so we have to decide what we should do to maximize our output. Going with ?? is a safe bet; we only have 2 bytes to use on our expression, but the additional output of INSPECT is basically free. So I use it to print a label string. This is 15 bytes.

??@A
STRING: (2)"@A"

The total is 29 bytes.

Microscript II, 23+47+71=141 bytes

1: C

The stringification of continuations is not strictly defined by the specs, but in the reference implementation this, run on its own, yields a 23 byte string.

<Continuation @t=\d\d\dus> (\d represents a digit, which digits varies).

On my computer, at least, this does, in fact, always take between about 180 and about 400 microseconds to run.

The first use I've ever actually had for this instruction.

2: CP

47 bytes of output- the output from the first one twice with a newline in between.

3: CPP

Fairly straightforward. 71 bytes of output- the output from the first one three times with newlines in between.

PowerShell, ~4300 bytes

Approximate output length, given the system that it's run on. All the snippets below are deterministic, in that if given the same initial state of the computer will output the same text, just that in practice the output could change from execution to execution.

Length 1, 107 bytes

?

This is an alias for Where-Object. It will output a user prompt asking for additional information:

cmdlet Where-Object at command pipeline position 1
Supply values for the following parameters:
Property: 

Length 2, 113 bytes

rp

This is an alias for Remove-ItemProperty. It will output a user prompt asking for additional information:

cmdlet Remove-ItemProperty at command pipeline position 1
Supply values for the following parameters:
Path[0]: 

Just barely longer than the length 1 snippet.

Length 3, ~4100 bytes

gps

This is an alias for Get-Process which will output a formatted table of all running processes on the system:

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName                                                                                          
-------  ------    -----      ----- -----   ------     -- -----------                                                                                
     85       8     1232       4452    46     0.14    544 armsvc                                                                                               
    151      10     6800       9888    39     0.58   5116 audiodg                                                                                              
    480      25     6060      17200   124     0.84   4536 AuthManSvr            
...

Javascript, 312 + 318 + 624 = 1254 bytes of output

$
$$
$+$

The two functions $ and $$ are available in all major browsers' consoles, as shortcuts for document.querySelector and document.querySelectorAll respectively. Different browsers have native code coerced to strings somewhat differently from each other, and IE uses plain JS in each function resulting in much longer representation.

For the byte count, I'm taking the length of the string representation of each rather than the sometimes-modified console display, so the total bytes are, for each of the following browsers:

• Chrome: 56 + 57 + 112 = 225 bytes
• IE: 312 + 318 + 624 = 1254
• Firefox: 33 + 33 + 66 = 132

(I'm considering the IE result to be the "official" count because it's the longest.)

For non-console browser environments, the largest outputs come from the following:

1
!1 // Or '{}' if being fed to a function instead of beginning a statement
Map

Results length by browser:

• Chrome: 1 + 5 (or 15 if {} is usable) + 32 = 38 (or 48) bytes
• IE: 1 + 5 (or 15 if {} is usable) + 38 = 44 (or 54)
• Firefox: 1 + 5 (or 15 if {} is usable) + 36 = 42 (or 52)

These two sets of input produce the largest output possible in all of these browsers and consoles. To prove this, let's check all alternatives:

• Existing variables: We can find all native available variables with maximum three characters with Object.getOwnPropertyNames(window).filter(x=>x.length<=3), and then map them to their string outputs to determine the larger ones. (Note that in some browsers such as Firefox, certain special console variables cannot be accessed this way as they're not a property of the window.)
• JS has a limited number of types of literals that can be created with so few characters:
  • Per the spec, decimal numbers must be a decimal digit (1234567890) optionally followed by . and more decimal digits and/or an exponent part, or be a . followed by one or more decimal digits and optionally an exponent part. Other kinds of numbers must be either 0o, 0x, or 0b (or uppercase forms), followed by one or more digits. For our purposes, we can deduce the following:
    • There are only ten single-character numbers, which are the integers 0 through 9. The only two-character numbers are integers 0-99 (0-9 by adding a decimal after), and the numbers 0.1 through 0.9 by omitting the initial zero. The only three-character numbers are 0-999, including 0x0-0xf, 0o0-0o7, 0b0, and 0b1, the exponential 1e1 through 9e9 (10 characters), and the numbers 0.1-9.9 and .01 through .99. While not technically a number literal, NaN can also be referenced in three characters.
  • Strings, arrays, and regexps, each of which can take at max only a single character of content. An array could be filled with $, a comma, or a single-digit number. Arrays with only one element are coerced to strings as the element itself. Empty arrays become empty strings.
  • Depending on environment, it may or may not be possible to create simple objects with three characters. Normally, {} alone at the beginning of a script would be treated as an enclosure rather than creating an object. eval({}) returns undefined, eval({$}) returns the $ function. There are insufficient characters to surround the {} in ().
• There are no keywords that are short enough to use. The keywords if, in, do, new, for, try, var, and let would all require a minimum of two other characters to use, exceeding the limit.
• Available unary operators include ~, +, -, !, ++, and --. The two-character operators can only be used with a single character variable, of which there is only one ($), which yields NaN. The other four operators can be used with any one- or two- character value, of which there are:
  • Several variables. (On some consoles $, $_, $0, $1, $2, $3, $4, $, $$, $x ). When used with these operators, the results are limited to -1, true, false, and NaN.
  • 109 numbers. Results: Integers -100 through 99, -0.9 through -0.1, true, false.
  • Empty strings. Results: -1, 0 (-0 becomes 0 on toString), true.
  • The results of any of the one-character values above associated with a one-character unary operator. New results: None.
• Usable binary operators (which must be a single character to have room left for both operands) are +, -, *, /, %, <, >, &, |, ^. They can only be used with a single-character value on each side. Options for values include $ and integers 0-9. Results of all combinations of these include Infinity, some numbers and binary values mentioned above, and numerous fractions which are coerced to strings of 19 characters or less (1/7 is 19 characters, unlike 1/9 suggested above which is only 18), and the text representation of $ preceded or followed by a single-digit integer or itself.
• Finally, all remaining operators and expressions: The member operator . requires an existing variable and a identifier referring to a property. All uses of this here result in undefined. Surrounding a value in ( ) returns the value, as does assigning it with =. Using () or `` to call a value as a function results in undefined or errors with all available values.

Adding all this up, there are a grand total of 1651 possible outputs when using a Chrome console. The longest outputs for one, two, and three characters are from $, $$, and $+$ respectively.

dc, 2+5+18=25 bytes

1: Ff yields (Try it online!):

15

2: Fdf yields (Try it online!):

15
15

3: Fd^f yields (Try it online!)

437893890380859375

None of which are particularly interesting, but dc isn't really great for spitting out piles of output. I do like that each answer builds on the previous. Anyway, F is just the number 15; f prints the entire stack; d duplicates top-of-stack; ^ raises next-to-top-of-stack to the power of top-of-stack (in this case, 15^15). I don't believe this can be topped in dc.

Ruby, 3+14+28 = 45 bytes

Why did I do this.

p

Prints nil.

$>

Prints #<IO:<STDOUT>>.

dup

Prints something along the lines of #<Object:0x0000000003610988>.

irb

Launches an instance of Interactive Ruby. Upon exiting, the returned object is #<IRB::Irb: @context=#<IRB::Context:0x0000000003643040>, @signal_status=:IN_EVAL, @scanner=#<RubyLex:0x00000000038900a0>> for 121, but since it requires you to press ^D or something to actually exit the irb instance, I wasn't sure if it'd actually count as a solution in "3 bytes" so I'm not actually including it in the score unless it gets an OK.

Perl 6, 53 (17 + 18 + 18) bytes

e
-e
e*e

1. e outputs $e$ to 15 decimal places
2. -e outputs $-e$ to 15 decimal places
3. e*e outputs $e^2$, but oddly, it gives one more decimal place

Runic Enchantments, 4,000,000 bytes of output

The first program is:

a@

Takes 2 bytes to: push a value to the stack, print a value from the stack, and terminate. In this case it prints 10 (though any integer value from 0 to 16 are also just as valid)

For 3 bytes:

aY@

Prints 10000, Again, a could be 1 through 16 inclusive (in order to generate more output than the original program, 0 is potentially valid under other operators) and there aren't a whole lot of operators that take a single input and produce any output, much less longer output. XCYZ:E are the only real options. aY@ is just the one that results in the most output.

P$!;

According to language specification, this runs infinitely. However as the interpreter has a built in "ok, that's enough" maximum execution limit, this is the most output achievable in 4 characters (and TIO cuts off execution after ~130,000 bytes for exceeding 128kib) and as the interpreter defines the language, this works. And while I have raised that threshold once before (from 10k steps to 1 million), I don't plan on messing with it any time soon.

Bigger?

If I invoke the three assumptions I made here, then sure.

`AA@

Which works out to Ack(65,Ack(65,64)), which aren't terribly large values to go shoving into the Ackerman function initially--certainly smaller than the 255 in the older post--but its ok, we can call Ack twice in 4 instructions.

And only god knows what it'll print.

_{Note: the A instruction has since then been made the Math meta-instruction, which consumes 3 objects on the stack: a char for what instruction to perform and then two inputs, x and y. As such this program doesn't actually do anything, both because neither A nor @ map to a math function and because two subsequent calls results in a stack underflow.}