In dieser Herausforderung sollten Sie ein Programm oder eine Funktion schreiben, die keine Eingabe akzeptiert und eine Zeichenfolge mit der gleichen Anzahl von Bytes wie das Programm selbst ausgibt oder zurückgibt. Es gibt einige Regeln:

• Sie dürfen nur Bytes im druckbaren ASCII-Bereich (0x20 bis einschließlich 0x7E) oder Newlines (0x0A oder 0x0D) ausgeben.
• Ihr Code darf kein Quine sein, daher müssen sich der Code und die Ausgabe in mindestens einem Byte unterscheiden.
• Ihr Code muss mindestens ein Byte lang sein.
• Wenn Ihre Ausgabe nachgestellte Zeilenumbrüche enthält, sind diese Teil der Bytezahl.
• Wenn für Ihren Code nicht standardmäßige Befehlszeilenflags erforderlich sind, zählen Sie diese wie gewohnt (dh, indem Sie die Differenz zu einem Standardaufruf der Implementierung Ihrer Sprache zur Byteanzahl hinzufügen), und die Länge der Ausgabe muss mit der Punktzahl Ihrer Lösung übereinstimmen. Wenn Ihr Programm beispielsweise abein nicht standardmäßiges Flag benötigt -n(wir gehen davon aus, dass es nicht mit Standard-Flags kombiniert werden kann, also 3 Byte), sollten Sie insgesamt 5 Byte ausgeben.
• Die Ausgabe muss nicht immer gleich sein, solange Sie nachweisen können, dass jede mögliche Ausgabe die oben genannten Anforderungen erfüllt.
• Übliche quine Regeln nicht gelten. Sie können den Quellcode oder seine Größe lesen, aber ich bezweifle, dass dies in den meisten Sprachen kürzer ist als das Hardcodieren.

Sie können ein Programm oder eine Funktion schreiben und eine der Standardmethoden zur Ausgabe verwenden. Beachten Sie, dass Sie beim Drucken des Ergebnisses entweder die Standardausgabe oder den Standardfehlerstrom verwenden können, aber nur einer von ihnen zählt.

Sie können jede Programmiersprache verwenden , beachten Sie jedoch, dass diese Lücken standardmäßig verboten sind.

Das ist Code-Golf , also gewinnt die kürzeste gültige Antwort - gemessen in Bytes .

Bestenliste

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>

C (modernes Linux), 19 Bytes

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

Beim Kompilieren und Ausführen wird Folgendes ausgegeben:

Segmentation fault

Excel, 11 Bytes

Norwegische Sprachversion:

=SMÅ(13^9)

Englische Sprachversion (12 Bytes):

=LOWER(17^9)

Erzeugt eine n-stellige Zahl und konvertiert sie in Text, indem sie in Kleinbuchstaben konvertiert.

Labyrinth , 4 Bytes

!!>@

Probieren Sie es online!

Druckt 0000

Erläuterung

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

Bash (nur Builtins), 8 Bytes

{e,,}cho

Drucke cho chound eine Newline.

Netzhaut , 2 Bytes

no

Probieren Sie es online!

Ausdrucke 0und ein Zeilenvorschub.

Es gibt viele 2-Byte-Lösungen, aber ich halte dies für optimal. Standardmäßig druckt die Netzhaut immer eine nachgestellte neue Zeile, und es dauert zu viele Bytes, bis sie entfernt ist. Wir müssten also ein 1-Byte-Programm finden, das die leere Eingabe unverändert lässt. Ich glaube, das einzige Programm, das dies tut, ist das Programm, das einen einzelnen Zeilenvorschub enthält, der daher der Ausgabe entspricht und daher von der Herausforderung nicht zugelassen wird.

Am einfachsten ist es, mit Retina zu leben, die eine einzelne Ziffer ausgibt (die Anzahl der Übereinstimmungen einiger regulärer Ausdrücke mit der leeren Eingabe), und dies können wir mit vielen fehlgeschlagenen (oder übereinstimmenden) 2-Byte-Mustern tun.

