Manchmal will ich einen Hot Dog (nicht wir alle) und mache mir einen. Nun, um einen Hot Dog zu machen, ist es sehr einfach.

1) Die Hot Dogs in kochendes Wasser legen

2) Warten Sie eine gewisse Zeit (siehe unten)

3) Essen Sie den Hot Dog, sobald die Zeit abgelaufen ist.

Sie haben vielleicht bemerkt, dass ich sagte

bestimmte Zeit (unten detailliert)

und so werde ich ins Detail gehen.

Viele verschiedene Marken haben viele verschiedene Empfehlungen, wie lange wir die Hot Dogs kochen sollen, aber ich habe festgestellt, dass es am besten ist, sie genau 4 Minuten und 27 Sekunden lang zu kochen (fragen Sie nicht). Ich habe viele verschiedene Timer ausprobiert, aber festgestellt, dass ein Programm, das kontinuierlich ausgegeben wird, der beste Weg ist, meine Aufmerksamkeit zu erregen.

DEINE AUFGABE

Sie müssen ein Programm erstellen, das die Nachricht Not ready yetgenau 4 Minuten und 27 Sekunden lang ausgibt . Nach Ablauf dieser Zeit sollten Sie Eat your hot dogbis zum Ende der Zeit ausgeben . Bitte nehmen Sie keine Eingaben.

WIE GEWINNT MAN

Sie müssen den kürzesten Code in Bytes schreiben , um zu gewinnen, da dies ein Code-Golf ist

Scratch, 93 78 Bytes

Code:

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

Erstellt von https://scratchblocks.github.io/ , dem Standard für Scratch-Scoring.

Ziemlich selbsterklärend. Wenn das Programm startet, sagen Sie "Noch nicht bereit", bis der Timer (der in Sekunden gezählt wird) größer als 267 ist. Dann startet eine Endlosschleife, in der es heißt Eat your hot dog.

Es ist eine kontinuierliche Ausgabe, da der sayBlock für immer ausgeführt wird, es sei denn, Sie say []odersay etwas anderes.

Bash + Coreutils, 50

timeout 267 yes Not ready yet
yes Eat your hot dog

Erläuterung

Ziemlich selbsterklärend, denke ich, aber nur für den Fall:

• Das yescoreutil gibt kontinuierlich wiederholt alle Parameter aus, die ihm in der Befehlszeile übergeben wurden
• Das timeoutcoreutil akzeptiert einen numerischen Timeout-Parameter, gefolgt von einem Befehl. Der Befehl wird ausgeführt und nach dem angegebenen Timeout beendet.

Operation Flashpoint- Skriptsprache, 67 Byte

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

Speichern Sie als "hotdog.sqs"(oder was auch immer) im Missionsordner und rufen Sie mit an [] exec "hotdog.sqs".

Erläuterung:

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

Ich habe viele verschiedene Timer ausprobiert, aber festgestellt, dass ein Programm, das kontinuierlich ausgegeben wird, der beste Weg ist, meine Aufmerksamkeit zu erregen.

Diese Lösung sollte besonders gut geeignet sein, um Ihre Aufmerksamkeit auf sich zu ziehen, da der hintBefehl bei jedem Aufruf einen anhaftenden Soundeffekt ausgibt, der sehr ärgerlich klingt, wenn die gleichzeitigen Sounds in einer engen Schleife abgeschnitten werden.

JavaScript ES6, 76 Bytes

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

Erläuterung

Dies druckt alle 517 Millisekunden etwas auf die Konsole. Zuerst wird 'Not ready yet'der Zähler gedruckt und verringert. Nach 517 Iterationen ( = 517 * 517 = 267289 ms) wird der Druckvorgang gestartet 'Eat your hot dog'.

Prüfung

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

Es gibt wahrscheinlich einen viel besseren Weg, also Kritik willkommen! Dies ist mein erster Golfversuch :)

EDIT unten ein ganzes 14 Bytes dank AdmBorkBork! Und definitiv eine Technik zum Erinnern!

EDIT 2 Weitere 12 Bytes sind dank Matt weg. Nicht zweimal aufrufend schreibe auch 2 Leerzeichen entfernt, sehr hilfreich!

GameMakers Skriptsprachenvariante, die in der Nuclear Throne Together-Modifikation verwendet wird, 68 Byte

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

