bfcat - кодує файл у вигляді програми brainf ***


18

Виклик

Напишіть програму або функцію, яка дала рядок, повертає дійсну програму Brainfuck, яка при компіляції та виконанні як Brainfuck повертає цю рядок ..

  1. Припустимо, всі входи кодуються як ASCII.

  2. Припустимо, що виведена програма BF буде виконуватися в середовищі з нескінченною стрічкою.

  3. Припустимо, що вказівник починається з комірки 0 з кожною коміркою, ініціалізованою до нуля.

  4. Кожен приклад нижче представляє один можливий правильний вихід для даного вводу. Зокрема, приклади включають додаткові нові рядки та пробіли для полегшення читабельності людини. Рішення можуть форматувати вихідний код BF будь-яким способом.

  5. Стрічка подвійно нескінченна.

  6. Усі клітини, що надаються інтерпретатором, є рівно 8-бітовими клітинами. Перелив і перелив обгортаються передбачуваною і здоровою справою.

Приклади

Пробіл

З огляду на вхід , ваша програма / функція може повернутись:

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

Знак оклику

З огляду на вхід !, ваша програма / функція може повернутись:

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

Дві букви

З огляду на вхід hi, ваша програма / функція може повернутись:

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

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

++++
.
+
.

Це , тому виграє код з найменшою кількістю байтів. Удачі.


10
Більше тестів, будь ласка.
Лина монашка

1
Які саме вказівки згадуються у Версії 9 ?
користувач8397947

4
Я знову відкриваю це. Я думаю, що проблеми Пітера були вирішені, і ми маємо досить чіткий консенсус щодо того, що вважається дублікатом, і це завдання не відповідає цим критеріям.
Мартін Ендер

"Обтікання переливів та переливів передбачувано та здорово" - так 127 + 1 обгортання до 0 та -128-1 також обгортання до 0, правильно? Це один із можливих передбачуваних та розумних способів.
користувач253751

1
@immibis Рівно.
користувач8397947

Відповіді:


18

Желе , 8 байт

O”+ẋp“.>

Спробуйте в Інтернеті!

Вибірка зразка

Для введення hiця програма друкує

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

(без стрічкових каналів), який, у свою чергу, друкуєhi .

Як це працює

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.

Ваш не працює на обмеженій пам’яті, моє.
Leaky Nun

5
Не зовсім. Ми обидва зберігаємо весь вихід у пам'яті перед друком. Для перекладачів BF, які мають досить велику стрічку, це стане проблемою задовго до того, як стрічка зробить це.
Денніс

Чому не .>відображається у висновку?
кіт

2
@cat Оскільки декартовий продукт ( p) коротший, ніж до кожного ( ;€). Ці вихідні програми подвоюють комірку після друку та перед перемиканням. Оскільки ми ніколи не переглядаємо комірку, це не впливає на вихід.
Денніс

@Dennis ах, цікаво.
кіт

55

Brainfuck, 55 51 байт

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

Спробуйте в Інтернеті!

Приклад виводу для hi(без стрічкових каналів):

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

Пояснення

Це рухається по стрічці під час написання програми. Навколишній ,[...,]- це стандартний вхідний контур. Для кожного символу ми використовуємо чотири комірки:

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

де xзнаходиться клітина, в яку ми пишемо вхід.

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

Ця частина використовує клітинку aдля запису 21в клітинку bза допомогою стандартного множення 3і 7.

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

Тепер ми використовуємо це 21для запису 42в aі 63в cмноження на2 і 3відповідно. Потім <+<повертається назад до комірки x, перетворюючи 42в 43(кодову точку +). Резюме:

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

Тепер основний вихідний цикл:

[>.<-]

Тобто, під час декрементування xми друкуємо по одному +кожного разу.

>+++.

Після закінчення ми використовуємо цю +клітинку повторно , додаючи 3to give ..

>>-.

Нарешті, ми переходимо до 63, декрементуємо його до 62( >) і також виводимо його. Наступна ітерація використовуватиме цю клітинку якx .


