Brainf interpretieren ***

113

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.

  1. Zellengröße: 8bit ohne Vorzeichen. Überlauf ist undefiniert.
  2. Array-Größe: 30000 Bytes (nicht eingekreist)
  3. Fehlerhafte Befehle sind nicht Teil der Eingabe
  4. Kommentare beginnen mit # und erstrecken sich bis zum Ende der Zeile. Kommentare sind alles, was nicht enthalten ist+-.,[]<>
  5. 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 
Alexandru
quelle
5
Sie sollten etwa 1) Größe des Speichers 2) ist Speicher eingekreist 4) vielleicht andere Details
Nakilon
3
Ich frage mich, ob es zwei Kategorien geben sollte: Programme, die eval verwenden (oder zum Kompilieren Shell-out verwenden) - und solche, die dies nicht tun.
MtnViewMark
34
Ich würde gerne jemanden sehen, der das in Brainfuck beantwortet.
Hannesh
3
Was bedeutet "kein EOF-Symbol"? Dass der Zellenwert beim Anprobieren ,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?
Martin Ender
3
Was sollte auch passieren, wenn jemand versucht, die 30.000 Zellen auf beiden Seiten zu belassen? Sollte der Bandkopf an Ort und Stelle bleiben oder ist dieses Verhalten undefiniert?
Martin Ender

Antworten:

46

Perl, 120-138

%c=qw(> $p++ < $p-- + D++ - D-- [ while(D){ ] } . print+chrD , D=ord(getc));
$/=$,;$_=<>;s/./$c{$&};/g;s[D]'$b[$p]'g;eval

Dies läuft hello.bf und primes.bf einwandfrei:

$ perl bf.pl hello.bf
Hello World!
$ perl bf.pl 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

Initialisierung: Der Opcode zur Perl-Übersetzungstabelle wird in gespeichert %c. Das lesbare Formular sieht folgendermaßen aus:

%c=(
  '>' => '$p++',
  '<' => '$p--',
  '+' => '$b[$p]++',
  '-' => '$b[$p]--',
  '[' => 'while($b[$p]){',
  ']' => '}',
  '.' => 'print chr$b[$p]',
  ',' => '$b[$p]=ord(getc)',
);

Schritt 1: Slurp-Programmeingabe in $_und Umwandlung in Perl-Code unter Verwendung der Übersetzungstabelle. Kommentare werden undefin diesem Schritt automatisch entfernt (durch ersetzt ).

Schritt 2: Dekomprimieren Sie alle $b[$p]Vorkommen

Schritt 3: Starten Sie das Programm mit eval.

JB
quelle
Verwenden Sie einfach die Perl- qwSyntax, um %cdirekt zu definieren - gut für 7 Zeichen weniger (Sie müssen sagen print+chr$b[$p]und ord(getc)trotzdem)
mob
Ich zähle 18 gerettet ... danke! (Aktualisierung in einer Minute)
JB
1
@olivecoder Worüber in aller Welt redest du?
JB
Die% c-Tabelle wird in der ersten Zeile deklariert und definiert. seine Charaktere sind perfekt erklärt.
JB
@JB hey, ich habe versehentlich die Stimme für deine Antwort gedrückt und sie ist gesperrt. Kannst du sie bearbeiten, damit ich die Stimme umkehren kann?
Cyclohexanol.
67

Python (keine Auswertung), 317 Bytes

from sys import*
def f(u,c,k):
 while(c[1]>=k)*u:
  j,u='[]<>+-,.'.find(u[0]),u[1:];b=(j>=0)*(1-j%2*2);c[1]+=b*(j<2)
  while b*c[c[0]]and j<1:f(u,c,k+1);c[1]+=1
  b*=c[1]==k;c[[0,c[0],2][j/2-1]]+=b
  if(j==6)*b:c[c[0]]=ord(stdin.read(1))
  if(j>6)*b:stdout.write(chr(c[c[0]]))
f(open(argv[1]).read(),[-1]+[0]*30003,0)
boothby
quelle
70
+1 für dief(u,c,k)
Joel Cornett
9
Das ist ein schönes Geräusch, Sir
globby
-1 Byte, wenn Sie ersetzen while b*c[c[0]]and j<1durchwhile b*c[c[0]]*(j<1)
Daniil Tutubalin
50

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'

gMYQUoDGEFKzgI1XAgIfiEcBtD3NIR8HcmOL2LQ/i88z0s0hcleL2DPA86sz/zP2/sU783NHrL0I
AGgyAU14DTqGmAF194qOoAH/4UfDJv4Fwyb+DcO0AiaKFc0hw7QBzSGqT8MmODV1+jPtO/NzDaw8
W3UBRTxddfJNee/DJjg1dPoz7U509YpE/zxddQFFPFt18U157sM+PCstLixbXUxjTlJWXmV+

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

    add dh,10h                              
    push dx                                 
    add dh,10h                              
    push dx                                 
    mov bl,80h                              
    lea dx,[bx+2]                         
    add bl,[bx]                            
    mov [bx+1],al                         
    mov ah,3dh                              
    int 21h                                 
    pop ds                                 
    pop es                                 
    jb ret                               
    mov bx,ax                              
    mov ah,3fh                              
    mov cx,di                              
    xor dx,dx                              
    int 21h                                 
    jb ret                               
    mov bx,ax                              
    xor ax,ax                              
    repz stosw                                     
    xor di,di                              
    xor si,si                              
    inc ch                                 
program_loop:
    cmp si,bx                              
    jnb ret                               
    lodsb                                    
    mov bp,8                            
    push program_loop
symbol_search:                       
    dec bp                                 
    js ret
    cmp al,[bp+symbols]
    jnz symbol_search
    mov cl,[bp+instructions]
    jmp cx                                 
forward:
    inc di                                 
    ret                                    
increment:
    inc b es:[di]                      
    ret                                    
decrement:
    dec b es:[di]                      
    ret                                    
output:
    mov ah,2                              
    mov dl,es:[di]                            
    int 21h                                 
    ret                                    
input:
    mov ah,1                              
    int 21h                                 
    stosb                                    
backward:
    dec di                                 
    ret                                    
jumpforwardifzero:
    cmp es:[di],dh                            
    jnz ret                               
    xor bp,bp
l1: cmp si,bx                              
    jnb ret
    lodsb                                    
    cmp al,'['                              
    jnz l2
    inc bp
l2: cmp al,']'                              
    jnz l1
    dec bp                                 
    jns l1
    ret                                    
jumpbackwardifnotzero:
    cmp es:[di],dh                            
    jz  ret
    xor bp,bp
l3: dec si                                 
    jz  ret
    mov al,[si-1]                         
    cmp al,']'
    jnz l4
    inc bp  
l4: cmp al,'['                              
    jnz l3
    dec bp                                 
    jns l3
    ret                                    
symbols:
    db '><+-.,[]'
instructions:
    db forward and 255
    db backward and 255
    db increment and 255
    db decrement and 255
    db output and 255
    db input and 255
    db jumpforwardifzero and 255
    db jumpbackwardifnotzero and 255
