bfcat - kodiere eine Datei als brainf *** Programm

18

Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die eine Zeichenfolge angibt und ein gültiges Brainfuck-Programm zurückgibt, das diese Zeichenfolge zurückgibt, wenn es als Brainfuck kompiliert und ausgeführt wird.

  1. Angenommen, alle Eingaben sind als ASCII codiert.

  2. Angenommen, das ausgegebene BF-Programm wird in einer Umgebung mit einem unendlichen Band ausgeführt.

  3. Angenommen, der Zeiger beginnt bei Zelle 0, wobei jede Zelle auf den Wert Null initialisiert wird.

  4. Jedes Beispiel unten repräsentiert eine mögliche korrekte Ausgabe für die angegebene Eingabe. Die Beispiele enthalten insbesondere zusätzliche Zeilenumbrüche und Leerzeichen, um die Lesbarkeit zu verbessern. Die Lösungen können den ausgegebenen BF-Code beliebig formatieren.

  5. Das Band ist doppelt unendlich.

  6. Alle vom Interpreter bereitgestellten Zellen sind genau 8-Bit-Zellen. Über- und Unterlauf sind eine vorhersehbare und vernünftige Angelegenheit.

Beispiele

Leerzeichenfolge

In Anbetracht der Eingabe könnte Ihr Programm / Ihre Funktion Folgendes zurückgeben:

+++++ +++++
+++++ +++++
+++++ +++++
++ .

Ausrufezeichen

In Anbetracht der Eingabe könnte !Ihr Programm / Ihre Funktion Folgendes zurückgeben:

+++++ +++++
+++++ +++++
+++++ +++++
+++
.

Zwei Buchstaben

In Anbetracht der Eingabe könnte hiIhr Programm / Ihre Funktion Folgendes zurückgeben:

+++++ +++++
+++++ +++++
+++++ +++++
+++++ +++++
+++++ +++++

+++++ +++++
+++++ +++++
+++++ +++++
+++++ +++++
+++++ +++++

++++
.
+
.

Das ist , also gewinnt der Code mit der geringsten Anzahl von Bytes. Viel Glück.

Yeow_Meng
quelle
10
Weitere Testfälle bitte.
Undichte Nonne
1
Was genau sind die in Revision 9 genannten Richtlinien ?
user8397947
4
Ich öffne das wieder. Ich denke, Peters Bedenken wurden ausgeräumt und wir haben einen ziemlich klaren Konsens darüber, was als Duplikat gilt, und diese Herausforderung erfüllt diese Kriterien nicht.
Martin Ender
"Überlauf und Unterlauf in vorhersehbarer und vernünftiger Weise umbrechen" - also wird 127 + 1 auch auf 0 und -128-1 auch auf 0 umbrochen, richtig? Das ist eine mögliche vorhersehbare und vernünftige Art und Weise.
user253751
1
@immibis Genau.
user8397947

Antworten:

18

Gelee , 8 Bytes

O”+ẋp“.>

Probieren Sie es online!

Probelauf

Zur Eingabe hidruckt dieses Programm

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++>

(ohne die Zeilenvorschübe), die wiederum gedruckt werdenhi .

Wie es funktioniert

O”+ẋp“.>  Main link. Argument: s (string)

O         Ordinal; convert each character in s into its code point.
 ”+       Yield the character '+'.
   ẋ      Repeat '+' k times, for each k in the code points.
     “.>  Yield the string ".>".
    p     Take the Cartesian product of both results.
Dennis
quelle
Deiner arbeitet nicht mit begrenztem Speicher, meiner schon.
Undichte Nonne
5
Nicht wirklich. Wir beide speichern die gesamte Ausgabe im Speicher, bevor wir drucken. Für BF-Dolmetscher mit einem ausreichend großen Band wird dies lange vor dem Band zu einem Problem.
Dennis
Warum wird .>in der Ausgabe nicht angezeigt?
Katze
2
@cat Weil das kartesische Produkt ( p) kürzer ist als an jedes ( ;€) anzuhängen . Diese Ausgabeprogramme verdoppeln die Zelle nach dem Drucken und vor dem Umschalten. Da wir die Zelle nie wieder besuchen, hat dies keine Auswirkungen auf die Ausgabe.
Dennis
@ Tennis ahh, interessant.
Katze
55

