Usted sabe que las API de reloj / hora de su idioma están rotas y no son confiables en absoluto.

Por lo tanto, no puede utilizar ninguna API integrada para acceder a la hora / fecha del sistema.

Pero también sabe que la capacidad de su idioma para realizar cálculos de fechas y retener un valor de fecha / hora en una variable es correcta.

Escriba un programa que imprima la fecha / hora actual sin llamar a ninguna API de fecha / hora / reloj. Por ejemplo DateTime.Now, GetDate()y funciones similares no están permitidas.

La respuesta con la mayoría de los votos a favor gana.

En caso de empate, la respuesta con más precisión gana (es decir, precisa hasta segundos, luego milisegundos, luego microsegundos, etc.).

Java

Casi todas las soluciones actuales suponen que la computadora local / remota no miente sobre una hora actual (¿creería usted también en T-600?).
El punto clave en el cálculo del tiempo es confiar en una naturaleza pura .
Esta aplicación de Android le pide al usuario que tome una foto del cielo y predice la hora actual con una precisión sobresaliente:

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:

Rubí

Seamos honestos: el tiempo solo cambia cuando algo se publica en stackoverflow.com ;)

El script extrae el tiempo de la etiqueta "Hace XYs" en la pregunta principal.

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

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

Salida:

2014-03-10 18:40:05Z

Golpetazo

¿Me gusta esto? (requiere wgety grep)

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

La salida que obtuve hace unos minutos:

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

¿O esto? (requiere wgety eog)

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

Salida que obtengo ahora: (Imagen de xkcd )

mapa mundial con zona horaria http://c.xkcd.com/redirect/comic/now

sh / coreutils

touch . && stat . -c %z

Emite la fecha en un formato algo no estándar:
YYYY-MM-DD hh:mm:ss.nanoseconds +timezone
aunque supongo que podría depender de la configuración regional.

PHP

Explote el hecho de que uniqid()devuelve una identificación basada en el tiempo.

$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 mi prueba, ha devuelto: Year=2014 Days=79 Hours=18 Minutes=9 Seconds=49.
No sé si puedo usar datepara formatear correctamente, así que lo convertí manualmente.

DNS

¿Solo desconfiamos de nuestra propia máquina? Si es así, ¿cuenta esto?

ssh $othermachine date

Si eso no cuenta, el tiempo de extracción de la actualización de DNS definitivamente sí:

dig stackexchange.com | grep WHEN

Golpetazo

Solo para ser siempre absolutamente preciso y correcto:

echo "Now"

o motivador:

echo "Now, do something useful today"

curl: preciso a cualquier velocidad de ping

curl -s time.nist.gov:13

Pitón

¿Estás seguro de que no sabes qué hora es? Aquí hay un recordatorio:

print "It's Adventure Time!"

Python 2

Entonces, el reloj es correcto pero la API de tiempo está manguera, ¿verdad? ¿Por qué no verificar una marca de tiempo del sistema de archivos sin formato? En lugar de crear un archivo de prueba, que sólo tiene que utilizar nuestra propia marca de tiempo de acceso desde el guión tiene que ser leído a correr (incluso si se ha compilado). Preciso al segundo. *

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

Esto debe guardarse y ejecutarse como t.py. Alternativamente, obtenga el nombre del script en tiempo de ejecución coninspect.getfile(inspect.currentframe())

Nota * Ocasionalmente precisa al segundo anterior .

Rubí

HTTP, pero solo usando metadatos de respuesta.

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

PD

No puedo psdecir la hora? ¡Puede!

sleep 1&  ps -o lstart -p $!

El proceso se inicia en segundo plano y psle dice a qué hora comenzó el proceso. Dado que el proceso comenzó en segundo plano, la hora de inicio del proceso es más o menos la misma que ahora.

Además, la ventaja es que la hora se obtiene en la zona horaria local. ¡Y tampoco necesitas una conexión a Internet!

vba

porque no debería

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

