Bienvenido al mundo del compilador de golf. Su tarea es escribir un programa que genere otro programa para reproducir una variante de FizzBuzz en las especificaciones.
Su compilador
Escriba un compilador que genere variantes del programa FizzBuzz según las especificaciones. La especificación de esta variante se expresa en forma de una matriz de pares enteros / cadenas.
- La entrada puede ser de cualquier forma que sea conveniente para su idioma. (Mis ejemplos usan n: xxxx, pero esto es solo para fines ilustrativos).
- Cada entrada entera solo puede usarse una vez por invocación de su compilador.
- El entero de cada par tendrá un valor de al menos uno.
- La cadena de cada par estará compuesta de solo cuatro letras ASCII exactamente.
- El resultado debe ser un solo programa completo que cumpla con las siguientes reglas.
- La salida puede estar en cualquier forma conveniente, siempre que sea un programa textual. (Entonces no hay expresiones lambda que regresen).
El comportamiento no está definido para las entradas que no se ajustan a las reglas anteriores.
Su programa generado de FizzBuzz
El programa generado por su compilador tomará un solo entero, n , como entrada. Producirá una secuencia de números comenzando desde uno hasta e incluyendo n , reemplazando los números con cadenas FizzBuzz cuando sea necesario.
- El programa generado debe estar en el mismo idioma que el compilador.
- La entrada n puede estar en cualquier forma conveniente para su idioma.
- n tendrá un valor de al menos uno.
- Un número que es un múltiplo de al menos uno de los enteros ingresados al compilador debe ser reemplazado por todas las cadenas emparejadas con esos enteros unidos.
- Un número que no debe ser reemplazado por una cadena FizzBuzz debe enviarse en ASCII decimal.
Por ejemplo;
> GenFizzBuzz 3:Fizz 5:Buzz
> a.out 5
1
2
Fizz
4
Buzz
Puntuación
Su entrada se puntuará según la duración de los programas que genera su compilador agregados a la duración de su compilador. Ejecute su compilador muchas veces con cada uno de los siguientes parámetros y agregue las longitudes de los programas generados junto con la longitud del compilador para encontrar su puntaje.
- Solo cuenta. (Sin entradas: el programa generado contará de 1 a n sin reemplazos).
- Solo golf. (1: Golf: el programa generado generará "Golf" n veces).
- FizzBuzz clásico. (3: Fizz, 5: Zumbido)
(Tenga en cuenta que se requiere que su compilador genere código para cualquier entrada válida, no solo estas enumeradas).
Respuestas:
Python 3 -
168162 + 230 = 392¡Oh, Python, te esfuerzas tanto, pero multiplicar las
import sys;sys.argv
cosas por 4 realmente duele!Programas de salida:
La entrada esperada para el programa principal es una secuencia evaluable de tuplas de Python o
'()'
para ninguna entrada. (Dijiste "conveniente".) Ejemplo de entrada:'()'
,'("Golf",1),'
,'("Fizz",3),("Buzz",5)'
Nota citando para la cáscara y de salida para una entrada por comas.Se corrigió el error de 1 a.m. al cambiar de dict (¡orden indefinido!) A tuplas.
La entrada esperada para los otros programas es solo el número
fuente
perl6
37634084 + 115 = 199ACTUALIZACIÓN: cambió de perl5 a perl6 para quedarse
say
sin éluse feature
.ACTUALIZACIÓN: tres casos de prueba en lugar de cinco
Hay cientos de soluciones ya desarrolladas para FizzBuzz, y muchos concursos terminan con el mismo resultado, así que ahí es donde comencé. Mi compilador solo produce una versión personalizada de esa solución. Se insertaron algunos caracteres adicionales para dar cuenta de la variación de "solo recuento".
compilador, espera argumentos como este: "Fizz 3" "Buzz 5"
programas compilados, espere un argumento así: 100
Programas compilados para casos de prueba antiguos:
fuente
Pyth - 51 + (38 + 43 + 50) = 182 bytes
Probablemente puede golf el compilador de unos pocos bytes. Los enlaces en todos ellos son enlaces permanentes al intérprete en línea.
Compilador - 51 bytes
Simplemente formatea cadenas con una tupla de entrada. Toma datos como:
Nada : 38 bytes
Just Golf - 43 bytes
Classic Fizz Buzz - 50 bytes
fuente
C ++ 11 ~ 486 + (234 + 244 + 255) = 1219
Primera participación aquí, este desafío no está entre los más difíciles, así que pensé en intentarlo. Sin embargo, usar C ++ e incluso con las adiciones de C ++ 11 sigue siendo un lenguaje bastante detallado, pero estoy seguro de que hay margen de mejora.
Compilador (486):
Asume argumentos en forma de
3Fizz 5Buzz
etc.Conde (234):
Golf (244):
FizzBuzz (255):
Información Adicional
Probado con GCC 4.8.1, sin trampas del compilador.
Aquí hay un pequeño archivo MAKE para automatizar la generación de los casos de prueba y ejecutarlos (uso
make run
):fuente
map<int,string> f
podría sermap<int,string>f
. Podrías inicializarj=1
al mismo tiempo conz
.Rubí 99 + (86 + 94 + 103) = 382
Uso:
fuente
Stax , 23 + 5 + 17 + 29 = 74
Ejecutar y depurarlo
Respuesta más corta hasta el momentoNo sorprendentemente golpeado por Jelly. La plantilla de cadena proporcionada en Stax es realmente ordenada y proporciona funciones similares a printf. Los programas generados por el compilador son casi siempre tan cortos como el mejor que se puede lograr codificando manualmente, sin usar el empaque.El compilador en sí tiene 23 bytes de longitud.
El equivalente ASCII es:
Entrada proporcionada
[]
, genera este (5 bytes)Ejecutar y depurarlo
Entrada proporcionada
[[1,"Golf"]]
, genera este (17 bytes)Ejecutar y depurarlo
Entrada proporcionada
[[3,"Fizz"],[5,"Buzz"]]
, genera este (29 bytes)Ejecutar y depurarlo
fuente
Lisp común,
636577Tomé mi otra respuesta y la envolví en cuasiquotes mientras agregaba parámetros de entrada. Imprimo el formulario resultante como una sola línea y elimino los espacios en blanco innecesarios. El compilador es un poco más largo que la versión anterior, pero la puntuación resultante se reduce.
Puntuación
Valores devueltos:
Bonito
El formato de entrada es una lista de
(number string)
parejas. Por ejemplo:... imprime en salida estándar:
... que, muy bien impreso, es:
Prueba de la función resultante:
fuente
Perl 5 , 77 + 93, 170 bytes
¡Prueba el compilador en línea!
¡Intenta simplemente contar en línea!
¡Pruebe solo jugar golf en línea!
¡Prueba fizz buzz en línea!
fuente
Gelatina ,
88848373 bytesLa respuesta más corta hasta ahora (supera la "respuesta más corta" anterior en 1 byte)
Compilador:
Pruébalo en línea! (compilador)
Pruébalo en línea! (verificar el bytecount)
Estadísticas:
fuente
C, 1080 bytes en total
Compilador [369 bytes]
Zumbido burbujeante [241]
Golf [237]
Recuento [233 bytes]
fuente
cc , 434 bytes
Pruébalo en línea!
La entrada para el compilador (168 bytes) debe colocarse en la pila como entero, cadena, entero, cadena, etc. (
3 [Fizz] 5 [Buzz]
). Debe darse en el orden en que uno quiere que se impriman sus efervescentes y zumbidos, lo que puede ser un poco engañoso (habiendo implementado la clasificación de burbujas endc
antes, creo que me costaría alrededor de 100 bytes) pero también permite al usuario , digamos, todavía tengo 'Fizz' en 3 y 'Buzz' en 5, pero 15 'BuzzFizz'.Estoy seguro de que esto se puede jugar un poco más; la macro principal en el programa final (
M
) se basa en dos macros (F
yP
) que son bastante innecesarias dado que no hay entrada. En este momento, el compilador busca entradas y salidas de versiones diferentes (mucho más pequeñas) de estas macros si no hay ninguna, pero no estoy seguro de que toda la configuración sea óptima.El compilador en sí es bastante sencillo, solo verifica si hay 'reglas' en la pila, y si es así, imprime el código que almacena la profundidad de la pila
z
, almacena la pila en una matriz indexada en 0a
y luego imprime la generalizada Código FizzBuzz. Si no había nada en la pila, realmente solo imprime una versión modificada del código FizzBuzz. Casos de prueba:Sin entrada (46 bytes):
3 [Fizz] 5 [Zumbido] (117 bytes):
1 [Golf] (103 bytes):
Todos esperan el valor n en la pila, esto se almacena en
n
. Los que tienen 'reglas' las colocan en la matriza
, con las cadenas en índices impares y los enteros en pares. La macro principalM
, incrementa lo que esté en la pila, ejecuta una macroF
que verifica el valor contra la matriza
, comprueba siF
establece el registrob
en verdadero o no e imprime la parte superior de la pila si es así o una nueva línea si no, se restableceb
en falso, y luego mantiene ejecutándose sin
aún no se ha alcanzado. MacroF
, dadas las reglas, recorre toda la matriz en busca de coincidencias. Se incrementa en dos ya que nuestros enteros y cadenas se entrelazan a través de la matriz, y en una coincidencia llama macroB
. MacroB
solo recupera la cadena (posición actual en la matriz menos uno) y la imprime. También se poneb
a la verdad. Nuestro compilador no se molesta en imprimirB
sin entrada, y esencialmente haceF
un nop.fuente
vim, 122 (compilador) + 73 (vacío) + 90 (golf) + 123 (fizzbuzz) = 392 bytes
Compilador
Formato de entrada
Código generado para el caso FizzBuzz
Código generado, anotado
<C-V>
es 0x16.<ESC>
es 0x1b.<C-A>
es 0x01.Sesión de ejemplo
fuente
SlooSarksi .Lang, 179
fuente