bfcat - codifica un archivo como un programa brainf ***

18

Desafío

Escriba un programa o función que, dada una cadena, devuelva un programa Brainfuck válido que, cuando se compila y ejecuta como Brainfuck, devuelve esa cadena.

  1. Suponga que todas las entradas están codificadas como ASCII.

  2. Suponga que el programa BF generado se ejecutará en un entorno con una cinta infinita.

  3. Suponga que el puntero comienza en la celda 0 con cada celda inicializada a un valor de cero.

  4. Cada ejemplo a continuación representa una posible salida correcta para la entrada dada. En particular, los ejemplos incluyen nuevas líneas y espacios adicionales para ayudar a la legibilidad humana. Las soluciones son libres de formatear el código BF generado de cualquier manera.

  5. La cinta es doblemente infinita.

  6. Todas las celdas proporcionadas por el intérprete son exactamente celdas de 8 bits. El desbordamiento y el subflujo se envuelven en una materia predecible y sana.

Ejemplos

Cadena espacial

Dada la entrada , su programa / función podría devolver:

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

Punto de exclamación

Dada la entrada !, su programa / función podría devolver:

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

Dos cartas

Dada la entrada hi, su programa / función podría devolver:

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

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

++++
.
+
.

Este es el código de golf , por lo que gana el código con el menor número de bytes. Buena suerte.

code-golf brainfuck Yeow_Meng
fuente
10
Más casos de prueba por favor.
Leaky Nun
1
¿Cuáles son exactamente las pautas mencionadas en la Revisión 9 ?
user8397947
44
Estoy reabriendo esto. Creo que las preocupaciones de Peter se han abordado y tenemos un consenso bastante claro sobre lo que cuenta como un duplicado, y este desafío no cumple con esos criterios.
Martin Ender
"Ajuste de desbordamiento y subflujo de una manera predecible y sensata", entonces 127 + 1 se ajusta a 0 y -128-1 también se ajusta a 0, ¿correcto? Esa es una posible manera predecible y sensata.
user253751
1
@immibis Exactamente.
user8397947

Respuestas:

18

Jalea , 8 bytes

O”+ẋp“.>

Pruébalo en línea!

Ejecución de la muestra

Para entrada hi, este programa imprime

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

(sin los avances de línea) que, a su vez, imprimehi .

Cómo 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
fuente
La tuya no funciona con memoria limitada, la mía sí.
Leaky Nun
55
Realmente no. Ambos almacenamos toda la salida en la memoria antes de imprimir. Para los intérpretes BF con una cinta lo suficientemente grande, eso se convertirá en un problema mucho antes que la cinta.
Dennis
¿Por qué no .>aparece en la salida?
gato
2
@cat Porque el producto cartesiano ( p) es más corto que agregar a cada ( ;€). Estos programas de salida duplican la celda después de imprimir y antes de cambiar. Como nunca volvemos a visitar la celda, no afecta la salida.
Dennis
@ Dennis ahh, interesante.
gato
55

Brainfuck, 55 51 bytes

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

Pruébalo en línea!

Ejemplo de salida para hi(sin los avances de línea):

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

Explicación

Esto se mueve a través de la cinta mientras escribe el programa. El entorno ,[...,]es un bucle de entrada estándar. Para cada personaje, usamos cuatro celdas:

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

¿Dónde xestá la celda donde escribimos la entrada?

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

Esta parte usa la celda apara escribir 21en una celda a btravés de una multiplicación estándar de 3y 7.

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

Ahora usamos eso 21para escribir 42dentro ay 63dentro cmultiplicando por 2y 3respectivamente. Luego <+<regresa a la celda xmientras se convierte 42en a 43(el punto de código de +). Resumen:

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

Ahora el bucle de salida principal:

[>.<-]

Es decir, mientras decrementamos ximprimimos uno +cada vez.

>+++.

Una vez que terminamos, reutilizamos la +celda, agregando 3para dar ..

>>-.

Finalmente, nos movemos a 63, lo decrementamos a 62( >) y lo mostramos también. La próxima iteración usará esta celda como x.

Martin Ender
fuente
55
Daría una recompensa por esto si tuviera más reputación.
user8397947
34

