Offensichtlich geht es beim Codegolf darum, das Beste aus dem wenigsten Code zu machen. Wen kümmert es wirklich, was die tatsächliche Ausgabe ist?

Während wir die Herausforderung hatten, das beste Input-Output- Verhältnis zu erzielen , ist dies eine Forderung nach einer möglichst endlichen und deterministischen Ausgabe mit vorgegebenen Codelängen. Ironischerweise ist diese Herausforderung dann nicht Code-Golf .

Regeln:

1. Schreiben Sie drei unabhängige Ausschnitte (nicht vollständige Programme / Funktionen).

2. Die Snippets müssen in derselben Sprache sein.

3. Score ist die Gesamtzahl der ausgegebenen Bytes.

4. Ausgaben können in Form eines Ergebnisses, STDOUT usw. erfolgen.

5. Die Schnipsel dürfen keinen Fehler verursachen.

6. Die Snippets können unterschiedliche Ausgabeformen verursachen.

7. Nachgestellte Zeilenumbrüche werden nicht gezählt.

8. Das erste Snippet muss 1 Byte oder die Mindestlänge sein, die mindestens 1 Byte Ausgabe erzeugt.

9. Das zweite Snippet muss ein Byte länger sein.

10. Das dritte Snippet muss zwei Byte länger sein als das erste.

gs2, 412 + 5,37 · 10 ⁹⁰² + 10 ^{10 903,1} Bytes

1. fdrückt 1\n2\nFizz\n4\nBuzz\n...\nFizzBuzzals 412-Byte String.

2. fôdruckt alle seine Permutationen, also 412! * 412Zeichen.

3. fôôGibt alle Permutationen dieser 412! -Element-Liste aus, wobei jedes Element 412 Zeichen lang ist, also 412 * (412!)!Bytes.

EDIT: Um die Dinge in die richtige Perspektive zu rücken, ist dies zumindest

10^{1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000}

Bytes, die alle bisherigen Antworten hier in den Schatten stellen.

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

Ich habe keine Ahnung, ob es möglich ist, die genaue Länge der Ausgabe für das dritte Programm zu berechnen. Ich kann nur Grenzen setzen. Es wird etwas dazwischen drucken4.37 × 10^20201781 und 1.25 × 10^20201790Zeichen .

G
yG
yyG

Dies druckt:

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

Der erste druckt das Alphabet, der zweite alle Untergruppen des Alphabets und der dritte die Untergruppen der Untergruppen des Alphabets, bei denen es sich um eine Liste mit Längen handelt 2^(2^26) ~= 1.09 × 10^20201781.

Offensichtlich wird kein Computer jemals in der Lage sein, diese große Liste zu berechnen und auszugeben.

CJam, 17 + 34 + 72987060245299200000 = 72987060245299200051 Bytes der Ausgabe

Zum leichteren Vergleich sind dies ca. 7,3 * 10 ¹⁹ .

P
PP
Ke!

Drucke:

3.141592653589793
3.1415926535897933.141592653589793
012345678910111213141516171819012345678910111213141516171918012...

Nun, die letzte besteht aus allen Permutationen, bei [0 1 2 ... 19]denen die Zahlen zusammengequetscht sind. Ich würde es nicht empfehlen, es auszuprobieren ... (Versuchen Sie es, als 4e!ob Sie einen Vorgeschmack bekommen möchten .)

Testen Sie es hier: Programm 1 , Programm 2 , Sane-Version von Programm 3 .

Jelly , 1,2 × 10 ²⁵⁶⁸ Bytes Ausgabe

ȷ
ȷ*
ȷ*!

Berechnet 1000 , 1000 ¹⁰⁰⁰ und 1000 ^1000!.

Probieren Sie es online aus: erstes Programm | zweites Programm |drittes Programm (modifiziert)

ȷKann zu Zwecken der Bytezählung in der aktuellen Version von Jelly als Byte 0xa0 codiert werden .

Wie es funktioniert

