Detectar Viagem no Tempo


51

Atualmente, os computadores estão em toda parte - em carros, trens, skates e até reatores nucleares. A possibilidade de o seu software ser executado em um dispositivo de viagem no tempo é apenas uma questão de tempo. Você pode lidar com isso? Você pode pelo menos detectá-lo?

Sua tarefa:

  1. Escreva um programa que faça loops e continue consultando a hora do sistema, a fim de detectar a viagem no tempo.
  2. Se o tempo avançar um dia ou mais entre duas consultas consecutivas, será uma viagem no tempo. Nesse caso, seu programa deve imprimir:
    TS TS: YYYY? You mean we're in the future?
  3. Se o tempo retroceder, em qualquer valor, entre duas consultas consecutivas, será uma viagem no tempo retrógrada. Nesse caso, seu programa deve imprimir:
    TS TS: Back in good old YYYY.
  4. TS TSsão os carimbos de data e hora antes e depois da viagem no tempo. YYYYé o ano de destino.
  5. Os carimbos de data e hora podem estar em qualquer formato, que inclua pelo menos o ano, mês, dia, dia, hora, minuto e segundo com quatro dígitos, separados por não dígitos.

Limitações:

  1. Você deve apoiar datas nos séculos 19, 20 e 21, pelo menos.
  2. Você deve usar um idioma que existia antes que este desafio fosse lançado.
  3. Você deve postar suas respostas somente após este desafio ter sido lançado.
  4. Você deve usar um idioma que existia antes de sua resposta ser publicada.
  5. Você pode editar sua resposta somente depois de publicá-la.
  6. Seu programa não deve imprimir nenhuma saída além da saída necessária. Um ocasional "Grande Scott!" é permitido.

Isso é código-golfe. A resposta mais curta vence.
Referências relevantes a filmes provavelmente tornarão sua resposta muito longa, mas podem levar a votos positivos.



4
Você poderia ser um pouco mais específico sobre o # 5?
Mego

4
separados por não-dígitos? vaia. AAAAMMDDHHmmSS é o meu formato de carimbo de data / hora favorito.
Sparr

3
@Aequitas como você sabe? talvez o relógio do sistema é, na verdade imutável e "setting" é actuallly tempo de viagem
Rune FS

5
A limitação 2,3,4,5 é realmente dura, não sei se consigo lidar com isso.
Surt,

Respostas:


4

CJam, 118 bytes

