Desafio

Escreva um programa ou função que tenha uma string, retorne um programa Brainfuck válido que, quando compilado e executado como Brainfuck, retorne essa string.

1. Suponha que todas as entradas sejam codificadas como ASCII.

2. Suponha que o programa BF emitido seja executado em um ambiente com uma fita infinita.

3. Suponha que o ponteiro comece na célula 0 com cada célula inicializada com um valor zero.

4. Cada exemplo abaixo representa uma saída correta possível para a entrada fornecida. Em particular, os exemplos incluem novas linhas e espaços extras para ajudar a legibilidade humana. As soluções são gratuitas para formatar o código BF emitido de qualquer maneira.

5. A fita é duplamente infinita.

6. Todas as células fornecidas pelo intérprete são exatamente células de 8 bits. Estouro e subfluxo envolvem uma questão previsível e sã.

Exemplos

Cadeia de espaço

Dada a entrada , seu programa / função pode retornar:

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

Ponto de exclamação

Dada a entrada !, seu programa / função pode retornar:

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

Duas cartas

Dada a entrada hi, seu programa / função pode retornar:

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

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

++++
.
+
.

Isso é código-golfe , então o código com o menor número de bytes vence. Boa sorte.

Gelatina , 8 bytes

O”+ẋp“.>

Experimente online!

Amostra de execução

Para entrada hi, este programa imprime

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

(sem as alimentações de linha) que, por sua vez, são impressashi .

Como funciona

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 bytes

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

Experimente online!

Exemplo de saída para hi(sem os feeds de linha):

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

Explicação

Isso se move pela fita enquanto escreve o programa. O ambiente ,[...,]é um loop de entrada padrão. Para cada personagem, usamos quatro células:

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

onde xestá a célula na qual escrevemos a entrada.

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

Esta parte usa célula apara escrever uma 21célula em buma multiplicação padrão de 3e 7.

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

Agora usamos isso 21para escrever 42dentro ae 63para dentro cmultiplicando por 2e 3respectivamente. Em seguida, <+<volta para a célula xenquanto transforma o 42em 43(o ponto de código de +). Recapitular:

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

Agora, o loop de saída principal:

[>.<-]

Ou seja, ao decrementar x, imprimimos um de +cada vez.

>+++.

Depois que terminamos, reutilizamos a +célula, adicionando 3para dar ..

>>-.

Finalmente, passamos para o 63, diminuímos para 62( >) e produzimos isso também. A próxima iteração usará essa célula como x.

Brainfuck, 39 33 32 31 bytes

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

O algoritmo que coloca 45 na fita é retirado das constantes Brainfuck de Esolang .

Esta resposta pressupõe que o intérprete do programa de saída tenha células delimitadoras; e isso ,zera a célula atual (implicando que o programa de saída é executado sem entrada). Experimente online!

Para uma solução (mais longa) que funciona incondicionalmente, veja minha outra resposta .

Execução de teste

Para entrada Code Golf, a seguinte saída é gerada.

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

Experimente online!

Como funciona

Começamos colocando o número inteiro 45 (código de caractere de -) em uma célula da fita. O código a seguir consegue isso.

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

Antes de entrarmos no loop, a fita fica assim.

         v
000 000 255

Essas três células - -2 , -1 e 0 - são as únicas que usaremos neste programa.

Na primeira cada iteração do loop, a célula mais à direita é, então essa célula e a célula do meio são decrementadas duas vezes, deixando o seguinte estado.

     v
000 254 252

Nas próximas 126 iterações, a inicial -diminui a célula do meio, [>]<salta para a célula mais à direita e --<--diminui a célula do meio e a direita. Como resultado, 3 é subtraído da célula do meio (módulo 256 ) e 2 é subtraído da célula mais à direita.

Como 254 ÷ 3 (mod 256) = (254 + 256) ÷ 3 = 510 ÷ 3 = 170 e 252 ÷ 3 = 84 , a célula mais à direita é zerada antes da do meio, deixando o seguinte estado.

     v
000 132 000

Da mesma forma que a primeira iteração do loop, a próxima iteração agora subtrai 3 da célula do meio e 2 da célula da esquerda, colocando a cabeça na célula da esquerda.

 v
254 129 000

As iterações subsequentes, como na iteração 126 anterior, subtraem 3 da célula mais à esquerda e 2 da célula mais à direita.

Como 254 ÷ 3 (mod 256) = 170 e 129 ÷ 2 (mod 256) é indefinido, isso é feito 170 vezes, deixando o seguinte estado.

 v
000 045 000

A célula sob a cabeça é zero; o loop termina.

Agora estamos prontos para gerar saída.

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

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

Esta resposta não faz suposições sobre o intérprete do programa de saída.Experimente online!

Para uma solução mais curta (que funciona apenas com alguns intérpretes), veja minha outra resposta .

Execução de teste

Para entrada Code Golf, a seguinte saída é gerada.

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

Experimente online!

Como funciona

Começamos colocando o número inteiro 43 (código de caractere de +) na segunda célula da fita. O código a seguir consegue isso.

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

Isso essencialmente executa a divisão modular 2 ÷ 6 (mod 256) . Como (2 + 256) ÷ 6 = 258 ÷ 6 = 43 , o resultado é 43 , como pretendido.

