Wyzwanie

Napisz program lub funkcję, która podała ciąg znaków, zwraca prawidłowy program Brainfuck, który po skompilowaniu i wykonaniu jako Brainfuck zwraca ten ciąg ..

1. Załóżmy, że wszystkie dane wejściowe są zakodowane jako ASCII.

2. Załóżmy, że wyprowadzony program BF wykona się w środowisku z nieskończoną taśmą.

3. Załóżmy, że wskaźnik zaczyna się od komórki 0, a każda komórka jest inicjowana na wartość zero.

4. Każdy przykład poniżej reprezentuje jedno możliwe prawidłowe wyjście dla danego wejścia. W szczególności przykłady obejmują dodatkowe znaki nowej linii i spacje, aby poprawić czytelność dla ludzi. Rozwiązania mogą dowolnie formatować wygenerowany kod BF.

5. Taśma jest podwójnie nieskończona.

6. Wszystkie komórki dostarczone przez interpreter są dokładnie 8-bitowymi komórkami. Przepełnienie i niedopełnienie zawijają się w przewidywalnej i zdrowej materii.

Przykłady

Ciąg spacji

Biorąc pod uwagę dane wejściowe , twój program / funkcja może zwrócić:

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

Wykrzyknik

Biorąc pod uwagę dane wejściowe !, twój program / funkcja może zwrócić:

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

Dwa listy

Biorąc pod uwagę dane wejściowe hi, twój program / funkcja może zwrócić:

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

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

++++
.
+
.

To jest code-golf , więc wygrywa kod z najmniejszą liczbą bajtów. Powodzenia.

Galaretka , 8 bajtów

O”+ẋp“.>

Wypróbuj online!

Przykładowy przebieg

Do wprowadzenia hiprogram ten drukuje

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

(bez wysuwu linii), który z kolei drukujehi .

Jak to działa

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 bajtów

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

Wypróbuj online!

Przykładowe dane wyjściowe dla hi(bez kanałów):

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

Wyjaśnienie

Porusza się po taśmie podczas pisania programu. Otoczenie ,[...,]to standardowa pętla wejściowa. Do każdej postaci używamy czterech komórek:

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

gdzie xjest komórka, do której zapisujemy dane wejściowe.

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

Ta część wykorzystuje komórkę a zapisuje 21komórkę bza pomocą standardowego mnożenia 3i 7.

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

Teraz używamy że 21pisać 42na ai 63pod cpoprzez pomnożenie przez 2i3 odpowiednio. Następnie <+<przesuwa się z powrotem do komórki x, zamieniając ją 42w 43(punkt kodowy +). Podsumować:

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

Teraz główna pętla wyjściowa:

[>.<-]

Oznacza to, że podczas zmniejszania xdrukujemy jeden za +każdym razem.

>+++.

Po zakończeniu ponownie używamy + komórkę, dodając „ 3daj” ..

>>-.

Wreszcie przechodzimy do 63, zmniejszamy do 62(> ) i wyprowadzamy również. Następna iteracja użyje tej komórki jako x.

Brainfuck, 39 33 32 31 bajtów

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

Algorytm, który umieszcza 45 na taśmie jest pobierany ze stałych Brainfuck Esolanga .

Ta odpowiedź zakłada, że ​​interpreter programu wyjściowego ma zawijane, ograniczone komórki; i to ,zeruje bieżącą komórkę (co oznacza, że ​​program wyjściowy jest uruchamiany bez danych wejściowych). Wypróbuj online!

Aby uzyskać (dłuższe) rozwiązanie, które działa bezwarunkowo, zobacz moją drugą odpowiedź .

Testowe uruchomienie

Dla danych wejściowych Code Golfgenerowane są następujące dane wyjściowe.

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

Wypróbuj online!

Jak to działa

Zaczynamy od podania liczby całkowitej 45 (kod znaku -) w komórce taśmy. Poniższy kod osiąga to.

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

Zanim wejdziemy w pętlę, taśma wygląda następująco.

         v
000 000 255

Te trzy komórki - -2 , -1 i 0 - są jedynymi, których użyjemy w tym programie.

W pierwszej każdej iteracji pętli najbardziej prawą komórką jest, następnie komórka i środkowa komórka są dwukrotnie zmniejszane, pozostawiając następujący stan.

     v
000 254 252

