Tantangan

Tulis program atau fungsi yang diberi string, mengembalikan program Brainfuck yang valid yang ketika dikompilasi dan dieksekusi sebagai Brainfuck, mengembalikan string itu ..

1. Asumsikan semua input dikodekan sebagai ASCII.

2. Asumsikan program BF yang dikeluarkan akan dieksekusi dalam lingkungan dengan rekaman tak terbatas.

3. Asumsikan pointer dimulai pada sel 0 dengan setiap sel diinisialisasi ke nilai nol.

4. Setiap contoh di bawah ini merupakan satu kemungkinan output yang benar untuk input yang diberikan. Secara khusus, contoh-contoh termasuk baris baru dan ruang ekstra untuk membantu keterbacaan manusia. Solusi bebas untuk memformat kode BF yang dihasilkan dengan cara apa pun.

5. Rekaman itu tak terbatas dua kali lipat.

6. Semua sel yang disediakan oleh juru persis sel 8-bit. Overflow dan underflow membungkus dalam hal yang dapat diprediksi dan waras.

Contohnya

String ruang

Diberikan input , program / fungsi Anda dapat kembali:

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

Tanda seru

Diberikan input !, program / fungsi Anda dapat kembali:

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

Dua huruf

Diberikan input hi, program / fungsi Anda dapat kembali:

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

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

++++
.
+
.

Ini adalah kode-golf , jadi kode dengan jumlah byte terkecil menang. Semoga berhasil.

Jelly , 8 byte

O”+ẋp“.>

Cobalah online!

Contoh dijalankan

Sebagai input hi, program ini mencetak

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

(tanpa umpan garis) yang, pada gilirannya, mencetakhi .

Bagaimana itu bekerja

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 byte

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

Cobalah online!

Contoh output untuk hi(tanpa umpan baris):

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

Penjelasan

Ini bergerak melintasi rekaman saat menulis program. Sekitarnya ,[...,]adalah loop input standar. Untuk setiap karakter, kami menggunakan empat sel:

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

di mana xsel kita menulis input.

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

Bagian ini menggunakan sel a untuk menulis 21ke dalam sel bmelalui perkalian standar 3dan 7.

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

Sekarang kita menggunakannya 21untuk menulis 42ke dalam adan 63ke cdengan mengalikan dengan 2dan 3masing - masing. Kemudian<+< bergerak kembali ke sel xsambil mengubah 42menjadi 43(titik kode +). Rekap:

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

Sekarang loop output utama:

[>.<-]

Yaitu, sambil mengurangi xkita mencetak satu +setiap kali.

>+++.

Setelah selesai kami menggunakan kembali + sel, dengan menambahkan 3memberi ..

>>-.

Akhirnya, kita pindah ke 63, kurangi ke 62( >) dan tampilkan juga. Iterasi berikutnya akan menggunakan sel ini sebagai x.

Brainfuck, 39 33 32 31 byte

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

Algoritma yang menempatkan 45 pada rekaman itu diambil dari konstanta Brainfuck Esolang .

Jawaban ini mengasumsikan bahwa interpreter program keluaran memiliki sel pembungkus dan terikat; dan itu, nol sel saat ini (menyiratkan bahwa program output dijalankan tanpa input). Cobalah online!

Untuk solusi (lebih lama) yang berfungsi tanpa syarat, lihat jawaban saya yang lain .

Uji coba

Untuk input Code Golf, output berikut dihasilkan.

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

Cobalah online!

Bagaimana itu bekerja

Kita mulai dengan meletakkan integer 45 (kode karakter -) ke dalam sel rekaman. Kode berikut mencapai ini.

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

Sebelum kita memasuki loop, rekaman itu terlihat seperti ini.

         v
000 000 255

Tiga sel ini - -2 , -1 , dan 0 - adalah satu-satunya yang akan kita gunakan dalam program ini.

Dalam setiap iterasi pertama dari loop, sel paling kanan adalah, kemudian sel dan sel tengah dikurangi dua kali, meninggalkan keadaan berikut.

     v
