Você sabe que as APIs de relógio / hora do seu idioma estão quebradas e não são confiáveis.

Portanto, você não tem permissão para usar nenhuma API interna para acessar a hora / data do sistema.

Mas você também sabe que a capacidade do seu idioma de realizar cálculos de datas e manter um valor de data / hora em uma variável estão corretos.

Escreva um programa que imprima a data / hora atual sem chamar nenhuma API de data / hora / relógio. Por exemplo DateTime.Now, GetDate()funções semelhantes não são permitidas.

A resposta com a maioria dos votos positivos vence.

Em caso de empate, a resposta com mais precisão vence (ou seja, precisa até segundos, depois milissegundos, depois microssegundos e assim por diante).

Java

Quase todas as soluções atuais assumem que o computador local / remoto não está mentindo cerca de uma hora atual (você acreditaria no T-600 também?).
O ponto chave no cálculo do tempo é confiar em uma natureza pura .
Este aplicativo Android pede ao usuário para tirar uma foto do céu e está prevendo a hora atual com precisão excepcional:

public void onActivityResult(int requestCode, int resultCode, Intent data) 
{
   if (resultCode == RESULT_OK) 
   {
      Uri selectedImageUri = data.getData();
      this.imageView.setImageURI(selectedImageUri);

      TimeGuesser guesser = new TimeGuesser(this);
      String result = guesser.guessTimeFromImage(selectedImageUri);
      this.textView.setText(result);   
   }
}

public class TimeGuesser {

    private Context context;
    public TimeGuesser(Context context)
    {
        super();
        this.context = context;
    }

    public String guessTimeFromImage(Uri uri) {
        Bitmap bitmap = null;
        try {
            bitmap = MediaStore.Images.Media.getBitmap(this.context.getContentResolver(), uri);
        } catch (IOException e) {
            return "There is no sky. Everyone's going to die";
        }

        float brightness = getBrightness(bitmap);

        if (brightness < 90.0)
        {
            return "It's sooo late";
        } else {
            return "It's sooo early";
        }
    }

    private float getBrightness(Bitmap bitmap)
    {
        float R, G, B;
        R = G = B = 0.0f;
        int pixelColor;
        int width = bitmap.getWidth();
        int height = bitmap.getHeight();
        int size = width * height;

        for (int x = 0; x < width; ++x) {
            for (int y = 0; y < height; ++y) {
                pixelColor = bitmap.getPixel(x, y);
                R += Color.red(pixelColor);
                G += Color.green(pixelColor);
                B += Color.blue(pixelColor);
            }
        }

        R /= size;
        G /= size;
        B /= size;

        float brightness =  (0.2126f*R ) + (0.7152f*G) + (0.0722f*B);
        return brightness;
    }
}

Resultados:

Rubi

Sejamos honestos: o tempo muda apenas quando algo é publicado no stackoverflow.com ;)

O script extrai o tempo do rótulo "XYs ago" na pergunta principal.

require 'net/http'
source = Net::HTTP.get('stackoverflow.com', '/')