W następnych 126 iteracjach początkowy -zmniejsza komórkę środkową, [>]<przeskakuje do komórki znajdującej się najbardziej na prawo i --<--zmniejsza komórkę środkową i prawą. W rezultacie 3 odejmuje się od środkowej komórki (modulo 256 ) i 2 jest odejmowane od prawej komórki.

Ponieważ 254 ÷ 3 (mod 256) = (254 + 256) ÷ 3 = 510 ÷ 3 = 170 i 252 ÷ 3 = 84 , skrajna prawa komórka jest zerowana przed środkową, pozostawiając następujący stan.

     v
000 132 000

Podobnie jak w pierwszej iteracji pętli, kolejna iteracja odejmuje teraz 3 od środkowej komórki i 2 od lewej komórki, umieszczając głowę na lewej komórce.

 v
254 129 000

Kolejne iteracje, podobnie jak w iteracji 126 przed nimi, odejmij 3 od komórki skrajnie lewej i 2 od komórki skrajnie prawej.

Ponieważ 254 ÷ 3 (mod 256) = 170 i 129 ÷ 2 (mod 256) jest niezdefiniowany, odbywa się to 170 razy, pozostawiając następujący stan.

 v
000 045 000

Komórka pod głową ma zero; pętla się kończy.

Teraz jesteśmy gotowi do generowania wyników.

,      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 bajtów

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

Ta odpowiedź nie przyjmuje żadnych założeń dotyczących interpretera programu wyjściowego. Wypróbuj online!

Krótsze rozwiązanie (które działa tylko z niektórymi tłumaczami), patrz moja inna odpowiedź .

Testowe uruchomienie

Dla danych wejściowych Code Golfgenerowane są następujące dane wyjściowe.

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

Wypróbuj online!

Jak to działa

Zaczynamy od podania liczby całkowitej 43 (kodu znakowego +) w drugiej komórce taśmy. Poniższy kod osiąga to.

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

To zasadniczo wykonuje podział modułowy 2 ÷ 6 (mod 256) . Ponieważ (2 + 256) ÷ 6 = 258 ÷ 6 = 43 , wynikiem jest 43 , zgodnie z przeznaczeniem.

Teraz jesteśmy gotowi do generowania wyników.

,      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 bajtów

sm+*\+Cd".>

Wypróbuj online tutaj .

05AB1E, 12 11 bajtów