000 254 252

Dalam 126 iterasi berikutnya, awal -mengurangi sel tengah, [>]<melompat ke sel paling kanan, dan --<--mengurangi tengah dan sel kanan. Akibatnya, 3 dikurangi dari sel tengah (modulo 256 ) dan 2 dikurangkan dari sel paling kanan.

Karena 254 ÷ 3 (mod 256) = (254 + 256) ÷ 3 = 510 ÷ 3 = 170 dan 252 ÷ 3 = 84 , sel yang paling kanan adalah nol sebelum yang tengah, meninggalkan keadaan berikut.

     v
000 132 000

Demikian pula dengan iterasi pertama loop, iterasi berikutnya sekarang mengurangi 3 dari sel tengah dan 2 dari sel paling kiri, menempatkan kepala di sel paling kiri.

 v
254 129 000

Iterasi berikutnya, seperti pada iterasi 126 sebelum mereka, kurangi 3 dari sel paling kiri dan 2 dari sel paling kanan.

Karena 254 ÷ 3 (mod 256) = 170 dan 129 ÷ 2 (mod 256) tidak terdefinisi, ini dilakukan 170 kali, meninggalkan status berikut.

 v
000 045 000

Sel di bawah kepala adalah nol; loop berakhir.

Sekarang kita siap untuk menghasilkan keluaran.

,      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 byte

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

Jawaban ini tidak membuat asumsi tentang interpreter dari program output.Cobalah online!

Untuk solusi yang lebih pendek (yang hanya berfungsi dengan beberapa penerjemah), lihat jawaban saya yang lain .

Uji coba

Untuk input Code Golf, output berikut dihasilkan.

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

Cobalah online!

Bagaimana itu bekerja

Kita mulai dengan meletakkan integer 43 (kode karakter +) di sel kedua rekaman itu. Kode berikut mencapai ini.

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

Ini pada dasarnya melakukan pembagian modular 2 ÷ 6 (mod 256) . Karena (2 + 256) ÷ 6 = 258 ÷ 6 = 43 , hasilnya adalah 43 , sebagaimana dimaksud.

Sekarang kita siap untuk menghasilkan keluaran.

,      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 byte

sm+*\+Cd".>

Cobalah online di sini .

05AB1E, 12 11 byte

