A veces me encuentro con ganas de un hot dog (no todos) y por eso hago uno. Ahora hacer un hot dog es muy simple.

1) Pon los hot dogs en agua hirviendo

2) Espere una cierta cantidad de tiempo (detallado a continuación)

3) Come el hot dog una vez que haya transcurrido el tiempo.

Puede que hayas notado que dije

cierto tiempo (detallado a continuación)

y así detallaré

Muchas marcas diferentes tienen muchas recomendaciones diferentes sobre cuánto tiempo debemos cocinar los hot dogs, pero he descubierto que es mejor cocinarlos exactamente durante 4 minutos y 27 segundos (no pregunte). He probado muchos temporizadores diferentes, pero he descubierto que un programa que genera continuamente es la mejor manera de llamar mi atención.

TU TAREA

Debe crear un programa que muestre el mensaje Not ready yetdurante exactamente 4 minutos y 27 segundos. Después de que haya transcurrido este tiempo, debe salir Eat your hot doghasta el final de los tiempos. Por favor no tome ninguna entrada.

CÓMO GANAR

Debes escribir el código más corto en bytes para ganar porque este es un código de golf

Scratch, 93 78 bytes

Código:

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

Generado por https://scratchblocks.github.io/ , que parece ser el estándar para la puntuación Scratch.

Bastante autoexplicativo. Cuando se inicie el programa, diga "Todavía no está listo" hasta que el temporizador (que se cuenta en segundos) sea mayor que 267. Luego comienza un ciclo infinito donde dice Eat your hot dog.

Que es la salida continua, debido a que el saybloque se ejecuta siempre a menos que say []o sayalgo más.

Bash + coreutils, 50

timeout 267 yes Not ready yet
yes Eat your hot dog

Explicación

Bastante autoexplicativo, creo, pero por las dudas:

• El yescoreutil continuamente emite repetidamente los parámetros que recibe en la línea de comandos
• El timeoutcoreutil toma un parámetro de tiempo de espera numérico seguido de un comando. El comando se ejecuta y luego se elimina después del tiempo de espera especificado.

Lenguaje de script Operation Flashpoint , 67 bytes

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

Guardar como "hotdog.sqs"(o lo que sea) en la carpeta de la misión y llamar con [] exec "hotdog.sqs".

Explicación:

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

He probado muchos temporizadores diferentes, pero he descubierto que un programa que genera continuamente es la mejor manera de llamar mi atención.

Esta solución debería ser especialmente buena para atraer su atención, ya que el hintcomando reproduce un efecto de sonido aferrado cada vez que se llama, lo que suena muy molesto cuando los sonidos simultáneos se recortan en un bucle cerrado.

JavaScript ES6, 76 bytes

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

Explicación

Esto imprime algo en la consola cada 517 milisegundos. Al principio, imprime 'Not ready yet'y disminuye el contador. Después de 517 iteraciones ( = 517 * 517 = 267289 ms), comienza a imprimir'Eat your hot dog' .

Prueba

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

Powershell, 85 71 59 bytes

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

Probablemente haya una forma mucho mejor, ¡así que las críticas son bienvenidas! Este es mi primer intento de golf :)

EDITAR Un total de 14 bytes gracias a AdmBorkBork! ¡Y definitivamente una técnica para recordar!

EDIT 2 Otros 12 bytes desaparecidos gracias a Matt. No llamar a escribir dos veces también eliminó 2 espacios, ¡muy útil!

Variante del lenguaje de scripting de GameMaker utilizada en el mod Nuclear Throne Together, 68 bytes

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

Explicación

• El analizador de GML es deliciosamente indulgente. Los punto y coma y los paréntesis son opcionales, y el compilador no está preocupado en absoluto por su espacio fuera de las reglas básicas ( 0whileanaliza como y 0, por lo whiletanto, está bien)
• Las variables se filtran en el contexto de ejecución a menos que se declare a través de var(igual que con JS).

• La variante GML utilizada en NTT introduce un waitoperador, que empuja el "microhilo" en ejecución a una lista para el número especificado de tramas, reanudando después. Corutinas, básicamente.

  El juego tiene una velocidad de 30 fps, por lo que 4m27s == 267s == 8010 cuadros.

• trace () genera la cadena dada en el chat.

Si tienes instalado el videojuego + mod, puedes guardarlo como algo test.mod.gmly /loadmod testejecutarlo, inundando el chat con "informes de estado":

Python 2, 92 bytes

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

Pruébalo en línea!

TI-Basic, 75 bytes

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

Explicación

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

Lote, 99 bytes

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

Batch no tiene aritmética de fechas, por lo que no se permite un tiempo de espera simple de 267 segundos, lo mejor que puedo hacer es un tiempo de espera de 267 segundos.

C # 144 bytes

()=>{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);}};

Programa completo sin 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();
    }
}