usar ?DateTimepara usar, o si lo pones en Excel, entonces =DateTime()funcionará como una fórmula.
La fecha / hora se devuelve en GMT: lo dejo como un ejercicio inútil para convertirlo de una cadena a hora local

Bash + last+ head+cut

Preciso al segundo. lastusa el archivo de registro/var/log/wtmp

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

EDITAR: agregado headpara limitar a una sola línea.

EDITAR: Esto funciona en Linux Mint 13 Cinnamon 64-bit pero parece que esto depende de su distribución. sysvinit-utils(que proporciona last) la versión se 2.88dsf-13.10ubuntu11.1 lastlee /var/log/wtmp(en mi caso), por lo que los resultados dependen de ese archivo de registro. Ver comentarios a continuación.

EDITAR: Aparentemente, esto depende del tiempo de actividad del sistema para que pueda ver la prueba aquí http://imgur.com/pqGGPmE

Pitón

Obtener precisión de nanosegundos sería complicado a menos que el tiempo devuelto se basara en cuándo el programa termina de ejecutarse, no cuando comienza. Con eso en mente, tiene más sentido calcular el tiempo en función de cuándo termina un programa. Esto significa que debemos controlar cuándo un programa deja de ejecutarse para obtener mayor precisión.

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

Tenga en cuenta que esto supone que mientras el reloj de pitón está descorchado, el reloj bash no lo está o que el reloj bash al menos sabe qué día es. Si no, podemos usar esto:

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

Sin embargo, podría ser un poco más lento. No lo he probado.

BrainFuck

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

Salida:

5PM

Creo que muestra la hora en Denver al momento de escribir. La explicación del algoritmo aquí por este video de Alan Jackson .

Rubí

`date`

No utiliza la API de reloj / hora del idioma.

Me gustó la idea de "leer desde un servidor horario". Sin embargo, mejoró su formato y agregó algunas ciudades por diversión.

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

Golpetazo

echo "It's eight o'clock."

Gracias a The Goon Show . (¡Además, es correcto dos veces al día!)

C / WinAPI

Esto supone que mis propias llamadas a la API para consultar el reloj están rotas, pero el sistema en sí puede funcionar correctamente con la hora.

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

La idea es crear un archivo temporal y leer el tiempo de creación, que en NTFS creo que es preciso hasta 10 ms. Tenga en cuenta que el formato de la salida es dudoso, pero eso es puramente como soy flojo.

Salida en mi máquina justo ahora: 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

Escribe una línea en blanco en el archivo por lotes (en sí), luego verifica el último tiempo de escritura del archivo.

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

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

HTML, CSS y Javascript / jQuery

Ok, sé que esto no es técnicamente un programa, y ​​probablemente esté fuera de los criterios, pero en solo unas pocas horas, ¡este será el reloj más preciso del 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();

Al principio iba a hacer un while(true)bucle, pero luego recordé que no quería bloquear ningún navegador ...

Aquí hay un violín en acción: http://jsfiddle.net/E7Egu/

Emacs Lisp

¡Lo de Google se ha hecho pero no en 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())+''

Dado que la API de reloj / hora está rota, uso la API de rendimiento para obtener la hora. Entonces Datesolo se usa para analizarlo en cadena.

PHP:

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

Esto leerá la hora del sistema desde la interfaz de línea de comandos disponible.

El operador de retroceso se usa para hacer exactamente eso: ejecutar un comando.

Otra forma sería:

$_SERVER['REQUEST_TIME'];

Que contiene la hora actual a la que se llamó el script.

Golpetazo

export PS1="(\t) $PS1"

Bordea las reglas un poco, pero nunca llama a una función de tiempo. Sin embargo, mostrará la hora actual al salir, y cada vez que presione enter después de eso.

C#

Este método súper exacto funcionará, siempre que ejecute el programa a las 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, la mayoría de los shells, en hardware con un RTC:

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

Java

Todos sabemos que la API de fecha / hora de Java no se puede usar y está rota. Entonces, aquí hay una solución que no utiliza (al menos directamente) ninguna de las API existentes. ¡Incluso admite segundos intercalares! :) La salida está en 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());        
    }
}