Mathematica, 2 Bytes

4!

Fakultät

24

C 20 Bytes

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

Gibt eine Zahl aus, die mit Leerzeichen bis zu einer Länge von 20 aufgefüllt ist. (Welche Zahl? Was auch immer als Nächstes im Speicher vorkommt.)

Einige Beispiele laufen auf meinem 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

Es ist eine Schande, dass die Ausgabe keine willkürlichen Bytes sein kann, denn das hätte diese 19-Byte-Lösung ermöglicht:

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

Die Ausgabe von 19 Byte Junk beginnt bei fder Adresse.

Bash unter Linux, 6

uname

(gefolgt von einer neuen Zeile)

Ausgaben Linuxgefolgt von einem Zeilenumbruch.

Javascript ES6, 9 Bytes

Verwenden von Vorlagenzeichenfolgen

_=>`${_}`

f=

_=>`${_}`

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

Pyramidenschema , 74 43 42 Bytes

Dank Khuldraeseth na'Barya 31 Bytes gespart! Dank der überarbeiteten JoKing-Lösung 1 Byte gespart!

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

Probieren Sie es online! Gibt die 41-stellige Nummer aus 28^28 = 33145523113253374862572728253364605812736, gefolgt von einer nachgestellten Zeile.

Alte Version

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

Probieren Sie es online!

Ausgänge 71277303925397560663333806233294794013421332605135474842607729452115234375= 160651015 ** 9oder ungefähr 10 ⁷⁴ .

Python 2 , 9 Bytes

print{+1}

Dies druckt set([1])und ein Zeilenvorschub.

Probieren Sie es online!

Python 2 , 9 Bytes

print 1e5

Die angezeigte Ausgabe enthält eine nachgestellte Newline.

Probieren Sie es online!

Brainfuck , 25 Bytes

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

Probieren Sie es online! Anmerkung: Erfordert eine Implementierung mit 8-Bit-Zellen ohne Vorzeichen

Ausgabe:

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

Erläuterung

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

C (Ideone), 14 Bytes

f(){warn(0);}

Auf Ideone , das seine ausführbare Datei benennt prog, wird das Folgende mit einem nachgestellten Zeilenumbruch ausgegeben.

prog: Success

C (GCC), 15 Bytes

f(){warn(00);}

Da GCC a.outstandardmäßig eine ausführbare Datei mit dem Namen schreibt (da keine zusätzlichen Flags vorhanden sind, die Byte kosten würden), wird die folgende Zeile mit einem nachgestellten Zeilenumbruch ausgegeben.

a.out: Success

C (gcc) , 18 bis 17 Bytes

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

Beachten Sie, dass sich zwischen und ein STX-Byte ( 0x02 ) befindet .@C

Probieren Sie es online!

Portabilität

Dies wurde mit gcc 6.3.1 und clang 3.9.1 unter Fedora 25, gcc 4.8.4 unter Ubuntu 14.04.4 und gcc 4.8.3 unter openSUSE 13.2 getestet und gibt die folgende Ausgabe aus.

inux-x86-64.so.2

Ich gehe davon aus, dass dies mit allen gcc-Versionen die gleiche Ausgabe liefert, sofern es zu einer ausführbaren Datei des folgenden Typs kompiliert wird.

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

Unterschiedliche Plattformen erfordern eine unterschiedliche Speicheradresse und möglicherweise eine unterschiedliche Reihenfolge für die Bytes in der aus mehreren Zeichen bestehenden Zeichenkonstante.

Zum Beispiel ersetzt @\2Cmit @\2\4druckt exec/ld-elf.so.1und eine neue Zeile auf FreeBSD 11 mit Klirren 3.8.0.

Offline-Überprüfung

$ 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

Wie es funktioniert