Erläuterung

• Der Parser von GML ist köstlich nachsichtig. Semikolons und Klammern sind optional, und der Compiler kümmert sich überhaupt nicht um Ihren Abstand außerhalb der Grundregeln ( 0whileanalysiert als 0,while und somit ist ok)
• Variablen gelangen in den ausführenden Kontext, sofern dies nicht über deklariert wurde var (wie bei JS) .

• Die in NTT verwendete GML-Variante führt ein wait Operator ein, der den ausführenden "Mikrothread" in eine Liste für die angegebene Anzahl von Frames schiebt und anschließend fortsetzt. Im Grunde genommen Coroutinen.

  Das Spiel ist mit 30 fps getaktet, also 4m27s == 267s == 8010 Frames.

• trace () gibt den angegebenen String in den Chat aus.

Wenn du den videogame + mod installiert hast, kannst du das als einiges speichern test.mod.gmlund es /loadmod testausführen , indem du den Chat mit "Statusberichten" überflutest:

Python 2, 92 Bytes

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

Probieren Sie es online!

TI-Basic, 75 Bytes

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

Erläuterung

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

Batch, 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 hat keine Datumsberechnung, so dass eine einfache Zeitüberschreitung von 267 Sekunden nicht zulässig ist. Das Beste, was ich tun kann, ist eine Zeitüberschreitung von 267 Sekunden.

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

Ungolfed volles Programm:

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

Leider konnte ich den ?:-operator nicht verwenden, da ich keine Möglichkeit gefunden habe, das Inkrementieren iohne den zu stoppen if.

C #, 174 172 147 Bytes

25 Bytes gespart durch "Ausleihen" einiger Ideen aus Raznaguls C # -Antwort und mit der Summe der ersten n Zahlen zusammengeführt wurden!

2 Bytes mit der Summe der ersten n Tricks für einen Genauigkeitsverlust von 185 Millisekunden gespart.

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

Ungolfed-Programm:

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

Erläuterung:

Da die Gesamtwartezeit mit 267 Sekunden fest codiert ist, kann man diese Zahl als teleskopische Summe der ersten n natürlichen Zahlen betrachten. n * (n + 1) / 2 , die 267000 Millisekunden entsprechen müssen.

Dies ist äquivalent zu n^2 + n - 534000 = 0 .

Durch diese Gleichung zweiter Ordnung zu lösen, n1 = 730.2532073142067, n2 = -n1. Natürlich wird nur die positive Lösung akzeptiert und kann als 730 angenähert werden .

Die Gesamtzeit kann wie folgt berechnet werden 730 * (730 + 1) / 2 = 266815 milliseconds. Die Ungenauigkeit beträgt 185 Millisekunden und ist für den Menschen nicht wahrnehmbar. Der Code bewirkt nun, dass der Haupt-Thread (und nur dieser) für 1 Millisekunde, 2 Millisekunden usw. bis zu 730 Sekunden in den Ruhezustand wechselt, sodass die gesamte Ruhezeit ~ 267 Sekunden beträgt.

Aktualisieren:

Die Programmlogik kann weiter vereinfacht werden - im Grunde muss eine Nachricht kontinuierlich angezeigt und eine bestimmte Zeit gewartet werden, bis zur zweiten Nachricht gewechselt wird.

Die Nachricht kann mithilfe eines ternären Operators geändert werden, um das Verstreichen der angegebenen Zeit (~ 267 Sekunden) zu überprüfen.

Der Timing-Aspekt wird gesteuert, indem ein zunehmender Zähler verwendet und der Ausführungsthread angehalten wird.

Da die Zählervariable jedoch unbegrenzt weiter ansteigt, ohne dass Bedingungen zur Überprüfung ihres Werts erfüllt sind, kann irgendwann ein ganzzahliger Überlauf erwartet werden, wenn die Nachricht auf zurückgesetzt wird Not ready yet.

Eine Bedingung kann hinzugefügt werden, um das Problem zu erkennen und zu mindern, indem ein positiver Wert größer als 730 zugewiesen wird, wenn der Überlauf auftritt - wie i=i<1?731:iin der forSchleife. Leider kostet es 11 zusätzliche Bytes:

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