5
Я б даровав цьому щедро, якби мав більше представників.
користувач8397947

34

Brainfuck, 39 33 32 31 байт

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

Алгоритм, який розміщує 45 на стрічці, взято від констант Brainfuck Esolang .

Ця відповідь передбачає, що інтерпретатор вихідної програми має обгорткові, обмежені комірки; і це, дорівнює нулю поточної комірки (мається на увазі, що вихідна програма працює без введення). Спробуйте в Інтернеті!

Про (довше) рішення, яке працює безумовно, див іншу мою відповідь .

Тестовий запуск

Для введення Code Golfгенерується наступний вихід.

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

Спробуйте в Інтернеті!

Як це працює

Почнемо з введення цілого числа 45 (код символу -) у комірку стрічки. Наступний код цього досягає.

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

Перш ніж увійти до циклу, стрічка виглядає приблизно так.

         v
000 000 255

Ці три комірки - -2 , -1 та 0 - єдині, які ми будемо використовувати в цій програмі.

У першій кожній ітерації циклу найправіша клітинка є, потім ця клітина та середня комірка зменшуються вдвічі, залишаючи такий стан.

     v
000 254 252

У наступних 126 ітераціях початкові -зменшення середньої комірки [>]<переходять до крайньої правої клітини та --<--зменшення середньої та правої клітини. В результаті 3 віднімається від середньої комірки (модуль 256 ), а 2 віднімається від самої правої клітини.

Оскільки 254 ÷ 3 (mod 256) = (254 + 256) ÷ 3 = 510 ÷ 3 = 170 і 252 ÷ 3 = 84 , найправіша клітинка нульова перед середньою, залишаючи такий стан.

     v
000 132 000

Подібно до першої ітерації петлі, наступна ітерація віднімає 3 із середньої комірки та 2 із самої лівої клітини, розміщуючи голову на самій лівій комірці.

 v
254 129 000

Подальші ітерації, як і в ітерації 126 перед ними, віднімають 3 від самої лівої клітини та 2 - від самої правої клітини.

Оскільки 254 ÷ 3 (mod 256) = 170 і 129 ÷ 2 (mod 256) не визначено, це робиться 170 разів, залишаючи такий стан.

 v
000 045 000

Клітина під головою дорівнює нулю; петля закінчується.

Тепер ми готові генерувати вихід.

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

Чому отриманий BF не перекладається назад на рядок введення для мене? Це перекладач, який я використовую, який працював на інші відповіді.
Божевільний,

2
Цей перекладач має багато налаштувань. Для версії 32 байта, ви повинні були б динамічна пам'ять і кінець введення:\0 .
Денніс

10

Brainfuck, 35 13 43 байт

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

Ця відповідь не дає припущень щодо перекладача вихідної програми. Спробуйте в Інтернеті!

Більш коротке рішення (яке працює лише з деякими перекладачами), дивіться іншу мою відповідь .

Тестовий запуск

Для введення Code Golfгенерується наступний вихід.

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

Спробуйте в Інтернеті!

Як це працює

Почнемо, помістивши ціле число 43 (код символу +) у другу клітинку стрічки. Наступний код цього досягає.

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

Це по суті виконує модульний поділ 2 ÷ 6 (mod 256) . Оскільки (2 + 256) ÷ 6 = 258 ÷ 6 = 43 , результат дорівнює 43 , як задумано.

Тепер ми готові генерувати вихід.

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

Ах, чоловіче! Ви не можете зламати перекреслений мем 44-є-44, давай! У будь-якому разі ваша спроба перемогти її зазнала невдач, тому що це не виглядає враженим, схоже, що на моєму екрані є бруд (PHP, можливо?): P
кішка

2
Все, щоб уникнути цього коментаря ...
Dennis


4

05AB1E, 12 11 байт

