Schreiben Sie das kürzeste Programm in Ihrer Lieblingssprache, um ein Brainfuck- Programm zu interpretieren . Das Programm wird aus einer Datei gelesen. Eingabe und Ausgabe sind Standardeingabe und Standardausgabe.
- Zellengröße: 8bit ohne Vorzeichen. Überlauf ist undefiniert.
- Array-Größe: 30000 Bytes (nicht eingekreist)
- Fehlerhafte Befehle sind nicht Teil der Eingabe
Kommentare beginnen mit # und erstrecken sich bis zum Ende der Zeile.Kommentare sind alles, was nicht enthalten ist+-.,[]<>
- kein EOF-Symbol
Einen sehr guten Test finden Sie hier . Es liest eine Zahl und druckt dann die Primzahlen bis zu dieser Zahl. Hier ist eine Kopie des Codes, um ein Verrotten des Links zu verhindern:
compute prime numbers
to use type the max number then push Alt 1 0
===================================================================
======================== OUTPUT STRING ============================
===================================================================
>++++++++[<++++++++>-]<++++++++++++++++.[-]
>++++++++++[<++++++++++>-]<++++++++++++++.[-]
>++++++++++[<++++++++++>-]<+++++.[-]
>++++++++++[<++++++++++>-]<+++++++++.[-]
>++++++++++[<++++++++++>-]<+.[-]
>++++++++++[<++++++++++>-]<+++++++++++++++.[-]
>+++++[<+++++>-]<+++++++.[-]
>++++++++++[<++++++++++>-]<+++++++++++++++++.[-]
>++++++++++[<++++++++++>-]<++++++++++++.[-]
>+++++[<+++++>-]<+++++++.[-]
>++++++++++[<++++++++++>-]<++++++++++++++++.[-]
>++++++++++[<++++++++++>-]<+++++++++++.[-]
>+++++++[<+++++++>-]<+++++++++.[-]
>+++++[<+++++>-]<+++++++.[-]
===================================================================
======================== INPUT NUMBER ============================
===================================================================
+ cont=1
[
- cont=0
>,
======SUB10======
----------
[ not 10
<+> cont=1
=====SUB38======
----------
----------
----------
--------
>
=====MUL10=======
[>+>+<<-]>>[<<+>>-]< dup
>>>+++++++++
[
<<<
[>+>+<<-]>>[<<+>>-]< dup
[<<+>>-]
>>-
]
<<<[-]<
======RMOVE1======
<
[>+<-]
]
<
]
>>[<<+>>-]<<
===================================================================
======================= PROCESS NUMBER ===========================
===================================================================
==== ==== ==== ====
numd numu teid teiu
==== ==== ==== ====
>+<-
[
>+
======DUP======
[>+>+<<-]>>[<<+>>-]<
>+<--
>>>>>>>>+<<<<<<<< isprime=1
[
>+
<-
=====DUP3=====
<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<<<
=====DUP2=====
>[>>+>+<<<-]>>>[<<<+>>>-]<<< <
>>>
====DIVIDES=======
[>+>+<<-]>>[<<+>>-]< DUP i=div
<<
[
>>>>>+ bool=1
<<<
[>+>+<<-]>>[<<+>>-]< DUP
[>>[-]<<-] IF i THEN bool=0
>>
[ IF i=0
<<<<
[>+>+<<-]>>[<<+>>-]< i=div
>>>
- bool=0
]
<<<
- DEC i
<<
-
]
+>>[<<[-]>>-]<<
>[-]< CLR div
=====END DIVIDES====
[>>>>>>[-]<<<<<<-] if divides then isprime=0
<<
>>[-]>[-]<<<
]
>>>>>>>>
[
-
<<<<<<<[-]<<
[>>+>+<<<-]>>>[<<<+>>>-]<<<
>>
===================================================================
======================== OUTPUT NUMBER ===========================
===================================================================
[>+<-]>
[
======DUP======
[>+>+<<-]>>[<<+>>-]<
======MOD10====
>+++++++++<
[
>>>+<< bool= 1
[>+>[-]<<-] bool= ten==0
>[<+>-] ten = tmp
>[<<++++++++++>>-] if ten=0 ten=10
<<- dec ten
<- dec num
]
+++++++++ num=9
>[<->-]< dec num by ten
=======RROT======
[>+<-]
< [>+<-]
< [>+<-]
>>>[<<<+>>>-]
<
=======DIV10========
>+++++++++<
[
>>>+<< bool= 1
[>+>[-]<<-] bool= ten==0
>[<+>-] ten = tmp
>[<<++++++++++>>>+<-] if ten=0 ten=10 inc div
<<- dec ten
<- dec num
]
>>>>[<<<<+>>>>-]<<<< copy div to num
>[-]< clear ten
=======INC1=========
<+>
]
<
[
=======MOVER=========
[>+<-]
=======ADD48========
+++++++[<+++++++>-]<->
=======PUTC=======
<.[-]>
======MOVEL2========
>[<<+>>-]<
<-
]
>++++[<++++++++>-]<.[-]
===================================================================
=========================== END FOR ===============================
===================================================================
>>>>>>>
]
<<<<<<<<
>[-]<
[-]
<<-
]
======LF========
++++++++++.[-]
@
Beispiellauf:
$ python2 bf.py PRIME.BF
Primes up to: 100
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
code-golf
interpreter
brainfuck
Alexandru
quelle
quelle
,
von EOF unverändert bleibt ? Oder dass es an uns liegt, einen Wert zu wählen, wenn wir,
EOF ausprobieren ? Oder ist EOF undefiniertes Verhalten insgesamt?Antworten:
Perl,
120-138Dies läuft hello.bf und primes.bf einwandfrei:
Initialisierung: Der Opcode zur Perl-Übersetzungstabelle wird in gespeichert
%c
. Das lesbare Formular sieht folgendermaßen aus:Schritt 1: Slurp-Programmeingabe in
$_
und Umwandlung in Perl-Code unter Verwendung der Übersetzungstabelle. Kommentare werdenundef
in diesem Schritt automatisch entfernt (durch ersetzt ).Schritt 2: Dekomprimieren Sie alle
$b[$p]
VorkommenSchritt 3: Starten Sie das Programm mit
eval
.quelle
qw
Syntax, um%c
direkt zu definieren - gut für 7 Zeichen weniger (Sie müssen sagenprint+chr$b[$p]
undord(getc)
trotzdem)Python (keine Auswertung), 317 Bytes
quelle
f(u,c,k)
while b*c[c[0]]and j<1
durchwhile b*c[c[0]]*(j<1)
16-Bit-8086-Maschinencode: 168 Bytes
Hier ist die Base64- codierte Version, konvertieren und speichern Sie sie unter 'bf.com' und führen Sie sie über die Windows-Eingabeaufforderung aus: 'bf progname'
BEARBEITEN
Hier ist ein Assembler (A86-Stil) zum Erstellen der ausführbaren Datei (ich musste dies rückentwickeln, da ich die ursprüngliche Quelle verlegt hatte!)
quelle
Brainfuck ,
843691 BytesBearbeiten: Entschloss sich, dies noch einmal zu wiederholen und fand eine überraschende Anzahl von Möglichkeiten, um aus Bytes Golf zu spielen
Dies erfolgt in der Form,
code!input
in der!input
das optional ist. Es simuliert auch negative Zellen, ohne negative Zellen selbst zu verwenden, und kann bis zu(30000-(length of code+6))/2
Zellen speichern .Probieren Sie es online!
quelle
Ruby 1.8.7,
188185149147 ZeichenEtwas lesbare Version:
Wie Sie sehen, habe ich Ihre Idee, in die Host-Sprache zu übersetzen und sie dann mit eval auszuführen, schamlos gestohlen.
quelle
>0
: Gleichheit statt testen!=0
. Die Spezifikationen sagen unsigned, und der Überlauf ist undefiniert.3e4
funktioniert auch im Gegensatz zu30000
File.read($*.pop).bytes
->$<.bytes
sollte auch funktionieren{?a,"foo"}
was äquivalent zu ist{?a=>"foo"}
. Und das Testen hier zeigt, dass Sie tatsächlich ohne ProblemeFile.read($*.pop).bytes
mit ersetzen$<
können. Auch das Inlinen von allem zu etwaseval"a[0]..."+$<.bytes.map{?.,"putc a[i]",...}*";"
verkürzt die Lösung um ein paar weitere Zeichen.Binäre Lambda-Rechnung 112
Das im Hex-Dump unten gezeigte Programm
erwartet, dass seine Eingabe aus einem Brainfuck-Programm besteht (wobei nur die Bits 0,1,4 zur Unterscheidung von, -. + <>] [), gefolgt von einem], gefolgt von der Eingabe für das Brainfuck-Programm.
Speichern Sie den obigen Hex-Dump mit xxd -r> bf.Blc
Besorgen Sie sich einen BLC-Interpreter unter https://tromp.github.io/cl/cl.html
Hallo Welt!
quelle
Retina 0.8.2 ,
386391386 BytesCode enthält nicht druckbare NUL (
0x00
) -Zeichen. Es ist auch noch nicht super Golf, weil es schon sehr langsam ist und wenn ich mehr Golf spiele, weiß ich nicht, wie lange es dauern würde, bis es fertig ist. Erscheint in der Prime-Finding-Stichprobe eine Zeitüberschreitung.Möglicherweise gibt es Fehler im Online-Interpreter oder in meinem Programm (führende neue Zeilen werden in der Ausgabe nicht angezeigt?).
Nimmt Eingaben wie
<code>│<input>
. Nein, das ist keine Pipe (|
). Es ist das Unicode-ZeichenU+2502
. Der Code verwendet auch die Unicode-Zeichenÿ▶◀├║
. Unicode-Zeichen werden verwendet, um die Eingabe aller ASCII-Zeichen zu unterstützen. Daher müssen diese Zeichen durch ein Nicht-ASCII-Zeichen vom Code getrennt werden.Probieren Sie es online aus
Beachten Sie, dass dort eine nachgestellte Zeile steht.
Kurze Erklärung:
0x00
Für das unbegrenzte Band werden Nullen verwendet. Die erste Ersetzung richtet den Interpreter in der Form ein▶<code>│<input>├<output>║▶<tape>
, wobei die erste▶
der Zeiger für den Code und die zweite der Zeiger für das Band ist.ÿ
ist0xFF
(255), das für die Transliteration verwendet wird (verwendet, um+
und zu implementieren-
), um die Zellen wieder auf Null zu setzen.◀
wird nur aus Gründen der Lesbarkeit verwendet (falls das Programm in der Mitte angehalten wird oder Sie das Programm während der Ausführung sehen möchten). Ansonsten konnte man nicht erkennen, in welche Richtung sich der Zeiger bewegte.Kommentierter Code:
Klicken Sie hier, um den Code mit Nullen anstelle von Nullbytes anzuzeigen. Alle Vorkommen von
$0
sollten nicht durch Nullen ersetzt werden.Bearbeiten : Unterstützt jetzt leere Eingaben und unterdrückt abschließende Zeilenumbrüche.
Unendliche Ausgabe wird jetzt unterstützt. (403 Bytes)
quelle
<code>
und das<tape>
nebeneinander gestellt (obwohl es mehr Zeichen wären), damit der Übergang zu einem SMBF-Interpreter einfacher wäre, wenn ich mich jemals dazu entscheide.TI-BASIC, 264 Bytes
Aufgrund von Einschränkungen in TI-BASIC ist dies für diese Herausforderung nicht geeignet, da Regel 2 verletzt wird. Der Arbeitsspeicher des Rechners ist sehr begrenzt, und wenn Sie so etwas wie
30000->dim(L1
(ich verwende L1 für den Stack / Array) tun, wird er gezwungen, eine zu werfenERR:MEMORY
. Als solches beginnt der Stapel / das Array mit einer Größe von 1 und wächst, wenn der Zeiger auf ein Element nach dessen Ende zeigt. Es verstößt auch gegen Regel 3, weil es bereits gegen Regel 2 verstößt.Könnte übrigens immer noch Golf spielen ... Ich habe ein oder zwei Änderungen vorgenommen, seit ich sie zum ersten Mal eingereicht habe, aber wenn die unten stehende Version nicht funktioniert, gehe zurück zur Bearbeitung vom 6. Mai '15 und benutze diese Code statt. Da es in TI-BASIC eigentlich kein ASCII gibt, werden hier Zahlen beliebiger Größe (und alles, was eine Zahl zurückgibt, wie z. B. eine Variable oder ein Ausdruck) als Eingabe verwendet und die Zahlen der Reihe nach ausgegeben.
Verwenden Sie SourceCoder , um es in eine .8xp-Datei zu integrieren, und senden Sie es dann mit TI-Connect oder TILP oder etwas anderem an Ihren Taschenrechner. Fügen Sie Ihr Brainfuck-Programm in doppelte Anführungszeichen ein, gefolgt von einem Doppelpunkt und dem Namen des TI-BASIC-Programms. Zum Beispiel, wenn Sie es Brainf genannt, würden Sie ein Programm wie folgt ausführen:
"brainfuck goes here":prgmBRAINF
. Wenn Sie eine Shell auf Calc, die anderen Befehlen ab , wenn es die erkenntprgm
Token, obwohl, dies zu tun:"brainfuck goes here" -> press ENTER -> prgmBRAINF
.Wenn Sie Ihren Rechner nicht an Ihren Computer anschließen können und dies stattdessen on-calc eingeben möchten (ich kann mir nicht vorstellen, warum Sie möchten, aber ich schweife ab), beachten Sie, dass dies
->
dieSTO>
Schaltfläche über ON ist Taste,~
ist das negative Symbol neben der EINGABETASTE und ersetzt alle Instanzen vonL<number>
durch das entsprechende Listentoken, das sich auf befindet2ND -> <number on keypad>
Vielen Dank an thomas-kwa (zumindest denke ich, dass dies sein Stack-Benutzername ist), der mir dabei geholfen hat, dies zu optimieren, insbesondere mit den Anweisungen
[
und]
.quelle
Ans+S
?S-sum(not(cumSum(L4(Ans)=seq(L4(X),X,Ans+1,dim(L4->S
. (a-a=0
). Und hey, mach dir keine Sorgen, dass du EINEN Operationsbefehl hier vergisst. Ich habe gesehen, dass eine ganze Menge Leute den Operationsbefehl für%
(Mod) bei einer Herausforderung vergessen haben .Python
275248255Ich beschloss, es zu versuchen.
quelle
exec t
?). Wenn Sie den Tipp von S.Mark verwenden und den gesamtenfor
Zyklus in einer Zeile zusammenfassen, können Sie ihn auf 243 Zeichen verkleinern.[]
, die ein gültiges, wenn auch triviales bf-Programm enthalten. Ich habe eine Änderung vorgeschlagen, die das behebt, aber die Anzahl der Zeichen erhöht. Um die Zeichenanzahl weiter zu verringern, können Siefrom sys import *
und'i+=1,...'.split(',')
anstelle von verwenden['i+=1',...]
.+1
, aber viele Verbesserungen wurden vorgeschlagen und nicht umgesetzt.Haskell,
457413 ZeichenDieser Code "kompiliert" das BF-Programm in eine
IO
Aktion der Form, inState -> IO State
der der Status ein Reißverschluss für eine unendliche Zeichenfolge ist.Schade, dass ich 29 Zeichen aufwenden musste, um die Pufferung auszuschalten. Ohne diese funktioniert es, aber Sie sehen die Eingabeaufforderungen nicht, bevor Sie Eingaben vornehmen müssen. Der Compiler selbst (
b
,f
, undk
) , ist nur 99 Zeichen, die Laufzeit (#
und%
) ist 216. Der Treiber w / Ausgangszustand eine andere 32.Update 15.02.2011: Vorschläge von JB wurden übernommen, ein wenig umbenannt und verschärft
main
quelle
IO
und die Argumente von justSystem
(-19) zu erhalten. Das Problem mit der Pufferung stört mich auch, da die Spezifikation es nicht wirklich erwähnt und die Antwort mit den besten Bewertungen nicht einmal E / A-Vorgänge ausführt. Wenn Sie es behalten müssen , ist es wahrscheinlich kürzer, alshFlush
nach jedem Schreibvorgang den globalen Puffermodus zu ändern (-34 + 15).Förderer, 953
Dies ist wahrscheinlich der schönste Code, den Sie jemals sehen werden:
quelle
C
284362 (Aus einer Datei)Primes:
Kompiliert und erfolgreich ausgeführt VS2008
Die ursprüngliche Lösung erkannte keine Schleifen, die ursprünglich auf Null gesetzt waren. Immer noch etwas Platz zum Golfen. Löst aber endlich das Primzahlprogramm.
Ungolfed:
Tests:
Hallo Welt
Rot13
quelle
l
jeder Schleife denselben Zeiger ( )? Ich denke, Sie sollten die aktuelle Position des Kopfes überprüfen (p
).l
im Puffer Null erreicht hat und bricht ab, ansonsten wird der Stream auf die ursprüngliche Schleife zurückgesetzt[
. Dies ist für verschachtelte[
Schleifen erforderlich .break;else
durchreturn;
.(c==62)?a:b
mit(c-62)?b:a
.PHP 5.4,
296294273263261209191183178166 Zeichen:Ich habe es ausprobiert, ohne eval zu benutzen, aber ich musste es schließlich benutzen
Alle Befehle funktionieren. Hierdurch werden variable Variablen in hohem Maße missbraucht und Warnungen ausgegeben. Wenn man jedoch die php.ini in Squelch-Warnungen ändert (oder stderr nach / dev / null leitet), funktioniert dies großartig.
Überprüfung (Dies ist das "Hello World!" - Beispiel von Wikipedia ): http://codepad.viper-7.com/O9lYjl
Ungolfed,
367365335296267 Zeichen:Dies sollte über die Befehlszeile ausgeführt werden:
php bf.php hello.bf
quelle
Windows PowerShell, 204
Ziemlich unkomplizierte Umsetzung der Anweisungen und dann
Invoke-Expression
.Geschichte:
3e4
ist kürzer als30000
.switch
.Write-Host
.quelle
C, 333 Zeichen
Dies ist mein erster BF-Interpreter und der erste Golf, den ich tatsächlich debuggen musste.
Auf diese Weise wird der Primzahlengenerator unter Mac OS X / GCC ausgeführt. Unter
#include<string.h>
Umständen ist jedoch eine zusätzliche Angabe erforderlich, die 19 Zeichen mehr kostet, wenn die implizite Definition vonstrchr
auf einer anderen Plattform nicht funktioniert. Auch davon geht es ausO_RDONLY == 0
. Abgesehen davon, wenn Sieint
die Deklaration vonM
save 3 Zeichen weglassen, scheint dies nicht C99-konform zu sein. Gleich mit dem dritten*
inb()
.Dies hängt von den Einzelheiten der ASCII-Codierung ab. Die Brainfuck-Operatoren sind alle komplementären Paare, die im ASCII-Code-Raum durch einen Abstand von 2 voneinander getrennt sind. Jede Funktion in diesem Programm implementiert zwei Operatoren.
quelle
#define
anstelle der Funktionstabelle wäre wahrscheinlich auch schärfer. Ich mag nur die Nummer 333 und die Tabelle: v).||
.CJam, 75 Bytes
Probieren Sie es online aus: String Reverser , Hello World .
Erläuterung
Nimmt Code in die erste Zeile von STDIN und gibt ihn in alle Zeilen darunter ein.
Was ist mit dieser magischen Liste?
Die resultierende Liste ist wie folgt:
Wir generieren die Schnipsel für
+
und>
aus denen für-
und<
, indem wir einfach die linken Parens (CJams "Dekrement") in die rechten Parens (CJams "Inkrement") ändern.quelle
F #: 489 Zeichen
Das folgende Programm springt nicht auf '[' / ']' - Anweisungen, sondern durchsucht den Quellcode nach dem nächsten passenden Token. Das macht es natürlich etwas langsam, aber es kann immer noch Primzahlen unter 100 finden. F # Integer-Typen laufen nicht über, sondern werden umbrochen.
Hier ist die kurze Version:
Ein böses Problem war, dass das Programm primes.bf an Windows-Zeilenumbrüchen drosselt. Um es auszuführen, musste ich die eingegebene Nummer in einem UNIX-formatierten Textdokument speichern und mit einer Pipe an das Programm übergeben:
Bearbeiten: Eingabe von Alt + 010 gefolgt von Eingabe funktioniert auch in Windows cmd.exe
Hier ist die längere Version:
quelle
Delphi,
397382378371366364328 ZeichenIss dieses Delphi!
Hier der gleiche Code, eingerückt und kommentiert:
Dieser hat ein paar Stunden gedauert, da es nicht die Art von Code ist, die ich normalerweise schreibe, aber viel Spaß damit!
Hinweis: Der Primer-Test funktioniert, hört aber nicht bei 100 auf, da er # 13 (CR) vor # 10 (LF) lautet. Leiden auch andere Einreichungen unter CRLF-Betriebssystemen unter diesem Problem?
quelle
C 260 + 23 = 283 Bytes
Ich habe ein C-Programm erstellt, das hier zu finden ist .
Muss über kompiliert werden
gcc -D"q(a,b)"="*c-a||(b);" -o pmmbf pmmbf.c
und kann wie folgt aufgerufen werden:pmmbf ",[.-]" 30000
wobei das erste Argument (zitiert) das auszuführende bf-Programm enthält, das zweite bestimmt, wie groß das Band sein soll.quelle
-D"q(a,b)"="*c-a||(b);"
Option zu aktivieren, da dies (zumindest nach meinem begrenzten Verständnis) dazu beiträgt, Ihren Code zu verkleinern.define
und die Zeilenumbrüche zu vermeiden , aber ich denke nicht, dass das wirklich koscher ist. Wie auch immer, bei den Zitaten und Kommentarengcc -D
sehe ich den Vorteil überhaupt nicht.C 267
Führen Sie als ./a.out primes.bf aus
Ungolfed Version:
quelle
Python 2, 223
Ich gebe zu, dass ich ein altes Programm von mir recycelt habe (musste es aber ein bisschen ändern, weil die alte Version keine Eingabe hatte, sondern eine Fehlerprüfung ...).
Läuft der Primzahlenrechner einwandfrei.
Ich sehe jetzt, dass Alexandru eine Antwort hat, die einige Ähnlichkeiten hat. Ich werde meine Antwort sowieso posten, weil ich denke, dass einige neue Ideen darin sind.
quelle
C (gcc) Linux x86_64,
884 621 525 487 439 383 358354 BytesProbieren Sie es online!
Dies ist eine JIT, die BF-Code zur Laufzeit in x86_64-Maschinensprache kompiliert. Dies führt eine gerade Übersetzung so häufig Sequenzen wie auftritt
>>>
,<<<
,+++
und---
ist nicht in schnelle Anweisungen verschmolzen.Weniger Golf Version:
quelle
C
374368Liest aus einer Datei. Besteht den PRIME.BF-Test.
Verwendung: ./a.out PRIME.BF
Neuformatiert:
quelle
Lua, 285
Etwas lesbare Version:
Funktioniert perfekt
Lua, 478, ohne Schnur
Lesbare Version:
quelle
Brainfuck, 948 Bytes
Nun, das hat eine Weile gedauert. Ich habe einen Brainfuck- Selbstdolmetscher von ... nicht von mir gespielt.
quelle
Rückruf 594 Bytes
Kurzum: Recall hat im klassischen Sinne keine arithmetischen Operatoren, sondern nur bitweise Operationen. Sie können nicht nur eine hinzufügen. Der Rückruf ist auch streng stapelbasiert.
Beispiel 1: Drucken Sie etwas
Eingang:
Ausgabe:
Beispiel 2: Ausgabe von Quadraten bis 100
Eingang:
Ausgabe:
Die Ausführung dieses Beispiels kann einige Minuten dauern und die Meldung "Diese Registerkarte ist eingefroren" auslösen. Ignoriere das und warte.
quelle
OCaml (Lex), 497 Zeichen
OCamllex ist Teil der Standarddistribution von OCaml.
Als b.mll speichern und mit ausführen
Ich mag es nicht, von Hand zu analysieren, deshalb habe ich den mitgelieferten Lexer-Generator verwendet. Aus den gelesenen Token erstellen wir eine Funktion für das gesamte Programm brainf * ck.
quelle
C # (2861 Zeichen, ~ 84 Zeilen)
Dies ist nicht die schönste Lösung für das Problem und wahrscheinlich auch nicht all das "Golf-isch", da ich mich nicht so sehr um die Länge gekümmert habe, wie ich es wahrscheinlich hätte tun sollen. (Ich habe die Kommentare oder zusätzlichen Leerzeichen nicht entfernt.) Ich wollte nur etwas in einer neuen Sprache ausprobieren, um zu sehen, ob ich das könnte. Wenn ich es noch einmal tun würde, würde ich die Verwendung des Stacks für die Rückkehr von ']' fallen lassen und einfach zurückblicken. Ohne Befehlszeilenargumente ausführen führt das in der Problembeschreibung angegebene Hallo-Welt-Programm aus. Es akzeptiert ein Befehlszeilenargument, den Dateinamen des auszuführenden Programms.
Bearbeiten: Nicht verwendete Referenzen wurden entfernt.
quelle
C (gcc) ,
273268 BytesProbieren Sie es online!
-5 dank ceilingcat
Übernimmt die Eingabe von stdin.
Dies hängt ein wenig von der Umwelt ab, ist aber ziemlich konsistent. Dies ist effektiv die eval Lösung für c. Es schreibt ein geeignetes C-Programm in die Datei wc, kompiliert es und führt es als die gewünschte ausführbare Datei aus. Als Bonus-Effekt kompiliert dies also tatsächlich den bf-Code und hinterlässt
a.out
eine Binärdatei dafür. Beachten Sie, dass Sie je nach System möglicherweise die letzte Zeichenfolge ändern müssen. Insbesondere nennen die meisten Windows C-Compiler die Standard-Programmdatei "a.exe". Zum Glück haben sie, soweit ich das beurteilen kann, alle die gleiche Länge, sodass der Bytecount gleich ist. (Wenn Sie jedoch kein CC definiert haben, müssen Sie möglicherweise einen Buchstaben wie gcc zum Kompilierungsbefehl hinzufügen und 1 Byte hinzufügen.)Ich bin mir bewusst, dass dieser Thread ein bisschen alt ist, aber ich habe diesen Stil der C-Lösung noch nicht gesehen, also dachte ich, ich würde ihn hinzufügen.
quelle
[BEARBEITEN]
C ++ 11, 355, liest aus Datei:
Prüfung
http://ideone.com/b7vO4
[ALTE VERSION]
C ++ 11, 391: http://ideone.com/yZHVv
quelle