Parfois, je me retrouve à vouloir un hot-dog (pas nous tous) et donc j'en fais un. Maintenant, pour faire un hot-dog, c'est très simple.

1) Mettez les hot-dogs dans de l'eau bouillante

2) Attendez un certain temps (détaillé ci-dessous)

3) Mangez le hot-dog une fois le temps écoulé.

Vous avez peut-être remarqué que j'ai dit

certain temps (détaillé ci-dessous)

et je vais donc détailler.

De nombreuses marques différentes ont de nombreuses recommandations différentes concernant la durée de cuisson des hot-dogs, mais j'ai trouvé préférable de les faire cuire pendant exactement 4 minutes et 27 secondes (ne demandez pas). J'ai essayé de nombreuses minuteries différentes, mais j'ai découvert qu'un programme qui sort continuellement est le meilleur moyen d'attirer mon attention.

TA TÂCHE

Vous devez créer un programme qui produira le message Not ready yetpendant exactement 4 minutes et 27 secondes. Une fois ce temps écoulé, vous devez sortir Eat your hot dogjusqu'à la fin des temps. Veuillez ne prendre aucune entrée.

COMMENT GAGNER

Vous devez écrire le code le plus court en octets pour gagner car il s'agit d'un code-golf

Scratch, 93 78 octets

Code:

