Dary!

Em eventos totalmente não relacionados ao que, esperançosamente, acontecerá comigo nos próximos dias, encarrego você de escrever um código que faça o seguinte:

1. Impressão

   Legen... wait for it...
   

   imediatamente, com uma nova linha à direita.

2. Aguarde até a próxima hora completa (quando a tarefa cron de atribuição do emblema for executada).

3. Impressão

   dary!
   

   com uma nova linha à direita opcional .

Regras adicionais

• Você pode escrever um programa ou uma função, mas a saída deve ser impressa em STDOUT (ou a alternativa mais próxima do seu idioma).

• Você precisa esperar até a próxima hora inteira , não apenas por 60 minutos. Se o código for executado às 6:58, ele deverá imprimir a segunda linha às 7:00.

• A última linha deve ser impressa no máximo um segundo após a próxima hora completa.

• No caso de o programa ser iniciado no primeiro segundo de uma hora completa, ele deverá aguardar a próxima hora completa.

• Você pode consultar a hora local ou UTC.

• Aplicam-se as regras padrão de código de golfe .

Pyth, 42 41

J.d6." wâ«­hÖ`Ùá©h´^"WqJ.d6;"dary!

Abaixo está um hexdump do código:

00000000  4a 2e 64 36 2e 22 20 77  0c 10 89 e2 ab 1b ad 68  |J.d6." w.......h|
00000010  0f 8c d6 60 d9 e1 a9 68  82 b4 5e 22 57 71 4a 2e  |...`...h..^"WqJ.|
00000020  64 36 3b 22 64 61 72 79  21                       |d6;"dary!|

Guardado 1 byte graças a @isaacg

Usa a .dfunção para obter valores relacionados à hora local. .d6retorna a hora atual. Isso imprime a primeira sequência e aguarda até que a hora seja diferente da hora do início do programa e, em seguida, imprime a segunda sequência.

Você pode experimentá-lo on-line com .d7ou .d8por minutos / segundos, mas o compilador on-line imprime apenas qualquer coisa quando o programa termina.

Parabéns, Dennis! :)

JavaScript (ES6), 74 bytes

Convém alterar o relógio do sistema antes de testar, parabéns se você chegou aqui aos 59 minutos atrás.

setTimeout(a=alert,36e5-new Date%36e5,"dary!");a`Legen... wait for it...
`

CJam, 49 48 bytes

et3="Legen... wait for it...
"o{_et3==}g;"dary!"

Usa hora local. Para fins de teste, você pode substituir as duas instâncias 3com 4ou 5para imprimi-lo no início do próximo minuto / segundo.

Teste aqui. Mas observe que o intérprete online não mostra nenhuma saída até o programa terminar. Como alternativa, você pode executá-lo no Try it online , onde a saída é mostrada quase imediatamente em vez de ser armazenada em buffer (mas quando você a testar com segundos em vez de horas, o atraso será perceptível). De qualquer forma, se você o executar localmente com o interpretador Java, ele funcionará como um encanto.

Explicação

Isso faz uso de CJam, etque oferece uma variedade de

[year month day hour minute second ms weekday utc_offset]

Aqui está um detalhamento do código:

et3=       e# Get the current hour.
"Legen..." e# Push the first string including the linefeed.
o          e# Print it.
{          e# While the top of stack is truthy (which is popped)...
  _        e#   Copy the original hour.
  et3=     e#   Get the current hour.
  =        e#   Check for equality.
}g
;          e# Discard the original hour.
"dary!"    e# Push the second string which is printed automatically.

Bônus

Isso também funciona para a mesma contagem de bytes:

et4<"Legen... wait for it...
"o{et1$#!}g;"dary!"

Em vez de selecionar a hora, estamos selecionando o prefixo com a data e a hora, e continuamos o loop enquanto a matriz de data e hora ainda possui esse prefixo.

AppleScript, 157 149 bytes

Hã. Surpreendentemente disputando.

defina d para o número 1 na sequência de tempo de (data atual)
log "Legen ... espere por isso ..."
repita enquanto d = número 1 na sequência de tempo de (data atual)
fim
log "dary!"

Como as logimpressões são feitas no painel Mensagens do Editor de Scripts, considero a saída mais próxima de STDOUT. Basicamente, se você obtiver a sequência de horas da data atual, fará algo assim:

Código:

seqüência de tempo de (data atual)

Resultado:

17:02:03

Ele pegará o primeiro número ( 5) antes dos dois pontos.

Eu pensei que seria muito mais longo do que isso, na verdade. xD

Boneco de neve 1.0.2 , 70 69 bytes

~"Legen... wait for it...
"sP3600000*vt#nDnC!*:vt+#nD!#nL;bD"dary!"sP

Explicação:

~              Make all variables active.
"..."sP        Print the first string.
3600000*vt#nD  Get the number of hours since the Unix epoch.
nC             Ceiling (round up), giving the time (divided by 36000) at which to
                 print the second string.
!*             Save that in a permavar.
:...;bD        Do the stuff in the block while its "return value" is truthy.
  vt+#nD       Again, get the number of hours since epoch.
  !#             Store the permavar that we saved earlier.
  nL             Is the current time less than the target time? (if so,
                   keep looping)
"..."sP        Print the second string.

PHP, 76, 70, 65, 62 51 bytes

Legen... wait for it...
<?while(+date(is));?>dary!

Lógica anterior (63b):

Legen... wait for it...
<?for($h=date(G);date(G)==$h;)?>dary!

Esse tipo de codificação faz com que você perca seu emprego, mas faz um loop até que o tempo seja 1 hora a mais que o init.

-1 byte substituindo {}afer o tempo para ;(graças ao manatwork)
-5 bytes substituindo echo'dary!';para ?>dary!(graças ao manatwork)
-4 bytes substituindo <?phppara a versão curta <?(graças ao primo)
-1 byte substituindo o whilepara for
-3 bytes substituindo date(G)!=$h+1para date(G)==$h(obrigado primo)

Perl 6 , 60 bytes

sleep 60²-now%60²+say 'Legen... wait for it..';say 'dary!'

Javascript 94 90 87 bytes

Não jogou tanto golfe ...

alert`Legen... wait for it...`,l=l=>~~(Date.now()/36e5);for(z=l();z==l(););alert`dary!`

Versão do Downgoat:

(a=alert)`Legen... wait for it...`,z=(b=new Date().getHours)();for(;z==b(););a`dary!`

Ele armazena a hora atual e faz um loop enquanto a hora "antiga" for igual à hora atual. Assim que a hora mudar, o restante será impresso! : D

Isenção de responsabilidade: se o seu navegador não gostar, você foi avisado.

MATLAB - 89 bytes

a=@()hour(now);disp('Legen... wait for it...');while(mod(a()+1,24)~=a())end;disp('dary!')

Bastante auto-explicativo. Primeiro, crie um identificador de função para pegar a hora atual do relógio do sistema. Em seguida, exiba Legen... wait for it...com um retorno de carro e, em seguida, entramos em um whileloop em que continuamos verificando se a hora atual adicionada com 1 não é igual à hora atual. Se for, continue em loop. Somente até o instante em que a próxima hora acontece, é exibido dary!e um retorno de carro ocorre depois.

A hora do MATLAB é baseada na indexação de 24 horas, portanto, a modoperação com a base 24 é necessária para lidar com derramamentos de 23:00 (23:00) até meia-noite (00:00).

Nota menor

A hourfunção requer a caixa de ferramentas Financial Time Series. A nowfunção não está sujeita a essa restrição, mas recupera a data e a hora atuais como um número de série que, hourportanto, utiliza para calcular a hora atual.

Deseja executar isso no Octave?

Certo! Como o Octave não possui essa caixa de ferramentas, basta modificar a hourfunção para que ela chame, datevecretornando um vetor de 6 elementos - um para cada ano, mês, dia, hora, minutos e segundos. Você apenas precisaria extrair o quarto elemento da saída:

a=@()datevec(now)(4);disp('Legen... wait for it...');while(mod(a()+1,24)~=a())end;disp('dary!')

Os caracteres adicionais fazem a solução subir para 98 bytes, mas você poderá executá-lo no Octave. Observe a indexação no local sem uma variável temporária no identificador da função.

Nenhuma caixa de ferramentas de séries temporais financeiras?

Se você deseja executar isso no MATLAB sem a Financial Time Series Toolbox, porque não é possível indexar as variáveis ​​imediatamente sem a temporária, isso levará um pouco mais de bytes para escrever:

disp('Legen... wait for it...');h=datevec(now);ans=h;while(mod(h(4)+1,24)~=ans(4)),datevec(now);end;disp('dary!');

Isso primeiro obtém a hora e a data atuais e as armazena na variável h, além de armazená- las na variável automática chamada ans. Depois, continuamos repetindo e verificando se a hora atual não é igual à próxima hora. A cada iteração, continuamos atualizando a variável automática com a hora e a data atuais. Assim que a próxima hora corresponder à hora e data atuais, exibiremos a última parte da sequência e sairemos. Isso eleva a contagem de bytes para 114.

Observe também que você não pode tentar isso online. Os intérpretes da Oitava on-line terão um limite de tempo para a execução do código e, como esse é um whileloop aguardando a próxima hora, você receberá um tempo limite enquanto aguarda a execução do código. A melhor coisa que você pode fazer é executá-lo em sua própria máquina e verificar se funciona.

Mathematica, 85 84 81 bytes

c=Print;c@"Legen... wait for it...";a:=DateValue@"Hour";b=a;While[a==b];c@"dary!"

C, 163 bytes

#include<time.h>
f(){puts("Legen... wait for it...");time_t t=time(0);struct tm l=*localtime(&t);while(l.tm_min+l.tm_sec)t=time(0),l=*localtime(&t);puts("dary!");}

Microscript II, 45 bytes

"Legen... wait for it..."P[36s5E*sD%_]"dary!"

Finalmente, um uso para a Dinstrução.

Imprime a primeira string, leva repetidamente o tempo UTC no módulo de milésimos de segundo 3.600.000 até que isso produz 0 e, em seguida, produz a segunda string que é impressa implicitamente. Os 3.600.000 são representados no código como 36x10 ⁵ .

TI-BASIC, 70 64 bytes

getTime
Disp "Legen... wait for it...
Repeat sum(getTime-Ans,1,1
End
"dary

Amaldiçoe essas letras minúsculas de dois bytes!

getTimeretorna uma lista de três elementos {hours minutes seconds}; portanto, a soma do 1º ao 1º é as horas. Quando há uma diferença entre as horas no início e as horas atuais, o loop termina. Obrigado a @FryAmTheEggman por esta observação.

R - 97 bytes

cat('Legen... wait for it...\n')
Sys.sleep(1)
while(as.double(Sys.time())%%3600>0){}
cat('dary!')

Python 3-92 89 bytes

from time import*;print("Legen... wait for it...");sleep(3600-time()%3600);print("dary!")

Python 2, 82 81 bytes

from time import*;print'Legen... wait for it...';sleep(-time()%3600);print'dary!'

Uma reputação muito baixa para comentar. Versão Python 2 da solução de Alexander Nigl. Salva os caracteres perdidos entre colchetes. Além disso, 3600 não são necessários no cálculo do tempo de suspensão.

7 caracteres salvos no geral.

Edit: -1 byte graças a @Kevin Cruijssen

Script de comando do Windows, 87 bytes

@set.=%time:~,2%&echo.Legen... wait for it...
:.
@if %.%==%time:~,2% goto:.
@echo.dary!

Isso compara continuamente uma variável de hora armazenada no início com a hora atual e é bem-sucedida se diferente.

Perl, 62 bytes

sleep -++$^T%3600+print'Legen... wait for it...
';print'dary!'

A variável especial $^T(aka $BASETIME) registra o número de segundos desde a época em que o script foi iniciado. Felizmente, os segundos bissextos não são contados no total, de modo que o seguinte seja equivalente:

print$^T%3600;
@T=gmtime;print$T[1]*60+$T[0];

Surpreendentemente, essa variável não é somente leitura.

Japt , 72 61 bytes

`{?tT?e?t(Ã?t,36e5-?w D?e%36e5,'ÜÝ!'),'Leg?... Ø2 f? ?...\n'}

