dary!

Dans des événements totalement indépendants de ce qui, espérons-le, m'arrivera dans les prochains jours, je vous charge d'écrire du code qui:

1. Impression

   Legen... wait for it...
   

   immédiatement, avec un retour à la ligne.

2. Attendez jusqu'à l'heure complète suivante (lorsque le travail cron pour l'attribution du badge sera exécuté).

3. Impression

   dary!
   

   avec un retour à la ligne optionnel .

Règles supplémentaires

• Vous pouvez écrire un programme ou une fonction, mais la sortie doit être imprimée sur STDOUT (ou son alternative la plus proche de votre langue).

• Vous devez attendre jusqu'à l' heure complète suivante , pas seulement pour 60 minutes. Si le code est exécuté à 6h58, il devrait imprimer la deuxième ligne à 7h00.

• La dernière ligne doit être imprimée au plus tard une seconde après l'heure complète suivante.

• Dans le cas où le programme est démarré dans la première seconde d'une heure complète, il devrait attendre une heure complète.

• Vous pouvez interroger l'heure locale ou l'heure UTC.

• Les règles standard de code-golf s'appliquent.

Pyth, 42 41

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

Ci-dessous, un hexdump du code:

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

Enregistré 1 octet grâce à @isaacg

Utilise la .dfonction pour obtenir les valeurs liées à l'heure locale. .d6renvoie l'heure actuelle. Cela permet d’imprimer la première chaîne, puis d’attendre que l’heure soit différente de l’heure du début du programme, puis d’imprimer la deuxième chaîne.

Vous pouvez l'essayer en ligne avec .d7ou .d8pendant quelques minutes / secondes, mais le compilateur en ligne n'imprime quoi que ce soit à la fin du programme.

Félicitations, Dennis! :)

JavaScript (ES6), 74 octets

Vous voudrez peut-être modifier votre horloge système avant les tests. Félicitations si vous arrivez ici à 59 minutes.

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

CJam, 49 48 octets

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

Utilise l'heure locale. À des fins de test, vous pouvez remplacer les deux instances de 3avec 4ou 5pour le faire imprimer au début de la minute / seconde suivante.

Testez-le ici. Mais notez que l'interprète en ligne ne montre aucune sortie jusqu'à la fin du programme. Vous pouvez également l'exécuter sur Essayez-le en ligne , où le résultat est affiché presque immédiatement au lieu d'être mis en mémoire tampon (mais lorsque vous le testez avec des secondes au lieu de plusieurs heures, le délai est perceptible). Dans tous les cas, si vous l'exécutez localement avec l'interpréteur Java, cela fonctionne comme un charme.

Explication

Ceci utilise CJam etqui vous donne un tableau de

[year month day hour minute second ms weekday utc_offset]

Voici le détail du code:

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.

Prime

Cela fonctionne également pour le même nombre d'octets:

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

Au lieu de sélectionner l'heure, nous sélectionnons le préfixe avec la date et l'heure et conservons la boucle en cours tant que le tableau datetime possède toujours ce préfixe.

AppleScript, 157 149 octets

Huh. Étonnamment en lice.

mettre d au numéro 1 dans la chaîne temporelle de (date du jour)
connectez-vous "Legen ... attendez ..."
répéter pendant que d = numéro 1 dans la chaîne temporelle de (date du jour)
fin
connectez-vous "dary!"

Depuis l' logimpression dans la sous-fenêtre Messages de Script Editor, je considère que c'est la sortie la plus proche de STDOUT. Fondamentalement, si vous obtenez la chaîne temporelle de la date actuelle, cela produira quelque chose comme ceci:

Code:

chaîne de temps de (date actuelle)

Sortie:

17h02:03

Il prendra le premier nombre ( 5) avant les deux points.

Je pensais que ce serait beaucoup plus long que ça, en fait. xD

Bonhomme de neige 1.0.2 , 70 69 octets

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

Explication:

~              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 octets

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

Logique précédente (63b):

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

Ce type de codage vous fait perdre votre travail, mais cela se répète jusqu’à 1 heure de plus que init.

-1 octet en remplaçant {}afer le temps pour ;(grâce manatwork)
-5 octets par le remplacement echo'dary!';de ?>dary!(manatwork de grâce)
-4 octets par le remplacement <?phpde la version courte <?(primo remerciements)
-1 octet en remplaçant le whilependant for
-3 octets par substitution , date(G)!=$h+1à date(G)==$h(merci primo)

Perl 6 , 60 octets

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

Javascript 94 90 87 octets

Pas beaucoup joué au golf ...

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

La version de Downgoat:

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

