Thử thách

Viết chương trình hoặc hàm đã cho một chuỗi, trả về chương trình Brainfuck hợp lệ mà khi được biên dịch và thực thi là Brainfuck, sẽ trả về chuỗi đó ..

1. Giả sử tất cả các đầu vào được mã hóa dưới dạng ASCII.

2. Giả sử chương trình BF xuất ra sẽ thực thi trong một môi trường với một băng vô hạn.

3. Giả sử con trỏ bắt đầu từ ô 0 với mỗi ô được khởi tạo thành giá trị 0.

4. Mỗi ví dụ dưới đây đại diện cho một đầu ra đúng có thể cho đầu vào đã cho. Đặc biệt, các ví dụ bao gồm các dòng mới và không gian bổ sung để giúp con người dễ đọc hơn. Các giải pháp được tự do định dạng mã BF xuất ra dưới bất kỳ hình thức nào.

5. Các băng là gấp đôi vô hạn.

6. Tất cả các ô được cung cấp bởi trình thông dịch là các ô chính xác 8 bit. Tràn và tràn xung quanh trong một vấn đề có thể dự đoán và lành mạnh.

Ví dụ

Chuỗi không gian

Đưa ra đầu vào , chương trình / chức năng của bạn có thể trả về:

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

Dấu chấm than

Đưa ra đầu vào !, chương trình / chức năng của bạn có thể trả về:

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

Hai chữ cái

Đưa ra đầu vào hi, chương trình / chức năng của bạn có thể trả về:

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

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

++++
.
+
.

Đây là mã golf , vì vậy mã có số byte nhỏ nhất sẽ thắng. Chúc may mắn.

Thạch , 8 byte

O”+ẋp“.>

Hãy thử trực tuyến!

Chạy mẫu

Đối với đầu vào hi, chương trình này in

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

(không có nguồn cấp dữ liệu), lần lượt, inhi .

Làm thế nào nó hoạt động

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

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

Hãy thử trực tuyến!

Ví dụ đầu ra cho hi(không có nguồn cấp dữ liệu):

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

Giải trình

Điều này di chuyển trên băng trong khi viết chương trình. Xung quanh ,[...,]là một vòng lặp đầu vào tiêu chuẩn. Đối với mỗi ký tự, chúng tôi sử dụng bốn ô:

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

ô ở đâu xchúng ta viết đầu vào.

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

Phần này sử dụng ô ađể ghi a 21vào ô bthông qua phép nhân chuẩn 3và 7.

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

Bây giờ chúng tôi sử dụng điều đó 21để viết 42vào avà 63vào cbằng cách nhân với 2và 3tương ứng. Sau đó <+<di chuyển trở lại ô xtrong khi biến 42thành một 43(điểm mã của +). Tóm tắt lại

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

Bây giờ vòng lặp đầu ra chính:

[>.<-]

Đó là, trong khi giảm dần xchúng tôi in +mỗi lần.

>+++.

Sau khi hoàn thành, chúng tôi sử dụng lại +tế bào, bằng cách thêm vào 3để cung cấp ..

>>-.

Cuối cùng, chúng ta di chuyển đến 63, giảm dần thành 62( >) và xuất ra nó. Lặp lại tiếp theo sẽ sử dụng ô này là x.

Brainfuck, 39 33 32 31 byte

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

Thuật toán đặt 45 trên băng được lấy từ các hằng số Brainfuck của Esolang .

Câu trả lời này giả định rằng trình thông dịch của chương trình đầu ra có các ô được bao bọc, giới hạn; và điều đó làm thay ,đổi ô hiện tại (ngụ ý rằng chương trình đầu ra được chạy mà không có đầu vào). Hãy thử trực tuyến!

Đối với một giải pháp (dài hơn) hoạt động vô điều kiện, xem câu trả lời khác của tôi .

Chạy thử nghiệm

Đối với đầu vào Code Golf, đầu ra sau đây được tạo ra.

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Chúng tôi bắt đầu bằng cách đặt số nguyên 45 (mã ký tự của -) vào một ô của băng. Các mã sau đây đạt được điều này.

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

Trước khi chúng ta vào vòng lặp, băng trông như thế này.

         v
000 000 255

Ba ô này - -2 , -1 và 0 - là những ô duy nhất chúng tôi sẽ sử dụng trong chương trình này.