Cada ?um representa um caractere não imprimível Unicode. Veja como obter o texto completo:

1. Abra o intérprete online .
2. Cole este código na caixa Código:

Oc"`\{setTimeout(alert,36e5-new Date%36e5,'dary!'),'Legen... wait for it...\\n'}

3. Execute o código e apague-o da caixa Código.
4. Selecione o conteúdo da caixa Saída e arraste para a caixa Código. Copiar e colar não funcionará .
5. Substitua o primeiro espaço por um espaço sem quebra.
6. (opcional) Ajuste o relógio do seu computador para xx: 59.
7. Execute o código.

Como alternativa, aqui está um hexdump (provavelmente reversível):

00000000: 607b a074 548b 658c 7428 c300 742c 3336 65    `{ tT?e?t(Ã?t,36e
00000011: 352d 9a77 2044 8565 2533 3665 352c 27dc dd    5-?w D?e%36e5,'ÜÝ
00000022: 2127 293b 274c 6567 812e 2e2e 20d8 3220 66    !'),'Leg?... Ø2 f
00000033: 8e20 8a2e 2e2e 5c6e 277d                      ? ?...\n'}

Esse código é baseado na resposta JavaScript de George Reith , com algumas alterações específicas do Japt. Descobri outro dia que, se você compactar o código e inseri-lo em uma string embrulhada em um bastão, ele será descompactado automaticamente. Veja como é processado através da compilação:

`{?tT?e?t(Ã?t,36e5-?w D?e%36e5,'ÜÝ!'),'Leg?... Ø2 f? ?...\n'}
"{setTimeout(alert,36e5-new Date%36e5,'dary!'),'Legen... wait for it...\n'}"
""+(setTimeout(alert,36e5-new Date%36e5,'dary!'),'Legen... wait for it...\n')+""

