Dary!

In eventi del tutto estranei a ciò che si spera possa accadermi nei prossimi due giorni, ti incarico di scrivere codice che procede come segue:

1. Stampa

   Legen... wait for it...
   

   immediatamente, con una nuova riga finale.

2. Attendere fino all'ora intera successiva (quando viene eseguito il processo cron per l'assegnazione del badge).

3. Stampa

   dary!
   

   con una nuova riga finale facoltativa .

Regole aggiuntive

• È possibile scrivere un programma o una funzione, ma l'output deve essere stampato su STDOUT (o la sua alternativa più vicina alla propria lingua).

• Devi aspettare fino alla prossima ora intera , non solo per 60 minuti. Se il codice viene eseguito alle 6:58, dovrebbe stampare la seconda riga alle 7:00.

• L'ultima riga deve essere stampata entro e non oltre un secondo dopo l'ora successiva successiva.

• Nel caso in cui il programma venga avviato nel primo secondo di un'ora intera, dovrebbe attendere l'ora successiva successiva.

• È possibile richiedere l'ora locale o UTC.

• Si applicano le regole standard del code-golf .

Pyth, 42 41

J.d6." wâ«­hÖ`Ùá©h´^"WqJ.d6;"dary!

Di seguito è riportato un hexdump del codice:

00000000  4a 2e 64 36 2e 22 20 77  0c 10 89 e2 ab 1b ad 68  |J.d6." w.......h|
00000010  0f 8c d6 60 d9 e1 a9 68  82 b4 5e 22 57 71 4a 2e  |...`...h..^"WqJ.|
00000020  64 36 3b 22 64 61 72 79  21                       |d6;"dary!|

Salvato 1 byte grazie a @isaacg

Utilizza la .dfunzione per ottenere valori relativi all'ora locale. .d6ritorna l'ora corrente. Ciò stampa la prima stringa, quindi attende che l'ora sia diversa dall'ora e l'inizio del programma, quindi stampa la seconda stringa.

Puoi provarlo online con .d7o .d8per minuti / secondi ma il compilatore online stampa qualsiasi cosa solo quando il programma termina.

Complimenti, Dennis! :)

JavaScript (ES6), 74 byte

Potresti voler cambiare l'orologio di sistema prima del test, congratulazioni se sei arrivato qui a 59 minuti.

setTimeout(a=alert,36e5-new Date%36e5,"dary!");a`Legen... wait for it...
`

CJam, 49 48 byte

et3="Legen... wait for it...
"o{_et3==}g;"dary!"

Utilizza l'ora locale. A scopo di test, è possibile sostituire le due istanze di 3con 4o5 farlo stampare all'inizio del minuto / secondo successivo.

Provalo qui. Tuttavia, l'interprete online non mostra alcun output fino al termine del programma. In alternativa, puoi eseguirlo su Provalo online , dove l'output viene mostrato quasi immediatamente invece di essere bufferizzato (ma quando lo collaudi con secondi anziché ore, il ritardo sarà evidente). In ogni caso, se lo esegui localmente con l'interprete Java, funziona come un incantesimo.

Spiegazione

Questo fa uso di CJam etche ti offre una serie di

[year month day hour minute second ms weekday utc_offset]

Ecco una ripartizione del codice:

et3=       e# Get the current hour.
"Legen..." e# Push the first string including the linefeed.
o          e# Print it.
{          e# While the top of stack is truthy (which is popped)...
  _        e#   Copy the original hour.
  et3=     e#   Get the current hour.
  =        e#   Check for equality.
}g
;          e# Discard the original hour.
"dary!"    e# Push the second string which is printed automatically.

indennità

Questo funziona anche per lo stesso conteggio byte:

et4<"Legen... wait for it...
"o{et1$#!}g;"dary!"

Invece di selezionare l'ora, stiamo selezionando il prefisso con la data e l'ora e continuiamo il ciclo mentre l'array datetime ha ancora quel prefisso.

AppleScript, 157 149 byte

Huh. Contesa sorprendentemente.

imposta d sul numero 1 nella stringa temporale di (data corrente)
log "Legen ... aspetta ..."
ripeti mentre d = numero 1 nella stringa temporale di (data corrente)
fine
log "dary!"

Dato che logstampa sul pannello Messaggi di Script Editor, lo considero l'output più vicino a STDOUT. Fondamentalmente, se ottieni la stringa di tempo della data corrente, farà qualcosa del genere:

Codice:

stringa di tempo di (data corrente)

Produzione:

17:02:03 PM

Afferrerà il primo numero ( 5) prima dei due punti.

Ho pensato che sarebbe molto più lungo di questo, in realtà. xD

Snowman 1.0.2 , 70 69 byte

~"Legen... wait for it...
"sP3600000*vt#nDnC!*:vt+#nD!#nL;bD"dary!"sP

Spiegazione:

~              Make all variables active.
"..."sP        Print the first string.
3600000*vt#nD  Get the number of hours since the Unix epoch.
nC             Ceiling (round up), giving the time (divided by 36000) at which to
                 print the second string.
!*             Save that in a permavar.
:...;bD        Do the stuff in the block while its "return value" is truthy.
  vt+#nD       Again, get the number of hours since epoch.
  !#             Store the permavar that we saved earlier.
  nL             Is the current time less than the target time? (if so,
                   keep looping)
"..."sP        Print the second string.

PHP, 76, 70, 65, 62 51 byte

Legen... wait for it...
<?while(+date(is));?>dary!

Logica precedente (63b):

Legen... wait for it...
<?for($h=date(G);date(G)==$h;)?>dary!

Questo tipo di codifica ti fa perdere il lavoro, ma questo continua fino a 1 ora in più rispetto a init.

-1 byte sostituendo {}il tempo a ;(grazie manatwork)
-5 byte sostituendo echo'dary!';a ?>dary!(grazie manatwork)
-4 byte sostituendo <?phpalla versione breve <?(grazie primo)
-1 byte sostituendo whileper a for
-3 byte sostituendo date(G)!=$h+1a date(G)==$h(grazie primo)

Perl 6 , 60 byte

sleep 60²-now%60²+say 'Legen... wait for it..';say 'dary!'

Javascript 94 90 87 byte

Non tanto da golf ...

alert`Legen... wait for it...`,l=l=>~~(Date.now()/36e5);for(z=l();z==l(););alert`dary!`

La versione di Downgoat:

(a=alert)`Legen... wait for it...`,z=(b=new Date().getHours)();for(;z==b(););a`dary!`

Memorizza l'ora corrente e scorre fino a quando l'ora "vecchia" è uguale a quella corrente. Non appena l'ora è cambiata, stamperà il resto! : D

Disclaimer: se il tuo browser non lo gradisce, sei stato avvisato.

MATLAB - 89 byte

a=@()hour(now);disp('Legen... wait for it...');while(mod(a()+1,24)~=a())end;disp('dary!')

Abbastanza autoesplicativo. Innanzitutto, crea un handle di funzione per afferrare l'ora corrente dell'orologio di sistema. Quindi, visualizziamo Legen... wait for it...con un ritorno a capo, quindi entriamo in un whileciclo in cui continuiamo a verificare se l'ora corrente aggiunta con 1 non è uguale all'ora corrente. Se lo è, continua ad eseguire il loop. Solo fino all'istante in cui si verifica l'ora successiva, visualizziamo dary!e dopo si verifica un ritorno a capo.

L'ora di MATLAB si basa sull'indicizzazione delle 24 ore, quindi l' modoperazione con la base 24 è necessaria per gestire la fuoriuscita dalle 23:00 (23:00) a mezzanotte (00:00).

Nota minore

La hourfunzione richiede la casella degli strumenti Serie temporali finanziaria. La nowfunzione non è soggetta a questa limitazione, ma recupera la data e l'ora correnti come un numero seriale che hourquindi utilizza per calcolare l'ora corrente.

Vuoi eseguirlo in Octave?

Sicuro! Poiché Octave non ha questo toolbox, dovremmo solo modificare la hourfunzione in modo che chiami datevecrestituendo un vettore di 6 elementi, uno per ciascuno di anno, mese, giorno, ora, minuti e secondi. Dovresti solo estrarre il quarto elemento dell'output:

a=@()datevec(now)(4);disp('Legen... wait for it...');while(mod(a()+1,24)~=a())end;disp('dary!')

I caratteri aggiuntivi rendono la soluzione fino a 98 byte, ma sarai in grado di eseguirlo in Octave. Notare l'indicizzazione sul posto senza una variabile temporanea nell'handle della funzione.

Nessuna casella degli strumenti per le serie temporali finanziarie?

Se vuoi eseguirlo in MATLAB senza la Casella degli strumenti delle serie temporali finanziarie, poiché non puoi indicizzare immediatamente le variabili senza una temporanea, ciò richiederà un po 'più di byte per scrivere:

disp('Legen... wait for it...');h=datevec(now);ans=h;while(mod(h(4)+1,24)~=ans(4)),datevec(now);end;disp('dary!');

Questo prima ottiene l'ora e la data correnti e la memorizza nella variabile h, oltre a memorizzarla nella variabile automatica chiamata ans. Dopo, continuiamo a fare il loop e controlliamo se l'ora corrente non è uguale all'ora successiva. Ad ogni iterazione, continuiamo ad aggiornare la variabile automatica con l'ora e la data correnti. Non appena l'ora successiva coincide con l'ora e la data correnti, visualizziamo l'ultima parte della stringa ed esci. Questo porta il conteggio dei byte a 114.

Inoltre, tieni presente che non puoi provarlo online. Gli interpreti di Octave online avranno un limite di tempo per l'esecuzione del codice e poiché si tratta di un whileloop in attesa dell'ora successiva, si verificherà un timeout durante l'attesa dell'esecuzione del codice. La cosa migliore che puoi fare è eseguirlo sul tuo computer e verificare che funzioni.

Mathematica, 85 84 81 byte

c=Print;c@"Legen... wait for it...";a:=DateValue@"Hour";b=a;While[a==b];c@"dary!"

C, 163 byte

#include<time.h>
f(){puts("Legen... wait for it...");time_t t=time(0);struct tm l=*localtime(&t);while(l.tm_min+l.tm_sec)t=time(0),l=*localtime(&t);puts("dary!");}

Microscript II, 45 byte

"Legen... wait for it..."P[36s5E*sD%_]"dary!"

Infine, un uso per l' Distruzione.

Stampa la prima stringa, impiega ripetutamente il tempo UTC in millesecondi modulo 3.600.000 fino a quando non si ottiene 0, quindi produce la seconda stringa che viene stampata implicitamente. I 3.600.000 sono rappresentati nel codice come 36x10 ⁵ .

TI-BASIC, 70 64 byte

getTime
Disp "Legen... wait for it...
Repeat sum(getTime-Ans,1,1
End
"dary

Maledici queste lettere minuscole a due byte!

getTimerestituisce un elenco di tre elementi {hours minutes seconds}, quindi la somma dal 1 ° al 1 ° è le ore. Quando c'è una differenza tra le ore all'inizio e le ore correnti, il ciclo termina. Grazie a @FryAmTheEggman per questa osservazione.

R - 97 byte

cat('Legen... wait for it...\n')
Sys.sleep(1)
while(as.double(Sys.time())%%3600>0){}
cat('dary!')

Python 3 - 92 89 byte

from time import*;print("Legen... wait for it...");sleep(3600-time()%3600);print("dary!")

Python 2, 82 81 byte

from time import*;print'Legen... wait for it...';sleep(-time()%3600);print'dary!'

Una reputazione troppo bassa per commentare. Versione Python 2 della soluzione di Alexander Nigl. Salva i caratteri persi tra parentesi. Inoltre, 3600 non sono necessari nel calcolo del tempo di inattività.

7 caratteri salvati complessivamente.

Modifica: -1 byte grazie a @Kevin Cruijssen

Script di comando di Windows, 87 byte

@set.=%time:~,2%&echo.Legen... wait for it...
:.
@if %.%==%time:~,2% goto:.
@echo.dary!

Ciò confronta continuamente una variabile oraria memorizzata all'inizio rispetto all'ora corrente e ha esito positivo se diversa.

Perl, 62 byte

sleep -++$^T%3600+print'Legen... wait for it...
';print'dary!'

La variabile speciale $^T(aka $BASETIME) registra il numero di secondi dall'epoca in cui è stato avviato lo script. Fortunatamente, i secondi intercalari non vengono conteggiati nel totale, quindi i seguenti sono equivalenti:

print$^T%3600;
@T=gmtime;print$T[1]*60+$T[0];

Sorprendentemente, questa variabile non è di sola lettura.

Japt , 72 61 byte

`{?tT?e?t(Ã?t,36e5-?w D?e%36e5,'ÜÝ!'),'Leg?... Ø2 f? ?...\n'}