et:Tes{es_@-[TS*Set:TS*':S]\_864e5<{[1$et0="? You mean we're in the future?"N]o}|0<{[_"Back in good old "et0='.N]o}&}g

Isso não funciona com o intérprete online.

Exemplo de saída após ajustar o tempo do meu computador duas vezes:

2015 10 21 11 2 45 1 3 -10800000 2015 10 23 11 2 45 0 5 -10800000: 2015? You mean we're in the future?
2015 10 23 11 2 53 448 5 -10800000 2015 10 21 11 2 52 0 3 -10800000: Back in good old 2015.

11
Por que ele não funciona com o intérprete on-line (exceto que não permite que você mexa com o tempo)?
Ugoren

11
Como esse é um loop infinito, o intérprete on-line mostra a saída somente após a conclusão do programa.
Dennis

11
Então, como você testa se funciona?
Ugoren

11
Usando o interpretador Java .
Dennis

9

Python 2, 210 bytes

from datetime import*
o=0
while 1:n=datetime.now();o=o or n;print"%s;%s: %s? You mean we're in the future?"%(o,n,n.year)if(n-o).days>=1else"%s;%s: Back in good old %s."%(n,o,n.year)if(n<o)else"Great Scott!";o=n

Os carimbos de data e hora são impressos em YYYY-MM-DD HH:MM:SSformato, separados por ponto e vírgula. Mudou para Python 2 de 3, uma vez que são 2 caracteres mais curtos para imprimir. Os spams costumam Great Scott!ser usados para normas que não viajam no tempo, já que é mais fácil e mais barato fazer isso do que configurar uma impressão condicional.


Ele espera o tempo como entrada? Não é isso que se pede (talvez seja vago). Além disso, parece imprimir linhas em branco quando o tempo se comporta bem.
Ugoren

Eu quis dizer perguntar ao sistema operacional, não ao usuário. Eu vou esclarecer.
Ugoren

8

JavaScript (ES6), 263 bytes

n=Date;o=n.now();(function g(){k=new n;j=new n(o);s=`${k} ${o} `;if(n.now()-o>86400)console.log(`${s}${k.getFullYear()}? You mean we're in the future?`);if(o-n.now()>84600){console.log(`${s}Back in good old ${k.getFullYear()}.`);}o=n.now();setTimeout(g,100);}());

Provavelmente, isso poderia ter relação com alguma reescrita para torná-la mais eficiente / pequena.

Fonte:

n=Date;
o=n.now();

(function go() {
   k=new n;
   j=new n(o);
   s=`${k} ${o} `;
   if (n.now() - o > 86400) {
      console.log(`${s}${k.getFullYear()}? You mean we're in the future?`);
   }
   if (o - n.now() > 84600) {
      console.log(`${s}Back in good old ${k.getFullYear()}.`);
   }
   o=n.now()
   setTimeout(go,100);
}());

11
Viagem para trás é definida como retroceder de qualquer quantia, não um dia. Além disso, devido às várias now()chamadas, ele pode perder um evento de viagem.
Ugoren

Uma tentativa de jogar isso: n = Data, o = n.now (); setInterval ("d = novo n, s = d +` $ {novo n (o)} `; f = d.getFullYear (); if ( n.now () - o> 8.64e + 7) console.log (s + f + `? Você quer dizer que estamos no futuro?`); if (o> n.now ()) console.log (s + ` De volta ao bom e velho $ {f} .`); o = n.now () ", 100);
21415 Stefhany

Eu acho que você pode jogar golfe na primeira parte o=(n=Date).now().
Conor O'Brien

Stefnotch 8.64e+7tem dois caracteres a mais que 86400.
quer

11
@ CᴏɴᴏʀO'Bʀɪᴇɴ Opa! Fiquei me perguntando por que não funcionou.
Florrie

5

Python 3, 195

from datetime import*
n=datetime.now
p=n()
while 1:
 c=n();f=(p,c,p.year);s=(0,("%s %s: %s? You mean we're in the future?"%f,"%s %s: Back in good old %s."%f)[p.day>c.day])[p>c];p=c
 if s:print(s)

Atualmente não imprime Great Scott porque não consigo encontrar uma boa maneira de torná-la ocasional.


5

Bash + coreutils, 177

d()(date -d@"$@")
for((b=`date +%s`;a=`date +%s`;b=a)){
t=`d $a`\ `d $b`
((a<b))&&d $b "+$t: Back in good old %Y."
((a>b+86400))&&d $b "+$t: %Y? You mean we're in the future?"
}

3

Ruby, 194 bytes

Ainda não tive tempo de reduzir isso. Tenho certeza de que há algumas otimizações escondidas lá.

require 'time';t=nil;while 1;n=Time.now;if t;s="#{t} #{n}: ";y=n.year;puts t>n ? "#{s}Back in good old #{y}" : (n>t+86400 ? "#{s}#{y}? You mean we're in the future?": "Great Scott!");end;t=n;end

Ungolfed (e muito mais legível):

require 'time'
t=nil
while 1
  n=Time.now
  if t                                             # on second or later pass
    s="#{t} #{n}: "                                # prepare the timestamp
    y=n.year
    puts t>n ?                                     # if we go back
      "#{s}Back in good old #{y}" :                # timestamp + phrase
      (n>t+86400 ?                                 # else, more than one day forward
        "#{s}#{y}? You mean we're in the future?": # timestamp + future
        "Great Scott!")                            # Great Scott!
  end
  t=n                                              # set a new jump point
end

Editar: corrigido para pedir tempo ao SO, em vez de um ser humano.


2
Algumas recomendações: use em loop{}vez de while 1...ende tente usar +para concatenação de cadeias de caracteres em vez de interpolação.
voikya

3

Lua 5.3, 174 bytes

T=os.time P=print l=T()::a::t=T()b=l.." "..t..": "y=os.date('%Y',t)_=t<l and
P(b.."Back in good old "..y)or t>l+86399 and
P(b..y.."? You mean we're in the future?")l=t goto a

Isto está jogando muito fora da regra "Timestamps pode estar em qualquer formato" ... o que eu tomei a liberdade de utilizar o formato de "segundos desde primeiro de janeiro de 1970"


Se eu continuar a minha interpretação de má qualidade de impressão de data e hora, e adotar o estrutura do MeepDarknessMeep, eu posso (sem ética) comprimir isso até ...

155 bytes

T=os.time::G::l=t or T()t=T()_=(t>l+86399or t<l)and
print(l.." "..t..": "..os.date(t<l
and"Back in good old %Y"or"%Y? You mean we're in the future?"))goto G

3
Timestamps may be in any format, that includes at least the 4-digit year, month, day, hour, minute and second, separated by non-digits.- isso não permite segundos desde a época.
Mego

4
coisa boa não "exclui" qualquer formato
thenumbernine

@ugoren Realmente essa exigência deve ser mais específico quanto à sua intenção
Mego

Eu não estou totalmente familiarizado com lua, então posso estar errado, mas parece que isso é impresso, Back in good ol YYYYmas deve ser impresso Back in good old YYYY. (Note o d no antigo)
Pokechu22

Nope boa captura, eu estava tentando barbear bytes onde quer que eu poderia :-p
thenumbernine

2

Lua 5.3, 179 178 173 171 169 168 163 bytes

q="%Y %c: "c=os.date::a::d=f f=os.time()_=d and(f-d>86399or f<d)and print(c(q,d)..c(q..(f<d and"Back in good old %Y."or"%Y? You mean we're in the future?")))goto a

Nota lateral: se você precisar de um número de ano inteiro, subtraia seis bytes. O motivo é que% c de lua (ou janelas ou de alguém!) Não produz o ano inteiro. Por esse motivo, os registros de data e hora podem parecer estranhos!

Isso também tira proveito dos carimbos de data / hora que podem ser separados por qualquer caractere que não seja um dígito!

Obrigado por me notificar da minha antiga referência math.abs e outras melhorias @thenumbernine :)

Lua 5.3, 151 bytes

Isso é 'copiar' o método de exibir a hora do @ thenumbernine, apenas mostrando o carimbo de data e hora em vez da data real. Isso não é competitivo, já que acho um pouco trapaceiro, basta postá-lo aqui para exibir meu trabalho :)