Il enregistre l'heure actuelle et les boucles tant que "l'ancienne" heure est égale à l'heure actuelle. Dès que l'heure aura changé, le reste sera imprimé! :RÉ

Avertissement: Si votre navigateur ne l'aime pas, vous avez été averti.

MATLAB - 89 octets

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

Assez explicite. Commencez par créer une poignée de fonction pour saisir l'heure actuelle de l'horloge système. Ensuite, affichez Legen... wait for it...avec un retour chariot, puis nous entrons dans une whileboucle où nous vérifions sans cesse si l’heure actuelle ajoutée à 1 n’est pas égale à l’heure actuelle. Si c'est le cas, continuez à boucler. Seulement jusqu'à l'instant où l'heure suivante se produit, nous affichons dary!et un retour chariot se produit après.

L’heure de MATLAB étant basée sur l’indexation sur 24 heures, l’ modopération avec la base 24 est nécessaire pour gérer les débordements de 23 h (23 h) à minuit (00 h).

Note mineure

Cette hourfonction nécessite la boîte à outils Série financière. La nowfonction n'est pas soumise à cette restriction, mais elle récupère la date et l'heure actuelles sous forme de numéro de série, qui permet hourainsi de calculer l'heure actuelle.

Voulez-vous exécuter ceci dans Octave?

Sûr! Comme Octave ne dispose pas de cette boîte à outils, il suffit de modifier la hourfonction pour qu’elle appelle datevecun vecteur de 6 éléments - un pour l’année, le mois, le jour, l’heure, les minutes et les secondes. Il vous suffira d'extraire le quatrième élément de la sortie:

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

Les caractères supplémentaires font passer la solution à 98 octets, mais vous pourrez l'exécuter dans Octave. Notez l'indexation sur place sans variable temporaire dans le descripteur de fonction.

Pas de boîte à outils de séries chronologiques financières?

Si vous souhaitez exécuter ceci dans MATLAB sans la boîte à outils Financial Time Series, car vous ne pouvez pas indexer immédiatement dans des variables sans variable temporaire, l'écriture nécessite un peu plus d'octets:

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

Cette première obtient l’heure et la date actuelles et les stocke dans la variable h, ainsi que dans la variable automatique appelée ans. Après, nous continuons à boucler et à vérifier si l'heure actuelle n'est pas égale à l'heure suivante. A chaque itération, nous continuons à mettre à jour la variable automatique avec l'heure et la date actuelles. Dès que l'heure suivante correspond à l'heure et à la date actuelles, nous affichons la dernière partie de la chaîne et nous quittons. Cela pousse le nombre d'octets à 114.

Prenez également note que vous ne pouvez pas essayer ceci en ligne. Les interprètes d’Octave en ligne auront une limite de temps pour l’exécution du code, et comme il s’agit d’une whileboucle attendant la prochaine heure, vous obtiendrez un délai d’attente en attendant l’exécution du code. La meilleure chose à faire est de l'exécuter sur votre propre ordinateur et de vérifier qu'il fonctionne.

Mathematica, 85 84 81 octets

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

C, 163 octets

#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 octets

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

Enfin, une utilisation pour l' Dinstruction.

Imprime la première chaîne, prend à plusieurs reprises l’heure UTC en millesecondes modulo 3 600 000 jusqu’à obtenir 0, puis génère la deuxième chaîne imprimée implicitement. Les 3 600 000 sont représentés dans le code sous la forme 36x10 ⁵ .

TI-BASIC, 70 64 octets

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

Maudissez ces lettres minuscules à deux octets!

getTimerenvoie une liste de trois éléments {hours minutes seconds}, ainsi la somme du premier élément au premier correspond aux heures. Lorsqu'il y a une différence entre les heures de début et les heures actuelles, la boucle se termine. Merci à @FryAmTheEggman pour cette observation.

R - 97 octets

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

Python 3 - 92 89 octets

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

Python 2, 82 81 octets

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

Une réputation trop basse pour commenter. Version Python 2 de la solution d'Alexander Nigl. Enregistre les caractères perdus sur des crochets. En outre, 3 600 non nécessaires au calcul du temps de sommeil.

7 caractères enregistrés au total.

Edit: -1 octet grâce à @ Kevin Cruijssen

Script de commande Windows, 87 octets

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

Ceci compare continuellement une variable horaire stockée au début avec l'heure actuelle et réussit si elle est différente.

Perl, 62 octets

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

La variable spéciale $^T(aka $BASETIME) enregistre le nombre de secondes écoulées depuis le début du script. Heureusement, les secondes intercalaires ne sont pas comptées dans le total. Par conséquent, les valeurs suivantes sont équivalentes:

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