puts source.match(/span title=\"(.*)\" class=\"relativetime/)[1]

Resultado:

2014-03-10 18:40:05Z

Bater

Como isso? (requer wgete grep)

wget -qO- 'http://www.wolframalpha.com/input/?i=current+time'|grep ' am \| pm '

A saída que recebi alguns minutos atrás:

                    Why am I seeing this message? 
  context.jsonArray.popups.pod_0200.push( {"stringified": "6:08:38 pm GMT\/BST  |  Monday, March 10, 2014","mInput": "","mOutput": "", "popLinks": {} });

Ou isto? (requer wgete eog)

wget http://c.xkcd.com/redirect/comic/now
eog ./now
rm ./now

Saída que recebo agora: (Imagem por xkcd )

mapa-múndi com fuso horário http://c.xkcd.com/redirect/comic/now

sh / coreutils

touch . && stat . -c %z

Mostra a data em um formato um pouco fora do padrão:
YYYY-MM-DD hh:mm:ss.nanoseconds +timezone
embora eu ache que possa depender da localidade.

PHP

Explorar o fato de que uniqid()retorna um ID com base no horário.

$u=hexdec(substr(uniqid(),0,8));

$y=floor($u/31536000);
$u-=$y*31536000;
$y+=1970;

$d=floor($u/86400);
$u-=$d*86400;

$h=floor($u/3600);
$u-=$h*3600;

$m=floor($u/60);

$s=$u-$m*60;

echo 'Year='.$y.' Days='.$d.' Hours='.$h.' Minutes='.$m.' Seconds='.$s;

Durante o meu teste, ele retornou: Year=2014 Days=79 Hours=18 Minutes=9 Seconds=49.
Não sei se posso usar datepara formatar corretamente e converti-o manualmente.

DNS

Desconfiamos apenas de nossa própria máquina? Se sim, isso conta?

ssh $othermachine date

Se isso não conta, extrair tempo da atualização do DNS definitivamente conta:

dig stackexchange.com | grep WHEN

Bater

Apenas para ser sempre absolutamente preciso e correto:

echo "Now"

ou motivador:

echo "Now, do something useful today"

curl - preciso para qualquer que seja sua taxa de ping

curl -s time.nist.gov:13

Pitão

Tem certeza de que não sabe que horas são?!? Aqui está um lembrete:

print "It's Adventure Time!"

Python 2

Então, o relógio está correto, mas a API da hora é liberada, certo? Por que não verificar um registro de data e hora do sistema de arquivos brutos. Em vez de criar um arquivo de teste, apenas usamos nosso próprio registro de data e hora de acesso, pois o script precisa ser lido para ser executado (mesmo que tenha sido compilado). Preciso para o segundo. *

import os
h, m = divmod(os.stat('t.py').st_atime % 86400, 3600)
print h+1, m // 60, m % 60

Isso deve ser salvo e executado como t.py. Como alternativa, obtenha o nome do script em tempo de execução cominspect.getfile(inspect.currentframe())

Nota * Ocasionalmente exato em relação ao segundo anterior .

Rubi

HTTP, mas apenas usando metadados de resposta.

require 'uri'
require 'net/http'

def get_now
  uri = URI.parse("http://google.com")
  http = Net::HTTP.new(uri.host, uri.port)
  request = Net::HTTP::Get.new(uri.request_uri)
  rsp = http.request(request)
  rsp['date']
end

ps

Não pssabe as horas? Pode!

sleep 1&  ps -o lstart -p $!

O processo é iniciado em segundo plano e psinforma a hora em que o processo foi iniciado. Desde que o processo começou em segundo plano, o horário de início do processo é praticamente o mesmo de agora.

Além disso, a vantagem é que a hora é obtida no fuso horário local. E você também não precisa de uma conexão à Internet!

vba

porque eu não deveria.

Public Function DateTime() As String
Dim myNTPsvr As String
Dim dattime As String
Dim oHTTP As Object

myNTPsvr = "time.windows.com"
Set oHTTP = CreateObject("WinHttp.WinHttpRequest.5.1")
oHTTP.Open "GET", "http://" & myNTPsvr & "/", False
oHTTP.Send

DateTime = oHTTP.GetResponseHeader("Date")

Set oHTTP = Nothing
End Function

use ?DateTimeto use, ou se você o colocar no Excel, =DateTime()funcionará como uma fórmula.
A data / hora é retornada no GMT - eu o deixo como um exercício de futilidade para convertê-lo de uma string para a hora local

Bash + last+ head+cut

Preciso para o segundo. lastusa o arquivo de log/var/log/wtmp

$ last -RF reboot | head -n1 | cut -c50-73
Tue Mar 11 09:38:53 2014
$ 

EDIT: Adicionado headpara limitar a apenas uma linha.

EDIT: Isso funciona no Linux Mint 13 Cinnamon de 64 bits, mas parece que isso depende da sua distribuição. sysvinit-utils(que fornece last) a versão é 2.88dsf-13.10ubuntu11.1 lastleituras /var/log/wtmp(no meu caso) para que os resultados dependam desse arquivo de log. Veja os comentários abaixo.

EDIT: Aparentemente, isso depende do tempo de atividade do sistema, para que você possa ver a prova aqui http://imgur.com/pqGGPmE

Pitão

Obter precisão em nanossegundos seria complicado, a menos que o tempo retornado fosse baseado no momento em que o programa termina a execução, não no início. Com isso em mente, faz mais sentido calcular o tempo com base no término de um programa. Isso significa que devemos controlar quando um programa para de ser executado para obter precisão extra.

import subprocess

def what_day_is_it(): return int(subprocess.check_output(["date", "+%dd"]))[:-2];

current_day = next_day = what_day_is_it # It's a bash call, 
while not current_day - next_day:
  next_day = what_day_is_it()
print "It's midnight."
print "Probably."

Observe que isso pressupõe que enquanto o relógio python está acionado, o relógio bash não está ou que o relógio bash sabe pelo menos que dia é hoje. Caso contrário, podemos usar isso:

def what_year_is_it(): return int(subprocess.check_output(["date", "+%yy"]))[:-2];

Pode ser um pouco mais lento, no entanto. Eu não testei.

BrainFuck

>+++++++[-<++++++++>]<---.>+++++[-<+++++>]<++.---.>++++++++[-<-------->]<---.

Resultado:

5PM

Eu acho que mostra o tempo em Denver no momento em que escrevi. A explicação para o algoritmo aqui neste vídeo de Alan Jackson .

Rubi

`date`

Não usa a API de relógio / hora do idioma.

Gostei da idéia "ler de um servidor de horário". Melhorou sua formatação e adicionou algumas cidades por diversão.

PHP

$page = file_get_contents("http://www.timeapi.org/utc/now");
echo "In London: ".date("H:i:s - jS F, Y", strtotime($page))."<br>";
echo "In Rome: ".date("H:i:s - jS F, Y", strtotime($page)+3600)."<br>";
echo "In Athens: ".date("H:i:s - jS F, Y", strtotime($page)+7200)."<br>";

Bater

echo "It's eight o'clock."

Com agradecimentos ao The Goon Show . (Além disso, é certo duas vezes por dia!)

C / WinAPI

Isso pressupõe que minha própria API chama para consultar o relógio está quebrada, mas o próprio sistema pode funcionar com o horário corretamente.

// NO ERROR CHECKING - that's left as an exercise for the reader
TCHAR tmpfilename[MAX_PATH];
TCHAR tmpfilepath[MAX_PATH];

// get some information to create a temporary file
DWORD dwRes = GetTempPath(MAX_PATH, tmpfilepath);
UINT uiRes  = GetTempFileName(tmpfilepath, TEXT("golftime"), 0, tmpfilename);

// create the file
HANDLE hTempFile = CreateFile(tmpfilename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);

// read the creation time of the file. accuracy is to, uhm... 10ms on NTFS?
FILETIME created;
GetFileTime(hTempFile, &created, NULL, NULL);

// convert the filetime to a system time (in UTC)
SYSTEMTIME systime;
FileTimeToSystemTime(&created, &systime);

std::cout << "Time is " <<
    systime.wHour << ":" << systime.wMinute << ":" << systime.wSecond << "." << systime.wMilliseconds << "\n";

// close the file and delete
CloseHandle(hTempFile);
DeleteFile(tmpfilename);

A idéia é criar um arquivo temporário e ler o tempo de criação, que, no NTFS, acho que é preciso até 10ms. Observe que a formatação da saída é duvidosa, mas isso é puramente preguiçoso.

Saída na minha máquina agora: Time is 10:39:45.790

Lote

@echo off
echo.>>%0
for /f "tokens=2,3 skip=4" %%a in ('dir /TW %0') do echo %%a %%b & goto :EOF

Grava uma linha em branco no arquivo em lotes (em si) e verifica a última hora de gravação do arquivo.

H:\uprof>GetTime.bat
09:28 AM

H:\uprof>GetTime.bat
09:29 AM

HTML, CSS e Javascript / jQuery

Ok, então eu sei que tecnicamente não é um programa e provavelmente está fora dos critérios, mas em apenas algumas horas, este será o relógio mais preciso do mundo!

CSS

@font-face {
    font-family:"DSDIGI";
    src:url("http://fontsforweb.com/public/fonts/1091/DSDIGI.eot") format("eot"),
    url("http://fontsforweb.com/public/fonts/1091/DSDIGI.ttf") format("truetype");
    font-weight:normal;
    font-style:normal;
}
#backer {
    background-image: url('http://i.imgur.com/w3W5TPd.jpg');
    width: 450px;
    height: 354px;
    color: red;
    font-family: 'DSDIGI';
}
#backer p {
    width: 100%;
    display: block;
    line-height: 325px;
    font-size: 60px;
}

