Вызов

Напишите программу или функцию с заданной строкой, которая возвращает действительную программу Brainfuck, которая при компиляции и исполнении как Brainfuck возвращает эту строку.

1. Предположим, что все входы закодированы как ASCII.

2. Предположим, что выведенная BF-программа будет выполняться в среде с бесконечной лентой.

3. Предположим, что указатель начинается с ячейки 0, каждая ячейка инициализируется значением ноль.

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

5. Лента вдвойне бесконечна.

6. Все ячейки, предоставленные интерпретатором, являются ровно 8-битными ячейками. Переполнение и переполнение обернуты в предсказуемое и вменяемое дело.

Примеры

Космическая строка

Учитывая ввод , ваша программа / функция может вернуть:

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

Восклицательный знак

Учитывая ввод !, ваша программа / функция может вернуть:

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

Две буквы

Учитывая ввод hi, ваша программа / функция может вернуть:

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

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

++++
.
+
.

Это код-гольф , поэтому выигрывает код с наименьшим количеством байтов. Удачи.

Желе , 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.

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мы печатаем по одному +каждый раз.

>+++.

После того, как мы закончим, мы снова используем +ячейку, добавляя 3к ней ..

>>-.

Наконец, мы переходим к 63, уменьшаем его до 62( >) и выводим это тоже. Следующая итерация будет использовать эту ячейку как x.

Brainfuck, 39 33 32 31 байт

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

Алгоритм, который размещает 45 на ленте, взят из констант Эзоланга Brainfuck .

Этот ответ предполагает, что интерпретатор выходной программы имеет обернутые ограниченные ячейки; и это ,обнуляет текущую ячейку (подразумевая, что выходная программа выполняется без ввода). Попробуйте онлайн!

Для (более длительного) решения, которое работает безоговорочно, см. Мой другой ответ .

Тестовый забег

Для ввода 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 (мод 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 (мод 256) = 170 и 129 ÷ 2 (мод 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.

Brainfuck, 35 ₁₃ 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 (мод 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.

Pyth - 11 байт

sm+*\+Cd".>

Попробуйте это онлайн здесь .

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

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 с кучей служебных методов, так что давайте использовать массив!

Ungolfed:

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-программу, как сказано в заголовке.

Витси, 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

Попробуйте онлайн!

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

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

Python 3, 43 байта

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

Питон помещает количество плюсов, эквивалентных коду ASCII каждого символа, после чего .>печатает и перемещается в следующую ячейку. Мозговой фук увеличивается до правильного значения, печатает и переходит к следующей ячейке.

Вывод для hi(с символами новой строки для ясности):

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

Вывод этой программы:

hi

Perl, 25 байт

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

использование

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

объяснение

Использует операцию замены регулярного выражения для замены каждого символа в каждой строке, заданной на стандартном вводе, числом + вычисленным по порядковому значению этого символа, а затем выводом .>для печати и перехода к следующему символу.

Использует -pфлаг perl для автоматического считывания ввода и печати результата, добавляя еще 1 к байту.

Java, 91 байт

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

Реквизит дорукайхан за то, что я его избил :)

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

Результаты

• hi- http://paste.ubuntu.com/17995958/
• quick brown fox jumps over the lazy dog- http://paste.ubuntu.com/17996059/
• исходный код - http://paste.ubuntu.com/18000808/

CJam, 12 байт

Преобразует каждый символ в его значение ASCII и увеличивает текущую ячейку на это число раз перед ее печатью. Поскольку у нас бесконечная лента, мы можем просто переместиться вправо после обработки каждого символа.

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

Попробуйте онлайн!

Луа, 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, это должно вывести

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

J, 28 байт

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

Достаточно просто. 3&u:преобразует символы в коды символов Остальное просто повторить '+'это количество раз, затем конкатенируя .>в конце каждой строки, и; выравниваете результат.

Некоторые результаты

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

Пайк, 11 байт

F.o\+*".>"+

Попробуй это здесь!

На самом деле, 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)

Мышь-2002, 27 байт

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

Это работает теоретически и в соответствии с документацией языка, но эталонная реализация интерпретатора Mouse, похоже, имеет ошибку, при которой к строковому вводу добавляется a ', поэтому для aэтого выводится

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

Который в свою очередь выводит a'. Это может или не может быть хорошо, поэтому вот 39-байтовый, который не выводит 'когда-либо и, таким образом, вероятно, более недействительным.

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

Который дает правильный вывод в ссылке импл. до тех пор, пока нет 'с :)

Разъяснение:

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

Фактор, 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-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

выход

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

Ура! они все проходят.

Рубин, 40 38 байт

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

Sidef , 38 байт

Эй, такой же длины, как у Руби! только то, что Sidef не Ruby: D

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

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

GNU Bash, 100 85 байт

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

Спасибо @cat за то, что сэкономили мне 15 байтов!

Postramble

1. Предполагается, что входная строка представлена ​​как есть в файле, переданном в качестве первого аргумента.
2. Использование: bash bfcat.sh <path to file containing string>
3. Использование (с именованным каналом): bash bfcat.sh <(echo -n '<string>')

Ungolfed

while IFS= read -r -n1 c # Read file byte by byte [1]
do
    n=$(printf "%d" \'"$c") # `ord` of a char in bash [2]
    printf '+%.0s' $(seq 1 $n) # emit character $n times [3]
    echo '.>' # Emit output and shift command for bf. I love infinite memory.
done <"$1"

Ссылки в версии Ungolfed

1. Читать файл побайтно

2. ord полукокса в баш

3. испускать символ $ n раз

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

Сесос (неконкурентный)

HexDump:

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

Size   : 12 byte(s)

Попробуйте онлайн!

ассемблер

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

Рубин, 26 байт

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

+ 1 байт для параметра pкомандной строки. Например, чтобы получить код брейкфук, ABC xyzвы можете запустить

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

и получить

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

Haskell 50 байтов

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