::a::d=f f=os.time()_=d and(f-d>86399or f<d)and print(d.." "..f..os.date(f<d and": Back in good old %Y."or": %Y? You mean we're in the future?"))goto a

11
Publicamos as duas respostas Lua quase ao mesmo tempo. Isso tem a dizer algo sobre viagens no tempo.
thenumbernine

Ahah, obrigado @thenumbernine! Finalmente consegui comentar:) #
MeepDarknessMeep #

2

C: 363 bytes

Minificado usando este script útil :

#include<stdio.h>
#include<time.h>
void p(time_t*t){char b[64];strftime(b,64,"%FT%T",localtime(t));printf("%s ",b);}int main(void){time_t a,b,d=60*60*24;int y;time(&a);while(1){time(&b);y=localtime(&b)->tm_year+1900;if(b<a){p(&a);p(&b);printf("Back in good old %d\n",y);}else if(b>a+d){p(&a);p(&b);printf("%d? You mean we're in the future?\n",y);}a=b;sleep(1);}}

Original:

#include <stdio.h>
#include <time.h>

void p(time_t * t) {
  char b[64];
  strftime(b, 64, "%FT%T", localtime(t));
  printf("%s ", b);
}

int main(void) {
  time_t a, b, d = 60*60*24;
  int y;

  time(&a);
  while(1) {
    time(&b);
    y = localtime(&b)->tm_year+1900;
    if (b < a) {
      p(&a); p(&b); printf("Back in good old %d\n", y);

    } else if (b > a + d) {
      p(&a); p(&b); printf("%d? You mean we're in the future?\n", y);
    }
    a = b;
    sleep(1);
  }
}

Exemplo de execução:

2015-10-23T23:30:03 1985-06-14T16:27:00 Back in good old 1985   
1985-06-14T16:27:07 1999-02-09T14:15:00 1999? You mean we're in the future?
1999-02-09T14:15:09 2015-02-09T14:15:00 2015? You mean we're in the future?
2015-02-09T14:15:36 2015-10-21T07:28:00 2015? You mean we're in the future?
2015-10-21T07:29:06 1985-10-26T09:00:00 Back in good old 1985
1985-10-26T09:00:28 2055-11-12T06:38:00 2055? You mean we're in the future?
2055-11-12T06:38:12 1919-10-07T00:09:57 Back in good old 1919
1919-10-07T00:09:57 2055-11-12T06:38:14 2055? You mean we're in the future?  # tried to go to 1955 - fail.
2055-11-12T06:39:09 2015-10-23T23:32:03 Back in good old 2015  # auto-time back to 2015 because my laptop didn't like the jump to 2055!

Eu poderia me livrar de 10 bytes removendo o sleep eu acho.

A propósito, alguma praticidade que salta no tempo para Mac / Linux:

sudo date 1026090085  # Sat 26 Oct 1985 09:00:00
sudo date 1021072815  # Wed 21 Oct 2015 07:28:00
sudo date 1112063855  # Intended to be 1955 but is 2055. Don't use!

Sinta-se livre para soltar o sleep.
Ugoren

2

JavaScript (ES6) 181 174 170 Bytes

for(a=Date;c=b||a.now(),b=d();e=new a(b).getFullYear(),f=`${a(c)} ${a(b):`})b>c+864e5?(g=alert)`${f} ${e}? You mean we're in the future?`:c>b&&g`${f} Back in good old `+e

Nota: Não foi testado com uma máquina de tempo real.

Esse código é executado no Firefox, Chrome, Edge, Node.js Harmony (ou io.js ). Mas, eu uso alert, de modo que terá que ser substituído por Suporte console.logpara Node e Io : (187 bytes)

for(a=Date,b=0;c=b||(d=a.now)(),b=d();e=new a(b).getFullYear(),f=`${a(c)} ${a(b):`})b>c+864e5?(g=console.log)`${f} ${e}? You mean we're in the future?`:c>b&&g`${f} Back in good old ${e}.`

Explicado:

// Using for like a while loop, defining relevant variables:
  for (a = Date, b = 0;
// Defing b and c: c becomes b, b becomes now. Also defining a shorthand for Date.now:                                
  c = b || a.now(),
  b = d();
// Defining Variables Relevant to this loop: e is the year according to b, f is the "TS TS:" string:                        
  e = new a(b).getFullYear(),
  f = `${a(c)} ${a(b):`
  )
// If b is greater than c plus a day (in milliseconds):
  b > c + 864e5 ?
  // Alert Time Forwand String: 
    (g = alert)
    `${f} ${e}? You mean we're in the future?`:
// else if c is greater than b:
  c > b &&
  // Alert Time Back String: 
    g `${f} Back in good old `+e

Consegui escrever uma ainda mais curta, você pode querer dar uma olhada e possivelmente melhorar a sua. Além disso, eu acho ótimo!
27515 Stefhany #

Qual foi o tamanho da sua solução, quero ver se consigo vencê-la? ;)
MayorMonty 24/10/2015

Role para baixo ou clique no link: codegolf.stackexchange.com/a/61544/33160 Além disso, você está bem perto de vencê-lo! : D
Stefnotch

2

Python, 170 165 bytes

from datetime import*
n=datetime.now
c=n()
while 1:
 p=c;c=n()
 if(c-p).days:print p,"%s:"%c,["%s? You mean we're in the future?","Back in good old %s."][c<p]%c.year

Isso deve muito à resposta de Morgan Thrapp. O principal truque aqui é a normalização do timedelta, que convenientemente torna o timedelta.days negativo quando se move um pouco até o passado e 0 quando se move menos de um dia para o futuro.


Depois que import*você não precisa do datetime.prefixo.
ugoren

@ugoren: import*permite escrever em datetime.now()vez de datetime.datetime.now(). É o tipo de faz sentido, de uma forma ...
han

De uma maneira confusa, é verdade.
Ugoren

1

Objeto Caché, 199 bytes

l s k=86400 f  s e=+$H,t=$P($H,",",2) s:'d d=e,s=t s z=$ZDT(h)_" "_$ZDT($H)_": ",y=h\365+1841 w:e>d !,z,y,"? You mean we're in the future?" w:(k*t+e)<(k*s+d) !,z,"Back in good old ",y s h=$H,d=e,s=t