Brainfuck, 55 51 Bytes

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

Probieren Sie es online!

Beispielausgabe für hi(ohne die Zeilenvorschübe):

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>

Erläuterung

Dies bewegt sich über das Band, während das Programm geschrieben wird. Die Umgebung ,[...,]ist eine Standardeingabeschleife. Für jedes Zeichen verwenden wir vier Zellen:

[... x a b c ...]

Wo xist die Zelle, in die wir die Eingabe schreiben?

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

Dieser Teil verwendet cell a, um über eine Standardmultiplikation von und ein 21in cell zu schreiben .b37

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

Jetzt verwenden wir , dass 21zu schreiben 42in aund 63in cvon durch Multiplikation 2und 3jeweils. Bewegt <+<sich dann zurück zur Zelle xund verwandelt sich 42in einen 43(den Codepunkt von +). Rekapitulieren:

[... x 43 21 63 ...]

Nun die Hauptausgabeschleife:

[>.<-]

Das heißt, während xwir dekrementieren , drucken wir +jedes Mal eines.

>+++.

Nachdem wir fertig sind, verwenden wir die +Zelle wieder, indem wir addieren 3, um zu geben ..

>>-.

Schließlich bewegen wir uns zu 63, dekrementieren es zu 62( >) und geben es ebenfalls aus. Die nächste Iteration verwendet diese Zelle als x.

Martin Ender
quelle
5
Ich würde eine Prämie dafür geben, wenn ich mehr Repräsentanten hätte.
user8397947
34

Brainfuck, 39 33 32 31 Bytes

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

Der Algorithmus, der 45 auf das Band legt, wird aus Esolangs Brainfuck-Konstanten entnommen .

Diese Antwort setzt voraus, dass der Interpreter des Ausgabeprogramms umschließende, begrenzte Zellen hat. und das setzt ,die aktuelle Zelle auf Null (was bedeutet, dass das Ausgabeprogramm ohne Eingabe ausgeführt wird). Probieren Sie es online!

Eine (längere) Lösung, die bedingungslos funktioniert, finden Sie in meiner anderen Antwort .

Testlauf

Für die Eingabe Code Golfwird die folgende Ausgabe generiert.

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------.,-------------------------------------------------------------------------------------------------------------------------------------------------.,------------------------------------------------------------------------------------------------------------------------------------------------------------.,-----------------------------------------------------------------------------------------------------------------------------------------------------------.,--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------.,-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------.,-------------------------------------------------------------------------------------------------------------------------------------------------.,----------------------------------------------------------------------------------------------------------------------------------------------------.,----------------------------------------------------------------------------------------------------------------------------------------------------------.,

Probieren Sie es online!

Wie es funktioniert

Wir beginnen damit, die Ganzzahl 45 (Zeichencode von -) in eine Zelle des Bandes zu schreiben. Der folgende Code erreicht dies.

-      Decrement cell 0, setting it to 255.
[      While the cell under the head in non-zero:
  [>]    Advance to the next zero cell.
  <--    Decrement the cell to its left.
  <--    Decrement the next cell to the left.
]

Bevor wir in die Schleife eintreten, sieht das Band so aus.

         v
000 000 255

Diese drei Zellen - -2 , -1 und 0 - sind die einzigen, die wir in diesem Programm verwenden.

In der ersten Iteration der Schleife ist die Zelle ganz rechts, dann werden diese Zelle und die mittlere Zelle zweimal dekrementiert, wobei der folgende Zustand verbleibt.

     v