ȷKann in Jelly in Zahlenliteralen als Python's e(wissenschaftliche Notation) verwendet werden. Zum Beispiel 3ȷ4gibt 30000 . In Jelly wissenschaftlicher Notation, die Koeffizientenstandardmäßig auf 1 und die Exponenten standardmäßig auf 3 , so ȷ, 1ȷ3und 1000alle die gleiche Anzahl zurück.

ȷ      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!.

Hexagonie , 1 + 3 + 6 = 10 Bytes der Ausgabe

Naja ... kein sehr beeindruckendes Ergebnis, aber ich kann zumindest behaupten, dass es optimal ist. Mit einem einzelnen Byte ist es unmöglich, etwas auszudrucken und zu beenden, also beginnen wir mit zwei Bytes:

!@

Der entfaltete Code ist

 ! @
. . .
 . .

Dies gibt ein Byte aus und wird beendet.

Für drei Byte Code können drei Byte Ausgabe gedruckt werden. Zum Beispiel:

o!@

oder entfaltet:

 o !
@ . .
 . .

druckt 111. Jeder Kleinbuchstabe von dbis zfunktioniert und druckt seinen Zeichencode. Dies sind die einzigen 23 Möglichkeiten, 3 Byte mit 3 Byte Code zu drucken.

Schließlich gibt es für vier Bytes 169 Möglichkeiten, 6 Bytes zu drucken. Da keiner von ihnen etwas Interessanteres tut (mit Ausnahme eines ungeraden Kontrollflusses) als die einfache Lösung, werde ich Folgendes vorstellen:

o!!@

Entfaltet:

 o !
! @ .
 . .

Du hast es erraten. Es druckt 111111.

Woher weiß ich, dass diese optimal sind? Ich habe den Brute Forcer, den ich für den Wahrheitskatalog geschrieben habe, so angepasst , dass er in 7000 Zyklen nach maximaler Endlichkeit sucht.

Im Ernst, 2025409 Bytes

1 Byte:

N

(Erzeugt 11.756 Bytes an Ausgabe)

2 Bytes:

Nñ

Erzeugt 153.717 Byte Ausgabe

3 Bytes:

9!!

Erzeugt 1.859.936 Ausgabebytes

Im Ernst noch nicht mit Dingen wie "alle Teilmengen" oder "alle Kombinationen", so dass dies relativ schlecht abschneidet.

Python 3, 1 + 22 + 23 = 56

9
id
abs

Ausgabe

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

Drucken Sie 9 und dann die Definition für idund abs.

Labyrinth , 1 + 2 + 4 = 7 Bytes

Eine weitere niedrige Punktzahl, die ich hauptsächlich poste, weil ich bewiesen habe, dass sie für die Sprache optimal ist.

Wie Hexagony kann Labyrinth nicht mit einem einzigen Byte drucken und enden. Wir beginnen also mit zwei Bytes:

!@

Gibt eine Null aus und endet.

Für drei Bytes können wir die naive Lösung nicht schlagen:

!!@

