Às vezes me pego querendo um cachorro-quente (não todos nós) e então faço um. Agora, para fazer um cachorro-quente, é muito simples.

1) Coloque os cachorros-quentes em água fervente

2) Aguarde um certo período de tempo (detalhado abaixo)

3) Coma o cachorro-quente após o tempo decorrido.

Você deve ter notado que eu disse

certo tempo (detalhado abaixo)

e por isso vou detalhar.

Muitas marcas diferentes têm recomendações diferentes por quanto tempo devemos cozinhar os cachorros-quentes, mas achei melhor cozinhá-los por exatamente 4 minutos e 27 segundos (não pergunte). Eu tentei muitos timers diferentes, mas descobri que um programa que gera continuamente é a melhor maneira de atrair minha atenção.

SUA TAREFA

Você precisa criar um programa que produza a mensagem Not ready yetpor exatamente 4 minutos e 27 segundos. Após esse período, elas devem ser impressas Eat your hot dogaté o final dos tempos. Por favor, não aceite nenhuma entrada.

COMO GANHAR

Você deve escrever o código mais curto em bytes para ganhar, porque este é um código-golfe

Zero, 93 78 bytes

Código:

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

Gerado por https://scratchblocks.github.io/ , que parece ser o padrão para a pontuação do Scratch.

Bastante auto-explicativo. Quando o programa iniciar, diga "Ainda não está pronto" até que o timer (que é contado em segundos) seja maior que 267. Em seguida, inicia um loop infinito onde está indicado Eat your hot dog.

Ele é saída contínua, porque o saybloco é executado para sempre a menos que você say []ou sayqualquer outra coisa.

Bash + coreutils, 50

timeout 267 yes Not ready yet
yes Eat your hot dog

Explicação

Bastante auto-explicativo, eu acho, mas apenas no caso:

• o yes coreutil gera repetidamente continuamente todos os parâmetros passados ​​para ele na linha de comando
• O timeoutcoreutil usa um parâmetro de tempo limite numérico seguido por um comando. O comando é executado e, em seguida, eliminado após o tempo limite especificado.

Linguagem de script da operação Flashpoint , 67 bytes

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

Salve como "hotdog.sqs"(ou o que for) na pasta da missão e ligue com[] exec "hotdog.sqs" .

Explicação:

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

Eu tentei muitos timers diferentes, mas descobri que um programa que gera continuamente é a melhor maneira de atrair minha atenção.

Essa solução deve ser especialmente boa para atrair sua atenção, pois o hintcomando reproduz um efeito sonoro persistente toda vez que é chamado, o que soa muito irritante quando os sons simultâneos são cortados em um loop apertado.

JavaScript ES6, 76 bytes

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

Explicação

Isso imprime algo no console a cada 517 milissegundos. Inicialmente, imprime 'Not ready yet'e diminui o contador. Após 517 iterações ( = 517 * 517 = 267289 ms), inicia a impressão 'Eat your hot dog'.

Teste

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

Provavelmente existe uma maneira muito melhor, então as críticas são bem-vindas! Esta é a minha primeira tentativa de golfe :)

EDITAR 14 bytes inteiros graças ao AdmBorkBork! E definitivamente uma técnica para lembrar!

EDIT 2 Mais 12 bytes desaparecidos graças a Matt. Não chamar escrever duas vezes também removeu 2 espaços, muito útil!

Variante da linguagem de script do GameMaker usada no mod Nuclear Throne Together, 68 bytes

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

Explicação

• O analisador da GML é deliciosamente perdoador. Ponto-e-vírgula e parênteses são opcionais e o compilador não se preocupa com o seu espaçamento fora das regras básicas ( 0whileanalisa como 0,while e portanto, está ok)
• Variáveis ​​vazam para o contexto de execução, a menos que declaradas via var (o mesmo que com JS).

• A variante GML usada no NTT introduz uma wait operador, que envia o "micro-thread" em execução a uma lista para o número especificado de quadros, retomando posteriormente. Corotinas, basicamente.

  O jogo tem clock de 30fps, então 4m27s == 267s == 8010 quadros.

• trace () gera a string especificada no chat.

Se você tem o videogame + mod instalado, você pode salvá-lo como alguns test.mod.gmle /loadmod testexecutá-lo, inundando o bate-papo com "relatórios de status":

Python 2, 92 bytes

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

Experimente online!

TI-Basic, 75 bytes

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

Explicação

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

O lote não tem data aritmética, portanto, um simples tempo limite de 267 segundos não é permitido, o melhor que posso fazer é 267 tempos limite de um segundo.

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

Programa completo não destruído:

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

Infelizmente, não pude usar o ?:-operator porque não encontrei uma maneira de parar de incrementar isem o if.

C #, 174 172 147 bytes

Economizou 25 bytes "emprestando" algumas idéias da resposta C # do raznagul e mesclando-as com a soma do primeiro truque dos números n!

Economizou 2 bytes usando o truque da soma dos primeiros n números para uma perda de precisão de 185 milissegundos.

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 não destruído:

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

