有时我发现自己想要一只热狗（不是所有人），所以我做了一个。现在制作热狗，非常简单。

1）将热狗放入沸水中

2）等待一定的时间（详细信息如下）

3）时间一到，就吃热狗。

您可能已经注意到我说过

特定时间（详细信息如下）

所以我会详细说明。

许多不同的品牌对热狗煮多久有不同的建议，但是我发现最好将它们煮4分27秒（不要问）。我尝试了许多不同的计时器，但是发现连续输出的程序是吸引我注意力的最佳方法。

你的任务

您必须制作一个程序，该程序将在Not ready yet4分钟27秒内正确输出消息。在这段时间过去之后，您应该输出Eat your hot dog直到时间结束。请不要输入任何信息。

如何取胜

您必须以字节为单位编写最短的代码才能获胜，因为这是一个代码问题

临时，93 78字节

码：

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

由https://scratchblocks.github.io/生成，这似乎是Scratch评分的标准。

相当自我解释。程序启动时，说“尚未准备好”，直到计时器（以秒为单位）大于267。然后在其中显示，开始无限循环Eat your hot dog。

它是连续输出，因为say除非您say []或say其他人执行，否则该块将永远运行。

Bash + coreutils，50岁

timeout 267 yes Not ready yet
yes Eat your hot dog

说明

我认为这很不言自明，但以防万一：

• 所述yescoreutil连续反复输出传递给它的命令行上的任何参数
• 所述timeoutcoreutil需要一个数字超时参数随后的命令。运行该命令，然后在指定的超时后将其终止。

操作Flashpoint脚本语言，67字节

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

另存为"hotdog.sqs"（或其他）任务文件夹中的，然后使用调用[] exec "hotdog.sqs"。

说明：

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

我尝试了许多不同的计时器，但是发现连续输出的程序是吸引我注意力的最佳方法。

该解决方案在吸引您的注意力方面应该特别好，因为该hint命令每次被调用时都会发出粘着的声音效果，当同时发出的声音被紧紧地夹住时，这听起来很烦人。

JavaScript ES6，76个字节

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

说明

每隔517毫秒就会在控制台上打印一次。首先，它打印'Not ready yet'并减少计数器。经过517次迭代（= 517 * 517 = 267289 ms），它开始打印'Eat your hot dog'。

测试

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

Powershell，85 71 59字节

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

可能有更好的方法，欢迎批评！这是我的第一次高尔夫尝试：）

编辑由于AdmBorkBork，整个14个字节全部减少！绝对是一种要记住的技术！

编辑2由于马特，另外12个字节消失了。不调用两次写还会删除2个空格，非常有帮助！

GameMaker的脚本语言变体，用于“核子国宝典” mod，68字节

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

说明

• GML的解析器非常美味。分号和括号是可选的，并且编译器完全不关心基本规则之外的间距（0while解析为0，while因此可以）
• 除非通过声明var（与JS相同），否则变量会泄漏到执行上下文中。

• NTT中使用的GML变体引入了一个wait运算符，该运算符将正在执行的“微线程”推送到指定帧数的列表中，然后恢复。协程，基本上。

  游戏的主频为30fps，因此4m27s == 267s == 8010帧。

• trace（）将给定的字符串输出到聊天室中。

如果您安装了videogame + mod，则可以将其另存为some test.mod.gml，并/loadmod test执行它，并在“状态报告”中充斥聊天内容：

Python 2，92个字节

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

在线尝试！

TI基本（75字节）

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

说明

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

批处理，99字节

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

批处理没有日期算术，因此不允许简单的267秒超时，我能做到的最好是267秒延迟。

C＃144字节

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

完整的程序：

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

不幸的是我不能使用?:-运算符，因为我还没有找到一种方法来阻止递增i无if。

C＃，174个 172 147字节

通过从raznagul的C＃答案中 “借用”一些想法并将其与前n个数字的和合并来节省25个字节！

通过使用前n个数字的总和节省了2个字节，从而损失了185毫秒的精度。

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

非高尔夫节目：

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

说明：

由于等待的总时间被硬编码为267秒，因此可以将此数字视为前n个自然数的伸缩总和，该自然数n * (n + 1) / 2必须等于267000毫秒。

