Generar codigo

36

Relacionado con: Make a; # interpreter

En el desafío vinculado anterior, la tarea consistía en crear un intérprete para el lenguaje esotérico ;#.

El ;#idioma

El lenguaje tiene exactamente dos comandos: ;y #(el intérprete ignora todos los demás caracteres):

;: Incrementar el acumulador

#: Module el acumulador por 127, imprima el carácter ASCII correspondiente y restablezca el acumulador a 0.

Reto

Debido a que soy flojo pero todavía quiero probar más casos de prueba, necesito un programa o función que convierta texto plano a ;#código.

Entrada

La entrada es una cadena, tomada como argumento o mediante stdin. Solo contendrá caracteres ASCII imprimibles y líneas nuevas.

Salida

La salida es el ;#programa generado al regresar o imprimir en stdout. Siempre y cuando el programa sea válido, puede contener caracteres en exceso que no sean #y ;todos los demás caracteres se ignoren.

Ejemplos

Input: Hello, World!
Output: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Input: ABC
Output: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Input: ;#
Output: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Tabla de clasificación

Mostrar fragmento de código

code-golf  code-generation 
— kalsowerus
fuente
99
¡Brillante! Me alegra ver; ¡# está llamando la atención!
— caird coinheringaahing
1
Puede probar su salida aquí , ya que; # + es un superconjunto de; #.
— Adám
3
¿Puede la salida contener caracteres adicionales? ;#ignora todos los demás caracteres, por lo que el programa generado seguirá funcionando.
— Dennis
2
@ Benoît: El módulo es irrelevante al generar código, ya que siempre es más fácil generar código que use el número mínimo de ;. En segundo lugar, 127 es correcto, como se indica en la pregunta vinculada que contiene la especificación del lenguaje; #.
— Joey
2
Esto no está realmente ocurriendo. "Generar #; código" es un título mejor. Voy a cambiarlo por eso.
— Mego

Respuestas:

34

; # + , 40 bytes

