Recientemente creé un nuevo lenguaje llamado ;#
(pronunciado "Semicolon Hash") que solo tiene dos comandos:
;
agregue uno al acumulador
#
module el acumulador por 127, convierta a carácter ASCII y salga sin una nueva línea. Después de esto, restablezca el acumulador a 0. Sí, 127 es correcto.
Cualquier otro personaje es ignorado. No tiene ningún efecto sobre el acumulador y no debe hacer nada.
¡Su tarea es crear un intérprete para este poderoso lenguaje!
Debe ser un programa completo o una función que tome un ;#
programa como entrada y produzca la salida correcta.
Ejemplos
Output: Hello, World!
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
Output: ;#
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
Output: 2d{ (unprintable characters here; should have 4 `\000` bytes between the `d` and the `{` and 3 after the `{`)
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;hafh;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;f;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;###ffh#h#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ffea;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#au###h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;o
Output: Fizz Buzz output
Program: link below
Output: !
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
code-golf
interpreter
caird coinheringaahing
fuente
fuente
Respuestas:
Python 3 ,
6968 bytes-1 byte gracias a @WheatWizard
Pruébalo en línea!
fuente
if
. Pruébalo en línea!JavaScript (ES6),
768280 bytesManifestación
Mostrar fragmento de código
Versión recursiva,
8277 bytesGuardado 5 bytes gracias a Neil
Es probable que este bloquee para entradas grandes como el ejemplo de Fizz Buzz.
fuente
f(s,a+(c==';'))
podría eliminar tres bytes de su versión recursiva.Retina ,
336636765666259 bytesPruébalo en línea!
Versión legible con sintaxis de escape hipotética :
No imprime bytes NUL, porque TIO no los permite en el código fuente.
También imprime una nueva línea adicional al final, pero supongo que no puede hacer otra cosa.Nueva línea final suprimida gracias a @Leo .-273 (!) Bytes gracias a @ETHproductions .
-2 bytes gracias a @ovs .
-3 bytes gracias a @Neil . Echa un vistazo a su maravillosa solución de 34 bytes .
fuente
+T`\x01-~`_\x03-\x7f`[^\x01¯]\x01
? (incluidos los no imprimibles como caracteres únicos, por supuesto)#
en la entrada. Puede solucionarlo cambiando su segunda etapa a(;{127}|;+$)
T`;#\x01-ÿ`\x80\x7F_
\x80+$
(línea vacía)\+T`\x7Fo`\x01-\x80_`\x80[^\x80]
(usando escapes hexadecimales para representar no imprimibles). Salidas \ x7F en lugar de nulos.Java 8, 100 bytes
Pruébalo en línea!
fuente
Consumer<char[]>
:s->{char i=0;for(int b:s){if(b==59)i++;if(b==35){System.out.print(i%=127);i=0;}}}
Japt , 18 bytes
Hay un \ x7f char no imprimible después
%#
. ¡Pruébelo en línea!Cómo funciona
fuente
q'# ®è'; u# dì¯J
También funciona para el mismo puntaje.Python , 65 bytes
Este es un golf de esta respuesta anterior.
Pruébalo en línea! Python2
Pruébalo en línea! Python3
Explicación
Esta es una respuesta bastante sencilla. Determinamos cuántos
;
s hay entre cada uno#
e imprimimos elchr
mod 127. Lo único que puede ser un poco extraño es el[:-1]
. Necesitamos eliminar el último grupo porque no habrá más#
después.Por ejemplo
Se dividirá en
Pero no queremos el último
;;;
porque no hay#
después para imprimir el valor.fuente
t
yx
.> <> , 35 bytes
Pruébalo en línea! Reemplace
␡
con 0x7F,^?
o "eliminar".Bucle principal
Esto toma un carácter de input (
i
), comprueba si es menor que cero, es decir, EOF (:0(
) y finaliza el programa si es (?;
). De lo contrario, verifique si la entrada es igual a#
(:'#'=
). Si es así, bájese y reinicie el bucle (?v
...^ ... <
).Contra lógica
Compruebe si la entrada es igual a
;
(';'=
). Si es así, presione a0
. De lo contrario, no hagas nada. Esto reinicia el bucle principal.Lógica de impresión
Cuando el carácter de entrada es
#
, retire la entrada de la pila (~
), obtenga el número de miembros en la pila (l
), presione 127 ('␡'
) y tome el módulo (%
). Luego, escríbalo como un carácter (o
) e inicie una nueva pila ([0
). Esto "pone a cero" el contador. Luego, el bucle se reinicia.fuente
:0(
:(Python 3, 69 bytes
Mejorado, gracias a @Wheat Wizard, @Uriel
fuente
:
s.';'==c
ahorra un espacio, pero no usarif
declaraciones en absoluto sería aún más corto.Röda ,
443938 bytes5 bytes guardados gracias a @fergusq
Pruébalo en línea!
Función anónima que toma la entrada de la secuencia.
Si otros personajes no tienen que ser ignorados, obtengo esto:
Röda , 20 bytes
fuente
Ruby,
413534 caracteres(
4034código de 33 caracteres + opción de línea de comando de 1 carácter)Gracias a:
putc
para no necesitar conversión explícita con.chr
(6 caracteres)Ejecución de muestra:
Pruébalo en línea!
fuente
putc()
. Gracias, @Jordan05AB1E ,
161514 bytesCódigo:
Explicación:
Utiliza la codificación 05AB1E . Pruébalo en línea!
fuente
Jalea , 13 bytes
Pruébalo en línea!
Cómo funciona
fuente
semicola
no existe essemicolons
.Código de máquina x86 en MS-DOS: 29 bytes
Asamblea comentada:
fuente
05AB1E ,
252119 bytes-2 bytes gracias a Adnan
Explicación:
Pruébalo en línea!
fuente
i>}
por+
.Retina , 34 bytes
Pruébalo en línea! Incluye estuche de prueba. Editar: guardado 2 bytes con ayuda de @MartinEnder. Nota: El código incluye no imprimibles, y el uso de
&#x;
códigos genera resultados incorrectos ya que el navegador usa Windows-1252 en lugar de ISO-8859-1. Explicación: La primera línea limpia la entrada:;
se cambia a\x80
,#
a\x7F
(debido a las limitaciones de TIO) y se elimina todo lo demás. Luego, cada vez que vemos un\x80
que no está antes que otro\x80
, lo eliminamos e incrementamos cíclicamente el código de cualquier carácter siguiente. Esto se repite hasta que no quedan más\x80
caracteres. El código original que admite bytes nulos básicamente resta 1 de los bytes no imprimibles, excepto en la primera línea donde no\xFF
se modifica y se\x7F
convierte en\x00
. Con escapes para la lectura:fuente
\x80([^\x80]|$)
la última etapa.\s+T`\x7Fo`\x01-\x80_`\x80(?!\x80).?
también solo guarda un byte.[^\x80]|\x80$
ahorra dos bytes, creo.s
es molesto.R,
97908684 bytesUna función:
Cuando R comienza,
F
se define comoFALSE
(numérico0
).Sin golf:
fuente
pryr
es un paquete R, sigue siendo el código R.import
mientras que en R puede usar::
para acceder directamente a la función en paquetes. A menudo puede ver el uso de paquetes adicionales aquí (por ejemplo, para Python y Java). Sin embargo, cambié mi publicación anterior porque no quiero entablar una discusión.Python, 82 bytes
fuente
TeX simple, 156 bytes
Legible
fuente
C (gcc) , 58 bytes
Pruébalo en línea! (Sugerencia: haga clic en ▼ Pie de página para contraerlo).
fuente
Perl, 25 bytes
Ejecutar con
perl -043pe
(contado como 4 bytes, ya queperl -e
es estándar).Explicación:
-043
establece el terminador de línea en#
(ASCII 043).-p
itera sobre las "líneas" de entrada (en realidad # delimitadas por cadenas, ahora).y%;%%
cuenta el número de;
en cada "línea".x/#/
se asegura de que no imprimimos un carácter adicional para los programas que no terminan en un # (como el tercer caso de prueba).%127
Debería ser bastante obvio.$_=
es el habitual repetitivo.fuente
;;#;;;
que salga # 5 en lugar de # 2.echo -n ';;#;;;' | perl -043pe '$_=chr(y%;%%%127)x/#/' | xxd
sale correctamente00000000: 02
en mi máquina. Si dejó el043
, o está usando una página de códigos donde#
no es ASCII 043, eso explicaría su resultado.CJam, 27 bytes
Explicación:
Solución alternativa, 18 bytes
Explicación:
fuente
;
eliminar el acumulador?F #,
799193 bytesSin golf
Pruébalo en línea!
Editar: estaba tratando cualquier otro carácter que ';' como '#'. Lo cambió para que ignore los caracteres no válidos.
Alternativa
F #,
107104bytesEl uso de la celda de referencia ahorra 3 bytes
Sin golf
Pruébalo en línea
fuente
Processing.js (versión Khanacademy), 118 bytes
Pruébalo en línea!
Como la versión de procesamiento utilizada no tiene ningún método de entrada, la entrada se coloca en n.
fuente
keyTyped=function(){ ... }
: PLaberinto ,
6147 bytesPruébalo en línea!
Explicación
La ejecución del código comienza en la esquina superior izquierda y el primer punto y coma descarta un cero implícito de la pila y continúa hacia la derecha.
naranja
_36
empuja 36 en la pila. Esto es para comparar la entrada con#
}
mueve la parte superior de la pila a la pila secundaria,
empuja el valor entero del personaje en la pila)
incrementa la pila (si es el final de la entrada, esto hará que la pila sea 0 y el flujo del programa procederá a la@
salida){
mueve la parte superior de la pila secundaria a la parte superior de la pila primaria-
pop y, pop x, presione x - y. Esto es para comparar la entrada con#
(35 en ascii). Si la entrada fue#
el código continuará a la sección púrpura (porque la parte superior de la pila es 0, la IP continúa en la dirección en la que se movía antes), de lo contrario continuará a la sección verde.Púrpura
127
empujar 127 a la pila%
pop x, pop y, push x% y.
pop la parte superior de la pila (el acumulador) y la salida como un personajeDesde aquí, el código gris nos lleva a la esquina superior izquierda del programa sin nada en la pila.
Verde
_24
empuje 24 en la pila-
pop x, pop y, presione xy. 24 es la diferencia entre#
y;
entonces esto verifica si la entrada fue;
. Si fuera así,;
el código continúa directamente hacia el)
. De lo contrario, se convertirá en el#
que empuja la altura de la pila (siempre un número positivo, obligando al programa a girar a la derecha en la próxima intersección y perder el código que incrementa el acumulador);
descartar la parte superior de la pila)
incremente la parte superior de la pila, que es un cero implícito o es un cero previamente incrementado que actúa como el acumulador para la salidaDesde aquí, el código gris nos lleva a la esquina superior izquierda del programa con la pila con solo el acumulador.
gris
Las cotizaciones no son operacionales,
_
empujan un 0 a la pila y;
descartan la parte superior de la pila. Todo esto es solo un código para forzar el flujo de control de la manera correcta y descartar cualquier cosa adicional de la parte superior de la pila.fuente
MATL , 29 bytes
La entrada es una cadena entre comillas simples.
Pruébalo en línea!
El programa FizzBuzz es demasiado largo para los intérpretes en línea; verlo trabajando sin conexión en este gif:
Explicación
El valor del acumulador se implementa como el número de elementos en la pila. Esto hace que el programa sea más lento que si el valor del acumulador fuera un solo número en la pila, pero ahorra algunos bytes.
fuente
Alice , 22 bytes
Pruébalo en línea!
Explicación
Mantenemos en la pila solo un contador de cuántos
;
nos hemos encontrado. Cuando la pila está vacía (p. Ej. Al inicio del programa) esto es implícitamente un 0.Aquí se puede encontrar una versión más corta pero sin finalización de este programa .
fuente
~h
sin embargo.JS (ES6),
9792 bytesIntenté adoptar un enfoque diferente al de la respuesta de Shaggy . Oh bien.
fuente
; # + , 59 bytes, sin competencia
El lenguaje se hizo después de este desafío.
Pruébalo en línea! La entrada termina con un byte nulo.
Explicación
La generación es la misma que la de mi Generar; # respuesta de código . La única diferencia aquí es la iteración.
Iteración
fuente
Bash + coreutils,
4639 bytesPruébalo en línea!
Explicación
(¡Gracias Cows Quack por -7 bytes!)
La
tr
parte elimina todos los caracteres extraños (podría poner esto ensed
exactamente el mismo bytecount, pero luego no maneja el carácter de salto de línea correctamente, ya que lossed
deja adentro ydc
solo llega hasta el primer salto de línea con?
)sed
toma el resto y construye undc
programa:Cadenas de
;
convertirse en cadenas de1
(un literal largo)#
se convierte en.ZC7%P
(si esto sigue una cadena de1
, el.
es un punto decimal para un no-op. Pero si está al comienzo del programa, o después de otro#
, es un literal0
. Luego toma la longitud del número, lo modifica, e Imprime el ASCII correspondiente.)fuente
;
interior'...'
y simplemente puede cambiardc -ez?
adc
. Además de eso, en lugar de;
agregar 1 a la pila, puede agruparlos y obtener su longitud usandoZ
para alcanzar este tio.run/##S0oszvj/… .dc -ez?
fue una consecuencia de la necesidad de un cero adicional para iniciar el programa) Pero su programa agrega una salida adicionalstderr
en los casos consecutivos#
o de entrada que no termina con#
(en ambos casos, quiero decir después de que se eliminan los caracteres extraños) . No sé si hay consenso, pero siento que el resultado adicional invalida la solución. Sin embargo, ¡adapté tu idea y terminé en un byte más que tu sugerencia sindc
arrojar errores!#
s consecutivos debidoZ
a0
is1
, por lo que genera 0x01 en lugar de 0x00 (también caí en la misma trampa, pero mi navegador muestra no imprimibles como sus códigos hexadecimales, así que capté eso).C,
65 6460 bytes(-2 gracias a ceilingcat)
fuente
c
a cero para que la función sea reutilizable .c=0
, y no quisiera hacer trampa copiando la respuesta de Dennis.