Brainfuck, 39 33 32 31 bytes

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

El algoritmo que coloca 45 en la cinta se toma de las constantes Brainfuck de Esolang .

Esta respuesta supone que el intérprete del programa de salida tiene celdas ajustadas y ajustadas; y eso ,pone a cero la celda actual (lo que implica que el programa de salida se ejecuta sin entrada). Pruébalo en línea!

Para una solución (más larga) que funcione incondicionalmente, vea mi otra respuesta .

Prueba de funcionamiento

Para la entrada Code Golf, se genera la siguiente salida.

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

Pruébalo en línea!

Cómo funciona

Comenzamos colocando el número entero 45 (código de caracteres de -) en una celda de la cinta. El siguiente código logra esto.

-      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 entrar en el bucle, la cinta se ve así.

         v
000 000 255

Estas tres celdas, -2 , -1 y 0 , son las únicas que usaremos en este programa.

En la primera cada iteración del bucle, la celda más a la derecha es, luego esa celda y la celda central se disminuyen dos veces, dejando el siguiente estado.

     v
000 254 252

En las siguientes 126 iteraciones, la inicial -disminuye la celda del medio, [>]<salta a la celda más a la derecha y --<--disminuye la celda del medio y la derecha. Como resultado, 3 se resta de la celda central (módulo 256 ) y 2 se resta de la celda más a la derecha.

Desde 254 ÷ 3 (mod 256) = (254 + 256) ÷ 3 = 510 ÷ 3 = 170 y 252 ÷ 3 = 84 , la celda más a la derecha se pone a cero antes que la del medio, dejando el siguiente estado.

     v
000 132 000

De manera similar a la primera iteración del bucle, la siguiente iteración ahora resta 3 de la celda central y 2 de la celda más a la izquierda, colocando la cabeza en la celda más a la izquierda.

 v
254 129 000

Las iteraciones posteriores, como en la iteración 126 anterior, restan 3 de la celda más a la izquierda y 2 de la celda más a la derecha.

Como 254 ÷ 3 (mod 256) = 170 y 129 ÷ 2 (mod 256) no está definido, esto se hace 170 veces, dejando el siguiente estado.

 v
000 045 000

La celda debajo de la cabeza es cero; El bucle termina.

Ahora estamos listos para generar resultados.

,      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
fuente
¿Por qué el BF resultante no se traduce de nuevo a la cadena de entrada para mí? Este es el intérprete que estoy usando, que ha funcionado para las otras respuestas.
Loco
2
Ese intérprete tiene muchas configuraciones. Para la versión de 32 bytes, que había necesidad de memoria dinámica y el final de la entrada:\0 .
Dennis
10

Brainfuck, 35 13 43 bytes

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

Esta respuesta no hace suposiciones sobre el intérprete del programa de salida. Pruébalo en línea!

Para una solución más corta (que funciona solo con algunos intérpretes), vea mi otra respuesta .

Prueba de funcionamiento

Para la entrada Code Golf, se genera la siguiente salida.

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

Pruébalo en línea!

Cómo funciona

Comenzamos colocando el número entero 43 (código de caracteres de +) en la segunda celda de la cinta. El siguiente código logra esto.

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

Esto esencialmente realiza la división modular 2 ÷ 6 (mod 256) . Como (2 + 256) ÷ 6 = 258 ÷ 6 = 43 , el resultado es 43 , según lo previsto.

Ahora estamos listos para generar resultados.

,      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
fuente
Aw, hombre! No puedes romper el meme tachado-44-es-44, ¡vamos! De todos modos, su intento de derrotarlo fracasó miserablemente porque no parece tachado, parece que hay algo de suciedad en mi pantalla (¿PHP, tal vez?): P
cat
2
Cualquier cosa para evitar ese comentario ...
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

Pruébalo en línea

Guardado 1 byte gracias a @Adnan

Emigna
fuente
'+×en lugar de F'+}guardar un byte.
Adnan
1
@Adnan: ¡Gracias! Estaba buscando un 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;}}

StringLos s no son más que inmutables char[]con un montón de métodos de utilidad, así que ¡usemos la matriz!

Sin golf:

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