HTML

<div id="backer">
    <p>
        BEER<span id="fade">:</span>30
    </p>
</div>

jQuery

function start() {
    $('#fade').fadeOut(function() {
        $('#fade').fadeIn();
    });
    setTimeout(start, 1000);
}
start();

No começo, eu fazia um while(true)loop, mas depois lembrei que não queria travar nenhum navegador ...

Aqui está um violino em ação: http://jsfiddle.net/E7Egu/

Emacs Lisp

A coisa do google foi feita, mas não no emacs!

(url-retrieve "http://www.google.com/search?q=time" (lambda(l)            
        (search-forward-regexp "[0-9]?[0-9]:[0-9][0-9][ap]m")
        (print (buffer-substring (point) (1+ (search-backward ">"))))))

node.js / Javascript

var fs = require('fs'),
    util = require('util');

var date = null, time = null;

fs.readFile('/sys/class/rtc/rtc0/date', 'UTF-8', function(err, d) {
    date = d.trim();
    if(time)
        done();
})

fs.readFile('/sys/class/rtc/rtc0/time', 'UTF-8', function(err, t) {
    time = t.trim();
    if(date)
        done();
});

function done() {
    console.log(util.format('%sT%sZ', date, time));
}

Javascript

new Date(performance.timing.navigationStart+performance.now())+''

