Legen… attendez…


68

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 s'appliquent.


1
Je ne comprends pas en quoi la troisième règle supplémentaire diffère de la règle de base "attendre jusqu'à la prochaine heure complète"
Fatalize

2
@Fatalize C'est juste une précision qu'il faut attendre que l'heure change, et non pas que les minutes et les secondes soient toutes les deux à 00 .
Dennis

25
Joyeux insigne légendaire, @Dennis!
Kritixi Lithos

36
@ ΡιτικσιΛίθος Merci! (Merci mon dieu pour la complétion.)
Dennis

2
"À l'heure" serait une manière plus standard (et je crois beaucoup plus claire) de décrire ce que vous appelez "la prochaine heure complète" (au moins en anglais américain).
jpmc26

Réponses:


12

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


La chaîne peut être compressée de 1 octet en utilisant pack-str. Hexdump:0000000: 2e22 2077 0c10 89e2 ab1b ad68 0f8c d660 ." w.......h...` 0000010: d9e1 a968 82b4 5e22 0a ...h..^".
isaacg

@isaacg Oups, j'avais vérifié cela, mais je devais avoir raté le compte. Je pensais qu'il ne comprenait qu'un octet afin que le supplément .le rende de la même longueur. Silly off-by-one erreurs: P
FryAmTheEggman

Juste essayer de comprendre ce que cela pourrait faire (sans aucune expérience avec pyth) m'a fait rire. Je vois dary, mais non legen! Et pyth affirme être plus facile à comprendre pour ceux qui sont habitués à la programmation conventionnelle ...
Cyoce

@Cyoce Si vous regardez dans l'historique des modifications, vous trouverez une version plus facile à lire. Le ."indique que certaines opérations doivent être effectuées sur la chaîne pour obtenir la chaîne réelle. C'est juste un truc de compression pour jouer au golf. Si vous décidez d'essayer d'apprendre Pyth, bonne chance! N'oubliez pas qu'il y a aussi une salle de discussion pour cela :)
FryAmTheEggman

