bfcat - codifica um arquivo como um programa brainf ***

18

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 é , então o código com o menor número de bytes vence. Boa sorte.

Yeow_Meng
fonte
10
Mais casos de teste, por favor.
Leaky Nun
1
Quais são exatamente as diretrizes mencionadas na revisão 9 ?
user8397947
4
Estou reabrindo isso. Acho que as preocupações de Peter foram abordadas e temos um consenso bastante claro sobre o que conta como duplicado, e esse desafio não atende a esses critérios.
Martin Ender
"Quebra de transbordamento e subfluxo de maneira previsível e sã" - então 127 + 1 passa para 0 e -128-1 também passa para 0, correto? Essa é uma maneira possível previsível e sã.
user253751
1
@immibis Exatamente.
user8397947

Respostas:

18

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.
Dennis
fonte
O seu não funciona com memória limitada, o meu funciona.
Leaky Nun
5
Na verdade não. Nós dois armazenamos toda a saída na memória antes de imprimir. Para intérpretes BF com uma fita grande o suficiente, isso se tornará um problema muito antes da fita.
Dennis
Por que não .>aparece na saída?
cat
2
@cat Como o produto cartesiano ( p) é mais curto que o anexo a cada ( ;€). Esses programas de saída duplicam a célula após a impressão e antes da troca. Como nunca revisitamos a célula, ela não afeta a saída.
Dennis
@ Dennis ahh, interessante.
cat
55

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.

Martin Ender
fonte
5
Eu daria uma recompensa a isso se tivesse mais representantes.
user8397947
34

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.
Dennis
fonte
Por que o BF resultante não é convertido de volta para a string de entrada para mim? Este é o intérprete que estou usando, que trabalhou para as outras respostas.
Insane
2
Esse intérprete tem muitas configurações. Para a versão de 32 bytes, você precisaria de memória dinâmica e final de entrada:\0 .
Dennis
10

Brainfuck, 35 13 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.
Dennis
fonte
Aw, meu! Você não pode quebrar o meme riscado-44-é-44, vamos lá! De qualquer forma sua tentativa de derrotá-lo falharam miseravelmente, porque não olhar bateu para fora, parece que há alguma sujeira na minha tela (PHP, talvez?): P
cat
2
Qualquer coisa para evitar esse comentário ...
Dennis
4

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

Emigna
fonte
'+×em vez de F'+}salvar um byte.
Adnan
1
@ Adnan: Obrigado! Eu estava procurando por um comando "repetir".
Emigna
4

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.

user8397947
fonte
2
Sou apenas eu ou a maneira como o programa não-destruído é recortado parece incrível?
user8397947
Percebi logo antes de postar que minha resposta é basicamente uma versão sua.
Insano
2

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!

Addison Crump
fonte
2

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.
kirbyfan64sos
fonte
2

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.
kirbyfan64sos
fonte
Explicação plz: D
Addison Crump
@VTCAKAVSMoACE Done! :)
kirbyfan64sos
2

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
bkul
fonte
2

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.

tubo
fonte
2

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 :)

Insano
fonte
Você não pode simplesmente remover o padrão e alterar todos os nomes das variáveis ​​e depois reivindicar isso como uma nova resposta.
Freira vazando
@LeakyNun eu não fiz, mas poderia, se quisesse.
Insano
Qual é a diferença desta resposta para a qual você vinculou?
Freira vazando
@LeakyNun Voto a favor e seguir em frente
Insane
2

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

Jacajack
fonte
Por que co bit a bit é inverso getchar, especialmente se você inverte a inversão novamente?
cat
@cat é c = ~getchar( )avaliado como 0 em EOF. c = ~getchar( )e ~c++são simplesmente mais curtos que ~( c = getchar( ) )ec--
Jacajack
2

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!

caso
fonte
2

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

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>
Katenkyo
fonte
Como eu uso isso? Apenas colá-lo no REPL dá attempt to index a nil value, e f = ...dá o mesmo, e function f ... endunexpected symbol near ':'
cat
@cat Apenas salve-o em um arquivo e execute-o como lua file.lua "argument", atualizarei o post para fornecer instruções.
precisa
Como isso funciona? é ...um identificador com argv?
cat
1
@cat ...contém os valores na tabela argdescompactados. O que significa que ele sempre corresponderá a arg[1]menos que você o use em uma chamada de função como o último parâmetro, então ele gastará.
precisa
n=...for n:gmatch"."do print(("+"):rep(c:byte())..".>")endpara 48 bytes
Freira gotejante
1

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 ' ~'
++++++++++++++++++++++++++++++++>.
                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>.
Conor O'Brien
fonte
1

Pyke, 11 bytes

F.o\+*".>"+

Experimente aqui!

Azul
fonte
1

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)
Mego
fonte
1

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(".>")
)              ~ }
gato
fonte
1

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.

gato
fonte
1

Rubi, 40. 38 bytes

gets.chop.each_byte{|o|puts"+"*o+".>"}
Semente de cacau
fonte
Eu não sei ruby, mas eu sei que você pode usar putsem vez de print, como o formato da saída não é significativo, desde que ele é brainfuck válido e brainfuck não se preocupa com outros personagens
cat
@cat oh eu não sabia que bf ignora outros personagens, obrigado!
precisa saber é o seguinte
1

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.

gato
fonte
1

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

Yeow_Meng
fonte
1
Aprimorei parte da formatação e outras coisas na sua resposta e removi informações redundantes dos links. Sinta-se à vontade para desfazê-lo se não gostar. Além disso, é GNU Bash, não GNU / Bash como GNU / Linux. :)
gato
1
Golfe dicas (Eu não sou nenhum golfista bash): read -rn1, livrar-se dos espaços depois ;, livrar-se do espaço em done <"$1"salvar um total de 9 bytes
cat
1
@cat Parece incrível! Eu realmente preciso adquirir o hábito de edit-> visualização prévia> Editar -> ...
Yeow_Meng
1

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

bodqhrohro
fonte
1
Você pode atribuir charCodeAta alguns var (digamos c) e usar assim: s[c](i)para diminuir em 1 byte e também remover alguns caracteres (eu encontrei 3: space antes [...s], substitua OR lógico por bit a bit um e ponto-e-vírgula antes return).
Leibrug
1

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
Freira Furada
fonte
0

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

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>
daniero
fonte
0

Haskell 50 Bytes

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