Como a API de relógio / hora está quebrada, eu uso a API de desempenho para obter a hora. Então Dateé usado apenas para analisá-lo em string.

PHP:

 $n=PHP_SHLIB_SUFFIX=='dll'?strtotime(str_replace(PHP_EOL,' ',`date /t&time /t`).' GMT'):`date +%s`;

Isso lerá a hora do sistema na interface de linha de comando disponível.

O operador backtick é usado para fazer exatamente isso: execute um comando.

Outra maneira seria:

$_SERVER['REQUEST_TIME'];

Que contém o horário atual em que o script foi chamado.

Bater

export PS1="(\t) $PS1"

Contorna as regras um pouco, mas nunca chama uma função de tempo. No entanto, ele exibirá a hora atual na saída e toda vez que você pressionar enter depois disso.

C #

Esse método super-exato funcionará - desde que você execute o programa em 0: 00: 00.0000

using System;
using System.Threading;

namespace ConsoleApplication1 {
  class Program {
    private static volatile int s_Hour;
    private static volatile int s_Minute;
    private static volatile int s_Second;
    private static volatile int s_Millisecond;

    class Looper {
      public int Length { get; set; }
      public Action Update { get; set; }
    }

    static void Loop(object args) {
      var looper = (Looper)args;
      while (true) {
        Thread.Sleep(looper.Length);
        looper.Update.Invoke();
      }
    }

    static void Main(string[] args) {
      var starter = new ParameterizedThreadStart(Loop);
      new Thread(starter).Start(new Looper { Length = 100, Update = () => { s_Millisecond = (s_Millisecond + 100) % 1000; } });
      new Thread(starter).Start(new Looper { Length = 1000, Update = () => { s_Second = (s_Second + 1) % 60; } });
      new Thread(starter).Start(new Looper { Length = 60 * 1000, Update = () => { s_Minute = (s_Minute + 1) % 60; } });
      new Thread(starter).Start(new Looper { Length = 60 * 60 * 1000, Update = () => { s_Hour++; } });

      Console.Out.WriteLine(@"Press e to exit, enter to write current time...");
      while (true) {
        string input = Console.In.ReadLine();
        if (input == "e") {
          Environment.Exit(0);
          return;
        }
        Console.Out.WriteLine("{0:00}:{1:00}:{2:00},{3}", s_Hour, s_Minute, s_Second, s_Millisecond);
      }
    }
  }
}

Linux, a maioria dos shells, em hardware com um RTC:

echo `cat /sys/class/rtc/rtc0/{date,time} | tr "\n" " "`

Java