000 254 252

In den nächsten 126 Iterationen -dekrementiert der Anfang die mittlere Zelle, [>]<springt zur Zelle ganz rechts und --<--dekrementiert die mittlere und die rechte Zelle. Infolgedessen wird 3 von der mittleren Zelle (Modulo 256 ) und 2 von der Zelle ganz rechts subtrahiert.

Da 254 ≤ 3 (mod 256) = (254 + 256) ≤ 3 = 510 ≤ 3 = 170 und 252 ≤ 3 = 84 ist , wird die Zelle ganz rechts vor der mittleren auf Null gesetzt, wodurch der folgende Zustand verbleibt.

     v
000 132 000

Ähnlich wie bei der ersten Iteration der Schleife werden bei der nächsten Iteration nun 3 von der mittleren Zelle und 2 von der Zelle ganz links subtrahiert , wobei der Kopf auf die Zelle ganz links gelegt wird.

 v
254 129 000

Nachfolgende Iterationen subtrahieren, wie in der vorhergehenden Iteration 126, 3 von der Zelle ganz links und 2 von der Zelle ganz rechts.

Da 254 ≤ 3 (mod 256) = 170 und 129 ≤ 2 (mod 256) undefiniert ist, wird dies 170 Mal durchgeführt, wobei der folgende Zustand verbleibt.

 v
000 045 000

Die Zelle unter dem Kopf ist Null; Die Schleife endet.

Jetzt können wir die Ausgabe generieren.

,      Read a character from STDIN and put it the leftmost cell.
[        While the leftmost cell is non-zero:
  [        While the leftmost cell is non-zero:
    >.     Print the content of the middle cell ('-').
    <-     Increment the leftmost cell.
  ]      If the leftmost cell held n, the above will print 256 - n minus signs
         which, when executed, will put n in cell 0 of the output program.
  >      Increment the middle cell, setting it to 46 ('.').
  .      Print its content ('.').
  --     Decrement the middle cell twice, setting it to 44 (',').
  .      Print its content (',').
         When executed, since the output program receives no input, the above
         will zero cell 0 of the output program.
  +      Increment the second cell, setting it back to 45 ('-').
  <,     Go back to the leftmost cell and read another character from STDIN.
]      Once EOF is reached, this will put 0 in the leftmost cell, ending the loop.
Dennis
quelle
Warum wird die resultierende BF für mich nicht zurück in die Eingabezeichenfolge übersetzt? Dies ist der Dolmetscher, den ich benutze und der für die anderen Antworten funktioniert hat.
Insane
2
Dieser Interpreter hat viele Einstellungen. Für die 32 - Byte - Version, dann würden Sie brauchen dynamische Speicher und Ende der Eingabe:\0 .
Dennis
10

Brainfuck, 35 13 43 Bytes

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

Diese Antwort enthält keine Annahmen über den Interpreter des Ausgabeprogramms. Probieren Sie es online!

Für eine kürzere Lösung (die nur mit einigen Dolmetschern funktioniert), siehe meine andere Antwort .

Testlauf

Für die Eingabe Code Golfwird die folgende Ausgabe generiert.

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.-------------------------------------------------------------------+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.---------------------------------------------------------------------------------------------------------------++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.----------------------------------------------------------------------------------------------------+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.-----------------------------------------------------------------------------------------------------++++++++++++++++++++++++++++++++.--------------------------------+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.-----------------------------------------------------------------------+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.---------------------------------------------------------------------------------------------------------------++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.------------------------------------------------------------------------------------------------------------++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.------------------------------------------------------------------------------------------------------+++++++++++++++++++++++++++++++++.---------------------------------

Probieren Sie es online!

Wie es funktioniert

Wir beginnen damit, die Ganzzahl 43 (Zeichencode von +) in die zweite Zelle des Bandes zu setzen. Der folgende Code erreicht dies.