Trong mỗi lần lặp đầu tiên của vòng lặp, ô ngoài cùng bên phải, sau đó ô đó và ô giữa được giảm hai lần, để lại trạng thái sau.

     v
000 254 252

Trong 126 lần lặp tiếp theo, lần đầu tiên phân -rã ô giữa, [>]<nhảy đến ô ngoài cùng bên phải và phân --<--rã ô giữa và ô bên phải. Kết quả là 3 bị trừ khỏi ô giữa (modulo 256 ) và 2 bị trừ khỏi ô ngoài cùng bên phải.

Vì 254 3 (mod 256) = (254 + 256) 3 = 510 3 = 170 và 252 3 = 84 , ô ngoài cùng bên phải bị bỏ trống trước ô giữa, để lại trạng thái sau.

     v
000 132 000

Tương tự như lần lặp đầu tiên của vòng lặp, lần lặp tiếp theo bây giờ trừ 3 từ ô giữa và 2 từ ô ngoài cùng bên trái, đặt đầu vào ô ngoài cùng bên trái.

 v
254 129 000

Các lần lặp tiếp theo, như trong lần lặp 126 trước chúng, trừ 3 từ ô ngoài cùng bên trái và 2 từ ô ngoài cùng bên phải.

Vì 254 ÷ 3 (mod 256) = 170 và 129 2 (mod 256) không được xác định, điều này được thực hiện 170 lần, để lại trạng thái sau.

 v
000 045 000

Tế bào dưới đầu bằng không; vòng lặp kết thúc.

Bây giờ chúng tôi đã sẵn sàng để tạo đầu ra.

,      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

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

Câu trả lời này không đưa ra giả định nào về trình thông dịch của chương trình đầu ra. Hãy thử trực tuyến!

Đối với một giải pháp ngắn hơn (chỉ hoạt động với một số thông dịch viên), hãy xem câu trả lời khác của tôi .

Chạy thử nghiệm

Đối với đầu vào Code Golf, đầu ra sau đây được tạo ra.

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Chúng tôi bắt đầu bằng cách đặt số nguyên 43 (mã ký tự của +) vào ô thứ hai của băng. Các mã sau đây đạt được điều này.

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

Điều này về cơ bản thực hiện phân chia mô-đun 2 6 (mod 256) . Vì (2 + 256) 6 = 258 6 = 43 , kết quả là 43 , như dự định.

Bây giờ chúng tôi đã sẵn sàng để tạo đầu ra.

,      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".>

Hãy thử trực tuyến tại đây .

05AB1E, 12 11 byte