Todos sabemos que a API Java Data / Hora não pode ser usada e está corrompida. Então, aqui está uma correção que (pelo menos diretamente) não usa nenhuma API existente. Ele ainda suporta segundos bissextos! :) A saída está no UTC.

import java.lang.reflect.Field;
import java.net.HttpCookie;
import java.util.*;

public class FixedTimeAPI4Java {

    private static final List<Integer> MONTHS_WITH_30_DAYS = Arrays.asList(4, 6, 9, 11);
    private static final List<Integer> YEARS_WITH_LEAP_SECOND_IN_DECEMBER = Arrays.asList(1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 1987, 1989, 1990, 1995, 1998, 2005, 2008);
    private static final List<Integer> YEARS_WITH_LEAP_SECOND_IN_JUNE =  Arrays.asList(1972, 1981, 1982, 1983, 1985, 1992, 1993, 1994, 1997, 2012);

    /**
    * Returns the UTC time, at the time of method invocation, with millisecond
    * precision, in format <code>yyyy-MM-dd HH:mm:ss.SSS</code>.
    */
    public String getTime() throws Exception {

        // The cookie is only used for accessing current system time
        HttpCookie cookie = new HttpCookie("Offline", "Cookie");
        Field created = HttpCookie.class.getDeclaredField("whenCreated");
        created.setAccessible(true);

        long millisecondsSinceEpoch = created.getLong(cookie);        
        long fullSecondsSinceEpoch = millisecondsSinceEpoch / 1000L; 

        int year = 1970, month = 1, dayOfMonth = 1, hour = 0, minute = 0, second = 0,
            millisecond = (int)(millisecondsSinceEpoch - (fullSecondsSinceEpoch * 1000L));

        ticks: 
        for (;; year++) {
            for (month = 1; month <= 12; month++) {
                for (dayOfMonth = 1; dayOfMonth <= daysInMonth(month, year); dayOfMonth++) {
                    for (hour = 0; hour < 24; hour++) {
                        for (minute = 0; minute < 60; minute++) {
                            for (second = 0; second < secondsInMinute(minute, hour, dayOfMonth, month, year); second++, fullSecondsSinceEpoch--) {
                                if (fullSecondsSinceEpoch == 0) {
                                    break ticks;
                                }
                            }
                        }
                    }
                }
            }
        }
        return String.format("%04d-%02d-%02d %02d:%02d:%02d.%03d", year, month,
            dayOfMonth, hour, minute, second, millisecond);
    }

    /**
     * Returns the seconds in the given minute of the given hour/day/month/year,
     * taking into account leap seconds that can be added to the last minute of
     * June or December.
     */
    private static int secondsInMinute(int minute, int hour, int day, int month, int year) {
        return (minute == 59 && hour == 23 && ((day == 30 && month == 6) || (day == 31 && month == 12))) 
                ? 60 + leapSecondsInMonth( month, year) 
                : 60;
    }

    /**
     * Returns the number of days in the given month of the given year.
     */
    private static int daysInMonth(int month, int year) {
        return month == 2 ? isLeapYear(year) ? 29 : 28
                : MONTHS_WITH_30_DAYS.contains(month) ? 30
                    : 31;
    }

    /** 
     * Returns whether the given year is a leap year or not. 
     * A leap year is every 4th year, but not if the year is divisible by 100, unless if it's divisible by 400.
     */
    private static boolean isLeapYear(int year) {
        return (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) ? true : false;
    }

    /** 
     * Returns the number of leap seconds that were added to UTC time at the end of the given month and year.
     * Leap seconds are added (by the decison of International Earth Rotation Service / Paris Observatory)
     * in order to keep UTC within 0.9 seconds of international atomic time (TAI).
     * <p>TODO: implement parser for updated list at http://www.ietf.org/timezones/data/leap-seconds.list :)
     */
    private static int leapSecondsInMonth(int month, int year) {        
        return (year < 1972 || year > 2012) ? 0
                : (month == 6 && YEARS_WITH_LEAP_SECOND_IN_JUNE.contains(year)) ? 1
                    : (month == 12 && YEARS_WITH_LEAP_SECOND_IN_DECEMBER.contains(year)) ? 1
                        : 0;
    }

    public final static void main(String[] args) throws Exception {
        System.out.println(new FixedTimeAPI4Java().getTime());        
    }
}