Skizz
quelle
Ich habe eine Quellcode-Version des Programms hinzugefügt. Ich habe gerade bemerkt, dass Nicht-BF-Zeichen dazu führen, dass das Programm beendet und nicht ignoriert wird. Das lässt sich leicht beheben, und ich überlasse es den Leuten, dies selbst zu tun.
Skizz
Ich erinnere mich, dass ich vor 10 Jahren die Linux-ELF-Version 166 Bytes erhalten habe, hier muppetlabs.com/~breadbox/software/tiny
Emmanuel
39

Brainfuck , 843 691 Bytes

Bearbeiten: 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!inputin der !inputdas optional ist. Es simuliert auch negative Zellen, ohne negative Zellen selbst zu verwenden, und kann bis zu (30000-(length of code+6))/2Zellen speichern .

Probieren Sie es online!

Scherzen
quelle
Nur um sicherzugehen, dass ich das richtig gemacht habe, wenn ich dieses Programm mit diesem Programm
ausführte,
@Draco18s Ich vermute, dass Ihnen zuvor die 30000 Zellen ausgehen würden, da die Größe jedes verschachtelten Interpreters exponentiell zunimmt. Ich denke, Sie werden 2, vielleicht 3 Level tief bekommen
Jo King
Sogar 3 deep wäre komisch dumm.
Draco18s
27

Ruby 1.8.7, 188 185 149 147 Zeichen

eval"a=[i=0]*3e4;"+$<.bytes.map{|b|{?.,"putc a[i]",?,,"a[i]=getc",?[,"while a[i]>0",?],"end",?<,"i-=1",?>,"i+=1",?+,"a[i]+=1",?-,"a[i]-=1"}[b]}*";"

Etwas lesbare Version:

code = "a = [0] * 3e4; i = 0;"
more_code ARGF.bytes.map {|b|
  replacements = {
    ?. => "putc a[i]",
    ?, => "a[i] = getc",
    ?[ => "while a[i] > 0 do",
    ?] => "end",
    ?< => "i -= 1",
    ?> => "i += 1",
    ?+ =>"a[i]+=1",
    ?- =>"a[i]-=1"
  }
  replacements[b]
}.join(";")
eval code+more_code

Wie Sie sehen, habe ich Ihre Idee, in die Host-Sprache zu übersetzen und sie dann mit eval auszuführen, schamlos gestohlen.

sepp2k
quelle
Sie können ein Byte Byte Vergleich zu Null abrasieren >0: Gleichheit statt testen !=0. Die Spezifikationen sagen unsigned, und der Überlauf ist undefiniert.
Anonymer Feigling
3e4funktioniert auch im Gegensatz zu30000
anonymer Feigling
@ Charlie: Danke. Um fair zu sein, sagte es nicht "unsigniert", als ich den Code schrieb. Ich wusste ehrlich gesagt nicht, dass man 3e4 schreiben kann. Das ist ein sehr guter Punkt und gut zu wissen.
Sepp2k
File.read($*.pop).bytes-> $<.bytessollte auch funktionieren
Arnaud Le Blanc
1
Ruby 1.8.7 hat eine noch kürzere Syntax zum Erstellen eines Literal-Hashs:, {?a,"foo"}was äquivalent zu ist {?a=>"foo"}. Und das Testen hier zeigt, dass Sie tatsächlich ohne Probleme File.read($*.pop).bytesmit ersetzen $<können. Auch das Inlinen von allem zu etwas eval"a[0]..."+$<.bytes.map{?.,"putc a[i]",...}*";"verkürzt die Lösung um ein paar weitere Zeichen.
Ventero
26

Binäre Lambda-Rechnung 112

Das im Hex-Dump unten gezeigte Programm