Agora estamos prontos para gerar saída.

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

Pitão - 11 bytes

sm+*\+Cd".>

Experimente online aqui .

05AB1E, 12 11 bytes

vyÇ`'+ׄ.>J

Explicado

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

Experimente online

Guardado 1 byte graças a @Adnan

Java, 98 bytes

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

Strings nada mais são do que imutáveis char[] com métodos utilitários, então vamos usar o array!

Ungolfed:

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

Programa independente equivalente com 138 bytes de comprimento:

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

Bônus:

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

Na verdade, esse aplicativo de 207 bytes codifica um arquivo como um programa BF, como dito no título.

Vitsy, 19 17 bytes

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.

Observe que esta resposta é uma das poucas vezes que eu já usei Ie u. : D

Experimente online!

O , 13 bytes

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

Explicação:

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 bytes

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

Uso

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

Explicação

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

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

O Python coloca um número de vantagens equivalentes ao código ASCII de cada caractere, seguido por .> para imprimir e mover para a próxima célula. O golpe cerebral aumenta até o valor correto, imprime e passa para a próxima célula.

Saída para hi(com novas linhas para maior clareza):

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

A saída desse programa:

hi

Perl, 25 bytes

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

Uso

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

Explicação

Utiliza uma operação de substituição de expressão regular para substituir cada caractere em cada linha fornecida na entrada padrão por um número +calculado a partir do valor ordinal desse caractere, em seguida, sai .>para imprimir e avançar para o próximo caractere.

Usa o -psinalizador perl para ler automaticamente a entrada e imprimir o resultado, adicionando 1 extra ao número de bytes.

Java, 91 bytes

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

Adereços para dorukayhan por me bater nele :)

C, 72 64 60 bytes

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

Versão não destruída:

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

Compile e teste com:
gcc -o bfcat bfcatgolf.c && cat 1.txt | ./bfcat > o.txt && beef o.txt

Resultados

• hi- http://paste.ubuntu.com/17995958/
• quick brown fox jumps over the lazy dog- http://paste.ubuntu.com/17996059/
• código fonte - http://paste.ubuntu.com/18000808/

CJam, 12 bytes

Converte cada caractere em seu valor ASCII e incrementa a célula atual por esse número de vezes antes de imprimi-la. Como temos fita infinita, podemos simplesmente mover para a direita após processar cada caractere.

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

Experimente online!

Lua, 67 66 61 bytes

Simplesmente itere sobre cada caractere no argumento e imprima uma linha para cada um com n + s seguido de .>onden está o valor desse caractere na Tabela ASCII.

Usa gmatch como @LeakyNun recomendado no comentário por economizar 1 Bytes sobre a solução gsub

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

Solução antiga usando gsub

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

Antigo 67

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

Para executá-lo, salve-o como um arquivo ( golf.luapor exemplo) e execute-o com lua golf.lua "hi". Para hi, deve produzir

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

J, 28 bytes

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

Simples o suficiente. 3&u:converte caracteres em códigos de caracteres. O resto é apenas repetir '+'esse número de vezes e concatenar .>no final de cada linha e ;nivelar o resultado.

Alguns resultados

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

Pyke, 11 bytes

F.o\+*".>"+

Experimente aqui!

Na verdade, 13 bytes

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

Experimente online!

A estratégia usada aqui é a mesma que em muitas das outras soluções - para cada personagem, produz bastante + s para incrementar uma célula inicializada com zero para o ordinal ASCII adequado, produzi-la com .e passar para a próxima célula com> .

Explicação:

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 bytes

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

Isso funciona na teoria e de acordo com a documentação da linguagem, mas a implementação de referência do intérprete do Mouse parece ter um bug no qual a entrada de string acrescenta a ', portanto, para aessas saídas

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

Que por sua vez, produz a'. Isso pode ou não ser bom, então aqui está um de 39 bytes de comprimento que 'nunca sai e, portanto, é provavelmente mais inválido.

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

O que fornece saída correta no impl impl. contanto que não haja' s :)

Explicado:

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

Fator, 58 bytes

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

Funciona como:

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

Como o Factor vem com um intérprete Brainfuck, é fácil testar.

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

resultado

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! todos eles passam.

Rubi, 40. 38 bytes

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

Sidef , 38 bytes

Ei, do mesmo tamanho que Ruby! só que Sidef não é Ruby: D

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

Leia alguns caracteres e, para cada byte, faça isso.

GNU Bash, 100 85 bytes

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

Obrigado @cat por me salvar 15 bytes!

Postramble

1. Assume que a sequência de entrada é representada como está em um arquivo passado como primeiro argumento.
2. Uso: bash bfcat.sh <path to file containing string>
3. Uso (com pipe nomeado): 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"

Referências na versão Ungolfed

1. Ler arquivo byte por byte

2. ord de um char na festança

3. emitir caractere $ n vezes

ES6, 119 115 bytes

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}

Guardado 4 bytes, graças a @Leibrug

Sesos (não concorrente)

Hexdump:

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

Size   : 12 byte(s)

Experimente online!

Montador

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

Ruby, 26 bytes

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

+ 1 byte para a popção de linha de comando. Para, por exemplo, obter o código brainfuck, ABC xyzvocê pode executar

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

e pegue

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

Haskell 50 Bytes

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