when gf clicked
say[Not ready yet
wait until<(timer)>[267
say[Eat your hot dog

Généré par https://scratchblocks.github.io/ , qui semble être la norme pour la notation Scratch.

Assez explicite. Lorsque le programme démarre, dites "Pas encore prêt" jusqu'à ce que la minuterie (qui est comptée en secondes) soit supérieure à 267. Commence alors une boucle infinie où il est ditEat your hot dog .

Il s'agit d' une sortie continue, car le saybloc s'exécute indéfiniment, sauf si vous say []ou sayquelque chose d'autre.

Bash + coreutils, 50

timeout 267 yes Not ready yet
yes Eat your hot dog

Explication

Je pense assez explicite, mais juste au cas où:

• Le yescoreutil émet en continu de façon répétée tous les paramètres qui lui sont transmis sur la ligne de commande
• Le timeoutcoreutil prend un paramètre de délai d'attente numérique suivi d'une commande. La commande est exécutée, puis supprimée après le délai spécifié.

Opération FlashpointLangage de script , 67 octets

#l
s="Not ready yet"
?_time>267:s="Eat your hot dog"
hint s
goto"l"

Enregistrer sous "hotdog.sqs" (ou autre) dans le dossier de mission et appelez avec [] exec "hotdog.sqs".

Explication:

#l                                  // Label for the "goto"
s="Not ready yet"
?_time>267:s="Eat your hot dog"     // "?:" means "if () then" in a script.
                                    // "_time" is a local variable that is automatically
                                    // created and updated in every script. Its value
                                    // is the time in seconds since the script started.

hint s                              // Outputs the text in a text box.

~.1                                 // Sleeps for a tenth of a second.
                                    // The script seems to work without sleeping too,
                                    // so I didn't include this in the golfed version.
                                    // Looping in a script without sleeping is always
                                    // a bad idea, though. It sometimes crashes the game.

goto"l"                             // Go back to the beginning of the loop.
                                    // This is the only way to create a loop if you don't 
                                    // want to halt the game (and the time calculation)
                                    // until the loop finishes.

J'ai essayé de nombreuses minuteries différentes, mais j'ai découvert qu'un programme qui sort continuellement est le meilleur moyen d'attirer mon attention.

Cette solution devrait être particulièrement efficace pour attirer votre attention, car la hintcommande joue un effet sonore accrocheur à chaque appel, ce qui semble très ennuyeux lorsque les sons simultanés sont coupés en boucle serrée.

JavaScript ES6, 76 octets

$=>setInterval("console.log(--_>0?`Not ready yet`:`Eat your hot dog`)",_=517)

Explication

Cela imprime quelque chose sur la console toutes les 517 millisecondes. Au début, il imprime 'Not ready yet'et diminue le compteur. Après 517 itérations ( = 517 * 517 = 267289 ms), l'impression démarre 'Eat your hot dog'.

Tester

f=
  $=>setInterval("console.log(--_>0?`Not ready yet`:`Eat your hot dog`)",_=517);
(setInterval("console.log('DONE NOW')",267000)&&f())();

Powershell, 85 71 59 octets

1..276|%{Sleep 1;'Not ready yet'};for(){'Eat your hot dog'}

Il y a probablement une bien meilleure façon, donc critique bien accueillie! Ceci est ma première tentative de golf :)

EDIT vers le bas tout un 14 octets grâce à AdmBorkBork! Et certainement une technique à retenir!

EDIT 2 Encore 12 octets disparus grâce à Matt. Ne pas appeler écrire deux fois a également supprimé 2 espaces, très utile!

Variante du langage de script de GameMaker utilisée dans le mod Nuclear Throne Together, 68 octets

t=0while 1{trace(t++<8010?"Not ready yet":"Eat your hot dog")wait 1}

Explication

• L'analyseur de GML pardonne délicieusement. Les points-virgules et les parenthèses sont facultatifs, et le compilateur ne se soucie pas du tout de votre espacement en dehors des règles de base ( 0whileanalyse comme 0, whileet est donc correct)
• Les variables fuient dans le contexte d'exécution sauf si elles sont déclarées via var(comme avec JS).

• La variante GML utilisée dans NTT introduit un waitopérateur, qui pousse le "micro-thread" d'exécution à une liste pour le nombre spécifié de trames, reprenant ensuite. Coroutines, en gros.

  Le jeu est cadencé à 30fps, donc 4m27s == 267s == 8010 images.

• trace () renvoie la chaîne donnée dans le chat.

Si vous avez installé le jeu vidéo + le mod, vous pouvez l'enregistrer comme certains test.mod.gml, et le faire /loadmod testpour l'exécuter, inondant le chat de "rapports d'état":

Python 2, 92 octets

from time import*
t=time()
while 1:print"Not ready yet"if time()-t<267else"Eat your hot dog"

Essayez-le en ligne!

TI-Basic, 75 octets

For(A,1,267
Disp "Not ready yet
Wait 1
End
While 1
Disp "Eat your hot dog
End

Explication

For(A,1,267             # 9 bytes, for 267 times...
Disp "Not ready yet     # 26 bytes, display message
Wait 1                  # 3 bytes, and wait one second
End                     # 2 bytes, ...end
While 1                 # 3 bytes, after that, continuously...
Disp "Eat your hot dog  # 31 bytes, output second message
End                     # 1 byte, ...end

Lot, 99 octets

@for /l %%t in (1,1,267)do @echo Not ready yet&timeout/t>nul 1
:l
@echo Eat your hot dog
@goto l

Le lot n'a pas d'arithmétique de date, donc comme un simple délai d'attente de 267 secondes n'est pas autorisé, le mieux que je puisse faire est de 267 délais d'attente d'une seconde.

C # 144 octets

()=>{for(int i=0;;){var s="\nEat your hot dog";if(i<267e3){i++;s="\nNot ready yet";}System.Console.Write(s);System.Threading.Thread.Sleep(1);}};

Programme complet non golfé:

class P
{
    static void Main()
    {
        System.Action a = () => 
            {
                for (int i = 0; ;)
                {
                    var s = "\nEat your hot dog";
                    if (i < 267e3)
                    {
                        i++;
                        s = "\nNot ready yet";
                    }
                    System.Console.Write(s);
                    System.Threading.Thread.Sleep(1);
                }
            };

        a();
    }
}

Malheureusement, je n'ai pas pu utiliser ?:-operator car je n'ai pas trouvé de moyen d'arrêter l'incrémentation isans if.

C #, 174 172 147 octets

Vous avez économisé 25 octets en "empruntant" quelques idées à la réponse C # de raznagul et en les fusionnant avec la somme des premiers n nombres.

Enregistrement de 2 octets en utilisant la somme des n premiers nombres pour une perte de précision de 185 millisecondes.

class P{static void Main(){for(int i=1;;){System.Console.WriteLine(i++<731?"Not ready yet":"Eat your hot dog");System.Threading.Thread.Sleep(i);}}}

Programme non golfé:

class P
{
    static void Main()
    {
        for (int i=1;;)
        {
            System.Console.WriteLine( i++ < 731 ? "Not ready yet" : "Eat your hot dog");
            System.Threading.Thread.Sleep(i);
        }
    }
}

Explication:

Étant donné que le temps total d'attente est codé en dur à 267 secondes, on peut considérer ce nombre comme une somme télescopique des n premiers nombres naturels n * (n + 1) / 2, qui doivent être égaux à 267000 millisecondes.

C'est équivalent à n^2 + n - 534000 = 0.

En résolvant cette équation du second degré, n1 = 730.2532073142067, n2 = -n1. Bien sûr, seule la solution positive est acceptée et peut être estimée à 730 .

Le temps total peut être calculé comme 730 * (730 + 1) / 2 = 266815 milliseconds. L'imprécision est de 185 millisecondes , imperceptible pour l'homme. Le code va maintenant faire en sorte que le thread principal (et uniquement) dort pendant 1 milliseconde, 2 millisecondes et ainsi de suite jusqu'à 730, de sorte que la période de sommeil totale est d'environ 267 secondes.

Mise à jour:

La logique du programme peut être encore simplifiée - en gros, il doit afficher en continu un message et attendre un temps spécifié jusqu'au passage au deuxième message.

Le message peut être modifié en utilisant un opérateur ternaire pour vérifier le temps écoulé (~ 267 secondes).

L'aspect temporel est contrôlé en utilisant un compteur croissant et en interrompant le thread d'exécution.

Cependant, étant donné que la variable compteur continue d'augmenter indéfiniment sans aucune condition pour vérifier sa valeur, on peut s'attendre à un débordement d'entier à un moment donné, lorsque le message revient à Not ready yet.

Une condition peut être ajoutée pour détecter et atténuer le problème en attribuant une valeur positive supérieure à 730 lorsque le débordement se produit - comme i=i<1?731:ià l'intérieur de la forboucle. Malheureusement, cela coûte 11 octets supplémentaires:

class P{static void Main(){for(int i=1;;i=i<1?731:i){System.Console.Write(i++<731?"\nNot ready yet":"\nEat your hot dog");System.Threading.Thread.Sleep(i);}}}

La clé ici est d'utiliser la valeur du compteur en millisecondes pour retarder considérablement le moment du débordement.

Le temps avant le débordement peut être calculé selon la sum(1..n)formule, où n = la valeur entière signée 32 bits maximale en C # (et le framework .NET) ou 2 ^ 31 - 1 = 2147483647:

2 147 483 647 * 2 147 483 648 / 2 = 2,305843008 x 10^18 milliseconds = 2,305843008 x 10^15 seconds = 26 687 997 779 days = ~73 067 755 years

Après 73 millions d'années , peu importe si un problème survient dans le système - le hot-dog, le PO affamé et peut-être la race humaine elle-même ont disparu depuis longtemps.

Version précédente (172 octets):

namespace System{class P{static void Main(){for(int i=1;i<731;){Console.Write("\nNot ready yet");Threading.Thread.Sleep(i++);}for(;;)Console.Write("\nEat your hot dog");}}}

Programme non golfé:

namespace System
{
    class P
    {
        static void Main()
        {
            for (int i = 1; i < 731; )
            {
                Console.Write("\nNot ready yet");
                Threading.Thread.Sleep(i++);
            }
            for ( ; ; )
                Console.Write("\nEat your hot dog");
        }
    }
}

Version précédente (174 octets):

namespace System{class P{static void Main(){for(int i=0;i++<267e3;){Console.Write("\nNot ready yet");Threading.Thread.Sleep(1);}for(;;)Console.Write("\nEat your hot dog");}}}

Programme non golfé:

namespace System
{
    class P
    {
        static void Main()
        {
            for (int i=0; i++ < 267e3; )
            {
                Console.Write("\nNot ready yet");
                Threading.Thread.Sleep(1);
            }
            for ( ; ; )
                Console.Write("\nEat your hot dog");
        }
    }
}

Alternativement, le programme peut s'afficher Not ready yetune seule fois, attendre la fin de l'heure spécifiée, puis sortir Eat your hot dogen écrasant le message précédent tout en étant plus court de quelques octets:

C #, 145 octets

namespace System{class P{static void Main(){Console.Write("Not ready yet");Threading.Thread.Sleep(267000);Console.Write("\rEat your hot dog");}}}

Programme non golfé:

namespace System
{
    class P
    {
        static void Main()
        {
            Console.Write("Not ready yet");
            Threading.Thread.Sleep(267000);
            Console.Write("\rEat your hot dog");
        }
    }
}

Rubis, 80 71 67 octets

Edit: Merci à manatwork pour avoir rasé 13 octets entiers

267.times{puts"Not ready yet"
sleep 1}
loop{puts"Eat your hot dog"}

05AB1E, 43 29 28 octets (Merci à Adnan)

267F…€–Žä‡«ªw,}[“Eat€ž…ß‹·“,

Ne fonctionne pas en ligne, car il arrive à expiration. Hors ligne, cela fonctionnera.

267F: Boucle 267 fois

…€–Žä‡«ª: Première chaîne avec dictionnaire

w,: Attendez une seconde et imprimez

}[: Fin de la boucle if et démarrage de la boucle infinie

“Eat€ž…ß‹·“: Deuxième chaîne avec dictionnaire

,: Impression

Python, 115 bytes

My first time trying something like this. I am also a beginner so here it goes in Python 3 for 115 bytes:

import time
for i in range(267):
    time.sleep(1)
    print("Not ready yet")
while 1:
    print("Eat your hotdog")

JavaScript Blocks Editor for micro:bit, 90 Bytes

The code:

basic.showString("Not ready yet")
basic.pause(254000)
basic.showString("Eat your hot dog")

You can try it here.

Got inspired by the Scratch answer to solve the task with my micro:bit. The only Problem is that the pause-block starts after outputting the first string so i needed to reduce the pause by 13s.

Note: The old Microsoft Block Editor for micro:bit is shorter to create but produces more code so is in fact longer.

On the basis that the OP wants hotdogs continuously, until the end of time - which I understand from the phrase:

After this time has elasped, you should output Eat your hot dog until the end of time.

This is my answer:

C++, 187 188 224 167 bytes

Whitespace removed (167 bytes):

#include<stdio.h>
#include<windows.h>
int main(){for(;;){for(int x=0;x<267;x++){Sleep(1000);printf("Not ready yet");}Sleep(1000);printf("Eat your hot dog");}return 0;}

readable form (224 bytes):

#include <stdio.h>
#include <windows.h>

int main() {
  for( ; ; ){ 
    for(int x=0; x < 267; x++){
      Sleep(1000);
      printf("Not ready yet"); 
    }
    Sleep(1000);
    printf("Eat your hot dog");
  }
  return 0;
}

If, on the other hand, OP enjoys his hot dogs in moderation, then this is my answer:

Whitespace removed (158 bytes):

#include<stdio.h>
#include<windows.h>
int main(){for(int x=0;x<267;x++){Sleep(1000);printf("Not ready yet");}Sleep(1000);printf("Eat your hot dog");return 0;}

readable form (198 bytes):

#include <stdio.h>
#include <windows.h>

int main() {
  for(int x=0; x < 267; x++){
    Sleep(1000);
    printf("Not ready yet"); 
  }
  Sleep(1000);
  printf("Eat your hot dog");
  return 0;
}

Excel VBA, 82 Bytes

Anonymous VBE immediates window function that takes no input and outputs whether or not you should eat your hot dog to cell [A1].

d=Now+#0:4:27#:Do:[A1]=IIf(Now<d,"Not ready yet","Eat your hot dog"):DoEvents:Loop

Excel VBA 122 94 bytes

Sub p()
e=Now+#0:4:27#
Do
[a1]=IIf(Now<e,"Not ready yet","Eat your hot dog")
Loop
End Sub

Thanks Taylor Scott

Javascript, 83 Bytes

d=Date.now()
while(1)alert(Date.now()-d<267000?"Not ready yet":"Eat your hot dog"))

Alertz for everyone!

PERL, 76 bytes

$|++;
for(1..247){print'Not ready yet';sleep 1};print "Eat your hot dog";for(;;){}

PHP 88 bytes

<?$t=0;do{$t++;echo "Not ready yet";sleep(1);} while ($t<267);echo "Eat your hotdog";?>

REXX, 82 bytes

do forever
if time(e)<267 then say 'Not ready yet'
else say 'Eat your hot dog'
end

Java 7, 152 bytes

void c(){for(long s=System.nanoTime(),e=s+(long)267e9;s<e;s=System.nanoTime())System.out.println("Not ready yet");System.out.print("Eat your hot dog");}

Explanation:

void c(){                                 // Method
  for(                                    //  Loop
      long s=System.nanoTime(),           //    Current time in nanoseconds as start
      e=s+(long)267e9;                    //    End time (267 seconds later)
      s<e;                                //    Loop as long as we haven't reached the end time
      s=System.nanoTime())                //    After every iteration get the new current time in nanoseconds
    System.out.println("Not ready yet");  //   Print "Not ready yet" as long as we loop
                                          //  End of loop (implicit / single-line body)
  System.out.print("Eat your hot dog");   //  Print "Eat your hot dog"
}                                         // End of method

PHP, 68 bytes

for($t=268;$t--;sleep(1))echo$t?"Not ready yet←":"Eat your hot dog";

continuous output; ← is ASCII 10 = LF. Run with -r.

one-time output, 50 bytes

Not ready yet<?sleep(267);echo"←Eat your hot dog";

where ← is ASCII 13 = CR. Save to file or use piping to run.

RBX.Lua, 69 bytes

for i=1,267 do print"Not ready yet"Wait(1)end;print"Eat your hot dog"

RBX.Lua is the language used on ROBLOX.com. It is a modified version of Lua 5.1 that features a built-in 'Wait' function. The above code is pretty self-explanatory, below is a more readable version:

for i = 1, 267 do
    print("Not ready yet");
    Wait(1);
end

print("Eat your hot dog");

The code outputs "Not ready yet" continuously into STDOUT, for 267 seconds (4 minutes 27 seconds) before outputting "Eat your hot dog".

C - 130 bytes

It could be slightly shorter (128bytes), but I thought it neater to overwrite "Not ready yet"

#include<stdio.h>
#include<unistd.h>
int main(){printf("Not ready yet");fflush(stdout);sleep(267);printf("\rEat your hot dog\n");}

VBA,126 Bytes

sub hd()
Debug.print "Not ready Yet"
application.wait(now+timevalue(00:04:27))
Debug.print "Eat your hot dog"
end sub

Python 2.7, 90 88 bytes

import time;exec"print'Not ready yet';time.sleep(1);"*267;while 1:print"Eat your hotdog"