Standardmäßig verwendet ld 0x400000 als Basisadresse des Textsegments, was bedeutet, dass der Inhalt des ELF ab der Speicheradresse 0x400000 gefunden wird .

Die ersten 640 Bytes des ELF sind weitgehend unabhängig vom eigentlichen Quellcode. Wenn beispielsweise die Erklärung von f durch folgt main(){f();}und nichts anderes, sie sehen aus wie folgt.

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]...@.....
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].......
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   ...............

Die Verwendung von beispielsweise main(int c, char**v){f();}ändert stattdessen einige Bytes, jedoch nicht den Versatz der Zeichenfolge /lib64/ld-linux-x86-64.so.2, mit dem die Ausgabe erfolgt.

Der Offset dieser Zeichenfolge beträgt 0x238 und ist 27 Byte lang. Wir wollen nur 17 Bytes ausgeben (und das letzte wird eine neue Zeile sein, wenn wir verwenden puts), also addieren wir 11 zum Offset, um 0x243 , den Offset von, zu erhalten inux-x86-64.so.2. Das Hinzufügen von 0x400000 und 0x243 ergibt 0x400243 , den Speicherort von inux-x86-64.so.2.

Um diese Speicheradresse zu erhalten, können wir aus mehreren Zeichen bestehende Zeichenkonstanten verwenden, die ein implementierungsdefiniertes Verhalten aufweisen. 0x400243 ist (64) (2) (67) in der Basis 256, und die aus mehreren Zeichen bestehenden Zeichenkonstanten von gcc verwenden die Big-Endian-Bytereihenfolge, sodass '@\2C'die Speicheradresse der gewünschten Zeichenfolge ermittelt wird.

Zum Schluss wird putsder (nullterminierte) String an diesem Speicherort und in einer nachgestellten Zeile ausgegeben, wodurch 17 Byte Ausgabe erstellt werden.

Selbstmodifizierender Brainfuck , 5 Bytes

<[.<]

Probieren Sie es online!

