É 10 de agosto de 2019, mas sua tarefa ainda envolve o Y2K. Estranho, certo?

Crie um programa que se imprima com um número de dois dígitos anexado. Na primeira vez em que você o executa, ele deve anexar 00 à sua saída (seu código-fonte, porque esta é uma variante quine). Quando você executa essa saída, o programa original sem um número de dois dígitos, ele deve produzir o programa original, mas com 01 anexado a ele. Execute essa saída para obter o programa OG com 02 anexado e, em seguida, para obter o programa com 03 ... Essa cadeia deve continuar até 99. Esse programa deve ser gerado BREAKING NEWS: WORLD ENDS.

Se o seu programa for Y2Kparanoia: yes:

1. Deve produzir Y2Kparanoia: yes00
2. Essa saída deve imprimir Y2Kparanoia: yes01
3. Essa saída deve imprimir Y2K paranoia: yes02
4. Repita até a etapa 100: este programa exibe as notícias do dia do juízo final especificadas

Esse é o código de golfe, portanto, o programa mais curto que pode ser impresso ao mesmo tempo em que segue essas etapas vence.

Perl 6 , 122 114 106 bytes

-8 bytes graças a Shelvacu

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

Experimente online!

Adota o formato padrão de quine e adiciona a sequência de notícias de última hora, bem como uma nova chamada de função com o número anexado. Isso é usado ENDpara executar a função quando o programa termina.

Ruby, 158 154 146 128 122 100 bytes

Inspirado por esta resposta .

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

Edição: Consegui removê (s.split(35.chr)[0]+35.chr).inspect-lo e substituí-lo por s[0..-2](intervalo de todos os valores, exceto o último) e a %{ ... }sintaxe da string que eu usei antes. Economizou 22 bytes!

Versão antiga:

EDIT: Salva um par de parênteses (e o par correspondente na seção de dados) ao perceber que "BREAKING NEWS: WORLD ENDS"é uma sequência de formato perfeitamente válida e o ruby ​​ignora todos os 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

Ao iniciar isso, percebi que, como o número precisa ir até o final do programa, e o ruby ​​não permite o uso de variáveis ​​antes de serem declaradas, eu precisaria executar o código após os dígitos de alguma forma. Eu poderia ter feito algo como o def a(s) ... end;a 1que se tornaria ...end;a 100, no entanto, usar a ENDsintaxe menos conhecida do ruby usa menos bytes. No entanto, o bloco interno ENDestá em um escopo diferente, portanto Sdeve ser uma variável global ou constante.

Explicação:

• END{ ... };S=1: Execute o bloco de código imediatamente antes do programa terminar; Defina constante Scomo 1(ou 100- 199em futuras iterações)
• $><<( ... ): $>é um atalho em ruby ​​para stdout e <<em um IO grava no IO. Os parênteses são necessários, caso contrário, torna-se($><<S)>198...

• S>198?"BREAKING NEWS: WORLD ENDS":(q=...)%[q,S<2?0:S-99]: Se eu dividisse isso em um código um pouco mais razoável, seria:

  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

  O %operador aplicado a uma string é efetivamente printf, com o LHS sendo a string de formato e o RHS sendo os argumentos.

• %{ ... (q=%%{%s}) ... S=1%02d}: ruby ​​tem uma sintaxe interessante para strings que também permite que pares de colchetes apareçam dentro da string sem escapar enquanto estiverem equilibrados. Isso é muito útil, pois, caso contrário, um quine semelhante teria que escapar da string para inseri-la como uma literal de string. As duas substituições na cadeia de caracteres de formato são %spara uma cadeia regular e %02dpara um número preenchido à direita para um tamanho de 2 com o caractere 0.

Meus pensamentos em diminuir ainda mais:

• Seria bom poder usar em svez de $s, mas definir s s=$s;ou tornar uma função def a(s) ...usa mais bytes do que economiza, e não consigo pensar em outra maneira de fazê-lo. EDIT: As constantes são globais e podem ser um caractere!
• Seria bom se Sfosse sempre menor do 100que isso, para que pudesse ser comparado usando números de 2 dígitos em vez de números de 3 dígitos. No entanto, se eu usar S=0no final, os próximos dois dígitos serão interpretados como octais, 8e 9são inválidos e tudo é beliche. S=simplesmente não é válido e não conheço outra maneira de validar um valor antes e depois de anexar dois dígitos. É importante notar que 0(e todos os outros números inteiros) é verdade em rubi.

Quaisquer pensamentos sobre como tornar isso mais curto, por favor me avise!

Experimente online!

Go, 382366354 340305298272 bytes

Não vou ganhar, mas eu me diverti com o desafio.

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

Experimente no Go Playground!

Baseado em uma solução. Se a variável nfor menor que 199, ela adiciona à variável de sequência num acento grave ( \x60), o caractere de Go para sequências de múltiplas linhas, seguido por uma vírgula ,. Ele continua imprimindo os primeiros 147 caracteres de s(para impedir a impressão ,porque isso ocorre apenas no final), depois imprime scomo um todo e, finalmente, imprime 100se n == 1e de n+1outra forma. O resultado é que execuções sucessivas alteram a variável nno final do programa para 100, 101 etc. Se a variável nfor 199 ou mais, ela imprime as últimas notícias.

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

Experimente online!

Adaptado de um quine

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, se funções de stringing forem permitidas

f=_=>((p=`f=${f}`.split`|`)[4]=p[4]-1?-~p[4]:100)-200?p.join`|`:'BREAKING NEWS: WORLD ENDS'||1

C # (compilador interativo do Visual C #) , 193 bytes

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

Experimente online!

Pitão , 81 80 bytes

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

Experimente online!

Explicação:

.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

E o código na string é (as últimas notícias abreviadas):

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