Programa independiente equivalente que tiene 138 bytes de longitud:

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

Prima:

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

Esta aplicación de 207 bytes en realidad codifica un archivo como un programa BF, tal como se dice en el título.

user8397947
fuente
2
¿Soy solo yo o la forma en que se sangra el programa sin golf parece increíble?
user8397947
Me di cuenta justo antes de publicar que mi respuesta es básicamente una versión suya.
Loco
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.

Tenga en cuenta que esta respuesta es una de las pocas veces que he usado Iyu . :RE

Pruébalo en línea!

Addison Crump
fuente
2

O , 13 bytes

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

Explicación:

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
fuente
2

K6, 16 bytes

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

Uso

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

Explicación

  {           }'  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
fuente
Explicación por favor: D
Addison Crump
@VTCAKAVSMoACE ¡Listo! :)
kirbyfan64sos
2

Python 3, 43 bytes

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

Python pone una serie de más ventajas equivalentes al código ASCII de cada carácter, seguido de .> imprimir y pasar a la siguiente celda. El brainfuck se incrementa hasta el valor correcto, imprime y pasa a la siguiente celda.

Salida para hi(con nuevas líneas para mayor claridad):

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

La salida de ese programa:

hi
bkul
fuente
2

Perl, 25 bytes

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

Uso

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

Explicación

Utiliza una operación de reemplazo de expresión regular para reemplazar cada carácter en cada línea dada en la entrada estándar con un número de + calculado a partir del valor ordinal de ese carácter, y luego genera.> para imprimir y avanzar al siguiente carácter.

Utiliza el -pindicador perl para leer automáticamente la entrada e imprimir el resultado, agregando 1 extra al recuento de bytes.

tubo
fuente
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;}

Apoyos a dorukayhan por vencerme :)

Insano
fuente
No puede simplemente eliminar el repetitivo y cambiar todos los nombres de las variables y luego reclamarlo como una nueva respuesta.
Leaky Nun
@LeakyNun No lo hice, pero podría hacerlo si quisiera.
Loco
¿Cómo es esta respuesta diferente de la respuesta a la que se vinculó?
Leaky Nun
@LeakyNun Downvote y seguir adelante
Insane
2

C, 72 64 60 bytes

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

Versión sin golf:

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

Compila y prueba con:
gcc -o bfcat bfcatgolf.c && cat 1.txt | ./bfcat > o.txt && beef o.txt

Resultados

Jacajack
fuente
¿Por qué es cel inverso a nivel de bits getchar, especialmente si simplemente invierte la inversión nuevamente?
gato
@cat se c = ~getchar( )evalúa a 0 en adelante EOF. c = ~getchar( )y ~c++son simplemente más cortos que ~( c = getchar( ) )yc--
Jacajack
2

CJam, 12 bytes

Convierte cada carácter en su valor ASCII e incrementa la celda actual en ese número de veces antes de imprimirlo. Como tenemos una cinta infinita, podemos movernos hacia la derecha después de procesar cada carácter.

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

Pruébalo en línea!

caso
fuente
2

Lua, 67 66 61 Bytes

Simplemente itere sobre cada carácter en el argumento e imprima una línea para cada uno con n +s seguido de .>dónde nestá el valor de este carácter en la tabla ASCII.

Utiliza gmatch como @LeakyNun aconsejó en el comentario para guardar 1 Bytes sobre la solución gsub

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

Solución anterior usando gsub

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

Viejo 67

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

Para ejecutarlo, simplemente guárdelo como un archivo ( golf.luapor ejemplo) y ejecútelo con lua golf.lua "hi". Para hi, debe salir

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>
Katenkyo
fuente
¿Cómo uso esto? Solo pegarlo en el REPL da attempt to index a nil value, y f = ...da lo mismo, y function f ... enddaunexpected symbol near ':'
gato
@cat Simplemente guárdelo en un archivo y ejecútelo como lua file.lua "argument", actualizaré la publicación para dar instrucciones.
Katenkyo
¿Cómo funciona eso? es ...un identificador con argv?
gato
1
@cat ...contiene los valores de la tabla sin argempaquetar. Lo que significa que siempre corresponderá a arg[1]menos que lo use en una llamada de función como último parámetro, entonces se gastará.
Katenkyo
n=...for n:gmatch"."do print(("+"):rep(c:byte())..".>")endpor 48 bytes
Leaky Nun
1