Explicação:

Como o tempo total de espera é codificado em 267 segundos, pode-se considerar esse número como uma soma telescópica dos primeiros n números naturais, n * (n + 1) / 2 , que devem ser iguais a 267000 milissegundos.

Isso é equivalente a n^2 + n - 534000 = 0 .

Ao resolver esta equação de segunda ordem, n1 = 730.2532073142067, n2 = -n1. Obviamente, apenas a solução positiva é aceita e pode ser aproximada como 730 .

O tempo total pode ser calculado como 730 * (730 + 1) / 2 = 266815 milliseconds. A imprecisão é de 185 milissegundos , imperceptível aos seres humanos. O código agora fará com que o encadeamento principal (e somente) seja suspenso por 1 milissegundo, 2 milissegundos e assim por diante até 730, portanto o período total de suspensão é de ~ 267 segundos.

Atualizar:

A lógica do programa pode ser simplificada ainda mais - basicamente, ele precisa exibir continuamente uma mensagem e aguardar um tempo especificado até mudar para a segunda mensagem.

A mensagem pode ser alterada usando um operador ternário para verificar a passagem do tempo especificado (~ 267 segundos).

O aspecto do tempo é controlado usando um contador crescente e pausando o encadeamento de execução.

No entanto, como a variável do contador continua aumentando indefinidamente, sem condições para verificar seu valor, pode-se esperar um estouro de número inteiro em algum momento, quando a mensagem reverter para Not ready yet.

Uma condição pode ser adicionada para detectar e atenuar o problema, atribuindo um valor positivo maior que 730 quando o estouro ocorrer - como i=i<1?731:identro do forloop. Infelizmente, tem o custo de 11 bytes adicionais:

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

A chave aqui é usar o valor do contador em milissegundos para atrasar bastante o momento do estouro.

O tempo até o estouro pode ser calculado de acordo com a sum(1..n)fórmula, em que n = o valor inteiro máximo assinado de 32 bits em C # (e na estrutura .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

Depois de 73 milhões de anos , pode não importar se uma falha no sistema aparecer - o cachorro-quente, o OP com fome e talvez a própria raça humana já se foi há muito tempo.

Versão 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 não destruído:

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

Versão 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 não destruído:

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

Como alternativa, o programa pode ser exibido Not ready yetapenas uma vez, aguarde até que o tempo especificado termine e depois saiaEat your hot dog substituindo a mensagem anterior, sendo alguns bytes mais curtos:

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 não destruído:

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: Graças à manatwork por remover 13 bytes inteiros

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

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

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

Não funciona online, pois atinge o tempo limite. Offline funcionará.

267F: Loop 267 vezes

…€–Žä‡«ª: Primeira string com dicionário

w,: Aguarde um segundo e imprima

}[: Finaliza o loop se e inicia o loop infinito

“Eat€ž…ß‹·“: Segunda string com dicionário

,: Impressão

Python, 115 bytes

Minha primeira vez tentando algo assim. Eu também sou iniciante, então aqui está o Python 3 por 115 bytes:

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

Editor de blocos JavaScript para micro: bit, 90 bytes

O código:

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

Você pode tentar aqui.

Fui inspirado pela resposta do Scratch para resolver a tarefa com o meu micro: bit. O único problema é que o bloco de pausa começa após a saída da primeira string, então eu precisava reduzir a pausa em 13s.

Nota: O antigo Microsoft Block Editor para micro: bit é mais curto para criar, mas produz mais código e, na verdade, é mais longo.

Com base no fato de que o OP deseja cachorro-quente continuamente, até o fim dos tempos - o que entendo da frase:

Após esse período, elas devem ser consumidas Coma seu cachorro-quente até o final dos tempos.

Esta é a minha resposta:

C ++, 187 188 224 167 bytes

Espaço em branco removido (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;}

formato legível (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;
}

Se, por outro lado, o OP gosta de seus cachorros-quentes com moderação, então esta é a minha resposta:

Espaço em branco removido (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;}

formulário legível (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

O VBE anônimo imediata a função da janela que não recebe nenhuma entrada e gera se você deve ou não comer seu cachorro-quente na célula [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

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

Explicação:

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

saída contínua; ←é ASCII 10 = LF. Corra com -r.

saída única, 50 bytes

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

onde ←é ASCII 13 = CR. Salve no arquivo ou use a tubulação para executar.

RBX.Lua , 69 bytes

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

RBX.Lua é o idioma usado no ROBLOX.com . É uma versão modificada do Lua 5.1 que apresenta uma função interna 'Wait'. O código acima é bastante auto-explicativo, abaixo está uma versão mais legível:

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

print("Eat your hot dog");

O código gera "Ainda não está pronto" continuamente em STDOUT , por 267 segundos (4 minutos e 27 segundos) antes de emitir "Eat your hot dog".

C - 130 bytes

Poderia ser um pouco mais curto (128 bytes), mas achei melhor substituir "Não está pronto ainda"

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