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 Code-Golf , also gewinnt der Code mit der geringsten Anzahl von Bytes. Viel Glück.

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.

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.

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.

Brainfuck, 35 ₁₃ 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.

Pyth - 11 Bytes

sm+*\+Cd".>

Probieren Sie es hier online aus .

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

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.

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!

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.

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.

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

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.

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

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

• hi - http://paste.ubuntu.com/17995958/
• quick brown fox jumps over the lazy dog - http://paste.ubuntu.com/17996059/
• Quellcode - http://paste.ubuntu.com/18000808/

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!

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

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

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 ' ~'
++++++++++++++++++++++++++++++++>.
                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>.

Pyke, 11 Bytes

F.o\+*".>"+

Probieren Sie es hier aus!

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)

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(".>")
)              ~ }

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.

Rubin, 40 38 Bytes

gets.chop.each_byte{|o|puts"+"*o+".>"}

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.

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

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

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

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

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

Haskell 50 Bytes

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