Y2K ... en 2019?

18

Es el 10 de agosto de 2019, pero su tarea aún involucra Y2K. Raro, verdad?

Cree un programa que se imprima solo, con un número de dos dígitos adjunto. La primera vez que lo ejecute, debería agregar 00 a su salida (su código fuente, porque esta es una variante quine). Cuando ejecuta esa salida, el programa original sin un número de dos dígitos, debe generar el programa original, pero con 01 añadido. Ejecute esa salida para obtener el programa OG con 02 añadido, luego para obtener el programa con 03 ... Esta cadena debería continuar hasta 99. Ese programa debería salir BREAKING NEWS: WORLD ENDS.

Si su programa es Y2Kparanoia: yesentonces:

  1. Debería salir Y2Kparanoia: yes00
  2. Esa salida debería imprimir Y2Kparanoia: yes01
  3. Esa salida debería imprimir Y2K paranoia: yes02
  4. Repita hasta el paso 100: este programa emite las noticias del día del juicio final especificadas

Este es el código de golf, por lo que gana el programa más corto que puede imprimirse mientras sigue estos pasos.

code-golf quine Andrés
fuente
77
De acuerdo con la descripción, la 99a vez que corremos estaremos corriendo 2Kparanoia: yes97y produciendo 2Kparanoia: yes98, así que ¿no debería (4) leer Repeat to step 100, but step 101 will output "BREAKING NEWS: WORLD ENDS"? (es decir, 2Kparanoia: yes99produce la noticia)
Jonathan Allan

Respuestas:

7

Perl 6 , 122114106 bytes

-8 bytes gracias a Shelvacu

END {<print $!-199??"END \{<$_>~~.EVAL};\$!="~($!-1&&$!-99)+100!!"BREAKING NEWS: WORLD ENDS">~~.EVAL};$!=1

Pruébalo en línea!

Toma el formato estándar de quine y agrega la cadena de noticias de última hora, así como una nueva llamada de función con el número adjunto. Esto se utiliza ENDpara ejecutar la función cuando finaliza el programa.

Jo King
fuente
Puede guardar 3 bytes más utilizando ENDy una ourvariable:END {<print $s-199??"END\{<$_>~~.EVAL};our\$s="~($s-1&&$s-99)+100!!"BREAKING NEWS: WORLD ENDS">~~.EVAL};our$s=1
Shelvacu
Por ahora, este es el ganador actual.
Andrew
7

Ruby, 158 154 146 128 122 100 bytes

Inspirado por esta respuesta .