Em JS, um par de parênteses retornará o último valor interno; portanto, esse código define o evento cronometrado e retorna a 'Legen...'string, que é automaticamente enviada para STDOUT. Como o Japt atualmente não tem como adicionar conteúdo ao STDOUT além da saída automática na compilação, usei a função vanilla JS alertpara a saída temporizada. Espero que isso seja permitido.

Powershell, 52 51 bytes

-1 byte thanks @Veskah

'Legen... wait for it...'
for(;Date|% M*e){}'dary!'

Essa expressão Date|% M*eobtém valor da Minutepropriedade do valor Current DateTime. O loop termina quando Minuteigual a 0.

Python, 112 bytes

import time as t;print "Legen... wait for it...";n=t.ctime();t.sleep((60-n.tm_min)*60+60-n.tm_sec);print "dary!"

Bastante auto-explicativo.

Python - 159 bytes

from datetime import*;from threading import*;p=print;n=datetime.now();p('Legen... wait for it...');Timer(3600-(n.minute*60+n.second),lambda:p('dary!')).start()

Mouse-2002 , 62 bytes

Requer que o usuário pressione enter. Eu acho que.

"Legen... wait for it..."?&HOUR 1+x:(&HOUR x.=["dary"33!'0^])

Ok, bem, enquanto estamos pegando muitos bytes e não ganhando nada, vamos nos divertir um pouco.

"Legen... wait for it... "?     ~ print & require keypress

&HOUR 1+ x:                     ~ get hr, add 1 and assign
(                               ~ while(1)
  &HOUR x. =                    ~ cmp current hr, stored hr
  [                             ~ if same
    #B;                           ~ backspace
    "dary"36!'                    ~ print this string and a !
    0^                            ~ exit cleanly
  ]                             ~ fi
  &MIN 59 - &ABS !              ~ get min, subtract from 59, abs & print
  ":"                           ~ record sep
  &SEC 59 - &ABS !              ~ same for second
  #B;                           ~ backspace
)
$B 8!' 8 !' 8 !' 8 !' 8 !'@     ~ backspace 5*
$                               ~ \bye

Amostra:

$ mouse legend.m02
Legen... wait for it... 20:32

Veja, é um cronômetro de contagem regressiva no local atualizado para a próxima hora! Ele faz bom uso do loop while, que, mesmo sem fazer nada, ocupará um núcleo.

BASIC, 90 bytes

Print"Legen... wait for it...":x$=Left(Time,2):Do:Loop Until x$<>Left(Time,2):Print"dary!"

Simples, jogou golfe usando os prefixos de tipo e a Endinstrução implícita . O custo é que ele funciona apenas no dialeto FreeBasicfblite .

Befunge 98 - 69 63 bytes

 v
v>a"...ti rof tiaw ...negeL<ETB>"k,
>"EMIT"4(MS+_"!yrad"5k,@

O código contém um caractere não imprimível (representado por <ETB>como não imprimíveis não parece aparecer em blocos de código). Seu código de caractere é 23 (um caractere de bloco de transmissão final ).

Aviso: O código anterior será executado em um loop ocupado, com a pilha aumentando a cada repetição e, portanto, pode consumir grandes quantidades de memória.

Gelatina , 48 47 bytes , não concorrente

-1 byte graças a Erik, o jogador de golfe (use "Leg" como uma palavra na compactação)

“ÇỴġƒḃhlḂṀ⁷*Ḣ¡w*Jḷv»Ṅø3ŒTṣ”:V_@59ḅ60‘œS@“dary!”

TryItOnline! ou execute uma versão de teste com uma cadeia de caracteres formatada por tempo codificada de“59:57”("mm: ss").

O primeiro commit de Jelly foi feito por Dennis apenas alguns dias após ele ter criado esse desafio. Não sei em que data esse código teria funcionado pela primeira vez, mas, de qualquer forma, não é concorrente.
No momento da escrita, existe apenas uma maneira de acessar a hora que é por meio de uma string formatada ŒT,.

Este código calcula quanto tempo esperar e depois dorme. Se chamado, hh:00:00ele espera por 3600segundos: ele converte "00:00"para [0,0]subtrai o valor de 59para render [59,59], converte isso da base sessenta para dar e 3599, em seguida, adiciona um por um período de espera total de 3600segundos.

Talvez um loop possa ser feito; ou uma string compactada usando a palavra inteira "Legendary" poderia ser utilizada de alguma forma?

“ÇỴġƒḃhlḂṀ⁷*Ḣ¡w*Jḷv»Ṅø3ŒTṣ”:V_@59ḅ60‘œS@“dary!” - Main link: no arguments
“ÇỴġƒḃhlḂṀ⁷*Ḣ¡w*Jḷv»                            - compressed "Legen... wait for it..."
                    Ṅ                           - print z + '\n', return z
                     ø                          - niladic chain separation
                      3ŒT                       - '011' (3) time formatted string = "mm:ss"
                         ṣ”:                    - split on ':' -> ["mm","ss"]
                            V                   - eval -> [m,s]
                             _@59               - subtract from 59 - > [59-m, 59-s]
                                 ḅ60            - convert from base 60 -> 60*(59-m)+(59-s)
                                    ‘           - increment -> 60*(59-m)+(59-s) = y
                                        “dary!” - "dary!" = x
                                     œS@        - sleep y seconds then return x
                                                - implicit print

MathGolf , 39 bytes

"Legen... wait for it..."pÆt♪/╚÷▼"dary!

Experimente online!

Quase venceu pyth ...

Explicação

Æ     ▼  Repeat the next 5 characters while false
 t       push unix time in milliseconds
  ♪/     divide by 1000
    ╚÷   check if divisible by 3600 (tio solution has 3 in its place)

Pitão - 36 bytes

Espera até que os minutos sejam 0 com um loop while.

"Legen... wait for it..."W.d7)"dary!

Java, 136 bytes

class a{void A(){System.out.println("Legen... wait for it...");while(System.currentTimeMillis()%3600000!=0);System.out.print("dary!");}}

Quantos milissegundos passaram desde a última hora completa é o resultado de System.currentTimeMillis()mod 3.600.000.

O programa monolítico equivalente tem 159 bytes:

interface a{static void main(String[]A){System.out.println("Legen... wait for it...");while(System.currentTimeMillis()%3600000!=0);System.out.print("dary!");}}

QBIC , 58 bytes

?@Legen... wait for it...|#Dary!|{~mid$$|(_d,4,2)=@00||_XB

Explicação

?@Legen... wait for it...|     Define string literal "Leg[..]it..." and print it
#Dary!|                        Define string B as "Dary!", but don't use it yet
{                              Opens an indefinite DO loop
~mid$$|(...)=@00|              Translates to IF MID$(...) = C$, where C$ is "00"
    The MID$ takes two characters, starting from pos 4, from the system's time (_d)
    So, if the string "11:00" has "00" starting at pos 4,
_XB                            Terminate the program and print string B
(The DO loop and the IF are closed implicitly)