Ausgabe:

]<.[<

Erläuterung:

Ganz einfach, druckt die Quelle in umgekehrter Reihenfolge. In SMBF wird der Inhalt des Programms links von der Anfangsposition des Zeigers auf dem Band gespeichert. Wenn Sie nach links gleiten und drucken, wird der Quellcode rückwärts ausgegeben.

Da das Lesen von Quellen in dieser Challenge erlaubt ist, sollte dies definitiv innerhalb der Regeln liegen.

Grundrechenart , 2 Bytes

1=

Drucke 1.oder:

    |
    |
    |  .

auf diesen albernen Siebensegmentanzeigen.

Um zu reproduzieren, nimm einen beliebigen Taschenrechner. Alle haben diese Programmiersprache irgendwie installiert.

Fourier, 26 22 20 Bytes

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

Probieren Sie es auf FourIDE!

Ausgänge:

nananananana Batman!

Für eine korrekte Großschreibung sind es 4 zusätzliche Bytes:

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

Probieren Sie es auf FourIDE!

Nanananananananana Batman!

_{RIP Adam West}

Brachylog , 1 Byte

w

Probieren Sie es online!

Erläuterung

wist das eingebaute "schreiben". Hier wird der Eingang geschrieben. Da die Eingabe eine freie Variable ist, wwird sie vor dem Drucken als Ganzzahl gekennzeichnet. Die erste Ganzzahl, die es versucht, ist 0.

Java (OpenJDK 8) , 11 Byte

o->1e8-1+""

Probieren Sie es online!

Ausgabe:

9.9999999E7

Nur ein bisschen ausgefeilter als die offensichtliche Antwort ()->"".format("%23s",0).

Speichert

• 18 -> 16 Bytes: Vorteilhaftere Kombination aus Rundung und Potenz von 10 dank PunPun1000
• 16 -> 13 Bytes: Bessere Formel dank JollyJoker
• 13 -> 11 Bytes: Verbesserte Formel dank Kevin Cruijssen

05AB1E , 1 Byte

õ

Gibt einen einzelnen Zeilenumbruch aus. õdrückt eine leere Zeichenkette und wird implizit mit einem Zeilenumbruch ausgegeben.

Probieren Sie es online!

Einige andere 2-Byte-Lösungen für Ihr Sehvergnügen (die Ausgabe befindet sich in den Klammern und alle Ausgaben haben eine nachgestellte Zeile):

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

Es gibt jedoch viel mehr 2-Byte-Lösungen.

V / Vim, 1 Byte

o

Dies gibt eine einzelne neue Zeile aus.

Probieren Sie es online!

Es gibt eine Reihe von Varianten, die auch funktionieren würden. Zum Beispiel,

O

in vim und

Ä
ä
ï
Ï

in V.

Es gibt auch viele, viele Drei-Byte-Lösungen. Zum Beispiel:

3ii
i³i
¬ac

Diese sind alle spezifisch für V.

Batch, 12 Bytes

@echo %OS%

Die Byteanzahl umfasst den Zeilenumbruch sowohl für das Skript als auch für die Ausgabe

Windows_NT

Hexagony , 3 Bytes

o!@

Probieren Sie es online!

Druckt 111.

Entfaltet:

 o !
@ . .
 . .

Aber der Code wird wirklich nur in der Reihenfolge ausgeführt o!@.

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

/// , 12 Bytes

/a/bcd/aaaa/

Probieren Sie es online!

Dies wird gedruckt bcdbcdbcdbcd, und da dies 12 Byte sind, habe ich am Ende des Codes einen harmlosen / Code hinzugefügt , um ihn aufzufüllen.

R, 7 Bytes

mode(T)

Druckt "logisch"

MATL , 2 Bytes

H

Es gibt einen nachgestellten Zeilenumbruch.

Probieren Sie es online!

Erläuterung

Die Zwischenablage H enthält 2standardmäßig eine Zahl . Hschiebt diesen Inhalt auf den Stapel, der implizit mit einer nachgestellten Newline angezeigt wird.

Holzkohle , 2 Bytes

→¹

Probieren Sie es online!

Druckt eine horizontale Linie der Länge 1 -nach rechts und eine neue Linie.

Gelee , 1 Byte

V

Nicht wenige Jelly one-Bytes - dies ist eins - wertet das linke Argument aus, das, wenn nichts als Eingabe bereitgestellt wird, standardmäßig null ergibt, was wiederum null ergibt und das Ergebnis implizit gedruckt wird 0. A.

Probieren Sie es online!

In der Tat, der 256 Bytes im Code-Seite gibt es nur 95 , die noch nicht zur Zeit einen anderen Byteausgabe innerhalb des angegebenen Bereichs erzeugen , wenn sie als vollwertiges Programm ausführen; Dies sind (als Codepage-Zeichen in Byte-Reihenfolge):

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

Anmerkungen:

• Die meisten 1-Byte-Programme drucken ein 0(no-ops / Ergebnis einer Liste mit einer einzelnen Null in, die ein druckt 0), die meisten anderen drucken ein 1( 0=0und dergleichen)

• Ọdas ein Programm ist , das tut ein anderes Byte ergeben, aber eine , die außerhalb des Bereichs gemäß der Spezifikation ist - es erzeugt den Null-Byte (wirft die 0auf Rolle)

• ⁶ erzeugt ein Leerzeichen (ein Literal)

• ⁷ Erzeugt einen Zeilenvorschub (ein Literal)

• Einige Bytes, die jetzt funktionieren, könnten dies in Zukunft nicht tun - es gibt ein paar Bytes, die (glaube ich) für niladische Werte reserviert sind, die, wenn sie zugewiesen werden, mit ziemlicher Sicherheit keine 1-Byte-Ausgabe erzeugen.

Befunge , 2 Bytes

.@

Probieren Sie es online!

Druckt 0mit einem Leerzeichen nach. Funktioniert auch in Befunge 98.