Desafortunadamente no pude usar el ?:operador, ya que no he encontrado una manera de dejar de incrementar isin el if.

C #, 174 172 147 bytes

¡Ahorré 25 bytes al "tomar prestadas" algunas ideas de la respuesta C # de raznagul y fusionarlas con la suma del primer truco de n números!

Ahorró 2 bytes usando la suma del primer truco de n números para una pérdida de precisión de 185 milisegundos.

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

Programa sin 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);
        }
    }
}

Explicación:

Dado que el tiempo total de espera está codificado en 267 segundos, se puede considerar este número como una suma telescópica de los primeros n números naturales n * (n + 1) / 2, que debe ser igual a 267000 milisegundos.

Esto es equivalente a n^2 + n - 534000 = 0.

Al resolver esta ecuación de segundo orden, n1 = 730.2532073142067, n2 = -n1. Por supuesto, solo se acepta la solución positiva y se puede aproximar a 730 .

El tiempo total se puede calcular como 730 * (730 + 1) / 2 = 266815 milliseconds. La imprecisión es de 185 milisegundos , imperceptible para los humanos. El código ahora hará que el subproceso principal (y solo) duerma durante 1 milisegundo, 2 milisegundos y así sucesivamente hasta 730, por lo que el período de suspensión total es de ~ 267 segundos.

Actualizar:

La lógica del programa se puede simplificar aún más: básicamente, debe mostrar continuamente un mensaje y esperar un tiempo específico hasta cambiar al segundo mensaje.

El mensaje se puede cambiar utilizando un operador ternario para verificar el paso del tiempo especificado (~ 267 segundos).

El aspecto del tiempo se controla utilizando un contador creciente y pausando el hilo de ejecución.

Sin embargo, dado que la variable de contador continúa aumentando indefinidamente sin ninguna condición para verificar su valor, uno puede esperar un desbordamiento de enteros en algún momento, cuando el mensaje vuelve a Not ready yet.

Se puede agregar una condición para detectar y mitigar el problema asignando un valor positivo mayor que 730 cuando se produce el desbordamiento, como i=i<1?731:identro del forbucle. Lamentablemente, tiene un costo de 11 bytes adicionales:

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 clave aquí es usar el valor del contador en milisegundos para retrasar en gran medida el momento de desbordamiento.

El tiempo hasta el desbordamiento se puede calcular de acuerdo con la sum(1..n)fórmula, donde n = el valor entero máximo de 32 bits con signo en C # (y el marco .NET) o 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

Después de 73 millones de años , podría no importar si aparece una falla en el sistema: el perro caliente, el OP hambriento y tal vez la raza humana en sí se han ido.

Versión anterior (172 bytes):

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

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

Versión anterior (174 bytes):

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

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

Alternativamente, el programa puede mostrarse Not ready yetsolo una vez, esperar hasta que termine el tiempo especificado y luego emitir Eat your hot dogsobrescribiendo el mensaje anterior mientras se acortan bastantes bytes:

C #, 145 bytes

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

Programa sin golf:

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

Rubí, 80 71 67 Bytes

Editar: Gracias a manatwork por recortar 13 bytes completos

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

05AB1E, 43 29 28 bytes (Gracias a Adnan)

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

No funciona en línea, ya que se agota el tiempo de espera. Fuera de línea funcionará.

267F: Loop 267 veces

…€–Žä‡«ª: Primera cadena con diccionario

w,: Espere un segundo e imprima

}[: Finalizar si bucle e iniciar bucle infinito

“Eat€ž…ß‹·“: Segunda cadena con diccionario

,: Impresión

Python, 115 bytes

La primera vez que intento algo como esto. También soy un principiante, así que aquí va en Python 3 para 115 bytes:

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

Editor de bloques de JavaScript para micro: bit, 90 bytes

El código:

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

Puedes probarlo aquí.

Me inspiré en la respuesta de Scratch para resolver la tarea con mi micro: bit. El único problema es que el bloque de pausa comienza después de la salida de la primera cadena, por lo que necesitaba reducir la pausa en 13 segundos.

Nota: El antiguo Microsoft Block Editor para micro: bit es más corto de crear pero produce más código, por lo que en realidad es más largo.

Sobre la base de que el OP quiere perritos calientes continuamente, hasta el final de los tiempos, lo que entiendo por la frase:

Después de que haya transcurrido este tiempo, debe salir Coma su hot dog hasta el final de los tiempos.

Esta es mi respuesta:

C ++, 187 188 224 167 bytes

Espacio en blanco eliminado (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;}

forma legible (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;
}

Si, por otro lado, OP disfruta sus perros calientes con moderación, entonces esta es mi respuesta:

Espacio en blanco eliminado (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;}

forma legible (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

El VBE anónimo evoca la función de ventana que no toma entrada y da salida si debe o no comer su hot dog a la celda [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

Gracias Taylor Scott

Javascript, 83 bytes

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

Alertz para todos!

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"