++         Increment the first cell twice, setting it to 2.
[          While the first cell in non-zero:
  >+         Increment the second cell.
  <------    Decrement the first cell six times.
]

Dies führt im wesentlichen die modulare Division 2 ÷ 6 (mod 256) durch . Da (2 + 256) ≤ 6 = 258 ≤ 6 = 43 ist , ist das Ergebnis wie beabsichtigt 43 .

Jetzt können wir die Ausgabe generieren.

,      Read a character from STDIN and put it the first cell.
[        While the first cell is non-zero:
  [        While the first cell is non-zero:
    >.     Print the content of the second cell ('+').
    >+     Increment the third cell.
    <<-    Decrement the first cell.
  ]      If the first cell held n, the above prints n plus signs
         and puts n in the third cell.
  >+++   Add three to the second cell, setting it to 46 ('.').
  .      Print its content ('.').
  -      Decrement, setting it to 45 ('-').
  >      Advance to the third cell.
  [      While the third cell is non-zero:
    <.     Print the content of the second cell ('-').
    >-     Decrement the third cell.
  ]      If the first cell held n, the above prints n minus signs,
         thus negating the plus signs and zeroing the cell of the output program.
  <--    Subtract 2 from the second cell, setting it back to 43.
  <,     Go back to the first cell and read another character from STDIN.
]      Once EOF is reached, ',' will put 0 in the first cell, ending the loop.
Dennis
quelle
Oh Mann! Du kannst das durchgestrichene-44-is-44-Mem nicht brechen, komm schon! Wie auch immer, Ihr Versuch, es zu besiegen, ist kläglich gescheitert, weil es nicht durchgestrichen aussieht. Es sieht so aus, als wäre etwas Schmutz auf meinem Bildschirm (PHP, vielleicht?): P
cat
2
Alles, um diesen Kommentar zu vermeiden ...
Dennis
4

05AB1E, 12 11 Bytes

vyÇ`'+ׄ.>J

Erklärt

v             # for each char in input string
 yÇ`          # convert to its ascii value
    '+×       # push the char '+' that many times
       „.>J   # push string ".>" and join with the plus signs
              # implicitly print combined string

Probieren Sie es online aus

1 Byte dank @Adnan gespeichert

Emigna
quelle
'+×statt F'+}speichert ein Byte.
Adnan
1
@Adnan: Danke! Ich habe nach einem "Wiederholungs" -Befehl gesucht.
Emigna
4

Java, 98 Bytes

class a{String A(char[]b){String z="";for(char B:b){for(int c=B;c-->0;)z+="+";z+=".>";}return z;}}

Strings sind nichts anderes als unveränderliche char[]s mit einer Reihe von Dienstprogrammmethoden. Verwenden wir also das Array!

Ungolfed:

class a {
    void A(char[] b) {
        for (char B : b) {
            for (int c = B; c-- > 0;)
                 System.out.print('+');
            System.out.print(".>");
        }
    }
}

Gleichwertiges eigenständiges Programm mit 138 Byte Länge:

interface a{static void main(String[]A){for(char b:A[0].toCharArray()){for(int B=b;B-->0;)System.out.print('+');System.out.print(".>");}}}

Bonus:

interface a{static void main(String[]A){for(char b:new java.util.Scanner(new java.io.File(A[0])).useDelimiter("\\Z").next().toCharArray()){for(int B=b;B>0;B--)System.out.print('+');System.out.print(".>");}}}

Diese 207-Byte-App kodiert tatsächlich eine Datei als BF-Programm, wie im Titel erwähnt.

user8397947
quelle
2
Ist es nur ich oder sieht die Art und Weise, wie das ungolfed Programm eingerückt ist, fantastisch aus?
user8397947
Kurz bevor ich gepostet habe, wurde mir klar, dass es sich bei meiner Antwort im Grunde um eine heruntergespielte Version von dir handelt.
Insane
2

Vitsy, 19 17 Bytes