vyÇ`'+ׄ.>J

Dijelaskan

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

Cobalah online

Disimpan 1 byte berkat @Adnan

Java, 98 byte

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

Strings tidak lebih dari char[]s tidak berubah dengan banyak metode utilitas, jadi mari kita gunakan array!

Tidak Disatukan:

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

Program mandiri yang setara yaitu 138 byte:

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

Aplikasi 207-byte ini benar-benar mengkodekan file sebagai program BF, seperti yang disebutkan dalam judul.

Vitsy, 19 17 byte

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.

Perhatikan bahwa jawaban ini adalah satu dari beberapa kali yang pernah saya gunakan Idan u. : D

Cobalah online!

O , 13 byte

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

Penjelasan:

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 byte

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

Pemakaian

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

Penjelasan

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

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

Python menempatkan sejumlah plus yang setara dengan kode ASCII dari setiap karakter, diikuti oleh .> untuk mencetak dan pindah ke sel berikutnya. Brainfuck bertambah hingga nilai yang benar, dicetak, dan pindah ke sel berikutnya.

Output untuk hi(dengan baris baru untuk kejelasan):

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

Output program itu:

hi

Perl, 25 byte

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

Pemakaian

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

Penjelasan

Menggunakan operasi penggantian ekspresi reguler untuk mengganti setiap karakter di setiap baris yang diberikan pada input standar dengan jumlah yang +dihitung dari nilai ordinal karakter tersebut, kemudian menghasilkan.> untuk dicetak dan maju ke karakter berikutnya.

Menggunakan -pbendera perl untuk secara otomatis membaca input dan mencetak hasilnya, menambahkan 1 ekstra ke bytecount.

Java, 91 byte

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

Alat peraga untuk dorukayhan karena telah mengalahkan saya :)

C, 72 64 60 byte

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

Versi tidak disatukan:

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

Kompilasi dan uji dengan:
gcc -o bfcat bfcatgolf.c && cat 1.txt | ./bfcat > o.txt && beef o.txt

Hasil

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

CJam, 12 byte

Mengonversi setiap karakter ke nilai ASCII-nya, dan menambah sel saat ini beberapa kali sebelum mencetaknya. Karena kami memiliki rekaman tak terbatas, kami hanya dapat bergerak ke kanan setelah memproses setiap karakter.

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

Cobalah online!

Lua, 67 66 61 Bytes

Ulangi setiap karakter dalam argumen, dan cetak garis untuk masing-masing dengan n +s diikuti dengan di .>mana nnilai karakter ini dalam Tabel ASCII.

Gunakan gmatch seperti yang disarankan oleh @LeakyNun dalam komentar untuk menyimpan 1 Bytes di atas solusi gsub

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

Solusi lama menggunakan gsub

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

67 tahun

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

Untuk menjalankannya, cukup simpan sebagai file ( golf.luamisalnya) dan jalankan dengan lua golf.lua "hi". Sebab hi, seharusnya output

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

J, 28 byte

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

Cukup sederhana. 3&u:mengubah karakter menjadi kode char. Sisanya hanya mengulangi '+'jumlah itu kali, kemudian menyatu dengan .>pada akhir setiap baris, dan ;meratakan hasilnya.

Beberapa hasil

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

Pyke, 11 byte

F.o\+*".>"+

Coba di sini!

Sebenarnya, 13 byte

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

Cobalah online!

Strategi yang digunakan di sini adalah sama dengan di banyak solusi lain - untuk setiap karakter, output yang cukup +untuk meningkatkan sel nol diinisialisasi ke ordinal ASCII yang tepat, output dengan ., dan pindah ke sel berikutnya dengan> .

Penjelasan:

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 byte

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

Ini bekerja secara teori dan menurut dokumentasi bahasa, tetapi implementasi referensi dari juru bahasa Mouse tampaknya memiliki bug di mana input string menambahkan a ', jadi untuk aoutput ini

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

Yang pada gilirannya menghasilkan a'. Itu mungkin atau mungkin tidak apa-apa, jadi di sini panjangnya 39 byte yang tidak 'pernah keluar dan dengan demikian kemungkinan lebih tidak valid.

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

Yang memberikan output yang tepat di impl referensi. selama tidak ada 's :)

Dijelaskan:

(              ~ 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 byte

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

Bekerja seperti:

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

Karena Factor dilengkapi dengan penerjemah Brainfuck, mudah untuk menguji.

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

keluaran

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! mereka semua lulus.

Rubi, 40 38 byte

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

Sidef , 38 byte

Hei, panjangnya sama dengan Ruby! Hanya saja Sidef itu bukan Ruby: D

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

Baca beberapa karakter, lalu untuk setiap byte lakukan hal itu.

GNU Bash, 100 85 byte

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

Terima kasih @cat karena telah menyelamatkan saya 15 byte!

Postramble

1. Mengasumsikan string input diwakili sebagaimana adanya dalam file yang dikirimkan sebagai argumen pertama.
2. Pemakaian: bash bfcat.sh <path to file containing string>
3. Penggunaan (dengan pipa bernama): bash bfcat.sh <(echo -n '<string>')

Tidak disatukan

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"

Referensi dalam versi Ungolfed

1. Baca file byte demi byte

2. ord dari char in bash

3. memancarkan karakter $ n kali

ES6, 119 115 byte

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}

Disimpan 4 byte, terima kasih kepada @Leibrug

Sesos (tidak bersaing)

Hexdump:

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

Size   : 12 byte(s)

Cobalah 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 byte

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

+1 byte untuk popsi baris perintah. Misalnya, dapatkan kode brainfuck untuk ABC xyzAnda jalankan

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

dan dapatkan

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

Haskell 50 Bytes

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