Esse problema é solucionável em MUMPS antigos simples, mas seria excessivamente longo, já que o ANSI MUMPS não possui a $ZD[ATE]T[IME]função intrínseca para formatar datas em registros de data e hora legíveis por humanos.

Esse programa provavelmente não detectará viagens no tempo antes de 1 de janeiro de 1841, nem viagens após 31 de dezembro de 9999, pois esses são os limites intrínsecos da $H[OROLOG]cronometragem . Este programa também possui apenas precisão de segundo nível; as falhas de tempo anteriores ao sub-segundo nível provavelmente escaparão ao seu conhecimento.


1

TSQL, 355 bytes

No trabalho, nenhum idioma legal sofisticado fica com o servidor de produção do SQL Server =)

Versão Golfed

declare @a datetime=getdate(),@b datetime,@d float,@ char(99),@y char(4)while 0=0begin select @b=getdate(),@d=cast(@b as float)-cast(@a as float),@y=' '+DATEPART(y,@b),@=cast(@a as char(20))+' '+cast(@a as char(20))+': 'if @d>=1set @=@+@y+'? You mean we''re in the future?'if @d<0set @=@+'Back in good old '+@y+'.'print @ set @a=@b end

Versão mais legível com pequenas alterações.

declare @t0 datetime = getdate(), @t1 datetime, @d float, @m varchar(99), @y char(4)

while 0=0
begin

    set @t1 = getdate()
    set @d = cast(@t1 as float) - cast(@t0 as float)
    set @y = ' ' + DATEPART(yy, @t1)
    set @m = cast(@t0 as varchar(30)) + ' ' + cast(@t0 as varchar(30)) + ': '

    if @d >= 1 set @m = @m + @y + '? You mean we''re in the future?'
    if @d < 0 set @m = @m +  'Back in good old ' + @y + '.'

    print @m

    set @t0 = @t1
end

O SQL não é tão ruim em relação aos carimbos de data e hora, pois é um tipo de dados de primeira classe.

Para o bem do golfe, estamos usando um tipo com precisão de 3 milissegundos. O loop em si leva menos que isso para iterar (dependendo do seu servidor). A chave aqui é que o registro de data e hora é flutuante e o tipo inteiro conta quantos dias se passaram. Ele funcionará bem de 1º de janeiro de 1753 a 31 de dezembro de 9999.


1

VBA, 258 bytes

Correu com: Excel 2007 no Windows 7

305 bytes se a Usabilidade for necessária

AVISO Isso PODE Maximizar sua CPU e Crash Excel / Windows, se você estiver em um computador de núcleo único com rosca única (provavelmente encontrado em 1985)

Sub q()
h=CDbl(Now())
While 1
t=CDbl(Now())
If t>h+1 Then Debug.Print (CDate(t) & " " & CDate(h) & ":" & Year(t) & "? You mean we're in the future?")
If t<h Then Debug.Print (CDate(t) & " " & CDate(h) & ": Back in good old " & Year(t) & ".")
h=t
Wend
End Sub

Se você deseja que este código seja "testável", adicione Application.Wait (Now() + TimeValue("0:00:01"))depoish=t

Resultado

10/22/2015 3:04:45 PM 10/22/2015 3:04:43 PM:2015?You mean we're in the future?
10/22/2015 3:06:48 PM 10/22/2015 3:06:46 PM: Back in good old 2015.

Abaixo está o arquivo de teste que eu usei. Estou sinceramente impressionado com a pouca segurança do Windows às vezes. Pode não funcionar como esperado em todos os computadores

Correr por conta e risco pode ter efeitos colaterais prolongados !!!!
Sub DOC() t = 31346.6868055556 Date = DateSerial(Year(t), Month(t), Day(t)) Time = TimeSerial(Hour(t), Minute(t), Second(t)) q End Sub


1

Javascript 173 169 162 bytes

Javascript é bastante popular ...

for(e=Date,n=e.now;o=n(a=alert);)d=new e,f=d.getFullYear(n(o>n(s=d+` ${e(o)}:`)&&a(s+`Back in good old ${f}.`))-o>864e5&&a(s+f+`? You mean we're in the future?`))

Explicação (Versão mais antiga do código):