26

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...
`


11
Est-ce que 36e5travailler à la place de 3.6e6?
ETHproductions

8
@ETHproductions You beauty!
George Reith

3
@ETHproductions C'est une mauvaise notation scientifique. Je ne savais pas que cela fonctionnait sur Javascript. Appris quelque chose aujourd'hui !!!
Ismael Miguel

2
@Optimizer Ah ne savait pas ce que je setTimeoutferais eval. Vrai ... J'essayais à l'origine d'utiliser console.logmais cela ne fonctionne même pas lorsqu'il est stocké dans une variable en raison du contexte. Toi aussi tu es belle!
George Reith

1
Vous pouvez utiliser setTimeoutcorrectement et même économiser un octet:alert`Legen…`;setTimeout(alert,36e5-new Date%36e5,"dary!")
Bergi

9

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.


9

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


Alors que se passe-t-il si vous l'exécutez à 03:03:00?
Blacklight Shining

@BlacklightShining Il aura le numéro 3 à l'avant et attendra qu'il soit quatre. Il est seulement conscient du nombre avant les deux points.
Addison Crump

Oh, j'ai raté ça. D'accord. Curieusement, je viens juste "1"de number 1 in time string of(current date)
Blacklight Shining

@BlacklightShining Vous utilisez probablement une ancienne version - dans El Capitan, cela équivaut à first number in time string of (current date).
Addison Crump

Je suis sur Yosemite, oui. first numberme donne aussi juste le premier chiffre du temps ( "0"maintenant, à 04:38).
Blacklight Shining

8

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.

7

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)


Bien, mais {};et echo?>le réduiraient un peu. Bien que je préfèreLegen... wait for it...↵<?php while(+date('is'));?>dary!
manatwork

1
Quelques astuces: vous pouvez utiliser des balises ouvertes courtes ( <?plutôt que <?php). Utiliser a for(;;)la même longueur que while(), mais vous permet de déplacer l’ $haffectation sans avoir besoin d’un point-virgule ( for($h=date(h);...). Ce {}n'était pas nécessaire, mais le ;précédent non plus ?>. Vous pouvez avoir un problème avec $hest 12, cependant ( date(h)ne sera jamais 13).
Primo

Merci à vous deux, mis à jour ma réponse en conséquence. Je ne me sens pas trop bien, je suppose que je ne devrais pas faire de travail important aujourd'hui, car cela montre clairement haha
Martijn

2
Changer date(G)!=$h+1en date(G)==$h. Plus court, et résout le problème de l'heure;) En outre, supprimez le point-virgule avant ?>.
Primo

1
@manatwork, l'attente échouera si le code est exécuté HH:00:00, c'est-à-dire dans la première seconde d'une heure complète.
Primo


5

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.


2
87 octets:(a=alert)`Legen... wait for it...`,l=new Date,z=(b=l.getHours)();for(;z==b(););a`dary!`
Downgoat

@Downgoat Merci! (
J'essaye de jouer

1
Encore plus court (85 octets):(a=alert)`Legen... wait for it...`,z=(b=new Date().getHours)();for(;z==b(););a`dary!`
Downgoat

2
@Downgoat Un octet plus court:for((a=alert)`Legen... wait for it...`,z=(b=new Date().getHours)();z==b(););a`dary!`
Ismael Miguel

4

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.


Dans votre premier vous pourriez économiser 3 octets en cochant la place nowdans la boucle while: a=@()disp('Legen... wait for it...');while floor(mod(now*86400,3600))end;disp('dary!'). Vous pouvez également économiser 5 octets supplémentaires en supprimant le a=@()bit, car le code constitue un programme complet. Le code joint ne nécessite pas non plus la boîte à outils FTS.
Tom Carpenter

Comment avez-vous entendu parler de la hourfonction Boîte à outils financière ? :-)
Luis Mendo

Maintenant, je vois ce que vous vouliez dire par votre commentaire sur le besoin de variables intermédiaires pour l'indexation ...
Luis Mendo

4

Mathematica, 85 84 81 octets

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

Je pense que vous pouvez économiser 2 octets en faisant "dary!" la sortie d'expression.
CalculatriceFeline

@CatsAreFluffy Ce ne serait alors qu'un extrait et non un programme complet.
LegionMammal978

Alors? La sortie d'expression n'est-elle pas acceptable dans Mathematica ou manque-t-il quelque chose?
CalculatriceFeline

@CatsAreFluffy Les scripts Mathematica existent, donc tout programme complet donné doit être exécuté dans un seul.
LegionMammal978

4

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!");}

3
Bienvenue chez PPCG!
Erik the Outgolfer

155 octets (ne vous inquiétez pas de l'exécuter sur TIO, cela ne se terminera pas, il expirera après une minute)
MD XF

3

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 5 .


Pouvez-vous ajouter une explication? c:
Addison Crump

@VoteToClose Done
SuperJedi224

3

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.


3

R - 97 octets

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

3

Python 3 - 92 89 octets

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

3

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


1
Un octet supplémentaire peut être sauvegardé en supprimant la fin ;à la fin du programme. Semble bien fonctionner sans cela. :) Bonne réponse cependant, donc +1 de moi (maintenant vous pouvez commenter).
Kevin Cruijssen le

merci charges @KevinCruijssen
Henry T

2

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.


2

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.


Ne pas compter -Esemble être banal ici, vous pouvez donc économiser 5 octets en utilisant say.
Dennis

De la description du défi: "Vous pouvez écrire un programme ou une fonction." Le code exécuté à partir de la ligne de commande n'est ni l'un ni l'autre.
Primo

Je vois ce que tu veux dire. Cependant, la restriction aux programmes ou aux fonctions s’applique par défaut à tous les défis. Cependant, nous autorisons toujours les perl -Esoumissions et les langues n’ayant que des interprètes en ligne.
Dennis

Je ne suis pas d'accord que cela -Edevrait être autorisé par défaut. Dans la plupart des cas, l’amélioration est triviale et sans intérêt, de toute façon.
Primo

2

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


Pouvez-vous poster un hexdump de cela?
un spaghetto

@quartata Fait. Je crois que c'est correct.
ETHproductions

2

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.


1
Vous devriez pouvoir mettre le mot «dary» juste après les accolades, ou du moins dans le PSv5.
Veskah

1

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.


Peut économiser 2 en supprimant les espaces entre les instructions d'impression et les chaînes suivantes. :)
Henry T

1

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

1

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.


1

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 .


1

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.


1

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

1
Utilisez “ÇỴġƒḃhlḂṀ⁷*Ḣ¡w*Jḷv»au lieu de “¤ßƇṪOƭ!½ȯƤxEẹ<Ȯ¹z7⁷». Leg(de Legen) est aussi un mot :) En outre, cette réponse est invalide, car elle dépend des minutes et des secondes 00. Vous devriez faire quelque chose avec la 4ŒTplace, car il existe une règle stipulant que,In the event that the program is started in the first second of a full hour, it should it wait for the next full hour.
Erik the Outgolfer

Cool, "Leg" enregistre un octet, merci. Cependant, le lien fonctionne quand 00:00il est appelé car il ne teste pas cette condition. Il calcule le nombre de secondes avant la suivante "00:00", puis attend. Donc, il convertira "00:00"pour [0,0]soustraire de 59pour obtenir [59,59]que convertir de base soixante pour obtenir 3599et ensuite en ajouter un pour obtenir 3600(testez-le en utilisant la version de test avec "00:00"à la place de "59:57")
Jonathan Allan

1
Oh. Il semble que je ne puisse pas lire un long code Jelly et que je ne connaisse pas les utilisations et les attentes de chacun :) Bien que, dans l'explication, je pense que cela 60*(59-m)+(59-s)doit être à la 60*(59-m)+(59-s)+1place, la deuxième fois, cela apparaît?
Erik the Outgolfer

Pas de problème, le commentaire n'est pas le plus clair que j'ai jamais écrit.
Jonathan Allan

Eh bien, si vous ne pouvez pas supporter les tracas, je peux les éditer. De plus, je vous recommanderais de faire x / y en tant que left / right, et dites simplement sleep x seconds then return y- parce que <dyad>@peut être défini comme une autre dyade avec des arguments échangés.
Erik the Outgolfer

1

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)

"Presque"? On dirait que tu l'as fait.
Patrick Roberts

@PatrickRoberts, il existe une autre solution pyth de 36 octets, qui ne parvient pas à s'y rendre, même avec des chaînes compressées et d'autres astuces.
maxb

Oh celui-là. C'est faux, regardez le commentaire.
Patrick Roberts le

@ PatrickRoberts, je pourrais échouer aussi avec le critère "doit attendre une heure si elle est exécutée à 00:00", mais je pourrais le changer pour vérifier Unixtime en millisecondes divisible par 3600000 avec le même nombre d'octets. milliseconde, ça devrait toujours marcher
maxb

0

Pyth - 36 octets

Attend que les minutes soient 0 avec une boucle while.

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

11
Vous devez attendre que les minutes et les secondes soient 0 et attendre également une heure si le programme est exécuté à:00:00
lirtosiast

0

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!");}}

0

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)
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.