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