;;;;;~+++++++>~;~++++:>*(-(;~<#~):<#-*:)

Pruébalo en línea! La entrada termina con un byte nulo.

Explicación

El código se divide en dos partes: generación e iteración.

Generacion

;;;;;~+++++++>~;~++++:>

Esto pone las constantes ;y #en la memoria como tal:

;;;;;~+++++++>~;~++++:>
;;;;;                     set A to 5
     ~                    swap A and B
      +++++++             add B to A 7 times
                          (A, B) = (5*7, 5) = (35, 5)
             >            write to cell 0
              ~           swap A and B
               ;          increment A
                ~         swap A and B
                          (A, B) = (35, 6)
                 ++++     add B to A 4 times
                          (A, B) = (59, 6)
                     :    increment cell pointer
                      >   write to cell 1

Iteración

*(-(;~<#~):<#-*:)
*                    read a character into A
 (            * )    while input is not a null byte:
  -                  flip Δ
   (     )           while A != 0
    ;                decrement
     ~               swap A and B
      <              read ";" into A
       #             output it
        ~            swap A and B
           :         decrement cell pointer
            <        read "#" into A
             #       output it
              -      flip Δ
               *     take another character from input
                :    increment cell pointer
— Conor O'Brien
fuente
1
Todo esto de un lenguaje de broma que hice cuando estaba aburrido. Me halaga.
— caird coinheringaahing
@RandomUser: D es un concepto divertido para jugar
— Conor O'Brien
eh ¿Qué sucede si quiero que el programa imprima un byte nulo en; #?
— tuskiomi
— Conor O'Brien
@ ConorO'Brien, ¿cómo ingresaría eso en su programa?
— tuskiomi
12

Gelatina , 10 8 7 bytes

O”;ẋp”#

Pruébalo en línea!

O”;ẋp”#  Main Link
O        Map over `ord` which gets the codepoint of every character
 ”;ẋ     Repeat ';' the required number of times
     ”#  '#'
    p    Cartesian Product; this puts a '#' at the end of each element in the array

Implicit Output shows as a single string

-2 bytes gracias a @Emigna
-1 byte gracias a @Dennis

— Hiperneutrino
fuente
¿Podrías hacer en su O”;ẋ;€”#lugar?
— Emigna
@Emigna Ah, sí, gracias. No entiendo cómo funciona eso, pero lo entiendo. ¡Gracias!
— HyperNeutrino
44
;€puede llegar a ser p.
— Dennis
@ Dennis Oh, ahora entiendo cómo funciona eso. ¡Gracias! :)
— HyperNeutrino
11

GS2 , 6 bytes

■•;2•#

Pruébalo en línea!

Hexdump reversible (xxd)

0000000: ff 07 3b 32 07 23                                ■•;2•#

Cómo funciona

■       Map the rest of the program over  all code points C of the input.
 •;         Push ';'.
   2        Multiply; repeat ';' C times.
    •#      Push '#'.
— Dennis
fuente
2
■= ¿qué diablos?
— Erik the Outgolfer
1
2es el comando de multiplicación? GS2 es raro: P
— ETHproductions
1
@EriktheOutgolfer ejecuta el código para cada uno de los puntos de código del personaje de entrada o_O
— Sr. Xcoder
@EriktheOutgolfer Eso suena más elegante de lo que es. ■es solo map , y GS2 implementa cadenas como listas de enteros.
— Dennis
@ETHproductions GS2 no está basado en caracteres; interpreta el código fuente como una secuencia de bytes sin procesar, y generalmente no hay conexión entre la instrucción y el carácter CP-437 que codifica el byte. En x86_64 código de bytes, 2es XOR ...
— Dennis
10

Taxi, 779 bytes

Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to Chop Suey.Go to Chop Suey:n 1 r 1 l 4 r 1 l.[c]Switch to plan "e" if no one is waiting.Pickup a passenger going to Charboil Grill.Go to Charboil Grill:n 1 l 3 l 3 l.Pickup a passenger going to The Underground.Go to Writer's Depot:w 1 r.[p]; is waiting at Writer's Depot.Pickup a passenger going to Post Office.Go to Post Office:n 1 r 2 r 1 l.Go to The Underground:n 1 r 1 l.Switch to plan "n" if no one is waiting.Pickup a passenger going to The Underground.Go to Zoom Zoom:n 3 l 2 r.Go to Writer's Depot:w.Switch to plan "p".[n]# is waiting at Writer's Depot.Go to Writer's Depot:n 3 l 2 l.Pickup a passenger going to Post Office.Go to Post Office:n 1 r 2 r 1 l.Go to Chop Suey:n 1 r 1 l 4 r 1 l.Switch to plan "c".[e]

Pruébalo en línea!

Sin golf:

Go to Post Office: west 1st left 1st right 1st left.
Pickup a passenger going to Chop Suey.
Go to Chop Suey: north 1st right 1st left 4th right 1st left.
[c]
Switch to plan "e" if no one is waiting.
Pickup a passenger going to Charboil Grill.
Go to Charboil Grill: north 1st left 3rd left 3rd left.
Pickup a passenger going to The Underground.
Go to Writer's Depot: west 1st right.
[p]
; is waiting at Writer's Depot.
Pickup a passenger going to Post Office.
Go to Post Office: north 1st right 2nd right 1st left.
Go to The Underground: north 1st right 1st left.
Switch to plan "n" if no one is waiting.
Pickup a passenger going to The Underground.
Go to Zoom Zoom: north 3rd left 2nd right.
Go to Writer's Depot: west.
Switch to plan "p".
[n]
# is waiting at Writer's Depot.
Go to Writer's Depot: north 3rd left 2nd left.
Pickup a passenger going to Post Office.
Go to Post Office: north 1st right 2nd right 1st left.
Go to Chop Suey: north 1st right 1st left 4th right 1st left.
Switch to plan "c".
[e]

Explicación:

Pick up stdin and split it into characters.
Covert each character to ASCII.
Print ";" as you count down from that ASCII to zero.
Print "#".
Pickup the next character and repeat until done.
— Tostadas de ingeniero
fuente
+1 Me encantan idiomas como este y Mornington Crescent, ¡el código es tan hermoso!
— Karl-Johan Sjögren
9

05AB1E , 8 bytes

Ç';×'#«J

Pruébalo en línea!

Explicación

Ç          # convert each input char to its ascii value
 ';×       # repeat ";" those many times
    '#«    # append a "#" to each run of semi-colons
       J   # join to string
— Emigna
fuente
9

Brainfuck, 43 bytes

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

El byte nulo termina el programa.

Explicación

+[+[<]>->++]          59 (semicolon) location 5
--[>--<+++++++]>-       35 (hash) location 7
<,[                     input location 6
    [   while input byte not 0
        <.>     print semicolon
        -       decrement input byte
    ]
    >.< print hash
,]  loop while input not null
— Mika lammi
fuente
Eso es impresionantemente pequeño para Brainf * ck.
— MD XF
Casi compite con la respuesta de Python. Impresionante.
— raddish0
5

> <> , 22 bytes

i:0(?;\"#"o
o1-:?!\";"

Pruébelo en línea o en el área de juegos para peces

La entrada es STDIN, la salida es STDOUT. En> <>, los caracteres y los códigos ASCII son lo mismo, por lo que todo lo que tenemos que hacer es leer un carácter, imprimir ";"y disminuir el carácter hasta que sea 0, luego imprimir "#"y repetir hasta que no quede más entrada.

— No un arbol
fuente
5

F #, 79 bytes

let c i=System.String.Join("#",Seq.map(fun c->String.replicate(int c)";")i)+"#"

Pruébalo en línea!

Expandido

// string -> string
let convert input =
    System.String.Join(
        "#",      // join the following char seq with "#"
        input     // replicate ";" n times where n = ASCII value of char c
        |> Seq.map (fun c-> String.replicate (int c) ";") 
    ) + "#" // and add the last "#" to the output

convertir toma la cadena de entrada y genera un programa;

Uso

convert "Hello, World!" |> printfn "%s"
convert "ABC" |> printfn "%s"
convert ";#" |> printfn "%s"
— Brunner
fuente
44
Necesitamos más respuestas de F #
— aloisdg dice Reinstate Monica
@aloisdg Haré lo mejor que pueda :)
— Brunner
5

PowerShell, 29 27 25 bytes

$args|% t*y|%{';'*$_+'#'}

Muy claro. Toma entrada como argumento de línea de comando. La salida es un programa válido; # que imprime el texto solicitado.

— Joey
fuente
Necesita unir cadenas de resultados.
— mazzy
@mazzy: De la descripción de la tarea: »Mientras el programa sea válido, puede contener caracteres en exceso distintos #y ;todos los demás caracteres se ignoran.«
— Joey
como desee :-)
— mazzy
las comillas se pueden eliminar. $argses suficiente.
— mazzy
A menos que el argumento sea numérico.
— Joey
4

brainfuck , 47 bytes

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

Pruébalo en línea!

Ver también: la respuesta de ovs , que tiene un enfoque similar, pero con un método diferente de generar constantes y un diseño de celda diferente.

Explicación:

Este desafío se alinea bastante bien con la especificación brainfuck, lo que significa que la solución es esencialmente trivial. Brainfuck toma la entrada como valores ASCII, que es exactamente qué; # necesita salir como.

El esquema para transpilar es simple: generar el valor ASCII para ;e #, imprimir ;igual al valor ASCII del carácter de entrada, imprimir #, repetir para cada entrada.

+++++++[-             7
         >++++++++       * 8 = 56
         >+++++<<        * 5 = 35 (#)
       ]>+++<                  56 + 3 = 59 (;)
,[                    Input into first cell
  [>.<-]              Print ;'s equal to ASCII input
  >>.<<,              Print one #
 ]                    End on EOF
— Zack C.
fuente
-2 Bytes Solo -1 si estás evitando las células negativas
— Jo King
4

Mathematica, 49 bytes

StringRepeat[";",#]<>"#"&/@ToCharacterCode@#<>""&

Explicación

enter image description here

Convierte la cadena de entrada en una lista de códigos de caracteres, luego Maps la función StringRepeat[";",#]<>"#"&sobre la lista, luego StringJoins el resultado con la cadena vacía.

— ngenisis
fuente
¿Por qué necesitas el <>""?
— CalculatorFeline
@CalculatorFeline Without it I would be left with a list of strings for each character. StringJoining (<>) the empty string concatenates each string.
— ngenisis
Forgot about that :P
— CalculatorFeline
3

Aceto, 19 bytes

Since there's an interpreter in Aceto, I thought there outta be an Aceto answer to this challenge as well. It fits neatly in a 2rd order Hilbert curve:

\n;*
'o'p
`!#'
,dpO

En primer lugar, leemos un solo carácter ( ,) y lo duplicamos y lo negamos para probar si es una nueva línea ( d!cuando se lee una nueva línea, normalmente se inserta un carácter vacío en la pila). Luego uso lo que creo que es un truco bastante inteligente para manejar el caso de nueva línea de forma compacta:

`'\n

Si el valor en la pila es True(leemos una nueva línea), que los medios de código: no ( `) ponen un literal de caracteres en la pila ( '), que es un salto de línea: \n.

Si el valor en la pila es False(no leímos una nueva línea), ese código significa: no ( `) lee un carácter literal ( '). Eso significa que el siguiente personaje se ejecuta como un comando. Afortunadamente, una barra invertida escapa al siguiente comando (lo hace para que no se ejecute), por lo nque no imprime una nueva línea (que es lo que ngeneralmente hace).

El resto del código es sencillo; convertimos el carácter en la pila al entero de su punto de código unicode ( o), empujamos un punto y coma literal ( ';), multiplicamos el número con la cadena ( *como en Python), pborramos el resultado, empujamos un literal ( ') #, lo pborramos también, y volver al Origin.

Run with -F if you want to see immediate results (because buffering), but it works without, too.

— L3viathan
fuente
3

Perl, 24 bytes

s/./";"x(ord$&)."#"/ges

Run with perl -pe.

Alternative solution:

say";"x ord,"#"for/./gs

Run with perl -nE.

— Grimmy
fuente
3

Solace, 11 bytes

Yay, new languages.

';@jx{'#}Ep

Explanation

';           Push the code point of ';' (59).
  @j         Push the entire input as a list of code points.
    x        For each code point in the input, repeat 59 that many times.
     {  }E   For each resulting list of 59s:
      '#      Push the code point of '#' (35).
          p  Flatten and print as unicode characters.
— Business Cat
fuente
3

Fourier, 19 bytes

$(I(`;`&j)`#`0~j&i)

Try it on FourIDE!

To run, you must enclose the input string in quotation marks.

Explanation pseudocode

While i != Input length
    temp = pop first char of Input
    While j != Char code of temp
        Print ";"
        Increment j
    End While
    Print "#"
    j = 0
    Increment i
End While
— Beta Decay
fuente
3

JavaScript, 55 54 51 50 48 bytes

s=>1+[...s].map(c=>";".repeat(Buffer(c)[0])+"#")

Try it online

  • 1 byte saved thanks to Neil.

Alternatives

If we can take input as an array of individual characters then 5 bytes can be saved.

a=>1+a.map(c=>";".repeat(Buffer(c)[0])+"#")

If we can also output as an array then 2 more bytes can be saved.

a=>a.map(c=>";".repeat(Buffer(c)[0])+"#")
— Shaggy
fuente
\n should becomes ;;;;;;;;;;#.
— Neil
Hmm ... that's strange. Guess I'll have to roll back to the longer solution, so. Thank, @Neil.
— Shaggy
2
I think you could change . to [^], which would still leave it a byte shorter than map/join?
— Neil
Yup, that did the job, @Neil :)
— Shaggy
Just a heads up, the join() in your previous answer was unnecessary given the specification for ;#, and you can also declare that the input for your function is an array of characters, though the second suggestion is a bit of a stretch. Either way, that brings you down to at most 48 bytes.
— Patrick Roberts
2

Actually, 11 bytes

O⌠';*'#o⌡MΣ

Try it online!

Explanation:

O⌠';*'#o⌡MΣ
O            convert string to list of ASCII ordinals
 ⌠';*'#o⌡M   for each ordinal:
  ';*          repeat ";" that many times
     '#o       append "#"
          Σ  concatenate
— Mego
fuente
2

APL (Dyalog), 18 bytes

'#',¨⍨';'⍴¨⍨⎕UCS

Try it online!

⎕UCS Convert to Unicode code points

';'⍴¨⍨ use each code point to reshape (⍴ = Rho ≈ R; Reshape) a semicolon

#',¨⍨ append a hash to each string

— Adám
fuente
2

Ruby, 28 25 bytes

24 bytes, plus the -n command line switch to repeatedly operate on stdin.

$_.bytes{|b|$><<?;*b+?#}

3 bytes saved (and output corrected on newlines!) thanks to manatwork.

— Chowlett
fuente
You could avoid the use of .ord by working directly with character codes: $_.bytes{|b|$><<?;*b+?#}. There is difference: this one also encodes the newline in the input. Not sure what the question owner intends to say by “It will only contain printable ASCII characters and newlines.”, but to me sounds like newlines should be encoded too.
— manatwork
Your Ruby-fu exceeds mine, @manatwork - I'd forgotten about bytes. I've asked OP about newlines up top and will edit this afterwards.
— Chowlett
2

Alice, 12 bytes

'#I.h%&';d&O

Try it online!

Explanation

'#    Push 35, the code point of '#'.
I     Read a code point C from STDIN. Pushes -1 at EOF.
.h%   Compute C%(C+1). For C == -1, this terminates the program due to division
      by zero. For C > -1, this just gives back C, so it does nothing.
&';   Pop C and push that many 59s (the code point of ';').
d     Push the stack depth, which is C+1.
&O    Print that many code points from the top of the stack.
      The IP wraps around to the beginning and another iteration of this
      loop processes the next character.
— Martin Ender
fuente
2

PHP, 48 bytes

for(;$c?:~$c=~ord($argn[$i++]);)echo";#"[!++$c];
— user63956
fuente
2

jq, 30 characters

(26 characters code + 4 characters command line options)

explode|map(";"*.+"#")|add

Sample run:

bash-4.4$ jq -Rr 'explode|map(";"*.+"#")|add' <<< 'Hello, World!' | jq -Rrj '[scan(".*?#")|gsub("[^;]";"")|length%127]|implode'
Hello, World!

On-line test

— manatwork
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.