Dies druckt zwei Bytes vor dem Beenden. Es gibt noch einige andere Optionen, beispielsweise das Drucken -1mit (!@oder ~!@oder ,!@. Es gibt jedoch eine ziemlich coole Lösung, die die Quellcode-Rotation verwendet:

!>@

Dies gibt eine Null aus und verschiebt dann die Quelle zu @!>. An diesem Punkt stößt es auf eine Sackgasse, dreht sich um und führt das aus! auf dem Rückweg noch einmal aus, bevor es endet.

Für vier Bytes macht es ein bisschen mehr Spaß, da der einzige Weg, um 4 Zeichen zu drucken, darin besteht, den obigen Trick zu verwenden:

!!>@

Zwei Nullen @!!>drucken , verschieben zu , zwei weitere Nullen drucken.

In all diesen Fällen ignoriere ich, dass Sie auch ein Byte mit \oder drucken können ., da diese immer genau ein Byte ausgeben, während !mindestens eines und möglicherweise mehrere ausgegeben werden.

Bash, 1726 Bytes

(Ich habe es jetzt behoben. Bitte überlegen Sie, ob Sie abstimmen möchten.)

1 Byte :"

Ausgänge:

>

307 Bytes: id

Ausgänge:

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 Bytes: zip (Druckt nach STDOUT)

Copyright (c) 1990-2008 Info-ZIP - Geben Sie "zip" -L "für die Softwarelizenz ein.
Zip 3.0 (5. Juli 2008). Verwendung:
zip [-Optionen] [-b Pfad] [-t mmddyyyy] [-n Suffixe] [zipfile Liste] [-xi Liste]
  Die Standardaktion ist das Hinzufügen oder Ersetzen von Zipfile-Einträgen aus der Liste
  kann den speziellen Namen enthalten - um die Standardeingabe zu komprimieren.
  Wenn zip-Datei und Liste weggelassen werden, komprimiert zip stdin auf stdout.
  -f freshen: nur geänderte Dateien -u update: nur geänderte oder neue Dateien
  -d lösche Einträge in zipfile -m verschiebe in zipfile (lösche OS Dateien)
  -r rekursiv in Verzeichnisse -j Junk-Verzeichnisnamen (nicht aufzeichnen)
  -0 Nur speichern -l LF in CR LF konvertieren (-ll CR LF in LF)
  -1 komprimiere schneller -9 komprimiere besser
  -q leiser Betrieb -v ausführlicher Betrieb / Druckversionsinfo
  -c füge einzeilige Kommentare hinzu -z füge einen Zipfile-Kommentar hinzu
  - @ read names from stdin -o macht zipfile so alt wie der neueste Eintrag
  -x schließt die folgenden Namen aus -i schließt nur die folgenden Namen ein
  -F Fix zipfile (-FF stärker versuchen) -D Verzeichniseinträge nicht hinzufügen
  -Einstellen der selbstextrahierenden exe -J Junk Zipfile Präfix (unzipsfx)
  -T Test der Zip-Datei-Integrität -X eXclude eXtra-Dateiattribute
  -y speichere symbolische Links als Link anstelle der referenzierten Datei
  -e verschlüssle -n komprimiere diese Suffixe nicht
  -h2 zeige mehr Hilfe

MATL , 313

Die aktuelle Version der Sprache ( 3.1.0 ) verwendet, die älter als diese Herausforderung ist.

1. Code (vordefiniertes Literal: Erzeugt Nummer 2, die implizit gedruckt wird):

   H
   

   Ausgabe (1 Byte):

   2
   

2. Code (erzeugt die Zahl pi, die implizit mit 15 Dezimalstellen gedruckt wird):

   YP
   

   Ausgabe (17 Bytes):

   3.141592653589793
   

3. Code (Zahlen von 1 bis 99, die standardmäßig mit Leerzeichen dazwischen gedruckt werden):

    99:
   

   Ausgabe (295 Bytes):

   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
   

Verarbeitung, 39 Bytes

Deterministisch

1 Byte :

print(X);

Ausgänge 0.

9 Bytes :

print(PI);

Ausgänge 3.1415927

29 Bytes :

print(P3D);

Ausgänge processing.opengl.PGraphics3D

Nicht deterministisch,> = 129 Bytes

> = 32 Bytes:

print(g);

Ausgänge processing.awt.PGraphicsJava2D@ + [mem-address]

> = 32 Bytes:

print( g);

Ausgänge processing.awt.PGraphicsJava2D@ + [mem-address]

> = 65 Bytes: (Vielen Dank an @anOKsquirrel für diesen Vorschlag.)

print(g,g);

Ausgänge

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

JavaScript, 1 + 3 + 18 = 18 22

Keine sehr interessante Antwort, aber wahrscheinlich das beste, zu dem JavaScript fähig ist.

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

Dank @UndefinedFunction wurden 4 Punkte hinzugefügt !

Ausgaben als Text:

1
0.1
0.1111111111111111

Befunge, 2 + 4 + 6 = 12

.@
..@
...@

Schnipsel, die kürzer als Länge 2 sind, können entweder nicht ausgegeben oder ihre Ausgabe nicht beenden.

Gibt in Befunge .den obersten Wert des Stapels als Ganzzahl gefolgt von einem Leerzeichen aus. Ein Leerzeichen ist kein Zeilenumbruch, daher wird es in die Zählung einbezogen. Zusätzlich ist der Stack "unendlich" mit Nullen gefüllt, so dass die Programme (bzw.) Folgendes ausgeben:

0 
0 0 
0 0 0 

SmileBASIC, 1 + 4 + 10 = 15 Bytes

Programm 1:

Der kürzeste Weg, um etwas zu drucken, ist mit? (DRUCKEN) und ein einzelnes Zeichen. Dies kann entweder eine Zahl oder ein Variablenname sein, und es spielt keine Rolle, da sie alle gleich lang sind.

?1
1

Programm 2:

Jetzt haben wir Zugang zu ein paar weiteren Dingen. Der längste Ausdruck, der erstellt werden kann, ist eine der Konstanten #Y, #L oder #R mit den Werten 128, 256 bzw. 512. Stattdessen verwende ich jedoch ein Komma, damit (in diesem Fall) 3 zusätzliche Leerzeichen gedruckt werden.

?1,
1   

Programm 3:

Mit 3 Zeichen können Sie E-Notationsnummern schreiben:

?1E9
1000000000

HQ9 +, 71304

9

Druckt den 11.884-stelligen Text von "99 Flaschen Bier"

99

Druckt zweimal "99 Flaschen Bier"

999

Druckt dreimal "99 Flaschen Bier"

Japt -Q, Ausgänge1.0123378918474279e+150 Bytes aus

Die vollständige Nummer lautet

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

Bytes.

# 1

M

Ausgänge

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

Für 67 Bytes. (Dank an Shaggy)

# 2

LÆ

Ausgänge

[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]

Das sind 501 Bytes.

(Dank an @Shaggy)

# 3

;Eá

Gibt alle Permutationen der 95 druckbaren ASCII-Zeichen im Format aus ["...","...","..."...] , das ist

$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 der Ausgabe.

Sie können unendlich viele Ausgabebytes erhalten, wenn Sie das -FFlag in Japt verwenden. Wenn der letzte Ausdruck des Programms false ergibt, wird stattdessen der im Flag angegebene Wert ausgegeben. Ich denke, die Punktzahl für Japt -F"Insert Super Long String Here"ist unendlich.

Malbolge , 1 + 2 + 3 = 6 Bytes

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

Probieren Sie es online aus: erstens , zweitens , drittens

Ausgänge:

r
ll
xxx

Brute gezwungen. Angenommen, es \0handelt sich nicht um ein gültiges Ausgabezeichen

Mit \0:

cP
cbO
cbaN

Ausgänge:

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

scg , 1 + 27 + 188 = 216

Erster:

1

Gibt nur 1 aus, da der Stapel am Ende des Programms ausgegeben wird.

Zweite:

.d

Gibt die Debug-Informationen aus, die folgendermaßen aussehen sollten:

Stack: []
Array Markers: []

Dritte:

99r

Fügt dem Stapel 99 hinzu und verwendet dann die Bereichsfunktion. Ausgänge 01234567891011 .... (Dies ist eines der Male, bei denen ich wünschte, ich hätte die Fakultätsfunktion implementiert. Ich habe es nicht getan.)

Marbelous 1 + 1 + 2 = 4 Bytes der Ausgabe

Marbelous wird hier durch Zwei-Byte-Anweisungen behindert. Sinnlose Kommentare oder unnötige Leerzeichen sind die einzigen Möglichkeiten, eine ungerade Byteanzahl zu erhalten.

Gib "A" aus und beende:

`A

Gib "B" aus und beende mit einem leeren EOL-Kommentar

`B#

"CD" drucken und beenden:

`C`D

Mathematica, 6 + 461 + 763 = 1230 1225 618 163 Bytes Ausgabe

%  (* -> 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

*)

Derzeit werden die letzten beiden verwendet Information, um die Dokumentation zu den Symbolen abzurufen, die viele Bytes ausgeben können. Beachten Sie, dass dies in der 10.1-Befehlszeile ausgeführt wurde MathKernel.

Javascript, 72 Bytes

Dies funktioniert im Mozilla JSShell Javascript-Befehlszeileninterpreter.

1 Byte: 1

Ausgänge 1

35 Bytes: gc

Ausgänge

function gc() {
    [native code]
}

36 Bytes: run

Ausgänge

function run() {
    [native code]
}

Oktave, 2818417 Bytes

e

14 Bytes für ans = 2.7183\n

pi

14 Bytes für ans = 3.1416\n

doc

Zeigen Sie die gesamte Dokumentation an. 2818389 Bytes, gezählt mit dd Online testen ! weil evalces nicht funktioniert hat.

SmileBASIC 4, 1 + 13 + 15 = 29 Bytes

Dies wird mit ein paar Anpassungen der SmileBASIC 3-Antwort von 12Me21 ähnlich sein.

1

Wie zuvor beträgt die kürzeste Menge an Code, um eine Ausgabe zu erzeugen, 2 Bytes: ?( PRINT) und ein Einzelbyte-Ausdruck. Der Konsens ist , dass PRINTsie nicht eine neue Zeile erzeugen , wenn es in der nächsten Zeile geht, aufgrund der Art und Weise des Textbildschirm funktioniert. Das ergibt also ein Byte Ausgabe.

?1
1

2

Mit 3 Bytes können wir etwas anderes machen. SB4 führt INSPECTmit einem Alias ​​als ein ??, der Informationen über einen einzelnen Wert ausgibt . Wenn wir zum Beispiel eine leere Zeichenfolge angeben, kann dies zu einer viel höheren Ausgabe führen als SB3. Das bringt uns 13 Bytes.

??"
STRING: (0)""

3

Wir müssen mit 4 Bytes arbeiten, also müssen wir entscheiden, was wir tun sollen, um unsere Ausgabe zu maximieren. Mitmachen ??ist eine sichere Sache; Wir haben nur 2 Bytes für unseren Ausdruck, aber die zusätzliche Ausgabe vonINSPECT ist grundsätzlich kostenlos. Also benutze ich es, um einen Etikettenstring zu drucken. Das sind 15 Bytes.

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

Die Summe beträgt 29 Bytes.

Microscript II, 23 + 47 + 71 = 141 Bytes

1: C

Die Stringifizierung von Fortsetzungen ist in den Spezifikationen nicht streng definiert, aber in der Referenzimplementierung ergibt dies, wenn es alleine ausgeführt wird, einen 23-Byte-String.

<Continuation @t=\d\d\dus> (\d Stellt eine Ziffer dar, deren Ziffern variieren).

Auf meinem Computer dauert dies in der Tat immer zwischen ungefähr 180 und ungefähr 400 Mikrosekunden.

Die erste Verwendung, die ich jemals für diese Anweisung hatte.

2: CP

47 Bytes Ausgabe - die Ausgabe der ersten zweimal mit einem Zeilenumbruch dazwischen.

3: CPP

Ziemliech direkt. 71 Bytes Ausgabe - die Ausgabe der ersten drei Mal mit Zeilenumbrüchen dazwischen.

PowerShell, ~ 4300 Byte

Ungefähre Ausgabelänge bei dem System, auf dem es ausgeführt wird. Alle folgenden Codefragmente sind deterministisch, da bei gleichem Ausgangszustand des Computers derselbe Text ausgegeben wird, nur dass sich die Ausgabe in der Praxis von Ausführung zu Ausführung ändern kann.

Länge 1, 107 Bytes

?

Dies ist ein Alias ​​für Where-Object . Es wird eine Benutzereingabeaufforderung ausgegeben, in der Sie nach zusätzlichen Informationen gefragt werden:

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

Länge 2, 113 Bytes

rp

Dies ist ein Alias ​​für Remove-ItemProperty . Es wird eine Benutzereingabeaufforderung ausgegeben, in der Sie nach zusätzlichen Informationen gefragt werden:

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

Nur knapp länger als die Länge 1 Schnipsel.

Länge 3, ~ 4100 Bytes

gps

Dies ist ein Alias, für Get-Processden eine formatierte Tabelle aller auf dem System ausgeführten Prozesse ausgegeben wird:

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 Ausgabe

$
$$
$+$

Die beiden Funktionen $und $$sind in allen gängigen Browsern Konsolen zur Verfügung, als Shortcuts für document.querySelectorund document.querySelectorAlljeweils. Unterschiedliche Browser haben systemeigenen Code, der zu etwas unterschiedlichen Zeichenfolgen gezwungen wird, und der IE verwendet in jeder Funktion einfaches JS, was zu einer viel längeren Darstellung führt.

Für die Byteanzahl nehme ich die Länge der Zeichenfolgendarstellung der einzelnen und nicht die manchmal geänderte Konsolenanzeige, sodass die Gesamtanzahl der Bytes für die folgenden Browser gilt:

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

(Ich betrachte das IE-Ergebnis als die "offizielle" Zählung, weil es die längste ist.)

In Nicht-Konsolen-Browserumgebungen stammen die größten Ausgaben aus folgenden Quellen:

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

Ergebnislänge nach Browser:

• Chrome: 1 + 5 (oder 15 wenn {} verwendbar) + 32 = 38 (oder 48) Bytes
• IE: 1 + 5 (oder 15 wenn {} verwendbar) + 38 = 44 (oder 54)
• Firefox: 1 + 5 (oder 15, falls {}verwendbar) + 36 = 42 (oder 52)

Diese beiden Eingaben erzeugen in all diesen Browsern und Konsolen die größtmögliche Ausgabe. Um dies zu beweisen, überprüfen wir alle Alternativen:

• Bestehende Variablen: Wir können mit alle nativen verfügbaren Variablen mit maximal drei Zeichen suchen Object.getOwnPropertyNames(window).filter(x=>x.length<=3)und diese dann mapan ihre String-Ausgaben anschließen, um die größeren zu ermitteln. (Beachten Sie, dass in einigen Browsern wie Firefox bestimmte spezielle Konsolenvariablen nicht auf diese Weise aufgerufen werden können, da sie keine Eigenschaft des Fensters sind.)
• JS verfügt über eine begrenzte Anzahl von Literaltypen, die mit so wenigen Zeichen erstellt werden können:
  • Gemäß der Spezifikation müssen Dezimalzahlen eine Dezimalziffer ( 1234567890), optional gefolgt von einer .oder mehreren Dezimalziffern und / oder einem Exponententeil, oder .eine oder mehrere Dezimalziffern und optional ein Exponententeil sein. Andere Arten von Zahlen muss entweder 0o, 0xoder0b (oder Groß Formen), gefolgt von einer oder mehreren Ziffern. Für unsere Zwecke können wir Folgendes ableiten:
    • Es gibt nur zehn einstellige Zahlen, die die ganzen Zahlen 0 bis 9 sind. Die einzigen zweistelligen Zahlen sind die ganzen Zahlen 0 bis 99 (0 bis 9 durch Hinzufügen einer Nachkommastelle) und die Zahlen 0,1 bis 0,9 durch Weglassen der anfänglichen Null . Die einzigen dreistelligen Zahlen sind 0-999, einschließlich 0x0-0xf, 0o0-0o7, ​​0b0 und 0b1, die Exponentialzahlen 1e1 bis 9e9 (10 Zeichen) und die Zahlen 0.1-9.9 und .01 bis .99. Obwohl es sich technisch gesehen nicht um ein Zahlenliteral handelt, kann auf NaN auch mit drei Zeichen verwiesen werden.
  • Zeichenfolgen, Arrays und reguläre Ausdrücke, von denen jeder maximal ein einzelnes Zeichen des Inhalts annehmen kann. Ein Array kann mit $einem Komma oder einer einstelligen Zahl gefüllt sein . Arrays mit nur einem Element werden als das Element selbst zu Strings gezwungen. Leere Arrays werden zu leeren Strings.
  • Je nach Umgebung ist es möglicherweise nicht möglich, einfache Objekte mit drei Zeichen zu erstellen. Normalerweise wird {}allein am Anfang eines Skripts eher als Anlage behandelt, als dass ein Objekt erstellt wird. eval({})gibt undefined zurück, eval({$})gibt die $Funktion zurück. Es gibt nicht genügend Zeichen , die umgeben {}in ().
• Es gibt keine Keywords, die kurz genug sind, um verwendet zu werden. Die Schlüsselwörter if, in, do, new, for, try, var, und letwürden alle mindestens zwei andere Zeichen erfordern die Grenze zu verwenden, zu überschreiten.
• Verfügbare unäre Operatoren umfassen ~, +, -, !, ++, und-- . Die zweistelligen Operatoren können nur mit einer einzelnen Zeichenvariablen verwendet werden, von denen es nur eine ( $) gibt, die ergibt NaN. Die anderen vier Operatoren können mit jedem ein- oder zweistelligen Wert verwendet werden. Davon gibt es:
  • Mehrere Variablen. (Auf einigen Konsolen $, $_, $0, $1, $2, $3, $4, $, $$, $x). Wenn mit diesen Betreibern verwendet wird , werden die Ergebnisse darauf beschränkt zu sein -1, true, false, und NaN.
  • 109 Nummern. Ergebnisse: Die ganzen Zahlen -100 bis 99, -0,9 bis -0,1 true, false.
  • Leere Zeichenfolgen. Ergebnisse: -1, 0( -0wird 0auf toString) true.
  • Die Ergebnisse aller oben genannten Ein-Zeichen-Werte, die einem unären Ein-Zeichen-Operator zugeordnet sind. Neue Ergebnisse: Keine.
• Nutzbare binäre Operatoren (die ein einzelnes Zeichen haben Raum für beide Operanden links sein muss) sind +, -, *, /, %, <, >, &, |, ^. Sie können nur mit einem einzelnen Zeichen pro Seite verwendet werden. Zu den Optionen für Werte gehören $und ganze Zahlen von 0 bis 9. Zu den Ergebnissen aller Kombinationen von diesen gehören Infinityeinige Zahlen und Binärwerte, die oben erwähnt wurden, sowie zahlreiche Brüche, die zu Zeichenfolgen von 19 Zeichen oder weniger ( 1/719 Zeichen, anders als 1/9oben vorgeschlagen, nur 18 Zeichen) gezwungen werden , und die Textdarstellung von $vorangestelltem oder gefolgt von einer einstelligen ganzen Zahl oder sich selbst.
• Zum Schluss alle verbleibenden Operatoren und Ausdrücke: Der Mitgliedsoperator .benötigt eine vorhandene Variable und einen Bezeichner, der sich auf eine Eigenschaft bezieht. Alle Verwendungen dieses hier führen zu undefined. Das Umgeben eines Wertes in ( )gibt den Wert zurück, ebenso wie das Zuweisen mit =. Die Verwendung von ()oder `` zum Aufrufen eines Werts als Funktion führt zu undefinierten Werten oder Fehlern mit allen verfügbaren Werten.

Zusammen ergeben sich bei Verwendung einer Chrome-Konsole insgesamt 1651 mögliche Ausgaben. Die längsten Ausgänge für eine, zwei und drei Buchstaben sind von $, $$und $+$sind.

Gleichstrom , 2 + 5 + 18 = 25 Bytes

1: FfErträge ( Online ausprobieren! ):

15

2: FdfErträge ( Online ausprobieren! ):

15
15

3: Fd^fErträge ( Online ausprobieren! )

437893890380859375

Keine davon ist besonders interessant, dceignet sich aber nicht besonders zum Ausspucken von Produktionsmengen. Mir gefällt, dass jede Antwort auf der vorherigen aufbaut. Wie auch immer, Fist nur die Nummer 15; fdruckt den gesamten Stapel; ddupliziert den Stapelanfang; ^Erhöht den Wert für "Next-to-Top-of-Stack" (in diesem Fall 15 ^ 15). Ich glaube nicht, dass das noch übertroffen werden kann dc.

Ruby, 3 + 14 + 28 = 45 Bytes

Warum habe ich das getan?

p

Druckt nil.

$>

Druckt #<IO:<STDOUT>>.

dup

Druckt etwas nach dem Vorbild von #<Object:0x0000000003610988>.

irb

Startet eine Instanz von Interactive Ruby. Beim Beenden ist das zurückgegebene Objekt #<IRB::Irb: @context=#<IRB::Context:0x0000000003643040>, @signal_status=:IN_EVAL, @scanner=#<RubyLex:0x00000000038900a0>>für 121, aber da Sie drücken ^Dmüssen, um die irb-Instanz tatsächlich zu beenden, war ich mir nicht sicher, ob es tatsächlich als Lösung in "3 Bytes" gelten würde, also bin ich es nicht es tatsächlich in die Partitur aufnehmen, es sei denn, es wird ein OK.

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

e
-e
e*e

1. e Ausgänge $e$ bis 15 Dezimalstellen
2. -e Ausgänge $-e$ bis 15 Dezimalstellen
3. e*e Ausgänge $e^2$, aber seltsamerweise gibt es noch eine Nachkommastelle

Runenverzauberungen, 4.000.000 Bytes Ausgabe

Das erste Programm ist:

a@

Nimmt 2 Bytes, um: einen Wert auf den Stapel zu legen, einen Wert vom Stapel zu drucken und zu beenden. In diesem Fall wird gedruckt 10(obwohl alle ganzzahligen Werte von 0 bis 16 ebenso gültig sind).

Für 3 Bytes:

aY@

Druck 10000, wieder a1 bis einschließlich 16 sein könnte (um mehr Leistung als das ursprüngliche Programm zu generieren, 0 unter anderen Betreibern potenziell gültig ist) , und es gibt nicht eine ganze Menge von Operatoren , die einen einzelnen Eingang nehmen und erzeugen eine Ausgabe, viel weniger längere Ausgabe. XCYZ:Esind die einzigen wirklichen Möglichkeiten. aY@ist nur derjenige, der die meiste Ausgabe ergibt .

P$!;

Dies läuft laut Sprachangabe unendlich. Da der Interpreter jedoch ein integriertes "ok, das ist genug" -Höchstausführungslimit hat, ist dies die höchste Ausgabe, die mit 4 Zeichen erreicht werden kann (und TIO unterbricht die Ausführung nach ~ 130.000 Bytes für mehr als 128 KB), und da der Interpreter die Sprache definiert , ist dies funktioniert. Und obwohl ich diese Schwelle schon einmal angehoben habe (von 10.000 Schritten auf 1 Million), habe ich nicht vor, bald damit herumzuspielen.

Größer?

Wenn ich mich auf die drei Annahmen berufe, die ich hier gemacht habe , dann sicher.

`AA@

Welches klappt Ack(65,Ack(65,64)) , das sind anfangs keine besonders großen Werte, um in die Ackerman-Funktion einzusteigen - sicherlich kleiner als die 255 in dem älteren Beitrag -, aber es ist in Ordnung, wir können Ack zweimal in 4 Befehlen aufrufen.

Und nur Gott weiß, was es drucken wird.

_{Anmerkung: Die AAnweisung wurde seitdem zur MathMetaanweisung, die 3 Objekte auf dem Stapel belegt: ein Zeichen für die auszuführende Anweisung und dann zwei Eingaben, x und y. Als solches dieses Programm nicht tut eigentlich nichts, sowohl weil weder Anoch @auf eine mathematische Funktion Karte und weil zwei nachfolgende Anrufe Ergebnisse in einem Stapel Unterlauf.}