Étonnamment, cette variable n’est pas en lecture seule.

Japt , 72 61 octets

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

Chacun ?représente un caractère Unicode non imprimable. Voici comment obtenir le texte intégral:

1. Ouvrez l' interprète en ligne .
2. Collez ce code dans la zone Code:

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

3. Exécutez le code, puis effacez-le de la zone Code.
4. Sélectionnez le contenu de la zone de sortie et faites -la glisser dans la zone Code. Le copier-coller ne fonctionnera pas .
5. Remplacez le premier espace par un espace insécable.
6. (facultatif) Réglez l’horloge de votre ordinateur sur xx: 59.
7. Exécutez le code.

Alternativement, voici un hexdump (espérons-le réversible):

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'}

Ce code est basé sur la réponse JavaScript de George Reith , avec quelques modifications spécifiques à Japt. J'ai découvert l'autre jour que si vous compressez le code et l'insérez dans une chaîne encapsulée par un backtick, il se décompressera automatiquement. Voici comment cela est traité lors de la compilation:

`{?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')+""

Dans JS, une paire de parenthèses renverra la dernière valeur à l'intérieur; ainsi, ce code définit l'événement timed, puis renvoie la 'Legen...'chaîne, qui est automatiquement envoyée à STDOUT. Comme Japt n'a actuellement aucun moyen d'ajouter du contenu à STDOUT autre que la sortie automatique lors de la compilation, j'ai plutôt utilisé la fonction vanilla JS alertpour la sortie minutée. J'espère que cela est permis.

Powershell, 52 51 octets

-1 octet merci @Veskah

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

Cette expression Date|% M*eobtient la valeur de la Minutepropriété à partir de la valeur DateTime actuelle. La boucle se termine lorsqu'elle est Minuteégale à 0.

Python, 112 octets

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!"

Assez explicite.

Python - 159 octets

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()

Souris-2002 , 62 octets

Requiert que l'utilisateur appuie sur Entrée. Je pense.

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

Bon, bien, alors que nous prenons beaucoup d'octets et que nous ne gagnons rien, amusons-nous un peu.

"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

Échantillon:

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

Vous voyez, c'est un compte à rebours actualisé sur place jusqu'à la prochaine heure! Il fait bon usage de la boucle while, qui même ne rien faire occupera une place de choix.

BASIC, 90 octets

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

Simple, joué au golf en utilisant les préfixes de type et la Enddéclaration implicite . Le coût est que cela ne fonctionne que dans le dialecte FreeBasicfblite .

Befunge 98 - 69 63 octets

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

Le code contient un caractère non imprimable (représenté par <ETB>les mots non imprimables ne semblent pas apparaître dans les blocs de code). Son code de caractère est 23 (caractère de fin de bloc de transmission ).

Avertissement: Le code précédent s'exécutera dans une boucle occupée, la pile devenant de plus en plus grosse, ce qui entraînerait une consommation importante de mémoire.

Gelée , 48 47 octets , non en compétition

-1 octet grâce à Erik le golfeur (utilisez "Leg" comme mot dans la compression)

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

TryItOnline! ou exécutez une version de test avec une chaîne codée en dur de“59:57”("mm: ss").

Le premier engagement de Jelly a été effectué par Dennis quelques jours à peine après avoir créé ce défi. Je ne sais pas à quelle date ce code aurait fonctionné pour la première fois, mais il n’est en aucun cas concurrentiel.
Il y a, au moment de l' écriture, une seule façon d'accéder au temps qui est au moyen d'une chaîne formatée, ŒT.

Ce code calcule combien de temps attendre, puis dort. Si elle est appelée à hh:00:00elle attend quelques 3600secondes: il convertit "00:00"à [0,0]soustraient alors que de 59Céder [59,59], convertit que de la base de soixante pour donner 3599, ajoute ensuite un pour une durée totale d'attente de 3600secondes.

Peut-être qu'une boucle pourrait être faite; ou une chaîne compressée utilisant le mot entier "légendaire" pourrait être utilisé en quelque sorte?

“ÇỴġƒḃ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 octets

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

Essayez-le en ligne!

Presque battre pyth ...

Explication

Æ     ▼  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 octets

Attend que les minutes soient 0 avec une boucle while.

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

Java, 136 octets

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

Le nombre de millisecondes écoulés depuis la dernière heure est le résultat de la System.currentTimeMillis()modification de 3 600 000.

Le programme monolithique équivalent a une longueur de 159 octets:

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 octets

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

Explication

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