Y2K… en 2019?

18

Nous sommes le 10 août 2019, mais votre tâche implique toujours l'an 2000. Bizarre, non?

Créez un programme qui s'imprime, avec un numéro à deux chiffres qui lui est ajouté. La première fois que vous l'exécutez, il devrait ajouter 00 à sa sortie (son code source, car il s'agit d'une variante quine). Lorsque vous exécutez cette sortie, le programme d'origine sans un numéro à deux chiffres, il doit sortir le programme d'origine, mais avec 01 ajouté. Exécutez cette sortie pour obtenir le programme OG avec 02 ajouté, puis celle pour obtenir le programme avec 03 ... Cette chaîne devrait continuer jusqu'à 99. Ce programme devrait sortir BREAKING NEWS: WORLD ENDS.

Si votre programme est Y2Kparanoia: yesalors:

  1. Il devrait sortir Y2Kparanoia: yes00
  2. Cette sortie devrait imprimer Y2Kparanoia: yes01
  3. Cette sortie devrait imprimer Y2K paranoia: yes02
  4. Répétez jusqu'à l'étape 100: ce programme affiche les nouvelles du Jugement Dernier spécifiées

C'est le golf de code, donc le programme le plus court qui peut s'imprimer tout en suivant ces étapes l'emporte.

code-golf quine Andrew
la source
7
Selon la description, la 99ème fois que nous courons, nous allons exécuter 2Kparanoia: yes97et produire 2Kparanoia: yes98, donc (4) ne devrait-il pas lire Repeat to step 100, but step 101 will output "BREAKING NEWS: WORLD ENDS"? (c.-à-d. 2Kparanoia: yes99produit les nouvelles)
Jonathan Allan

Réponses:

7

Perl 6 , 122 114 106 106 octets

-8 octets grâce à Shelvacu

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

Essayez-le en ligne!

Prend le format quine standard et ajoute la chaîne de nouvelles de rupture ainsi qu'un nouvel appel de fonction avec le numéro ajouté. Cela permet ENDd'exécuter la fonction à la fin du programme.

Jo King
la source
Vous pouvez enregistrer 3 octets supplémentaires en utilisant ENDet une ourvariable:END {<print $s-199??"END\{<$_>~~.EVAL};our\$s="~($s-1&&$s-99)+100!!"BREAKING NEWS: WORLD ENDS">~~.EVAL};our$s=1
Shelvacu
Pour l'instant, c'est le gagnant actuel.
Andrew
7

Rubis, 158 154 146 146 128 122 100 octets

Inspiré par cette réponse .

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

EDIT: J'ai pu le supprimer (s.split(35.chr)[0]+35.chr).inspectet le remplacer par s[0..-2](plage de chaque valeur sauf la dernière) et la %{ ... }syntaxe de chaîne que j'ai utilisée auparavant. Enregistré 22 octets!

Ancienne version:

EDIT: a enregistré une paire de parens (et la paire correspondante dans la section des données) en réalisant qu'il "BREAKING NEWS: WORLD ENDS"s'agit d'une chaîne de format parfaitement valide, et ruby ​​ignore tous les paramètres 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

Au début, j'ai réalisé que puisque le nombre doit aller à la toute fin du programme, et que ruby ​​ne permet pas d'utiliser des variables avant qu'elles ne soient déclarées, je devrais faire exécuter du code après les chiffres d'une manière ou d'une autre. J'aurais pu faire quelque chose def a(s) ... end;a 1qui deviendrait ...end;a 100, mais l'utilisation de la ENDsyntaxe moins connue de ruby utilise moins d'octets. Cependant, le bloc à l'intérieur ENDest dans une portée différente, donc Sdoit être une variable globale ou une constante.