vyÇ`'+ׄ.>J

Giải thích

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

Dùng thử trực tuyến

Đã lưu 1 byte nhờ @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 không có gì khác hơn là bất biến char[]với một loạt các phương thức tiện ích, vì vậy hãy sử dụng mảng!

Ung dung:

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

Chương trình độc lập tương đương dài 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(".>");}}}

Tặng kem:

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

Ứng dụng 207 byte này thực sự mã hóa một tệp dưới dạng chương trình BF, giống như đã nói trong tiêu đề.

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.

Lưu ý rằng câu trả lời này là một trong số ít lần tôi từng sử dụng Ivà u. : D

Hãy thử trực tuyến!

O , 13 byte

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

Giải trình:

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#"+"}'

Sử dụng

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

Giải trình

  {           }'  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 đặt một số điểm cộng tương đương với mã ASCII của mỗi ký tự, theo sau là .>in và di chuyển đến ô tiếp theo. Brainfuck tăng đến giá trị chính xác, in và chuyển sang ô tiếp theo.

Đầu ra cho hi(với dòng mới cho rõ ràng):

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

Đầu ra của chương trình:

hi

Perl, 25 byte

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

Sử dụng

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

Giải trình

Sử dụng một hoạt động thay thế biểu thức chính quy để thay thế mọi ký tự trong mỗi dòng được đưa ra trên đầu vào tiêu chuẩn với một số +tính toán từ giá trị thứ tự của ký tự đó, sau đó xuất ra .>để in và chuyển sang ký tự tiếp theo.

Sử dụng -pcờ perl để tự động đọc đầu vào và in kết quả, thêm 1 vào phụ.

Java, 91 byte

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

Đạo cụ cho dorukayhan vì đã đánh tôi với nó :)

C, 72 64 60 byte

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

Phiên bản bị đánh cắp:

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

Biên dịch và kiểm tra với:
gcc -o bfcat bfcatgolf.c && cat 1.txt | ./bfcat > o.txt && beef o.txt

Các kết quả

• hi- http://paste.ubfox.com/17995958/
• quick brown fox jumps over the lazy dog- http://paste.ubfox.com/17996059/
• mã nguồn - http://paste.ubfox.com/18000808/

CJam, 12 byte

Chuyển đổi từng ký tự thành giá trị ASCII của nó và tăng ô hiện tại theo số lần đó trước khi in. Vì chúng ta có băng vô hạn, chúng ta có thể di chuyển sang phải sau khi xử lý từng ký tự.

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

Hãy thử trực tuyến!

Lua, 67 66 61 byte

Đơn giản chỉ cần lặp qua mỗi nhân vật trong đối số, và in một dòng cho mỗi người với n +s tiếp theo .>ở đâu nlà giá trị của nhân vật này trong bảng ASCII.

Sử dụng gmatch như @LeakyNun đã khuyên trong nhận xét về việc tiết kiệm 1 Byte qua giải pháp gsub

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

Giải pháp cũ sử dụng gsub

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

67 tuổi

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

Để chạy nó, chỉ cần lưu nó dưới dạng tệp ( golf.luaví dụ) và chạy nó với lua golf.lua "hi". Đối với hi, nó nên xuất

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

J, 28 byte

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

Đủ đơn giản. 3&u:chuyển đổi ký tự thành mã char. Phần còn lại chỉ là lặp lại '+'số lần đó, sau đó nối với nhau .>ở cuối mỗi dòng và ;làm phẳng kết quả.

Một số kết quả

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

Pyke, 11 byte

F.o\+*".>"+

Hãy thử nó ở đây!

Trên thực tế, 13 byte

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

Hãy thử trực tuyến!

Chiến lược được sử dụng ở đây cũng giống như trong nhiều giải pháp khác - đối với mỗi ký tự, xuất ra đủ +s để tăng một ô được khởi tạo bằng 0 đến thứ tự ASCII thích hợp, xuất ra .và di chuyển đến ô tiếp theo >.

Giải trình:

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)

Chuột-2002, 27 byte

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

Điều này hoạt động trên lý thuyết và theo tài liệu của ngôn ngữ, nhưng việc triển khai tham chiếu trình thông dịch của Chuột dường như có một lỗi trong đó đầu vào chuỗi nối thêm một ', vì vậy đối với ađầu ra này

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

Mà lần lượt đầu ra a'. Điều đó có thể hoặc có thể không ổn, vì vậy đây là một byte dài 39 byte không xuất ra 'bao giờ và do đó có khả năng không hợp lệ hơn .

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

Mà cho đầu ra đúng trong tham chiếu impl. miễn là không có 's :)

Giải thích:

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

Yếu tố, 58 byte

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

Hoạt động như:

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

Vì Factor đi kèm với trình thông dịch Brainfuck, thật đơn giản để kiểm tra.

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

đầu ra

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! tất cả đều vượt qua.

Hồng ngọc 40 38 byte

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

Sidef , 38 byte

Này, cùng chiều dài với Ruby! chỉ là Sidef không phải là Ruby: D

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

Đọc một số ký tự, sau đó cho mỗi byte làm điều đó.

GNU Bash, 100 85 byte

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

Cảm ơn @cat đã tiết kiệm cho tôi 15 byte!

Bưu điện

1. Giả sử chuỗi đầu vào được biểu diễn dưới dạng trong một tệp được truyền dưới dạng đối số đầu tiên.
2. Sử dụng: bash bfcat.sh <path to file containing string>
3. Cách sử dụng (với đường ống có tên): bash bfcat.sh <(echo -n '<string>')

Ung dung

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"

Tài liệu tham khảo trong phiên bản Ungolfed

1. Đọc tệp byte theo byte

2. ord của một char trong bash

3. phát ra nhân vật $ n lần

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}

Đã lưu 4 byte, nhờ @Leibrug

Sesos (không cạnh tranh)

Hexdump:

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

Size   : 12 byte(s)

Hãy thử trực tuyến!

Nhà lắp ráp

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 cho ptùy chọn dòng lệnh. Ví dụ: lấy mã brainfuck để ABC xyzbạn có thể chạy

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

và lấy

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

Haskell 50 byte

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