vyÇ`'+ׄ.>J

Пояснив

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

Спробуйте в Інтернеті

Збережено 1 байт завдяки @Adnan


'+×замість F'+}збереження байта.
Аднан

1
@Adnan: Дякую! Я шукав команду «повторити».
Емінья,

4

Java, 98 байт

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

Strings - це не що інше, як незмінні char[]s з купою корисних методів, тому давайте використовувати масив!

Безголівки:

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

Еквівалентна автономна програма довжиною 138 байт:

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

Бонус:

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

Цей 207-байтний додаток насправді кодує файл як програму BF, як це було сказано в назві.


2
Це тільки я чи все, як програма з нерозділеним відступом виглядає приголомшливо?
користувач8397947

Я зрозумів прямо перед тим, як я розмістив, що моя відповідь - це, головним чином, твоя версія.
Божевільний

2

Віци, 19 17 байт

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.

Зауважте, що ця відповідь є одним з небагатьох разів, які я коли-небудь використовував Iі u. : D

Спробуйте в Інтернеті!


2

О , 13 байт

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

Пояснення:

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.

2

К6, 16 байт

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

Використання

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

Пояснення

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

Пояснення plz: D
Addison Crump

@VTCAKAVSMoACE Готово! :)
kirbyfan64sos

2

Python 3, 43 байти

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

Python ставить ряд плюсів, еквівалентних коду ASCII кожного символу, після чого .> друком та переходом до наступної комірки. Зростання мозкового ебанку до потрібного значення, друкує та переходить до наступної комірки.

Вихід для hi(з новими рядками для наочності):

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

Вихід цієї програми:

hi

2

Perl, 25 байт

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

Використання

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

Пояснення

Використовує операцію заміни регулярного виразу для заміни кожного символу в кожному рядку, заданого на стандартному вході, числом, +обчисленим від порядкового значення цього символу, а потім виведення.> для друку та переходить до наступного символу.

Використовує -pпрапор perl для автоматичного зчитування введення та друку результату, додаючи 1 додатковий рахунок до рахунку.


2

Java, 91 байт

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

Реквізит до снідакану за те, що він мене побив :)


Ви не можете просто зняти панель котлів і змінити всі назви змінних, а потім заявити про це як нову відповідь.
Leaky Nun

@LeakyNun Я цього не зробив, але міг би, якщо хотів.
Божевільний

Чим ця відповідь відрізняється від відповіді, з якою ви пов’язані?
Leaky Nun

@LeakyNun Downvote та рухайся далі
Insane

2

C, 72 64 60 байт

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

Негольована версія:

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

Складіть і тестуйте за допомогою:
gcc -o bfcat bfcatgolf.c && cat 1.txt | ./bfcat > o.txt && beef o.txt

Результати


Чому cпобітна обернена getchar, особливо якщо ви просто знову перевертаєте інверсію?
кіт

@cat c = ~getchar( )оцінює 0 до EOF. c = ~getchar( )і ~c++вони просто коротші ~( c = getchar( ) )таc--
Jacajack

2

CJam, 12 байт

Перетворює кожен символ у його значення ASCII та збільшує поточну комірку на цю кількість разів перед її друком. Оскільки у нас є нескінченна стрічка, ми можемо просто рухатися праворуч після обробки кожного символу.

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

Спробуйте в Інтернеті!


2

Луа, 67 66 61 байт

Просто перейдіть по кожному символу в аргументі та надрукуйте для кожного рядка рядок з n +s, а потім, .>де nзначення цього символу в таблиці ASCII.

Використовує gmatch, як @LeakyNun в коментарі порадив для економії 1 байтів над рішенням gsub

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

Старий розчин з використанням gsub

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

Старий 67

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

Щоб запустити його, просто збережіть його як файл ( golf.luaнаприклад) та запустіть його lua golf.lua "hi". Бо hiвін повинен вивести

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

Як це використовувати? Тільки вставляючи його у відповідь дає attempt to index a nil value, і f = ...дає те саме, і function f ... endдаєunexpected symbol near ':'
кіт

@cat Просто збережіть його у файлі та запустіть як lua file.lua "argument", я оновлю публікацію, щоб дати інструкції.
Katenkyo

Як це навіть працює? це ...ідентифікатор з argv?
кіт

1
@cat ...містить значення в argрозпакованій таблиці . Що означає, що він завжди буде відповідати, arg[1]якщо ви не використовуєте його у виклику функції в якості останнього параметра, тоді він витратить.
Katenkyo

n=...for n:gmatch"."do print(("+"):rep(c:byte())..".>")endдля 48 байт
Leaky Nun

1

J, 28 байт

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

Досить просто. 3&u:перетворює символи в char коди. Решта - це просто повторити '+'цю кількість разів, потім об'єднати .>в кінці кожного рядка і ;вирівняти результат.

Деякі результати

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


1

Власне, 13 байт

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

Спробуйте в Інтернеті!

Використовувана тут стратегія така ж, як і у багатьох інших рішень - для кожного символу виведіть достатньо +s, щоб збільшити нульову ініціалізовану комірку до належної порядкової лінії ASCII, вивести її за допомогою .та перейти до наступної комірки з> .

Пояснення:

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)

1

Миша-2002, 27 байт

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

Це працює в теорії та відповідно до мовної документації, але, схоже, реалізація інтерпретатора Мауса, здається, має помилку, коли додається рядок а ', тому для aцього виводиться

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

Що в свою чергу виводить a'. Це може або не може бути добре, так от 39 байт довжиною, який не вихід 'ніколи і , таким чином, ймовірно , більш недійсні.

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

Що дає правильний вихід у опорному імпл. до тих пір, поки немає 's :)

Пояснили:

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

1

Фактор, 58 байт

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

Працює як:

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

Оскільки Factor поставляється з перекладачем Brainfuck, тестувати його просто.

bfcat.factor

USING: sequences ;
IN: bfcat

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

bfcat-тести.фактор

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

вихід

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

Так! всі вони проходять.


1

Рубі, 40 38 байт

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

Я не знаю рубіну, але я знаю, що ви можете використовувати його putsзамість print, оскільки формат виводу не є значущим, доки він дійсний brainfuck і brainfuck не піклується про інших персонажів
кіт

@cat oh Я не знав, що BF ігнорує інших персонажів, дякую!
CocoaBean

1

Сидеф , 38 байт

Гей, така ж довжина, як і Рубі! тільки що Sidef - це не Ruby: D

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

Прочитайте кілька символів, а потім для кожного байта зробіть це.


1

GNU Bash, 100 85 байт

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

Дякую @cat, що врятував мені 15 байт!

Можливий

  1. Припускає, що вхідний рядок представлений як є у файлі, переданому як перший аргумент.
  2. Використання: bash bfcat.sh <path to file containing string>
  3. Використання (з названою трубою): bash bfcat.sh <(echo -n '<string>')

Безумовно

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"

Посилання у версії Ungolfed

  1. Читання файлів байт за байтом

  2. ord чару в баші

  3. випромінюють символ $ n разів


1
Я покращив частину форматування та деталей у вашій відповіді та видалив зайву інформацію із посилань. Відмініть її, якщо вам це не подобається. Крім того, це GNU Bash, а не GNU / Bash, як GNU / Linux. :)
кіт

1
Поради щодо гольфу (я не гольфіст): read -rn1позбудьтесь місця ;, позбудьтесь місця, done <"$1"щоб заощадити 9 байт
кіт

1
@cat Це виглядає приголомшливо! Мені справді потрібно ввійти в звичку редагувати-> попередньо-> редагувати -> ...
Yeow_Meng

1

ES6, 119 115 байт

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 байти, завдяки @Leibrug


1
Ви можете призначити charCodeAtякийсь var (скажімо c) та використовувати такий: s[c](i)скоротити на 1 байт, а також видалити деякі символи (я знайшов 3: пробіл раніше [...s], замініть логічний АБО на бітовий і крапку з комою раніше return).
Лейбруг


0

Рубін, 26 байт

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

+ 1 байт для параметра pкомандного рядка. Щоб, наприклад, дістати мозковий код, ABC xyzможна запустити

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

і дістати

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

Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.