Ciascuno ?rappresenta un carattere non stampabile Unicode. Ecco come ottenere il testo completo:

1. Apri l' interprete online .
2. Incolla questo codice nella casella Codice:

Oc"`\{setTimeout(alert,36e5-new Date%36e5,'dary!'),'Legen... wait for it...\\n'}

3. Esegui il codice, quindi cancellalo dalla casella Codice.
4. Seleziona il contenuto della casella Output e trascina nella casella Codice. Copia-incolla non funzionerà .
5. Sostituisci il primo spazio con uno spazio non interrotto.
6. (opzionale) Imposta l'orologio del tuo computer su xx: 59.
7. Esegui il codice

In alternativa, ecco un hexdump (si spera reversibile):

00000000: 607b a074 548b 658c 7428 c300 742c 3336 65    `{ tT?e?t(Ã?t,36e
00000011: 352d 9a77 2044 8565 2533 3665 352c 27dc dd    5-?w D?e%36e5,'ÜÝ
00000022: 2127 293b 274c 6567 812e 2e2e 20d8 3220 66    !'),'Leg?... Ø2 f
00000033: 8e20 8a2e 2e2e 5c6e 277d                      ? ?...\n'}

Questo codice si basa sulla risposta JavaScript di George Reith , con alcune modifiche specifiche di Japt. Ho scoperto l'altro giorno che se comprimi il codice e lo inserisci in una stringa avvolta da un backtick, si decomprimerà automaticamente. Ecco come viene elaborato tramite la compilazione:

`{?tT?e?t(Ã?t,36e5-?w D?e%36e5,'ÜÝ!'),'Leg?... Ø2 f? ?...\n'}
"{setTimeout(alert,36e5-new Date%36e5,'dary!'),'Legen... wait for it...\n'}"
""+(setTimeout(alert,36e5-new Date%36e5,'dary!'),'Legen... wait for it...\n')+""