eval s=%{$><<(D>198?'BREAKING NEWS: WORLD ENDS':'eval s=%%{%s}<<D=%d'%[s[0..-2],D<2?100:D+1])#}<<D=1

EDITAR: pude eliminarlo (s.split(35.chr)[0]+35.chr).inspecty reemplazarlo con s[0..-2](rango de cada valor excepto el último) y la %{ ... }sintaxis de cadena que usé antes. ¡Guardado 22 bytes!

Versión antigua:

EDITAR: guardó un par de parens (y el par correspondiente en la sección de datos) al darse cuenta de que "BREAKING NEWS: WORLD ENDS"es una cadena de formato perfectamente válida, y ruby ​​ignora los parámetros extraneos.

END{$><<(q=S>198?"BREAKING NEWS: WORLD ENDS":%{END{$><<(q=S>198?"BREAKING NEWS: WORLD ENDS":%%{%s})%%[q,S<2?0:S-99]}
S=1%02d})%[q,S<2?0:S-99]}
S=1

Al iniciar este me di cuenta de que, dado que el número tiene que ir al final del programa, y el rubí no permite el uso de variables antes de que se declaran, que tendría que hacer que el código se ejecute después de los dígitos de alguna manera. Podría haber hecho algo como lo def a(s) ... end;a 1que sería ...end;a 100, sin embargo, usar la ENDsintaxis menos conocida de Ruby usa menos bytes. Sin embargo, el bloque interior ENDtiene un alcance diferente, por lo que Sdebe ser una variable global o constante.

Explicación:

  • END{ ... };S=1: Ejecute el bloque de código justo antes de que finalice el programa; Establezca constante Sen 1(o 100- 199en futuras iteraciones)
  • $><<( ... ): $>es un atajo en ruby ​​para stdout, y <<en un IO escribe en el IO. Los padres son obligatorios, de lo contrario se convierte en($><<S)>198...

  • S>198?"BREAKING NEWS: WORLD ENDS":(q=...)%[q,S<2?0:S-99]: Si tuviera que dividir esto en un código un poco más razonable sería:

    if S > 198
  "BREAKING NEWS: WORLD ENDS"
else
  q = ...
  number_to_append = if S < 2
    0
  else
    S - 100 + 1
  end
  q % [q, number_to_append]
end

    El %operador aplicado a una cadena es efectivo printf, con LHS como cadena de formato y RHS como argumentos.

  • %{ ... (q=%%{%s}) ... S=1%02d}: ruby ​​tiene una sintaxis interesante para las cadenas que también permite que aparezcan pares de llaves dentro de la cadena sin escapar siempre que estén equilibradas. Esto es muy útil, ya que de lo contrario una quine similar tendría que escapar de la cadena para colocarla en sí misma como un literal de cadena. Las dos sustituciones en la cadena de formato son %spara una cadena normal y %02dpara un número rellenado a la derecha a un tamaño de 2 con el carácter 0.

Mis pensamientos sobre acortar aún más:

  • Sería bueno poder usarlo en slugar de hacerlo $s, pero al definir s s=$s;o hacer una función, def a(s) ...ambos usan más bytes de los que guardan, y no se me ocurre otra forma de hacerlo. EDITAR: ¡Las constantes son globales y pueden ser un solo personaje!
  • Sería bueno si Ssiempre fuera menor 100, de modo que pudiera compararse usando números de 2 dígitos en lugar de números de 3 dígitos. Sin embargo, si utilizo S=0al final, los dos dígitos siguientes se interpretan como octal, y 8y 9son válidos y todo está litera. S=simplemente no es válido, y no conozco otra forma de hacer que un valor sea válido tanto antes como después de agregar dos dígitos. Es de destacar que 0(y cualquier otro número entero) es verdadero en rubí.

Cualquier idea sobre cómo hacer esto más corto, ¡hágamelo saber!

Pruébalo en línea!

Shelvacu
fuente
Tal vez si solías s=100-1? Entonces sserá 99, 0, -1 ...- 99, y -sserá -99, 0 ... 99.
Purple P
@PurpleP No importa cómo lo intente, no puedo encontrar ninguna manera de hacerlo y guardar personajes.
Shelvacu
5

Ir, 382366354340305298272 bytes

No ganará pero me divertí con el desafío.

package main
func main(){if n<199{s+="\x60,"
print(s[:135],s,100+(n/100)*(n%100+1))}else{print("BREAKING NEWS: WORLD ENDS")}}
var s,n=`package main
func main(){if n<199{s+="\x60,"
print(s[:135],s,100+(n/100)*(n%100+1))}else{print("BREAKING NEWS: WORLD ENDS")}}
var s,n=`,1

¡Pruébalo en Go Playground!

Basado en una quine. Si la variable nes inferior a 199, agrega a la variable de cadena nun acento grave ( \x60), el carácter de Go para cadenas de varias líneas, seguido de una coma ,. Continúa imprimiendo los primeros 147 caracteres de s(para evitar imprimir ,porque solo ocurre al final), luego imprime scomo un todo y finalmente imprime 100si n == 1y de lo n+1contrario. El resultado es que las ejecuciones sucesivas cambian la variable nal final del programa a 100, 101, etc. Si la variable nes 199 o más, imprime las últimas noticias.

P púrpura
fuente
3

Haskell , 240 232 218 216 bytes

p=putStr;h 1=100;h k=k+1;g _=p$"n="++show(h n);main|n>198=p"BREAKING NEWS: WORLD ENDS"|1>0=p<>print<>g$"p=putStr;h 1=100;h k=k+1;g _=p$\"n=\"++show(h n);main|n>198=p\"BREAKING NEWS: WORLD ENDS\"|1>0=p<>print<>g$"
n=1

Pruébalo en línea!

Adaptado de una quine

B. Mehta
fuente
2

JavaScript (ES6), 116 bytes

setTimeout(s="alert((n-1?++n:n=100)-200?`setTimeout(s=${JSON.stringify(s)}),n=`+n:'BREAKING NEWS: WORLD ENDS')"),n=1

94 bytes, si se permiten funciones de cadena

f=_=>((p=`f=${f}`.split`|`)[4]=p[4]-1?-~p[4]:100)-200?p.join`|`:'BREAKING NEWS: WORLD ENDS'||1
Herman L
fuente
2
No puede leer su propio código fuente ( f=${f}), eso no es una quine según codegolf.meta.stackexchange.com/a/4878/13400
Shelvacu
1

Pyth , 81 80 bytes

.vh,K"?>J198\"BREAKING NEWS: WORLD ENDS\"s[\".vh,K\"N:KN+C92NN\"J\"?<J2*TT+J1"J1

Pruébalo en línea!

Explicación:

.vh,K" ... "J1
.v               Eval pyth code
  h              Get the first item in list
   ,             Make a list of the next two items
            J1   Set J = 1 (J = 100 to 199 in future iterations)
    K" ... "     Set K to the given string

Y el código en la cadena es (noticias de última hora acortadas):

?>J198"BNWE"s[".vh,K"N:KN+C92NN"J"?<J2*TT+J1
?                                              Ternary: If A then B else C
 >J198                                         Test if J > 198
      "BNWE"                                   String literal; If ternary was true, return this (which is then implicitly printed)
            s[".vh,K"N:KN+C92NN"J"?<J2*TT+J1   ternary else
            s                                  concatenate list of strings
             [                                 create list
              ".vh,K"                          string literal, list[0]
                     N                         N is set to the double-quote character, list[1]
                      :KN+C92N                 list[2]
                      :                        Regex substitution. In A, replace B with C
                       K                       Variable K (set to the string being eval'd)
                        N                      N is double-quote
                         +C92N                 A backslash followed by a double-quote
                         +                     concat two strings
                          C92                  character with code point 92 (backslash)
                             N                 N is double-quote
                              N                N is double-quote, list[3]
                               "J"             String literal, list[4]
                                  ?<J2*TT+J1   Inner ternary, list[5]
                                   <J2         If J < 2 ..
                                      *TT      return T * T (10 * 10), else
                                          +J1  return J+1
Shelvacu
fuente