I\[&'>.+'i1-\Du]Z

I                     Get the length of the input stack.
 \[            ]      Pop n, repeat this block of code n times.
   &                  Push a new stack and move to it.
    '>.+'             Push the string '+.>' to the stack.
         i            Pop an item from the input stack and push it to the current
                      program stack.
          1-          Subtract one from the top program stack item.
            \D        Duplicate the '+' in the stack that many times.
              u       Merge the current program stack with the previous.
                Z     Output the entire current stack as a string.

Beachten Sie, dass diese Antwort eines der wenigen Male ist, die ich jemals benutzt habe Iund u. : D

Probieren Sie es online!

Addison Crump
quelle
2

O , 13 Bytes

i{'+n#*".>"}d

Erläuterung:

i              Read standard input into a string and push it onto the stack.
 {         }d  For each character in the string...
  '+           Push "+".
    n#         Convert the character (n) to its ASCII code.
      *        Multiply the "+" by the character code to get the number of +'s needed.
       ".>"    Push the string ".>".
               In O, the stack is printed after execution, so this prints out the result.
kirbyfan64sos
quelle
2

K6, 16 Bytes

,/{|">.",x#"+"}'

Verwendung

,/{|">.",x#"+"}'"some string"

Erläuterung

  {           }'  For each character in the string...
         x#"+"    Repeat "+" as many times as the character's ASCII code.
        ,         Combine that with...
    ">."          The code to print it and move on.
   |              But we put the string together backwards...so now it gets reversed.
,/                Combine all the substrings into one BIG string.
kirbyfan64sos
quelle
Erklärung PLZ: D
Addison Crump
@VTCAKAVSMoACE Fertig! :)
kirbyfan64sos
2

Python 3, 43 Bytes

lambda s:''.join('+'*ord(c)+'.>'for c in s)

Das Python fügt eine Reihe von Pluszeichen ein, die dem ASCII-Code jedes Zeichens entsprechen, gefolgt vom .>Drucken und Verschieben in die nächste Zelle. Der Brainfuck erhöht sich auf den korrekten Wert, druckt und wechselt zur nächsten Zelle.

Ausgabe für hi(mit Zeilenumbrüchen zur Verdeutlichung):

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>

Die Ausgabe dieses Programms:

hi
bkul
quelle
2

Perl, 25 Bytes

s/./"+"x ord($&).".>"/eg

Verwendung

echo -n hi | perl -pe 's/./"+"x ord($&).".>"/eg'

Erläuterung

Verwendet eine Ersetzungsoperation mit regulären Ausdrücken, um jedes Zeichen in jeder Zeile, die bei der Standardeingabe angegeben wurde, durch eine Zahl zu ersetzen, +die aus dem Ordnungswert dieses Zeichens berechnet wird. Anschließend erfolgt die Ausgabe .>, um das nächste Zeichen zu drucken und fortzufahren.

Verwendet das Perl- -pFlag, um die Eingabe automatisch zu lesen und das Ergebnis auszudrucken, und fügt dem Bytecount 1 hinzu.

Rohr
quelle
2

Java, 91 Bytes

String b(char[] f){String k="";for(char b:f){for(int u=b;u>0;u--)k+="+";k+=".>";}return k;}

Requisiten an Dorukayhan, weil er mich geschlagen hat :)

Wahnsinnig
quelle
Sie können nicht einfach das Boilerplate entfernen und alle Namen der Variablen ändern und dann behaupten, dass dies eine neue Antwort ist.
Undichte Nonne
@LeakyNun habe ich nicht, aber ich könnte, wenn ich wollte.
Insane
Inwiefern unterscheidet sich diese Antwort von der Antwort, mit der Sie verknüpft sind?
Undichte Nonne
@LeakyNun Abstimmen und weitermachen
Wahnsinnig
2

C 72 64 60 Bytes

main(c){for(;c=~getchar();)for(;printf(~c++?"+":".>")^2;);}

Ungolfed-Version:

main( c )
{
    for ( ; c = ~getchar( ); )
        for ( ; printf( ~c++ ? "+" : ".>" ) ^ 2; );
}

Kompilieren und testen mit:
gcc -o bfcat bfcatgolf.c && cat 1.txt | ./bfcat > o.txt && beef o.txt

Ergebnisse

Jacajack
quelle
Warum ist cdie bitweise Inversion von getchar, besonders wenn Sie die Inversion nur erneut invertieren?
Katze
@cat wird am c = ~getchar( )mit 0 bewertet EOF. c = ~getchar( )und ~c++sind einfach kürzer als ~( c = getchar( ) )undc--
Jacajack
2

CJam, 12 Bytes

Konvertiert jedes Zeichen in seinen ASCII-Wert und erhöht die aktuelle Zelle vor dem Drucken um diese Anzahl. Da wir unendlich viele Bänder haben, können wir uns nach der Bearbeitung jedes Zeichens einfach nach rechts bewegen.

q{i'+*'.'>}%

Probieren Sie es online!

Fall
quelle
2

Lua, 67, 66 61 Bytes

Einfach Iterierte über jedes Zeichen in dem Argument, und drucken Sie eine Zeile für jeden mit n +s gefolgt von .>wo nist der Wert dieses Zeichen in der ASCII - Tabelle.

Verwendet gmatch als @LeakyNun, das im Kommentar zum Speichern von 1 Byte gegenüber der gsub-Lösung empfohlen wurde

for c in(...):gmatch"."do print(("+"):rep(c:byte())..".>")end

Alte Lösung mit gsub

(...):gsub(".",function(c)print(c.rep("+",c:byte())..".>")end)

Alt 67

(...):gsub(".",function(c)print(string.rep("+",c:byte())..".>")end)

Um es auszuführen, speichern Sie es einfach als Datei ( golf.luazum Beispiel) und führen Sie es mit aus lua golf.lua "hi". Für hisollte es ausgeben

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>
Katenkyo
quelle
Wie verwende ich das? Einfügen in die REPL gibt attempt to index a nil value, und f = ...gibt das gleiche, und function f ... endgibtunexpected symbol near ':'
cat
@cat Einfach in einer Datei speichern und ausführen lua file.lua "argument", ich werde den Beitrag aktualisieren, um Anweisungen zu geben.
Katenkyo
Wie funktioniert das überhaupt? ist ...ein Bezeichner mit argv?
Katze
1
@cat ...enthält die Werte in der Tabelle argentpackt. Das heißt, es wird immer entsprechen, es arg[1]sei denn, Sie verwenden es in einem Funktionsaufruf als letzten Parameter, dann wird es ausgegeben.
Katenkyo
n=...for n:gmatch"."do print(("+"):rep(c:byte())..".>")endfür 48 Bytes
Leaky Nun
1

J, 28 Bytes

[:;[:('.>',~'+'#~])"0[:]3&u:

Einfach genug. 3&u:wandelt Zeichen in Zeichencodes um. Der Rest wird nur so '+'oft wiederholt , dann .>am Ende jeder Zeile verkettet und ;das Ergebnis geglättet.

Einige Ergebnisse

   bf =: [:;[:('>.',~'+'#~])"0[:]3&u:
   bf 'hi'
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>. +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>.
   bf ' !'
++++++++++++++++++++++++++++++++>. +++++++++++++++++++++++++++++++++>.
   bf ' ~'
++++++++++++++++++++++++++++++++>.
                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>.
Conor O'Brien
quelle
1

Eigentlich 13 Bytes

O`'+*".>"@`MΣ

Probieren Sie es online!

Die hier angewendete Strategie ist die gleiche wie in vielen anderen Lösungen: Geben Sie für jedes Zeichen genügend +s aus, um eine nullinitialisierte Zelle auf die richtige ASCII-Ordnungszahl zu erhöhen, sie mit auszugeben .und zur nächsten Zelle mit zu wechseln >.

Erläuterung:

O`'+*".>"@`MΣ
O              list of ordinals (technically this is Unicode code points, but code points 0-127 are the same for Unicode and ASCII)
 `'+*".>"@`M   for each ordinal:
  '+*            push a string containing that many +s
     ".>"@       push ".>" and swap (putting it before the +s)
            Σ  concatenate all the strings (if "[", "]", and "," weren't meaningful characters in BF, this technically wouldn't be necessary)
Mego
quelle
1

Mouse-2002, 27 Bytes

(?'l:l.^(l.^"+"l.1-l:)".>")

Dies funktioniert theoretisch und gemäß der Dokumentation der Sprache, aber die Referenzimplementierung von Mouse's Interpreter scheint einen Fehler zu haben, bei dem die Zeichenketteneingabe an a angehängt wird ', also für adiese Ausgaben

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++.>

Was wiederum ausgibt a'. Das mag sein oder auch nicht in Ordnung, so ist hier ein 39 Byte lang , das nicht der Fall ist Ausgang 'immer und so wird wahrscheinlich mehr ungültig.

(?'l:l.39=l.0=+0=^(l.0>^"+"l.1-l:)".>")

Was gibt die richtige Ausgabe in der Referenz impl. solange es keine 's gibt :)

Erklärt:

(              ~ while (true) {
  ?' l:        ~   l = getchar() 
  l. ^         ~   if (! (l) ) { break }
  (            ~   while (true) {
    l. ^       ~     if (! (l) ) { break }
    "+"        ~     puts("+")
    l. 1 - l:  ~     l-- // l = l - 1
  )            ~   }
  ".>"         ~   puts(".>")
)              ~ }
Katze
quelle
1

Faktor 58 Bytes

[ [ [ 43 ] ""replicate-as ".>"append ] { } map-as ""join ]

Funktioniert wie:

[ 
  [ 
    [ 43 ] "" replicate-as  ! ``+'' * code point, clone-like a string ""
    ".>" append             ! append ".>"
  ] 
  { } map-as                ! for each char in string and clone-like an array { }
  "" join                   ! join array of str into str by ""
]

Da Factor mit einem Brainfuck-Interpreter geliefert wird, ist es einfach zu testen.

bfcat.factor

USING: sequences ;
IN: bfcat

: string>brainfuck ( s -- bf )
  [ [ 43 ] "" replicate-as ".>" append ]
  { } map-as "" join ;

bfcat-tests.factor

USING: tools.test bfcat brainfuck ;
IN: bfcat.tests

{ "a"  } [ "a"  string>brainfuck get-brainfuck ] unit-test
{ "ab" } [ "ab" string>brainfuck get-brainfuck ] unit-test
{ "+++++++++++++" } [ "+++++++++++++" string>brainfuck get-brainfuck ] unit-test
{ "Code Golf" } [ "Code Golf" string>brainfuck get-brainfuck ] unit-test

Ausgabe

Unit Test: { { "a" } [ "a" string>brainfuck get-brainfuck ] }
Unit Test: { { "ab" } [ "ab" string>brainfuck get-brainfuck ] }
Unit Test: {
    { "+++++++++++++" }
    [ "+++++++++++++" string>brainfuck get-brainfuck ]
}
Unit Test: {
    { "Code Golf" }
    [ "Code Golf" string>brainfuck get-brainfuck ]
}

Yay! sie gehen alle vorbei.

Katze
quelle
1

Rubin, 40 38 Bytes

gets.chop.each_byte{|o|puts"+"*o+".>"}
Kakaobohne
quelle
Ich weiß nicht, Ruby, aber ich weiß, Sie können putsanstelle von verwenden print, da das Format der Ausgabe nicht von Bedeutung ist, solange es gültig ist Brainfuck und Brainfuck kümmert sich nicht um andere Zeichen
Katze
@cat oh ich wusste nicht, dass bf andere Zeichen ignoriert, danke!
CocoaBean
1

Sidef , 38 Bytes

Hey, genauso lang wie Ruby! nur dass Sidef nicht Ruby ist: D

read().bytes.each{|c|say"+"*c;say".>"}

Lies ein paar Zeichen, dann mache für jedes Byte das Ding.

Katze
quelle
1

GNU Bash, 100 85 Bytes

while IFS= read -rn1 c;do printf '+%.0s' $(seq 1 $(printf %d \'$c));echo '.>';done<$1

Danke @cat , dass du mir 15 Bytes gespart hast!

Postramble

  1. Angenommen, die Eingabezeichenfolge wird unverändert in einer Datei dargestellt, die als erstes Argument übergeben wird.
  2. Verwendung: bash bfcat.sh <path to file containing string>
  3. Verwendung (mit Named Pipe): bash bfcat.sh <(echo -n '<string>')

Ungolfed

while IFS= read -r -n1 c # Read file byte by byte [1]
do
    n=$(printf "%d" \'"$c") # `ord` of a char in bash [2]
    printf '+%.0s' $(seq 1 $n) # emit character $n times [3]
    echo '.>' # Emit output and shift command for bf. I love infinite memory.
done <"$1"

Referenzen in ungolfed version

  1. Datei byteweise lesen

  2. ord eines char in bash

  3. Zeichen $ n mal ausgeben

Yeow_Meng
quelle
1
Ich habe einige Formatierungen und Informationen in Ihrer Antwort verbessert und überflüssige Informationen aus den Links entfernt. Sie können es jederzeit rückgängig machen, wenn es Ihnen nicht gefällt. Es ist auch GNU Bash, nicht GNU / Bash wie GNU / Linux. :)
Katze
1
Golftipps (ich bin kein bash-Golfer): read -rn1Entfernen Sie nachher die Leerzeichen ;, entfernen Sie die Leerzeichen done <"$1", um insgesamt 9 Bytes zu sparen
cat
1
@cat Es sieht toll aus! Ich muss mich wirklich daran gewöhnen, zu bearbeiten-> Vorschau-> Bearbeiten-> ...
Yeow_Meng
1

ES6, 119 115 Bytes

f=s=>{a='';for(i in[...s]){b=s[c='charCodeAt'](i)-(s[c](i-1)|0);a+=(b>0?'+'.repeat(b):'-'.repeat(-b))+'.'}return a}

4 Bytes gespart, dank @Leibrug

bodqhrohro
quelle
1
Sie können eine Variable zuweisen charCodeAt(sagen wir mal c) und wie folgt verwenden: s[c](i)um 1 Byte zu verkürzen und auch einige Zeichen zu entfernen (ich habe 3: Leerzeichen vorher gefunden [...s], logisches ODER durch bitweises Eins und Semikolon vorher ersetzt return).
Leibrug
1

Sesos (nicht konkurrierend)

Hexdump:

0000000: 28cbf6 02e83d 655bae 243901                       (....=e[.$9.

Size   : 12 byte(s)

Probieren Sie es online!

Assembler

add 43,fwd 1,get
jmp
  jmp,sub 1,rwd 1,put,fwd 1,jnz
  add 46,put,add 16,put
  get
Undichte Nonne
quelle
0

Ruby, 26 Bytes

gsub(/./){?+*$&.ord+'.>'}

+ 1 Byte für die pBefehlszeilenoption. Um zB den Brainfuck-Code für ABC xyzdich zu bekommen, kannst du laufen

$ ruby -p -e 'gsub(/./){?+*$&.ord+".>"}' <<< "ABC xyz"

und bekomme

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>
daniero
quelle
0

Haskell 50 Bytes

f[]=[]
f(x:y)=replicate(fromEnum x)'+'++".>"++f y
ForemanBob
quelle