Y2K ... nel 2019?

18

È il 10 agosto 2019, ma il tuo compito riguarda ancora Y2K. Strano, vero?

Crea un programma che si stampa da solo, con un numero di due cifre aggiunto. La prima volta che lo esegui, dovrebbe aggiungere 00 al suo output (il suo codice sorgente, perché questa è una variante di quine). Quando si esegue quell'output, il programma originale senza un numero di due cifre, dovrebbe generare il programma originale, ma con 01 aggiunto ad esso. Esegui quell'output per ottenere il programma OG con 02, quindi quello per ottenere il programma con 03 ... Questa catena dovrebbe continuare fino al 99. L'output di quel programma BREAKING NEWS: WORLD ENDS.

Se il tuo programma è Y2Kparanoia: yesquindi:

  1. Dovrebbe essere prodotto Y2Kparanoia: yes00
  2. Tale output dovrebbe essere stampato Y2Kparanoia: yes01
  3. Tale output dovrebbe essere stampato Y2K paranoia: yes02
  4. Ripeti fino al passaggio 100: questo programma genera le notizie del giorno del giudizio specificate

Questo è il golf del codice, quindi vince il programma più breve che può stampare da solo seguendo questi passaggi.

code-golf  quine 
— Andrea
fonte
7
Secondo la descrizione della 99esima volta che correremo, saremo in esecuzione 2Kparanoia: yes97e produzione 2Kparanoia: yes98, quindi non dovresti (4) leggere Repeat to step 100, but step 101 will output "BREAKING NEWS: WORLD ENDS"? (ovvero 2Kparanoia: yes99produce la notizia)
— Jonathan Allan il

Risposte:

7

Perl 6 , 122 114 106 byte

-8 byte grazie a Shelvacu

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

Provalo online!

Prende il formato standard di quine e aggiunge la stringa di ultime notizie e una nuova chiamata di funzione con il numero aggiunto. Questo utilizza ENDper eseguire la funzione al termine del programma.

— Jo King
fonte
Puoi salvare altri 3 byte usando ENDe una ourvariabile:END {<print $s-199??"END\{<$_>~~.EVAL};our\$s="~($s-1&&$s-99)+100!!"BREAKING NEWS: WORLD ENDS">~~.EVAL};our$s=1
— Shelvacu l'
Per ora, questo è l'attuale vincitore.
— Andrew,
7

Rubino, 158 154 146 128 122 100 byte

Ispirato da questa risposta .

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

EDIT: Sono stato in grado di rimuoverlo (s.split(35.chr)[0]+35.chr).inspecte sostituirlo con s[0..-2](intervallo di ogni valore tranne l'ultimo) e la %{ ... }sintassi della stringa che ho usato prima. 22 byte salvati!

Vecchia versione:

EDIT: ha salvato una coppia di parentesi (e la corrispondente coppia nella sezione dati) realizzando che si "BREAKING NEWS: WORLD ENDS"tratta di una stringa di formato perfettamente valida e ruby ​​ignora qualsiasi parametro 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

All'inizio mi sono reso conto che dato che il numero deve andare alla fine del programma, e ruby ​​non consente di usare le variabili prima che vengano dichiarate, dovrei far funzionare il codice dopo le cifre in qualche modo. Avrei potuto qualcosa di fatto come def a(s) ... end;a 1che sarebbe diventato ...end;a 100, tuttavia utilizzando meno noti di Ruby ENDutilizza una sintassi meno byte. Tuttavia, il blocco all'interno ENDè in un ambito diverso, quindi Sdeve essere una variabile o costante globale.

Spiegazione:

  • END{ ... };S=1: Esegue il blocco di codice prima che il programma termini; Imposta costante Ssu 1(o 100- 199nelle iterazioni future)
  • $><<( ... ): $>è una scorciatoia in ruby ​​per stdout e <<su un IO scrive nell'IO. I genitori sono richiesti, altrimenti diventa($><<S)>198...

  • S>198?"BREAKING NEWS: WORLD ENDS":(q=...)%[q,S<2?0:S-99]: Se dovessi suddividerlo in un codice leggermente più ragionevole sarebbe:

    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' %operatore applicato a una stringa è efficace printf, con LHS come stringa di formato e RHS come argomenti.

  • %{ ... (q=%%{%s}) ... S=1%02d}: ruby ​​ha una sintassi interessante per le stringhe che consente anche alle coppie di parentesi graffe di apparire all'interno della stringa senza scappare fintanto che sono bilanciate. Questo è molto utile, poiché altrimenti un quine simile dovrebbe sfuggire alla stringa per metterla in se stessa come una stringa letterale. Le due sostituzioni nella stringa di formato sono %sper una stringa normale e %02dper un numero riempito a destra con una dimensione di 2 con il carattere 0.

I miei pensieri sull'accorciamento ulteriore:

  • Sarebbe bello poter usare sinvece di $s, ma definire s=$s;o creare una funzione def a(s) ...usa più byte di quanti ne salvino, e non riesco a pensare ad altro modo per farlo. EDIT: le costanti sono globali e possono essere un personaggio!
  • Sarebbe bello se lo Sfosse sempre meno 100, in modo da poterlo confrontare usando numeri a 2 cifre anziché numeri a 3 cifre. Tuttavia, se lo uso S=0alla fine, le due cifre successive vengono interpretate come ottali 8e 9non sono valide e tutto è a castello. S=semplicemente non è valido e non conosco altri modi per rendere valido un valore sia prima che dopo aver aggiunto due cifre. Da notare, 0(e ogni altro numero intero) è vero in rubino.

Qualche idea su come renderlo più breve, per favore fatemi sapere!

Provalo online!

— Shelvacu
fonte
Forse se hai usato s=100-1? Quindi ssarà 99, 0, -1 ...- 99 e -ssarà -99, 0 ... 99.
— Viola P
@PurpleP Non importa come ci provo, non riesco a capire come fare e salvare i personaggi.
— Shelvacu, il
5

Vai, 382366 354 340 305 298 272 byte

Non vincerò ma mi sono divertito con la sfida.

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

Provalo sul Go Playground!

Basato su un quine. Se la variabile nè inferiore a 199, aggiunge alla variabile stringa nun accento grave ( \x60), il carattere di Go per le stringhe multilinea, seguito da una virgola ,. Continua stampando i primi 147 caratteri di s(per impedire la stampa ,perché ciò si verifica solo alla fine), quindi stampa snel suo insieme e infine stampa 100se n == 1e n+1altrimenti. Il risultato è che le esecuzioni successive cambiano la variabile nalla fine del programma su 100, 101, ecc. Se la variabile nè 199 o più, stampa le ultime notizie.

— Viola P
fonte
3

Haskell , 240 232 218 216 byte

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

Provalo online!

Adattato da una quinta

— B. Mehta
fonte
2

JavaScript (ES6), 116 byte

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

94 byte, se sono consentite le funzioni di stringa

f=_=>((p=`f=${f}`.split`|`)[4]=p[4]-1?-~p[4]:100)-200?p.join`|`:'BREAKING NEWS: WORLD ENDS'||1
— Herman L
fonte
2
Non puoi leggere il tuo codice sorgente ( f=${f}), non è un quine secondo codegolf.meta.stackexchange.com/a/4878/13400
— Shelvacu
1

Pyth , 81 80 byte

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

Provalo online!

Spiegazione:

.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 il codice nella stringa è (ultime notizie abbreviate):

?>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
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.