Der Schlüssel hier ist die Verwendung des Zählerwerts in Millisekunden zu verwenden, um den Moment des Überlaufs stark zu verzögern.

Die Zeit bis zum Überlauf kann gemäß der sum(1..n)Formel berechnet werden, wobei n = der maximale vorzeichenbehaftete 32-Bit-Integer-Wert in C # (und .NET Framework) oder 2 ^ 31 - 1 = 2147483647 ist:

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

Nach 73 Millionen Jahren ist es vielleicht egal, ob ein Fehler im System auftritt - der Hot Dog, der hungrige OP und vielleicht die Menschheit selbst sind längst verschwunden.

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

Ungolfed-Programm:

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

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

Ungolfed-Programm:

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

Alternativ kann das Programm auch Not ready yetnur einmal angezeigt werden. Warten Sie, bis die angegebene Zeit abgelaufen ist, und geben Sie es dann aus, Eat your hot dogindem Sie die vorherige Nachricht überschreiben, während Sie einige Bytes kürzer sind:

145 Bytes

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

Ungolfed-Programm:

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

Ruby, 80 71 67 Bytes

Edit: Dank Manatwork für das Abschneiden von 13 ganzen Bytes

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

05AB1E, 43 29 28 Bytes (Dank an Adnan)

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

Funktioniert nicht online, da es eine Zeitüberschreitung gibt. Offline wird es funktionieren.

267F: 267-mal wiederholt

…€–Žä‡«ª: Erste Zeichenfolge mit Wörterbuch

w,: Warten Sie eine Sekunde und drucken Sie

}[: End if-Schleife und Endlosschleife starten

“Eat€ž…ß‹·“: Zweiter String mit Wörterbuch

,: Drucken

Python, 115 Bytes

Ich habe zum ersten Mal so etwas ausprobiert. Ich bin auch ein Anfänger, also hier geht es in Python 3 für 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 für Micro: Bit, 90 Bytes

Der Code:

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

Sie können es hier ausprobieren.

Ich habe mich von der Scratch-Antwort inspirieren lassen, die Aufgabe mit meinem Mikro-Bit zu lösen. Das einzige Problem ist, dass der Pause-Block nach der Ausgabe des ersten Strings startet, so dass ich die Pause um 13s reduzieren musste.

Hinweis: Der alte Microsoft Block Editor für micro: bit ist kürzer zu erstellen, produziert jedoch mehr Code und ist daher länger.

Auf der Grundlage, dass das OP ständig Hotdogs will, bis ans Ende der Zeit - was ich aus dem Satz verstehe:

Nach Ablauf dieser Zeit sollten Sie Eat your hot dog bis zum Ende der Zeit ausgeben.

Das ist meine Antwort:

C ++, 187 188 224 167 Bytes

Leerzeichen entfernt (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;}

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

Wenn OP dagegen seine Hotdogs in Maßen mag, dann ist dies meine Antwort:

Leerzeichen entfernt (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;}

lesbare 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 bietet sofort eine Fensterfunktion, die keine Ein- und Ausgaben vornimmt, ob Sie Ihren Hot Dog in die Zelle essen sollen oder nicht [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

Vielen Dank, Taylor Scott

Javascript, 83 Bytes

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

Alertz für alle!

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

Erläuterung:

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

kontinuierliche Ausgabe; ←ist ASCII 10 = LF. Laufen Sie mit -r.

einmalige Ausgabe, 50 Bytes

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

wo ←ist ASCII 13 = CR. In Datei speichern oder mit Piping ausführen.

RBX.Lua , 69 Bytes

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

RBX.Lua ist die Sprache, die auf ROBLOX.com verwendet wird . Es ist eine modifizierte Version von Lua 5.1, die eine eingebaute 'Wait'-Funktion bietet. Der obige Code ist ziemlich selbsterklärend, unten ist eine besser lesbare Version:

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

print("Eat your hot dog");

Der Code gibt 267 Sekunden (4 Minuten 27 Sekunden) lang kontinuierlich "Noch nicht bereit" in STDOUT aus , bevor "Eat your hot dog" ausgegeben wird.

C - 130 Bytes

Es könnte etwas kürzer sein (128 Byte), aber ich fand es besser, "Noch nicht fertig" zu überschreiben

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