等同于n^2 + n - 534000 = 0。

通过求解该二阶方程n1 = 730.2532073142067，，n2 = -n1。当然，仅接受正解并且可以近似为730。

总时间可以计算为730 * (730 + 1) / 2 = 266815 milliseconds。不精确度为185毫秒，人类无法察觉。该代码现在将使主（唯一）线程睡眠1毫秒，2毫秒，依此类推，直到730，因此总睡眠时间约为267秒。

更新：

程序的逻辑可以进一步简化-基本上，它需要连续显示一条消息并等待指定的时间，直到切换到第二条消息为止。

可以通过使用三元运算符检查指定时间（〜267秒）的流逝来更改该消息。

通过使用递增计数器并暂停执行线程来控制计时方面。

但是，由于计数器变量无限制地继续无限增加，因此没有任何条件可以检查其值，因此，当消息恢复为时，可能会在某个时刻出现整数溢出Not ready yet。

通过在溢出发生时（例如i=i<1?731:i在for循环内部）分配大于730的正值，可以添加条件来检测和缓解问题。可悲的是，它要付出11个额外字节的代价：

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

此处的关键是使用毫秒计数值来大大延迟溢出时间。

可以根据以下sum(1..n)公式计算直到溢出为止的时间，其中n = C＃（和.NET框架）中最大的32位有符号整数值或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

在7300万年之后，系统中是否出现小故障并不重要-热狗，饥饿的OP和人类本身早已消失。

先前版本（172字节）：

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

非高尔夫节目：

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

先前版本（174字节）：

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

非高尔夫节目：

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

或者，该程序可能Not ready yet只显示一次，等到指定的时间结束，然后Eat your hot dog通过覆盖前一条消息来输出，同时将其缩短几个字节：

C＃，145个字节

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

非高尔夫节目：

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字节

编辑：感谢manatwork削减了13个完整字节

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

05AB1E，43 29 28字节（感谢Adnan）

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

由于超时，因此无法在线运行。脱机它将起作用。

267F：循环267次

…€–Žä‡«ª：带字典的第一个字符串

w,：等待一秒钟并打印

}[：结束if循环并开始无限循环

“Eat€ž…ß‹·“：第二个带字典的字符串

,：打印

Python，115个字节

我第一次尝试这样的事情。我也是一个初学者，因此在Python 3中使用了115个字节：

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

适用于micro：bit的JavaScript块编辑器，90字节

代码：

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

您可以在这里尝试。

得到了Scratch答案的启发，用我的micro：bit解决了任务。唯一的问题是，暂停块在输出第一个字符串之后开始，因此我需要将暂停减少13秒。

注意：用于micro：bit的旧Microsoft块编辑器创建起来较短，但产生的代码更多，因此实际上更长。

基于OP持续需要热狗，直到时间结束-我从短语中了解到：

在这段时间过后，您应该输出吃热狗，直到时间结束。

这是我的答案：

C ++，187个 188 224 167字节

删除的空白（167个字节）：

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

可读形式（224字节）：

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

另一方面，如果OP适度享受他的热狗，那么这就是我的答案：

删除的空白（158个字节）：

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

可读形式（198字节）：

#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字节

匿名的VBE立即窗口功能，无需输入，即可输出是否应将热狗吃到单元格中[A1]。

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

Excel VBA 122 94字节

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

由于泰勒·斯科特

Javascript，83个字节

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

所有人的Alertz！

PERL，76个字节

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

PHP 88字节

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

REXX，82个字节

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

Java 7，152字节

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

说明：

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字节

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

连续输出；←是ASCII 10 = LF。用运行-r。

一次性输出，50字节

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

←ASCII 13 = CR 在哪里 保存到文件或使用管道运行。

RBX.Lua，69字节

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

RBX.Lua对所使用的语言ROBLOX.com。它是Lua 5.1 的修改版本，具有内置的“等待”功能。上面的代码很不言自明，下面是一个更具可读性的版本：

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

print("Eat your hot dog");

该代码在输出“吃掉你的热狗”之前，连续267秒（4分27秒）向STDOUT输出“尚未准备好”。

C-130个字节

它可能会稍短一些（128字节），但是我认为覆盖“尚未准备好”更为整洁

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

VBA，126字节

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个字节

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