J, 28 bytes

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

Suficientemente simple. 3&u:Convierte caracteres en códigos char. El resto es solo repetir '+'esa cantidad de veces, luego concatenando con .>al final de cada línea, y ;aplana el resultado.

Algunos resultados

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

En realidad, 13 bytes

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

Pruébalo en línea!

La estrategia utilizada aquí es la misma que en muchas de las otras soluciones: para cada carácter, genera suficientes +s para incrementar una celda inicializada en cero al ordinal ASCII adecuado, generarla con ., y pasar a la siguiente celda con >.

Explicación:

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
fuente
1

Mouse-2002, 27 bytes

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

Esto funciona en teoría y de acuerdo con la documentación del lenguaje, pero la implementación de referencia del intérprete de Mouse parece tener un error donde la entrada de cadena agrega a ', por lo que para aestas salidas

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

Que a su vez sale a'. Eso puede o no estar bien, así que aquí hay uno de 39 bytes de largo que 'nunca sale y por lo tanto es más inválido.

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

Lo que da salida correcta en la referencia impl. siempre y cuando no haya '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
fuente
1

Factor, 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 ""
]

Dado que Factor viene con un intérprete Brainfuck, es fácil de probar.

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

salida 

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

¡Hurra! Todos pasan.

gato
fuente
1

Rubí, 40 38 bytes

gets.chop.each_byte{|o|puts"+"*o+".>"}
Grano de cacao
fuente
No sé rubí, pero sí sé que puede utilizar putsen lugar de print, como el formato de la salida no es importante, siempre que es válido y brainfuck brainfuck no se preocupa por otros personajes
gato
@cat oh no sabía que bf ignora a otros personajes, ¡gracias!
CocoaBean
1

Sidef , 38 bytes

¡Hola, la misma longitud que Ruby! solo que Sidef no es Ruby: D

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

Lea algunos caracteres, luego por cada byte haga esa cosa.

gato
fuente
1

GNU Bash, 100 85 bytes

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

¡Gracias @cat por salvarme 15 bytes!

Preámbulo

  1. Asume que la cadena de entrada se representa como está en un archivo pasado como primer argumento.
  2. Uso: bash bfcat.sh <path to file containing string>
  3. Uso (con tubería con nombre): bash bfcat.sh <(echo -n '<string>')

Sin golf

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"

Referencias en versión Ungolfed

  1. Leer archivo byte por byte

  2. ord de un char en bash

  3. emitir caracteres $ n veces

Yeow_Meng
fuente
1
He mejorado algunos de los formatos y cosas en su respuesta, y eliminé información redundante de los enlaces. Siéntete libre de deshacerlo si no te gusta. Además, es GNU Bash, no GNU / Bash como GNU / Linux. :)
gato
1
Consejos de golf (no soy un jugador de golf): read -rn1elimine los espacios después ;, elimine el espacio done <"$1"para ahorrar un total de 9 bytes
cat
1
@cat ¡Se ve increíble! Realmente necesito acostumbrarme a editar-> vista previa-> 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, gracias a @Leibrug

bodqhrohro
fuente
1
Puede asignar charCodeAtalgunas var (digamos c) y usar así: s[c](i)para acortar en 1 byte, y también eliminar algunos caracteres (encontré 3: espacio antes [...s], reemplazar OR lógico con uno bit a bit y punto y coma antes return).
Leibrug
1

Sesos (no competidor)

Hexdump:

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

Size   : 12 byte(s)

Pruébalo en línea!

Ensamblador

add 43,fwd 1,get
jmp
  jmp,sub 1,rwd 1,put,fwd 1,jnz
  add 46,put,add 16,put
  get
Monja permeable
fuente
0

Rubí, 26 bytes

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

+ 1 byte para la popción de línea de comando. Por ejemplo, para obtener el código de brainfuck para ABC xyzusted, puede ejecutar

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

y obten

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>
daniero
fuente
0

Haskell 50 Bytes

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