vyÇ`'+ׄ.>J

Wyjaśniono

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

Wypróbuj online

Zapisano 1 bajt dzięki @Adnan

Java, 98 bajtów

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

Stringsą niczym niezmiennym char[] s z wieloma metodami narzędziowymi, więc użyjmy tablicy!

Nie golfowany:

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

Równoważny samodzielny program o długości 138 bajtów:

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

Premia:

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

Ta 207-bajtowa aplikacja faktycznie koduje plik jako program BF, tak jak napisano w tytule.

Vitsy, 19 lat 17 bajtów

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.

Pamiętaj, że ta odpowiedź jest jednym z niewielu razy, których kiedykolwiek użyłem I i u. :RE

Wypróbuj online!

O , 13 bajtów

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

Wyjaśnienie:

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 bajtów

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

Stosowanie

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

Wyjaśnienie

  {           }'  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 bajty

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

Python podaje liczbę plusów odpowiadającą kodowi ASCII każdego znaku, a następnie .> drukuje i przechodzi do następnej komórki. Uderzenie mózgu zwiększa się do prawidłowej wartości, drukuje i przechodzi do następnej komórki.

Dane wyjściowe dla hi(z nowymi liniami dla przejrzystości):

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

Wyjście tego programu:

hi

Perl, 25 bajtów

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

Stosowanie

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

Wyjaśnienie

Używa operacji zamiany wyrażenia regularnego, aby zastąpić każdy znak w każdym wierszu podanym na standardowym wejściu liczbą +obliczoną na podstawie wartości porządkowej tego znaku, a następnie zwraca wyniki.> do wydruku i przechodzi do następnego znaku.

Używa -pflagi perla do automatycznego odczytu danych wejściowych i wydrukowania wyniku, dodając 1 dodatkową do liczby bajtów.

Java, 91 bajtów

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

Rekwizyty dla dorukayhan za pobicie mnie :)

C, 72 64 60 bajtów

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

Wersja bez golfa:

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

Skompiluj i przetestuj za pomocą:
gcc -o bfcat bfcatgolf.c && cat 1.txt | ./bfcat > o.txt && beef o.txt

Wyniki

• hi- http://paste.ubuntu.com/17995958/
• quick brown fox jumps over the lazy dog - http://paste.ubuntu.com/17996059/
• kod źródłowy - http://paste.ubuntu.com/18000808/

CJam, 12 bajtów

Konwertuje każdy znak na jego wartość ASCII i zwiększa bieżącą komórkę o tę liczbę razy przed wydrukowaniem. Ponieważ mamy nieskończoną taśmę, możemy po prostu przejść w prawo po przetworzeniu każdej postaci.

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

Wypróbuj online!

Lua, 67 66 61 bajtów

Po prostu iteruj każdy znak w argumencie i wypisz wiersz dla każdego z n +s, po .>którym nnastępuje wartość tego znaku w tabeli ASCII.

Używa gmatch jako @LeakyNun zalecanego w komentarzu do zapisywania 1 bajtów w stosunku do rozwiązania gsub

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

Stare rozwiązanie za pomocą gsub

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

Stary 67

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

Aby go uruchomić, po prostu zapisz go jako plik ( golf.luana przykład) i uruchom za pomocą lua golf.lua "hi". Ponieważ hipowinno to generować

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

J, 28 bajtów

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

Wystarczająco proste. 3&u:konwertuje znaki na kody char. Reszta to po prostu powtórzenie '+'tej liczby razy, a następnie konkatenacja z .>końcem każdej linii i ;spłaszczenie wyniku.

Niektóre wyniki

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

Pyke, 11 bajtów

F.o\+*".>"+

Wypróbuj tutaj!

Właściwie 13 bajtów

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

Wypróbuj online!

Zastosowana tutaj strategia jest taka sama, jak w wielu innych rozwiązaniach - dla każdego znaku wypisz wystarczającą liczbę +s, aby zwiększyć komórkę o wartości zerowej do odpowiedniej liczby porządkowej ASCII, wyślij ją za pomocą .i przejdź do następnej komórki za pomocą >.

Wyjaśnienie:

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)

Mysz-2002, 27 bajtów

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

Działa to teoretycznie i zgodnie z dokumentacją języka, ale wydaje się, że referencyjna implementacja interpretera myszy zawiera błąd, w którym ciąg znaków dołącza a ', więc dla atych danych wyjściowych

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

Co z kolei daje wynik a'. To może, ale nie musi być w porządku, więc oto 39-bajtowy, który 'nigdy nie wyświetla danych wyjściowych , a zatem jest prawdopodobnie bardziej nieprawidłowy.

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

Co daje prawidłowy wynik w referencyjnym impl. tak długo jak nie ma' s :)

Wyjaśniono:

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

Współczynnik, 58 bajtów

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

Działa jak:

[ 
  [ 
    [ 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 ""
]

Ponieważ Factor jest wyposażony w interpreter Brainfuck, testowanie jest proste.

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

wynik

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 ]
}

Tak! wszyscy mijają.

Rubin, 40 38 bajtów

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

Sidef , 38 bajtów

Hej, tej samej długości co Ruby! tylko że Sidef nie jest Ruby: D

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

Przeczytaj kilka znaków, a następnie zrób to dla każdego bajtu.

GNU Bash, 100 85 bajtów

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

Dzięki @cat za uratowanie mnie 15 bajtów!

Postramble

1. Zakłada, że ​​ciąg wejściowy jest reprezentowany jako-jest w pliku przekazanym jako pierwszy argument.
2. Stosowanie: bash bfcat.sh <path to file containing string>
3. Zastosowanie (z nazwaną rurą): bash bfcat.sh <(echo -n '<string>')

Bez golfa

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"

Referencje w wersji Ungolfed

1. Plik bajt po bajcie

2. ord char w bash

3. emituj znak $ n razy

ES6, 119 115 bajtów

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}

Zaoszczędź 4 bajty dzięki @Leibrug

Sesos (niekonkurujące)

Hexdump:

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

Size   : 12 byte(s)

Wypróbuj online!

Monter

add 43,fwd 1,get
jmp
  jmp,sub 1,rwd 1,put,fwd 1,jnz
  add 46,put,add 16,put
  get

Rubinowy, 26 bajtów

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

+ 1 bajt dla popcji wiersza poleceń. Aby np. Pobrać kod pieprzenia mózgu ABC xyz, możesz uruchomić

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

i dostać

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

Haskell 50 bajtów

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