Explication:

  • END{ ... };S=1: Exécuter un bloc de code juste avant la fin du programme; Réglez la constante Ssur 1(ou 100- 199dans les futures itérations)
  • $><<( ... ): $>est un raccourci en rubis pour stdout, et <<sur un E / S écrit sur l'E / S. Les parens sont obligatoires, sinon cela devient($><<S)>198...

  • S>198?"BREAKING NEWS: WORLD ENDS":(q=...)%[q,S<2?0:S-99]: Si je décomposais cela en un code légèrement plus raisonnable, ce serait:

    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

    L' %opérateur appliqué à une chaîne est effectivement printf, le LHS étant la chaîne de format et le RHS les arguments.

  • %{ ... (q=%%{%s}) ... S=1%02d}: ruby ​​a une syntaxe intéressante pour les chaînes qui permet également à des paires de crochets d'apparaître dans la chaîne sans s'échapper tant qu'elles sont équilibrées. Ceci est très utile, car sinon un quine similaire devrait s'échapper de la chaîne pour la mettre en elle-même en tant que littéral de chaîne. Les deux substitutions dans la chaîne de format sont %spour une chaîne régulière et %02dpour un nombre rempli à droite à une taille de 2 avec le caractère 0.

Mes réflexions sur le raccourcissement supplémentaire:

  • Ce serait bien de pouvoir utiliser à la splace de $s, mais la définition de s s=$s;ou la création d'une fonction def a(s) ...utilisent toutes deux plus d'octets qu'elles n'en économisent, et je ne vois pas d'autre moyen de le faire. EDIT: Les constantes sont globales et peuvent être un seul caractère!
  • Ce serait bien si Sc'était toujours moins alors 100, afin qu'il puisse être comparé en utilisant des nombres à 2 chiffres au lieu de nombres à 3 chiffres. Cependant, si j'utilise S=0à la fin, les deux chiffres suivants sont interprétés comme octaux, 8et 9sont invalides et tout est superposé. S=n'est tout simplement pas valide, et je ne connais pas d'autre moyen de rendre une valeur valide avant et après l'ajout de deux chiffres. À noter, 0(et tous les autres entiers) est vrai en rubis.

Si vous avez des idées sur la façon de raccourcir cela, faites-le moi savoir!

Essayez-le en ligne!

Shelvacu
la source
Peut-être que si vous l'utilisiez s=100-1? Alors ssera 99, 0, -1 ...- 99, et -ssera -99, 0 ... 99.
Purple P
@PurpleP Peu importe comment j'essaie, je ne peux pas trouver de moyen de le faire et d'enregistrer des personnages.
Shelvacu
5

Aller, 382 366 354 340 305 298 272 octets

Ne gagnera pas mais je me suis amusé avec le défi.

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

Essayez-le sur le Go Playground!

Basé sur une quine. Si la variable nest inférieure à 199, elle ajoute à la variable de chaîne nun accent grave ( \x60), le caractère de Go pour les chaînes multilignes, suivi d'une virgule ,. Il continue en imprimant les 147 premiers caractères de s(pour éviter d'imprimer le ,car cela ne se produit qu'à la fin) puis s'imprime sdans son ensemble, et finalement imprime 100si n == 1et n+1sinon. Le résultat est que les exécutions successives changent la variable nà la fin du programme en 100, 101, etc. Si la variable nest 199 ou plus, elle imprime les dernières nouvelles.

Violet P
la source
3

Haskell , 240 232 218 216 216 octets

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

Essayez-le en ligne!

Adapté d'une quine

B. Mehta
la source
2

JavaScript (ES6), 116 octets

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

94 octets, si le filtrage des fonctions est autorisé

f=_=>((p=`f=${f}`.split`|`)[4]=p[4]-1?-~p[4]:100)-200?p.join`|`:'BREAKING NEWS: WORLD ENDS'||1
Herman L
la source
2
Vous ne pouvez pas lire votre propre code source ( f=${f}), ce n'est pas une quine selon codegolf.meta.stackexchange.com/a/4878/13400
Shelvacu
1

C # (compilateur interactif Visual C #) , 193 octets

x=>{var a=t>198?"BREAKING NEWS: WORLD ENDS":"x=>{{var a=t>198?{1}BREAKING NEWS: WORLD ENDS{1}:{1}{0}{1};Write(a,a,(char)34,t+(t<2?99:1));}};int t={2}";Write(a,a,(char)34,t+(t<2?99:1));};int t=1

Essayez-le en ligne!

Incarnation de l'ignorance
la source
1

Pyth , 81 80 octets

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

Essayez-le en ligne!

Explication:

.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

Et le code dans la chaîne est (dernières nouvelles raccourcies):

?>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
la source