In JS, una coppia di parentesi restituirà l'ultimo valore all'interno; quindi, questo codice imposta l'evento a tempo, quindi restituisce la 'Legen...'stringa, che viene automaticamente inviata a STDOUT. Dato che Japt attualmente non ha modo di aggiungere contenuto a STDOUT se non l'output automatico durante la compilazione, ho invece utilizzato la funzione JS vanilla alertper l'output temporizzato. Spero che questo sia permesso.

Powershell, 52 51 byte

-1 byte grazie @Veskah

'Legen... wait for it...'
for(;Date|% M*e){}'dary!'

Questa espressione Date|% M*eottiene valore dalla Minuteproprietà dal valore Current DateTime. Il ciclo termina quando è Minuteuguale a 0.

Python, 112 byte

import time as t;print "Legen... wait for it...";n=t.ctime();t.sleep((60-n.tm_min)*60+60-n.tm_sec);print "dary!"

Abbastanza esplicativo.

Python - 159 byte

from datetime import*;from threading import*;p=print;n=datetime.now();p('Legen... wait for it...');Timer(3600-(n.minute*60+n.second),lambda:p('dary!')).start()

Mouse-2002 , 62 byte

Richiede all'utente di premere Invio. Penso.

"Legen... wait for it..."?&HOUR 1+x:(&HOUR x.=["dary"33!'0^])

Ok, beh, mentre stiamo prendendo molti byte e non stiamo vincendo nulla, divertiamoci un po '.

"Legen... wait for it... "?     ~ print & require keypress

&HOUR 1+ x:                     ~ get hr, add 1 and assign
(                               ~ while(1)
  &HOUR x. =                    ~ cmp current hr, stored hr
  [                             ~ if same
    #B;                           ~ backspace
    "dary"36!'                    ~ print this string and a !
    0^                            ~ exit cleanly
  ]                             ~ fi
  &MIN 59 - &ABS !              ~ get min, subtract from 59, abs & print
  ":"                           ~ record sep
  &SEC 59 - &ABS !              ~ same for second
  #B;                           ~ backspace
)
$B 8!' 8 !' 8 !' 8 !' 8 !'@     ~ backspace 5*
$                               ~ \bye

Campione:

$ mouse legend.m02
Legen... wait for it... 20:32

Vedi, è un conto alla rovescia per l'aggiornamento sul posto all'ora successiva! Fa buon uso del ciclo while, che anche senza fare nulla occuperà un nucleo.

BASIC, 90 byte

Print"Legen... wait for it...":x$=Left(Time,2):Do:Loop Until x$<>Left(Time,2):Print"dary!"

Semplice, giocato a golf usando i prefissi di tipo e l' Endistruzione implicita . Il costo è che funziona solo in dialetto FreeBasicfblite .

Befunge 98 - 69 63 byte

 v
v>a"...ti rof tiaw ...negeL<ETB>"k,
>"EMIT"4(MS+_"!yrad"5k,@

Il codice contiene un carattere non stampabile (rappresentato da <ETB>come non stampabili non sembrano apparire in blocchi di codice). Il suo codice carattere è 23 (an carattere di blocco trasmissione End ).

Avviso: il codice precedente verrà eseguito in un ciclo occupato con lo stack che diventa più grande ogni ripetizione e quindi può consumare grandi quantità di memoria.

Gelatina , 48 47 byte , non competitiva

-1 byte grazie a Erik the Golfer (usa "Leg" come parola nella compressione)

“ÇỴġƒḃhlḂṀ⁷*Ḣ¡w*Jḷv»Ṅø3ŒTṣ”:V_@59ḅ60‘œS@“dary!”

TryItOnline! o esegui una versione di prova con una stringa con formattazione temporale codificata di“59:57” ("mm: ss").

Il primo impegno di Jelly è stato fatto da Dennis pochi giorni dopo aver creato questa sfida, non sono sicuro in quale data avrebbe funzionato questo codice, ma in ogni caso non è in competizione.
Vi è, al momento della scrittura, un solo modo per accedere all'ora che è tramite una stringa formattata,ŒT .

Questo codice calcola il tempo di attesa e quindi la sospensione. Se chiamato hh:00:00, attende alcuni 3600secondi: converte "00:00"per [0,0]poi sottrae da da 59a resa [59,59], converte quello da base sessanta a dare 3599, quindi ne aggiunge uno per un periodo di attesa totale di 3600secondi.

Forse potrebbe essere realizzato un ciclo; o una stringa compressa che utilizza l'intera parola "Leggendario" potrebbe essere utilizzata in qualche modo?

“ÇỴġƒḃhlḂṀ⁷*Ḣ¡w*Jḷv»Ṅø3ŒTṣ”:V_@59ḅ60‘œS@“dary!” - Main link: no arguments
“ÇỴġƒḃhlḂṀ⁷*Ḣ¡w*Jḷv»                            - compressed "Legen... wait for it..."
                    Ṅ                           - print z + '\n', return z
                     ø                          - niladic chain separation
                      3ŒT                       - '011' (3) time formatted string = "mm:ss"
                         ṣ”:                    - split on ':' -> ["mm","ss"]
                            V                   - eval -> [m,s]
                             _@59               - subtract from 59 - > [59-m, 59-s]
                                 ḅ60            - convert from base 60 -> 60*(59-m)+(59-s)
                                    ‘           - increment -> 60*(59-m)+(59-s) = y
                                        “dary!” - "dary!" = x
                                     œS@        - sleep y seconds then return x
                                                - implicit print

MathGolf , 39 byte

"Legen... wait for it..."pÆt♪/╚÷▼"dary!

Provalo online!

Quasi battere Pyth ...

Spiegazione

Æ     ▼  Repeat the next 5 characters while false
 t       push unix time in milliseconds
  ♪/     divide by 1000
    ╚÷   check if divisible by 3600 (tio solution has 3 in its place)

Pyth - 36 byte

Attende che i minuti siano 0 con un ciclo while.

"Legen... wait for it..."W.d7)"dary!

Java, 136 byte

class a{void A(){System.out.println("Legen... wait for it...");while(System.currentTimeMillis()%3600000!=0);System.out.print("dary!");}}

Quanti millisecondi sono trascorsi dall'ultima ora intera è il risultato di System.currentTimeMillis() mod 3.600.000.

Il programma monolitico equivalente è lungo 159 byte:

interface a{static void main(String[]A){System.out.println("Legen... wait for it...");while(System.currentTimeMillis()%3600000!=0);System.out.print("dary!");}}

QBIC , 58 byte

?@Legen... wait for it...|#Dary!|{~mid$$|(_d,4,2)=@00||_XB

Spiegazione

?@Legen... wait for it...|     Define string literal "Leg[..]it..." and print it
#Dary!|                        Define string B as "Dary!", but don't use it yet
{                              Opens an indefinite DO loop
~mid$$|(...)=@00|              Translates to IF MID$(...) = C$, where C$ is "00"
    The MID$ takes two characters, starting from pos 4, from the system's time (_d)
    So, if the string "11:00" has "00" starting at pos 4,
_XB                            Terminate the program and print string B
(The DO loop and the IF are closed implicitly)