00000000  44 51 a1 01 84 55 d5 02  b7 70 30 22 ff 32 f0 00  |DQ...U...p0".2..|
00000010  bf f9 85 7f 5e e1 6f 95  7f 7d ee c0 e5 54 68 00  |....^.o..}...Th.|
00000020  58 55 fd fb e0 45 57 fd  eb fb f0 b6 f0 2f d6 07  |XU...EW....../..|
00000030  e1 6f 73 d7 f1 14 bc c0  0b ff 2e 1f a1 6f 66 17  |.os..........of.|
00000040  e8 5b ef 2f cf ff 13 ff  e1 ca 34 20 0a c8 d0 0b  |.[./......4 ....|
00000050  99 ee 1f e5 ff 7f 5a 6a  1f ff 0f ff 87 9d 04 d0  |......Zj........|
00000060  ab 00 05 db 23 40 b7 3b  28 cc c0 b0 6c 0e 74 10  |....#@.;(...l.t.|
00000070

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

cc -O2 -DM=0x100000 -m32 -std=c99 uni.c -o uni
echo -n "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.]" > hw.bf
cat bf.Blc hw.bf | ./uni

Hallo Welt!

John Tromp
quelle
1
Warum gibt es das überhaupt? Anscheinend existiert es sogar im Bereich der Forschung . Oo
Isiah Meadows
Das würde also mit kommentierten Brainfuck-Programmen nicht funktionieren?
Kamoroso94
Nein, nicht ohne vorher die Kommentare zu streichen.
John Tromp
18

Retina 0.8.2 , 386 391 386 Bytes

Code 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-Zeichen U+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

s`^.*
▶$0├║▶
s{`(▶>.*║.*)▶(.)(.?)
$1$2▶$3
▶$
▶
║▶
║▶
(▶<.*║.*)(.)▶
$1▶$2
T`ÿ-`o`(?<=▶\+.*║.*▶).
^\+

T`-ÿ`ÿo`(?<=▶-.*║.*▶).
^-

(▶\..*├.*)(║.*▶)(.)
$1$3$2$3
(▶,.*│)(.?)(.*├.*▶).
$1$3$2
▶\[(.*║.*▶)
[▶▶${1}
{`(▶▶+)([^[\]]*)\[
$2[$1▶
}`▶(▶+)([^[\]]*)\]
$2]$1
r`([[\]]*)▶\](.*║.*▶[^])
$1◀◀]$2
r{`\[([^[\]]*)(◀+)◀
$2[$1
}`\]([^[\]]*)(◀◀+)
$2◀]$1
◀
▶
}`▶([^│])(.*║)
$1▶$2
s\`.*├|║.*

Beachten Sie, dass dort eine nachgestellte Zeile steht.

Kurze Erklärung:

0x00Fü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.

ÿist 0xFF(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:

s`^.*                       # Initialize
▶$0├║▶
s{`(▶>.*║.*)▶(.)(.?)        # >
$1$2▶$3
▶$
▶
║▶                          # <
║▶
(▶<.*║.*)(.)▶
$1▶$2
T`ÿ-`o`(?<=▶\+.*║.*▶).      # +
^\+

T`-ÿ`ÿo`(?<=▶-.*║.*▶).      # -
^-

(▶\..*├.*)(║.*▶)(.)         # .
$1$3$2$3
(▶,.*│)(.?)(.*├.*▶).        # ,
$1$3$2
▶\[(.*║.*▶)                 # [
[▶▶${1}
{`(▶▶+)([^[\]]*)\[
$2[$1▶
}`▶(▶+)([^[\]]*)\]
$2]$1
r`([[\]]*)▶\](.*║.*▶[^])    # ]
$1◀◀]$2
r{`\[([^[\]]*)(◀+)◀
$2[$1
}`\]([^[\]]*)(◀◀+)
$2◀]$1
◀
▶
}`▶([^│])(.*║)              # next instruction
$1▶$2
s\`.*├|║.*                  # print output

Klicken Sie hier, um den Code mit Nullen anstelle von Nullbytes anzuzeigen. Alle Vorkommen von $0sollten 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)

mbomb007
quelle
Ich wünschte, ich hätte das <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.
mbomb007
14

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 werfen ERR: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 erkennt prgmToken, obwohl, dies zu tun: "brainfuck goes here" -> press ENTER -> prgmBRAINF.

seq(inString("<>-+.,[]",sub(Ans,S,1)),S,1,length(Ans->L2
cumSum((Ans=7)-(Ans=8->L3
seq(Ans(X),X,dim(Ans),1,~1->L4
1->P:DelVar L11->dim(L1 //this is the same as DelVar L1:1->dim(L1 as DelVar does not require a colon or newline after its argument
For(S,1,dim(L2
L2(S->T
P-(T=1)+(T=2->P
dim(L1
Ans+(P-Ans)(P>Ans->dim(L1
L1(P)-(T=3)+(T=4->L1(P
If T=5
Disp Ans
If T=6:Then
Input V
V->L1(P
End
If T=7 and not(L1(P
S+2+sum(not(cumSum(L3(S)-1=seq(L3(X),X,S+1,dim(L3->S
1-S+dim(L3
If T=8 and L1(P
S-sum(not(cumSum(L4(Ans)=seq(L4(X),X,Ans+1,dim(L4->S
End

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 ->die STO>Schaltfläche über ON ist Taste, ~ist das negative Symbol neben der EINGABETASTE und ersetzt alle Instanzen von L<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 ].

MI Wright
quelle
1
Benötigen Sie die Eltern in der Nähe Ans+S?
Zacharý
@ Zacharý Guter Fang, nein. Ich muss unsicher gewesen sein, wie PEMDAS funktioniert oder so ... Ich werde mich jedoch der Bearbeitung enthalten, da es so lange her ist, dass es sich definitiv nicht lohnt, diesen Beitrag nach vorne zu schieben, und weil ein Zwei-Byte Reduktion wird der Antwort keinen Vorteil gegenüber den anderen geben lol.
MI Wright
1
Ich erinnere mich wie vor 2-3 Jahren, als ich dieses Programm benutzte, um Brainf *** auf meinem Rechner zu interpretieren. Und, es ist eine gedankliche Frage, ich denke, es sollte an der Spitze stehen, um ehrlich zu sein.
Zacharý
1
Eigentlich denke ich, dass die ganze Linie sein könnte 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 .
Zacharý
1
Oh, verdammt, ja. Okay, das ergibt mindestens 10 Bytes weniger, da das if auch als Einzeiler erstellt werden kann, plus ein paar andere Dinge ... dann kann es auch bearbeitet werden. Du hast mich zum ersten Mal seit einem Jahr gezwungen, meinen Taschenrechner auszupeitschen, um dieses Zeug zu überprüfen, haha
MI Wright
13

Python 275 248 255

Ich beschloss, es zu versuchen.

import sys
i=0
b=[0]*30000
t=''
for e in open(sys.argv[1]).read():
 t+=' '*i+['i+=1','i-=1','b[i]+=1','b[i]-=1','sys.stdout.write(chr(b[i]))','b[i]=ord(sys.stdin.read(1))','while b[i]:','pass','']['><+-.,['.find(e)]+'\n'
 i+=(92-ord(e))*(e in'][')
exec t 
Alexandru
quelle
12
Sie generieren Python-Quellcode mit Brainfuck.
1
Sie können 1 Zeichen entfernen, "sys als s importieren" und "sys" durch "s" ersetzen
YOU
Beachten Sie, dass dies tatsächlich 247 Zeichen sind. (Sehen Sie den fiesen Raum danach exec t?). Wenn Sie den Tipp von S.Mark verwenden und den gesamten forZyklus in einer Zeile zusammenfassen, können Sie ihn auf 243 Zeichen verkleinern.
Oleh Prypin
Dies schlägt bei allen Eingaben fehl [], 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 Sie from sys import *und 'i+=1,...'.split(',')anstelle von verwenden ['i+=1',...].
Stand
7
Ich würde +1, aber viele Verbesserungen wurden vorgeschlagen und nicht umgesetzt.
mbomb007
12

Haskell, 457 413 Zeichen

import IO
import System
z=return
'>'#(c,(l,d:r))=z(d,(c:l,r))
'<'#(d,(c:l,r))=z(c,(l,d:r))
'+'#(c,m)=z(succ c,m)
'-'#(c,m)=z(pred c,m)
'.'#t@(c,_)=putChar c>>hFlush stdout>>z t
','#(_,m)=getChar>>=(\c->z(c,m))
_#t=z t
_%t@('\0',_)=z t
i%t=i t>>=(i%)
b('[':r)=k$b r
b(']':r)=(z,r)
b(c:r)=f(c#)$b r
b[]=(z,[])
f j(i,r)=(\t->j t>>=i,r)
k(i,r)=f(i%)$b r
main=getArgs>>=readFile.head>>=($('\0',("",repeat '\0'))).fst.b

Dieser Code "kompiliert" das BF-Programm in eine IOAktion der Form, in State -> IO Stateder 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, und k) , ist nur 99 Zeichen, die Laufzeit ( #und %) ist 216. Der Treiber w / Ausgangszustand eine andere 32.

>ghc -O3 --make BF.hs 
[1 of 1] Compiling Main             ( BF.hs, BF.o )
Linking BF ...

>./BF HELLO.BF 
Hello World!

>./BF 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 

Update 15.02.2011: Vorschläge von JB wurden übernommen, ein wenig umbenannt und verschärftmain

MtnViewMark
quelle
1
Sie sollten in der Lage sein, die Pufferung von just IOund die Argumente von just System(-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, als hFlushnach jedem Schreibvorgang den globalen Puffermodus zu ändern (-34 + 15).
JB
11

Förderer, 953

Dies ist wahrscheinlich der schönste Code, den Sie jemals sehen werden:

0

:I\1\@p
>#====)
^#====<
PP0
P<=======================<
00t:)01t1  a:P:P:P:P:P:P:^
>===========">">2>">2>">"^
^           +^-^5^ ^5^]^.^
^           "^"^*^"^*^"^"^
^           -^-^6^-^6^-^-^
^           #^#^*^#^*^#^#^
^           P P -^P )^P P
^           P P #^P )^P P
^t1\)t0:))t01   P   -^  1
^===========<   P   #^  0
^  t1\(t0:))t01     P   t
^=============<     P   )
^         t11(t01   0 0 )
^===============<. t P 10
^                 FT#T#=<
^=================< P 
^             t11)t01 
^===================< 10t))0tP00t:(01t(1a:P:
^                     >=====#=>==========">"
^                             ^          ]^[
^                           P ^          "^"
^===========================<=^#=====<   -^-
                            ^==<     ^ PP#^#=
                                     ^===PTPT<
                                     ^  )P P
                                     ^=<=< (
                                       ^===<
Loovjo
quelle
8
Können Sie eine Erklärung und einen Link zu einer Implementierung hinzufügen? Ich möchte die Schönheit verstehen. ;)
DLosc
1
Nun, ich entwickle es gerade, es gibt einen Compiler und eine sehr schlechte Erklärung unter github.com/loovjo/Conveyor . Die Quelle ist ziemlich lesbar, wenn Sie es verstehen wollen.
Loovjo,
9

C 284 362 (Aus einer Datei)

#include <stdio.h>
char b[30000],z[9999],*p=b,c,*a,i;f(char*r,int s){while(c=*a++){if(!s){(c-62)?(c-60)?(c-43)?(c-45)?(c-46)?(c-44)?0:(*p=getchar()):putchar(*p):--*p:++*p:--p:++p;if(c==91)f(a,!*p);else if(c==93){if(!*p)return;else a=r;}}else{if(c==93){--s;if(!*p&&!s)return;}else if(c==91){s++;}}}}main(int c,char**v){fread(z,1,9999,fopen(*++v,"r"));a=z;f(0,0);}

Primes:

Primes bis zu: 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
Drücken Sie eine beliebige Taste, um fortzufahren . . .

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:

#include <stdio.h>
char b[30000],z[9999],*p=b,c,*a,i;
f(char*r,int s)
{
    while(c=*a++)
    {   
        if(!s)
        {
            (c-62)?(c-60)?(c-43)?(c-45)?(c-46)?(c-44)?0:(*p=getchar()):putchar(*p):--*p:++*p:--p:++p;
            if(c==91)f(a,!*p);
            else if(c==93){if(!*p)return;else a=r;}
        }
        else
        {
            if(c==93)
            {
                --s;
                if(!*p&&!s)return;
            }
            else if(c==91)
            {
                s++;
            }
        }
    }
}

main(int c,char**v){
    fread(z,1,9999,fopen(*++v,"r"));
    a=z;
    f(0,0);
}

Tests:

Hallo Welt

Rot13

snmcdonald
quelle
Überprüfen Sie bei ljeder Schleife denselben Zeiger ( )? Ich denke, Sie sollten die aktuelle Position des Kopfes überprüfen ( p).
Alexandru
Ich übergebe den Zeiger an den Puffer und den Zeiger an den Stream. Es prüft am Ende der Schleife, ob der Zeiger lim 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 .
snmcdonald
1
Ja. Ich dachte auch. Sie sollten nicht zuerst den Wert am Zeiger in die Schleife eingeben, sondern den Wert am aktuellen Zeiger. Überprüfen Sie den Test in der Frage. Ihr Programm hängt.
Alexandru
1
Sie können ersetzen break;elsedurch return;.
Alexandru
3
Ich glaube , Sie können ersetzen (c==62)?a:bmit (c-62)?b:a.
Alexandru
9

PHP 5.4, 296 294 273 263 261 209 191 183 178 166 Zeichen:

Ich habe es ausprobiert, ohne eval zu benutzen, aber ich musste es schließlich benutzen

<?$b=0;eval(strtr(`cat $argv[1]`,["]"=>'}',"["=>'while($$b){',"."=>'echo chr($$b);',","=>'$$b=fgetc(STDIN);',"+"=>'$$b++;',"-"=>'$$b--;',">"=>'$b++;',"<"=>'$b--;']));

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, 367 365 335 296 267 Zeichen:

<?php
$a[] = $b = 0;
$p = implode("",file($argv[1])); // Shorter than file_get_contents by one char
$m = array("]" => '}', "[" => 'while($a[$b]){',"." => 'echo chr($a[$b]);', "," => '$a[$b]=fgetc(STDIN);', "+" => '$a[$b]++;', "-" => '$a[$b]--;', ">" => '$b++;', "<" => '$b--;');
$p = strtr($p,$m);
@eval($p);

Dies sollte über die Befehlszeile ausgeführt werden: php bf.php hello.bf

Bass5098
quelle
8

Windows PowerShell, 204

'$c=,0*3e4;'+@{62='$i++
';60='$i--
';43='$c[$i]++
';45='$c[$i]--
';44='$c[$i]=+[console]::ReadKey().keychar
';46='write-host -n([char]$c[$i])
';91='for(;$c[$i]){';93='}'}[[int[]][char[]]"$(gc $args)"]|iex

Ziemlich unkomplizierte Umsetzung der Anweisungen und dann Invoke-Expression.

Geschichte:

  • 2011-02-13 22:24 (220) Erster Versuch.
  • 2011-02-13 22:25 (218) 3e4ist kürzer als 30000.
  • 2011-02-13 22:28 (216) Unnötige Zeilenumbrüche. Die Suche nach Ganzzahlen anstelle von Zeichen ist kürzer.
  • 2011-02-13 22:34 (207) Verwendete Indizes in einer Hash-Tabelle anstelle von switch.
  • 2011-02-13 22:40 (205) Eine bessere Umwandlung in eine Zeichenfolge entfernt zwei Klammern.
  • 2011-02-13 22:42 (204) Nach dem Argument zu ist kein Leerzeichen erforderlich Write-Host.
Joey
quelle
8

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 von strchrauf einer anderen Plattform nicht funktioniert. Auch davon geht es aus O_RDONLY == 0. Abgesehen davon, wenn Sie intdie Deklaration von Msave 3 Zeichen weglassen, scheint dies nicht C99-konform zu sein. Gleich mit dem dritten *in b().

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.

#include<unistd.h>
char C[30000],*c=C,o,P[9000],*p=P,*S[9999],**s=S,*O="=,-\\",*t;
m(){c+=o;}
i(){*c-=o;}
w(){o<0?*c=getchar():putchar(*c);}
b(){if(o>0)*c?p=*s:*--s;else if(*c)*++s=p;else while(*p++!=93)*p==91&&b();}
int(*M[])()={m,i,w,b};
main(int N,char**V){
read(open(V[1],0),P,9e3);
while(o=*p++)
if(t=strchr(O,++o&~2))
o-=*t+1,
M[t-O]();
}
Kartoffelklatsche
quelle
Ich denke, Sie können es mehr verkleinern, indem Sie die 'e'-Notation für alle großen Zahlen verwenden.
Luser Droog
@luser: Ich war anfangs auch überrascht, aber die Sprache und der Compiler lassen das nicht zu. Ich habe es geschafft, weitere 4 Zeichen mit Tweaks zu verkleinern, und die Verwendung einer #defineanstelle der Funktionstabelle wäre wahrscheinlich auch schärfer. Ich mag nur die Nummer 333 und die Tabelle: v).
Potatoswatter
Oh, richtig. Das hätte ich wirklich wissen müssen. E-Notation ist in der Produktion für eine Gleitkommakonstante, während eine Deklaration eine ganze Zahl erfordert. Übrigens, das mag ein Betrug sein, aber schau unter nieko.net/projects/brainfuck nach Urban Müllers Version. Der größte Gewinn scheint die starke Nutzung zu sein ||.
Luser Droog
8

CJam, 75 Bytes

lq3e4Vc*@{"-<[],.+>"#"T1$T=(t T(:T; { _T=}g \0+(@T@t _T=o "_'(')er+S/=}%s~@

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.

l            Read a line from STDIN (the program) and push it.
 q           Read the rest of STDIN (the input) and push it.
  3e4Vc*     Push a list of 30000 '\0' characters.
        @    Rotate the stack so the program is on top.

{               }%   Apply this to each character in prog:
 "-<[],.+>"#         Map '-' to 0, '<' to 1, ... and everything else to -1.
            ...=     Push a magical list and index from it.

s~       Concatenate the results and evaluate the resulting string as CJam code.
  @      Rotate the top three elements again -- but there are only two, so the
         program terminates.

Was ist mit dieser magischen Liste?

"T1$T=(t T(:T; { _T=}g \0+(@T@t _T=o "  Space-separated CJam snippets.
                                        (Note the final space! We want an empty
                                        string at the end of the list.)
_'(')er+                                Duplicate, change (s to )s, append.
        S/                              Split over spaces.

Die resultierende Liste ist wie folgt:

T1$T=(t    (-)
T(:T;      (<)
{          ([)
_T=}g      (])
\0+(@T@t   (,)
_T=o       (.)
T1$T=)t    (+)
T):T;      (>)
{          (unused)
_T=}g      (unused)
\0+(@T@t   (unused)
_T=o       (unused)
           (all other characters)

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.

Lynn
quelle
Kürzeste Antwort & größter Gewinner
Jack Giffin
7

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:

[<EntryPoint>]
let M a=
 let A,B,i,p,w=Array.create 30000 0uy,[|yield!System.IO.File.ReadAllText a.[0]|],ref 0,ref 0,char>>printf"%c"
 let rec g n c f a b=if c then f i;if B.[!i]=a then g(n+1)c f a b elif B.[!i]=b then(if n>0 then g(n-1)c f a b)else g n c f a b
 while !i<B.Length do(let x=A.[!p]in match B.[!i]with|'>'->incr p|'<'->decr p|'+'->A.[!p]<-x+1uy|'-'->A.[!p]<-x-1uy|'.'->w x|','->A.[!p]<-byte<|stdin.Read()|'['->g 0(x=0uy)incr '['']'|']'->g 0(x>0uy)decr ']''['|_->());incr i
 0

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:

interpret.exe prime.bf < number.txt

Bearbeiten: Eingabe von Alt + 010 gefolgt von Eingabe funktioniert auch in Windows cmd.exe

Hier ist die längere Version:

[<EntryPoint>]
let Main args =
    let memory = Array.create 30000 0uy
    let source = [| yield! System.IO.File.ReadAllText args.[0] |]
    let memoryPointer = ref 0
    let sourcePointer = ref 0
    let outputByte b = printf "%c" (char b)
    let rec scan numBraces mustScan adjustFunc pushToken popToken =
        if mustScan then
            adjustFunc sourcePointer
            if source.[!sourcePointer] = pushToken then
                scan (numBraces + 1) mustScan adjustFunc pushToken popToken
            elif source.[!sourcePointer] = popToken then
                if numBraces > 0 then scan (numBraces - 1) mustScan adjustFunc pushToken popToken
            else
                scan numBraces mustScan adjustFunc pushToken popToken 

    while !sourcePointer < source.Length do
        let currentValue = memory.[!memoryPointer]
        match source.[!sourcePointer] with
            | '>' -> incr memoryPointer
            | '<' -> decr memoryPointer
            | '+' -> memory.[!memoryPointer] <- currentValue + 1uy
            | '-' -> memory.[!memoryPointer] <- currentValue - 1uy
            | '.' -> outputByte currentValue
            | ',' -> memory.[!memoryPointer] <- byte <| stdin.Read()
            | '[' -> scan 0 (currentValue = 0uy) incr '[' ']'
            | ']' -> scan 0 (currentValue > 0uy) decr ']' '['
            |  _  -> ()
        incr sourcePointer
    0 
cfern
quelle
Ich löste das Enter-Problem, indem ich nicht drückte, sondern Strg + J :-)
Joey
Strg + J hat bei mir nicht funktioniert, aber die Eingabe von Alt + 010 gefolgt von der Eingabetaste hat funktioniert.
cfern
7

Delphi, 397 382 378 371 366 364 328 Zeichen

Iss dieses Delphi!

328 var p,d:PByte;f:File;z:Word=30000;x:Int8;begin p:=AllocMem(z+z);d:=p+z;Assign(F,ParamStr(1));Reset(F,1);BlockRead(F,p^,z);repeat z:=1;x:=p^;case x-43of 1:Read(PChar(d)^);3:Write(Char(d^));0,2:d^:=d^+44-x;17,19:d:=d+x-61;48,50:if(d^=0)=(x=91)then repeat p:=p+92-x;z:=z+Ord(p^=x)-Ord(p^=x xor 6);until z=0;end;Inc(p)until x=0;end.

Hier der gleiche Code, eingerückt und kommentiert:

var
  d,p:PByte;
  x:Int8;
  f:File;
  z:Word=30000;
begin
  // Allocate 30000 bytes for the program and the same amount for the data :
  p:=AllocMem(z+z);
  d:=p+z;
  // Read the file (which path must be specified on the command line) :
  Assign(F,ParamStr(1));
  Reset(F,1);
  BlockRead(F,p^,z);
  // Handle all input, terminating at #0 (better than the spec requires) :
  repeat
    // Prevent a begin+end block by preparing beforehand (values are only usable in '[' and ']' cases) :
    z:=1;                       // Start stack at 1
    x:=p^;                      // Starting at '[' or ']'
    // Choose a handler for this token (the offset saves 1 character in later use) :
    case x-43of
      1:Read(PChar(d)^);        // ','     : Read 1 character from input into data-pointer
      3:Write(Char(d^));        // '.'     : Write 1 character from data-pointer to output
      0,2:d^:=d^+44-x;          // '+','-' : Increase or decrease data
      17,19:d:=d+x-61;          // '<','>' : Increase or decrease data pointer
      48,50:                    // '[',']' : Start or end program block, the most complex part :
        if(d^=0)=(x=91)then     // When (data = 0 and forward), or when (data <> 0 and backward)
        repeat                  //
          p:=p+92-x;            // Step program 1 byte back or forward
          z:=z+Ord(p^=x)        // Increase stack counter when at another bracket
              -Ord(p^=x xor 6); // Decrease stack counter when at the mirror char
        until z=0;              // Stop when stack reaches 0
    end;
    Inc(p)
  until x=0;
end.

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?

PatrickvL
quelle
Beeindruckend! Ich hätte nie gedacht, dass ich C mit Delphi übertreffen würde! Nicht, bis Sie meine Ideen auf CI anwenden
;-)
7

C 260 + 23 = 283 Bytes

Ich habe ein C-Programm erstellt, das hier zu finden ist .

main(int a,char*s[]){int b[atoi(s[2])],*z=b,p;char*c=s[1],v,w;while(p=1,
*c){q('>',++z)q('<',--z)q('+',++*z)q('-',--*z)q('.',putchar(*z))q(',',*z
=getchar())if(*c=='['||*c==']'){v=*c,w=184-v;if(v<w?*z==0:*z!=0)while(p)
v<w?c++:c--,p+=*c==v?1:*c==w?-1:0;}c++;}}

Muss über kompiliert werden gcc -D"q(a,b)"="*c-a||(b);" -o pmmbf pmmbf.cund kann wie folgt aufgerufen werden: pmmbf ",[.-]" 30000wobei das erste Argument (zitiert) das auszuführende bf-Programm enthält, das zweite bestimmt, wie groß das Band sein soll.

phimuemue
quelle
1
Ich denke, dass Sie 23 Zeichen zu Ihrer Anzahl hinzufügen müssen, um die -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.
Gareth
Die Option ist im gebuchten Text enthalten. Der Grund dafür ist, das lange Wort defineund die Zeilenumbrüche zu vermeiden , aber ich denke nicht, dass das wirklich koscher ist. Wie auch immer, bei den Zitaten und Kommentaren gcc -Dsehe ich den Vorteil überhaupt nicht.
Potatoswatter
5

C 267

#define J break;case
char*p,a[40000],*q=a;w(n){for(;*q-93;q++){if(n)switch(*q){J'>':++p;J'<':--p;J'+':++*p;J'-':--*p;J'.':putchar(*p);J',':*p=getchar();}if(*q==91){char*r=*p&&n?q-1:0;q++;w(r);q=r?r:q;}}}main(int n,char**v){p=a+read(open(v[1],0),a,9999);*p++=93;w(1);}

Führen Sie als ./a.out primes.bf aus

Ungolfed Version:

#define J break;case

char*p,a[40000],*q=a; // packed so program immediately followed by data

w(n){
    for(;*q-93;q++){ // until ']'
        if(n)switch(*q){ // n = flagged whether loop evaluate or skip(0)
                J'>':++p;
                J'<':--p;
                J'+':++*p;
                J'-':--*p;
                J'.':putchar(*p);
                J',':*p=getchar();
        }
        if(*q==91){char*r=*p&&n?q-1:0;q++;w(r);q=r?r:q;} // recurse on '[', record loop start
    }
}

main(int n,char**v){
    p=a+read(open(v[1],0),a,9999);
    *p++=93; // mark EOF with extra ']' and set data pointer to next
    w(1); // begin as a loop evaluate
}
Baby-Kaninchen
quelle
5

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

P="";i,a=0,[0]*30000
import os,sys
for c in open(sys.argv[1]).read():x="><+-.[,]".find(c);P+=" "*i+"i+=1 i-=1 a[i]+=1 a[i]-=1 os.write(1,chr(a[i])) while+a[i]: a[i]=ord(os.read(0,1)) 0".split()[x]+"\n";i+=(x>4)*(6-x)
exec P

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.

WolframH
quelle
5

C (gcc) Linux x86_64, 884 621 525 487 439 383 358 354 Bytes

*z,*mmap();d[7500];(*p)();*j(a,g)char*a;{char*t=a,*n,c,q=0;for(;read(g,&c,!q);)t=c==91?n=j(t+9,g),z=mempcpy(t,L"\xf003e80Ƅ",5),*z=n-t-9,n:c==93?q=*t++=233,z=t,*z=a-13-t,z+1:stpcpy(t,c-62?c-60?c-43?c-45?c-46?c-44?"":"1\xc0P_\xF\5":"RXR_\xF\5":L"໾":L"۾":L"컿":L"웿");return t;}main(P,g)int**g;{p=mmap(0,1<<20,6,34,0,0);p(*j(p,open(g[1],0))=195,d,1);}

Probieren 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:

// size of data area
*z,c,*mmap();d[7500];(*p)();
// recursive function translates BF commands to x86_64 instructions
*j(a,g)char*a;{
  char*t=a,*n,q=0;
  for(;read(g,&c,!q);)
    t=c==91? // [
        // cmpb $0x0,(%rsi)
        // je n-t-9
        n=j(t+9,g),
        z=mempcpy(t,L"\xf003e80Ƅ",5)
        *z=n-t-9,
        n
      :
        c==93? // ]
          // jmp a-13-t
          q=*t++=233,
          z=t,
          *z=a-13-t,
          z+1
        :
          stpcpy(t,c-62? // >
                     c-60? // <
                       c-43? // +
                         c-45? // -
                           c-46? // .
                             c-44? // ,
                               ""
                             :
                               // xor %eax,%eax
                               // push %rax
                               // pop %rdi
                               // syscall
                               "1\xc0P_\xF\5"
                           :
                             // push %rdx
                             // pop %rax
                             // push %rdx
                             // pop %rdi
                             // syscall
                             "RXR_\xF\5"
                         :
                           // decb (%rsi)
                           L"໾"
                       :
                         // incb (%rsi)
                         L"۾"
                     :
                       // dec %esi
                       L"컿"
                   :
                     // inc %esi
                     L"웿");
  return t;
}
main(P,g)int**g;{
  // allocate text (executable) memory and mark as executable
  p=mmap(0,1<<20,6,34,0,0);
  // run JIT, set %rdx=1 and call code like a function
  p(*j(p,open(g[1],0))=195,d,1);
}
Ceilingcat
quelle
4

C 374 368

Liest aus einer Datei. Besteht den PRIME.BF-Test.

Verwendung: ./a.out PRIME.BF

#include <stdio.h>
main(int c,char**v){int m[30000],s[99],p=0,i=0,n=0;char l[9999],d;FILE*f=fopen(v[1],"r");for(l[i]=0;i<9999&&l[i]!=EOF;l[i]=getc(f))i++;for(i=1;d=l[i];i++){if(!n){p+=d-62?0:1;p-=d-60?0:1;m[p]+=d-43?0:1;m[p]-=d-45?0:1;if(d==46)putchar(m[p]);if(d==44){m[p]=getchar();}if(d==93){i=s[c]-1;c--;n++;}}if(d==91){if(m[p]){c++;s[c]=i;}else{n++;}}n-=d-93?0:1;}}


Neuformatiert:

#include <stdio.h>
main(int c,char**v){
    int m[3000],s[99],p=0,i=0,n=0;
    char l[9999],d;
    FILE*f=fopen(v[1],"r");
    for(l[i]=0;i<9999&&l[i]!=EOF;l[i]=getc(f))i++;
    for(i=1;d=l[i];i++){
        if(!n){ // > < + - . , ] \n [ ]
            p+=d-62?0:1;
            p-=d-60?0:1;
            m[p]+=d-43?0:1;
            m[p]-=d-45?0:1;
            if(d==46)putchar(m[p]);
            if(d==44){m[p]=getchar();}
            if(d==93){i=s[c]-1;c--;n++;}
        }
        if(d==91){if(m[p]){c++;s[c]=i;}else{n++;}}
        n-=d-93?0:1;
    }
}
jtjacques
quelle
3000 vs 30000. Ihr Puffer ist zu klein. Die Programmgröße ist auch zu klein.
Alexandru
Ich habe einen Tippfehler gemacht, behoben. Was meinst du mit Programmgröße? Wenn Sie die maximale Dateigröße meinen, haben Sie kein Minimum angegeben, das behandelt werden soll.
jtjacques
4

Lua, 285

loadstring("m,p={0},1 "..io.open(arg[1]):read"*a":gsub("[^.,<>[%]+-]",""):gsub(".",{["."]="io.write(string.char(@)) ",[","]="@=io.read(1):byte() ",["<"]="p=p-1 ",[">"]="p=p+1 @=@or 0 ",["["]="while @~=0 do ",["]"]="end ",["+"]="@=(@+1)%256 ",["-"]="@=(@-1)%256 "}):gsub("@","m[p]"))()

Etwas lesbare Version:

loadstring( --execute
    "m,p={0},1 ".. --initialize memory and pointer
    io.open(arg[1]) --open file
        :read"*a" --read all
            :gsub("[^.,<>[%]+-]","") --strip non-brainfuck
                :gsub(".", --for each character left
                    {["."]="io.write(string.char(@)) ", -- '@' is shortcut for 'm[p]', see below
                    [","]="@=io.read(1):byte() ",
                    ["<"]="p=p-1 ",
                    [">"]="p=p+1 @=@or 0 ", --if a before unexplored memory cell, set to 0
                    ["["]="while @~=0 do ",
                    ["]"]="end ",
                    ["+"]="@=(@+1)%256 ", --i like it overflowing
                    ["-"]="@=(@-1)%256 "
                    }
                )
                    :gsub("@","m[p]") --replace the '@' shortcut
    ) --loadstring returns a function
() --call it

Funktioniert perfekt

Lua, 478, ohne Schnur

local m,p,i,r,c={0},1,1,{},io.open(arg[1]):read"*a"while i<=#c do(({[43]=function()m[p]=(m[p]+1)%256 end,[45]=function()m[p]=(m[p]-1)%256 end,[62]=function()p=p+1 m[p]=m[p]or 0 end,[60]=function()p=p-1 end,[46]=function()io.write(string.char(m[p]))end,[44]=function()m[p]=io.read(1):byte()end,[91]=function()if m[p]==0 then i=select(2,c:find("%b[]",i))else r[#r+1]=i end end,[93]=function()if m[p]==0 then r[#r]=nil else i=r[#r] end end})[c:byte(i)]or function()end)()i=i+1 end

Lesbare Version:

local m,   p, i, r,  c= --memory, pointer, brackets stack, code
      {0}, 1, 1, {}, io.open(arg[1]) --open file
              :read"*a" --read it
while i<=#c do --while there's code
    (
        (
            {
                [43]=function() -- +
                    m[p]=(m[p]+1)%256
                end,
                [45]=function() -- -
                    m[p]=(m[p]-1)%256
                end,
                [62]=function() -- >
                    p=p+1 m[p]=m[p]or 0 --if new memory cell, set it to 0
                end,
                [60]=function() -- <
                    p=p-1
                end,
                [46]=function() -- .
                    io.write(string.char(m[p]))
                end,
                [44]=function() -- ,
                    m[p]=io.read(1):byte()
                end,
                [91]=function() -- [
                    if m[p]==0 then
                        i=select(2,c:find("%b[]",i)) --find matching ]
                    else
                        r[#r+1]=i --push position to the stack
                    end
                end,
                [93]=function() -- ]
                    if m[p]==0 then
                        r[#r]=nil --pop from stack
                    else
                        i=r[#r] --go to position on the top of stack
                    end
                end
            }
        )[c:byte(i)] --transform character into code
        or function()end --do nothing on non-brainfuck
    )() --run the resulting function
    i=i+1 --go to the next opcode
end
mniip
quelle
4

Brainfuck, 948 Bytes

Nun, das hat eine Weile gedauert. Ich habe einen Brainfuck- Selbstdolmetscher von ... nicht von mir gespielt.

->->>>-[,+>+<[->-]>[->]<+<-------------------------------------[+++++++++++++++++++++++++++++++++++++>-]>[->]<<[>++++++++[-<----->]<---[-[-[-[--------------[--[>+++++++[-<---->]<-[--[[+]->]<+[->++>]->]<+[->+>]->]<+[->+++++>]->]<+[->++++++>]->]<+[->+++++++>]->]<+[->++++>]->]<+[->++++++++>]->]<+[->+++>]->]+<+[->->]>[-<->]<]>>->>-<<<<<+++[<]>[-[-[-[-[-[-[-[-<<++++++++>>>[>]>>>>+[->>+]->,<<<+[-<<+]-<<<[<]<]>[<<<+++++++>>>[>]>>>>+[->>+]->.<<<+[-<<+]-<<<[<]]<]>[<<<++++++>>>[>]>>>>+[->>+]<<-<<+[-<<+]-<<<[<]]<]>[<<<+++++>>>[>]>>>>+[->>+]+>>-<<[-<<+]-<<<[<]]<]>[<<<++++>>>[>]>>>>+[->>+]->-<<<+[-<<+]-<<<[<]]<]>[<<<+++>>>[>]>>>>+[->>+]->+<<<+[-<<+]-<<<[<]]<]>[<++[>]>>>>+[->>+]->[<<<+[-<<+]-<<<[<]-[<<-[>->-[<+]]<+[->>[<]]<-[>-->+[<++]]<++[-->>[<]]<++>>[[-<+>]<<[->>+<<]]<[>]>]]<[<<+[-<<+]-<<<[<]>--<<++>]>]<]>[<<<+>>>[>]>>>>+[->>+]->[<<<+[-<<+]-<<<[<]]<[<<+[-<<+]-<<<[<]+[>-[<-<]<<[>>]>>-[<+<]<<[>>]>>++<[>[-<<+>>]<[->+<]]<[>]>]]>[[-<<+>>]<[->+<]>]]>]
MD XF
quelle
4

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.

DC505M22022M32032M606M42042M707M92092M4405022o032o06o042o07o092o044o1305022o06o042o092o52052q.q2305022o06o07o93093q.q5403206o07o14014q.q6403206o042o07o24024q.q74Yx34034z03MMMMMMMM034o3yY030401r3.4.101zyY040301r4.3.101zY01052gZ02Z040301052023s4.3.10zyY01023gZ02z030401023052s3.4.10zyY01093gZ02q20zyY01054gZ02u20zyY01014gZx20zyY01064gZ02X0zyY01024gZ03304302r33.43.20zyY01074gZ04303302r43.33.20zyyQ6205.8Y06208g6206208iZ08M808013izy062U7205.9Y07209g7207209iz09M909013izy072R53.63.82063MMMMMMMM053o63082013i53082KKKKKKKK82053063082S84.94.12.73.83t012073083TY083073012r83.73.12012084gzY012094gZt0zyy

Beispiel 1: Drucken Sie etwas

Eingang:

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

Ausgabe:

PPCG rocks!

Beispiel 2: Ausgabe von Quadraten bis 100

Eingang:

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

Ausgabe:

0
1
4
9
16
25
36
49
64
81
100

Die Ausführung dieses Beispiels kann einige Minuten dauern und die Meldung "Diese Registerkarte ist eingefroren" auslösen. Ignoriere das und warte.

mınxomaτ
quelle
4
Ihre Website-Domain ist abgelaufen. Diese Antwort ist auch nicht konkurrierend, da die Sprache neuer ist als die Herausforderung.
mbomb007
3

OCaml (Lex), 497 Zeichen

OCamllex ist Teil der Standarddistribution von OCaml.

{let a=Array.create 30000 0
let(%)f g h=f(g h)
let s v i=a.(i)<-v;i
let o d i=s(a.(i)+d)i
let p i=print_char(Char.chr a.(i));flush stdout;i
let r i=s(Char.code(input_char stdin))i
let rec w g i=if 0=a.(i)then i else w g(g i)
let n x=x}
rule t f=parse
|'>'{t(succ%f)lexbuf}
|'<'{t(pred%f)lexbuf}
|'+'{t((o 1)%f)lexbuf}
|'-'{t((o(-1))%f)lexbuf}
|'.'{t(p%f)lexbuf}
|','{t(r%f)lexbuf}
|'['{t((w(t n lexbuf))%f)lexbuf}
|']'|eof{f}
|_{t f lexbuf}
{let _=t n(Lexing.from_channel(open_in Sys.argv.(1)))0}

Als b.mll speichern und mit ausführen

ocamllex b.mll && ocaml b.ml prime.bf

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.

bltxd
quelle
3

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.

using System;
using System.Collections.Generic;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            String ProgSource;
            if (args.Length > 0)
                ProgSource = System.IO.File.ReadAllText(args[0]);
            else //hello world
                ProgSource = "";

            Stack<int> stack = new Stack<int>();
            char[] bfProg = ProgSource.ToCharArray();
            char[] mem = new char[30000];
            int ptr = 0;

            for (int ip = 0; ip<bfProg.Length; ip++){
                switch (bfProg[ip])
                {
                    case ('>'): ptr++;  break;
                    case ('<'): ptr--;  break;
                    case ('+'): mem[ptr]++; break;
                    case ('-'): mem[ptr]--; break;
                    case ('.'): Console.Write(mem[ptr]); break;
                    case (','): 
                        char key = Console.ReadKey(false).KeyChar;
                        if (key == '\r')
                        {
                            key = (char)10;
                            Console.WriteLine();
                        }
                        mem[ptr] = key;
                        break;
                    case ('['):
                        if (mem[ptr] == 0)
                        {
                            int openBraces = 1;
                            //find the closing brace for this expression
                            for (int x = 1; x < (bfProg.Length - ip); x++)
                            {
                                if (bfProg[ip + x] == ']') openBraces--;
                                if (bfProg[ip + x] == '[') openBraces++;
                                if (openBraces == 0)
                                {
                                    if (stack.Peek() == ip) stack.Pop();
                                    ip += x;
                                    break;
                                }                                
                            }
                       }
                       else
                       {
                           stack.Push(ip);
                       }
                       break;
                    case (']'):
                        if (mem[ptr] == 0)
                            stack.Pop();
                        else
                        {
                            ip = stack.Peek();
                        }
                        break;
                }
            }

            Console.WriteLine("\n\n\nExecution Completed Sucessfully. Press any key to continue...");
            Console.ReadKey();

        }
    }

}

Bearbeiten: Nicht verwendete Referenzen wurden entfernt.

theB
quelle
1
@ mbomb007 - Aktualisiert. Völlig vergessen, dass ich das überhaupt gemacht habe. (
Ich
Die Leute lesen sie nicht nur noch, sie antworten auch noch und spielen Golf.
mbomb007
3

C (gcc) , 273 268 Bytes

main(_,a){_=fopen("w.c","w");fputs("main(){char a[30000],*p=a;",_);x:a=getchar();fputs(a-62?a-60?a-43?a-45?a-46?a-44?a-91?a-93?~a?"":"}":"}":"while(*p){":"*p=getchar();":"putchar(*p);":"--*p;":"++*p;":"--p;":"++p;",_);if(~a)goto x;fclose(_);system("cc w.c;./a.out");};

Probieren 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.outeine 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.

LambdaBeta
quelle
259 Bytes
Ceilingcat
2

[BEARBEITEN]

C ++ 11, 355, liest aus Datei:

#include<functional>
#include<stdio.h>
main(){
char b[30000],g[9999],*f=g,*p=b,n[]="+-,.><[]",j;
std::function<void()>m[]={
[&p]{(*p)++;},
[&p]{(*p)--;},
[&p]{*p=getchar();},
[&p]{putchar(*p);},
[&p]{p++;},
[&p]{p--;},
[&p,&f]{if(!(*p))while(*f-93)f++;},
[&f,&m]{while(*f-91)f--;m[6]();}
};
fread(g,1,9999,fopen(a[1],0));
for(;*f;f++)for(j=0;n[j];j++)if(n[j]==*f)m[j]();
}

Prüfung

http://ideone.com/b7vO4

[ALTE VERSION]

C ++ 11, 391: http://ideone.com/yZHVv

#include<functional>
#include<stdio.h>
main(int c,char **a) {
  char b[30000],g[9999],*f=g,*r=f,*p=b;
  std::function<void()>m[256];
  m['>']=[&p]{p++;};  
  m['<']=[&p]{p--;};
  m['+']=[&p]{(*p)++;};
  m['-']=[&p]{(*p)--;};
  m['.']=[p]{putchar(*p);};
  m[',']=[&p]{*p=getchar();};
  m['[']=[p,&r,&f]{*p?r=f-1:r=0;};
  m[']']=[&r,&f]{r?f=r:r=f;};
  fread(g,1,9999,fopen(a[1],"r"));
  while (c=*(f++))if(m[c]&&(r||c==']'))m[c]();
}
Olivencoder
quelle