for(e=Date,n=e.now,a=alert,o=n();;o=n()) //Set up the variables and update o, the previous time

d=new e,s=d+` ${e(o)} `,f=d.getFullYear(), //d is the date, s is a string with the 2 timestamps, f is the year
n()-o>8.64e7&&a(s+f+`? You mean we're in the future?`), //Future check
o>n()&&a(s+`Back in good old ${f}.`) //Past check

0

Processando, 270 bytes

int p;long x=System.currentTimeMillis();void draw(){int q=millis(),y=year();if(q<p){t(p);print("Back in good old "+y+".");}if(q>p+86400000){t(p);print(y+"? You mean we're in the future?");}p=q;}void t(int m){print(new java.util.Date(x+m)+" "+new java.util.Date()+": ");}

Expandido:

int p;
long x=System.currentTimeMillis();
void draw() {
  int q=millis(), y=year();
  if (q<p) {
    t(p);
    print("Back in good old "+y+".");
  }
  if (q>p+86400000) {
    t(p);
    print(y+"? You mean we're in the future?");
  }
  p=q;
}
void t(int m) {
  print(new java.util.Date(x+m)+" "+new java.util.Date()+": ");
}

Saída de amostra:

Wed Oct 21 13:21:59 EDT 2015 Mon Oct 19 13:21:59 EDT 2015: Back in good old 2015.
Mon Oct 19 13:22:08 EDT 2015 Wed Oct 21 13:22:08 EDT 2015: 2015? You mean we're in the future

0

Ruby, 160 157 155 154 bytes

Muitas coisas para jogar golfe aqui

a=Time.new;loop{b,s,y=Time.new,"#{a} #{b}: ",b.year;$><<(a>b ? s+"Back in good old #{y}.\n":b>a+86400 ? s+"#{y}? You mean we're in the future?\n":"");a=b}

0

Mathematica, 295 bytes

O programa solicita ao sistema operacional a cada segundo novos TS.

f:=LocalTime[]
p=Print;
y:=DateString[#,"Year"]&
s:=ToString[#]<>" "&
d:=QuantityMagnitude@DateDifference[a,b]
j=StringJoin;
While[True,
  a=b;
  b=f;
  Pause@1;
  Which[d>=0,
   p@(j@@{s@a,s@b,": ",y@b, 
       "? You mean we are in the future?"}),
   d<0,
   p@(j@@{s@a,s@b," Back in good old ",y@b,"."})]];

Resultado

Testado pela alimentação manual de data / hora.

DateObject[{2015, 10, 23}, TimeObject[{18, 36, 17.9618}], TimeZone -> \
-4.] DateObject[{2015, 10, 25}, TimeObject[{18, 42, 0.264913}], \
TimeZone -> -4.] : 2015? You mean we are in the future?

DateObject[{2015, 10, 23}, TimeObject[{18, 43, 0.141572}], TimeZone -> -4.] DateObject[{2015, 10, 23}, TimeObject[{18, 42, 3.30681}], TimeZone -> -4.]  Back in good old 2015.

Definitivamente poderia ter o formato da saída melhor. Ele atende aos requisitos conforme indicado.


por que você atalho LocalTime[]? Aparece apenas uma vez no código a seguir.
Michael Stern

Em um ponto, eu estava usando duas vezes. Boa captura embora.
Lost in Knowledge

Remova-o e salve três caracteres.
Michael Stern

0

Groovy, 244 bytes

def s=9999,d={new Date()},y={it.year+1900},f={t,n->"$t $n: ${y(n)}? You mean we're in the future?"},p={t,n->"$t $n: Back in good old ${y(n)}."},t=d()
while(!sleep(s)){n=d()
c=n.time-t.time
println c<0?p(t,n):c>s*2?f(t,n):'Great Scott!'
t=n}

0

Java, 378 bytes.

function detect()
{
int diffInDays = (int)( (newerDate.getTime() - olderDate.getTime()) 
                 / (1000 * 60 * 60 * 24) );
if(diffInDays>0) 
System.out.println(olderDate+" "+newerDate+": "+newerDate.getYear()+"? You mean we're in the future?");
else if(diffInDays<0) 
System.out.println(olderDate+" "+newerDate+": "+"Back in good old "+newerDate.getYear());
} 
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.