Vous savez que les API d'horloge / temps de votre langue sont brisées et qu'elles ne sont pas fiables du tout.

Par conséquent, vous n'êtes pas autorisé à utiliser une API intégrée pour accéder à l'heure / la date du système.

Mais vous savez également que la capacité de votre langue à effectuer le calcul des dates et à conserver une valeur de date / heure dans une variable est correcte.

Ecrivez un programme qui imprime la date / heure actuelle sans appeler les API de date / heure / horloge. Par exemple DateTime.Now, GetDate()les fonctions similaires ne sont pas autorisées.

La réponse avec le plus de votes positifs l'emporte.

En cas d'égalité, la réponse avec plus de précision l'emporte (c'est-à-dire précise à quelques secondes près, puis en millisecondes, puis en microsecondes, etc.).

Java

Presque toutes les solutions actuelles supposent qu'un ordinateur local / distant ne ment pas sur une heure actuelle (croyez-vous également au T-600?).
Le calcul du moment clé consiste à faire confiance à une nature pure .
Cette application Android demande à l'utilisateur de prendre une photo du ciel et de prédire l'heure actuelle avec une précision exceptionnelle:

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

Résultats:

Rubis

Soyons honnêtes: le temps change seulement quand quelque chose est posté sur stackoverflow.com ;)

Le script extrait l'heure du libellé "Il y a XYs" dans la première question.

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

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

Sortie:

2014-03-10 18:40:05Z

Frapper

Comme ça? (nécessite wgetet grep)

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

La sortie que j'ai obtenue il y a quelques minutes:

                    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 ca? (nécessite wgetet eog)

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

La sortie que je reçois maintenant: (Image de xkcd )

carte du monde avec fuseau horaire http://c.xkcd.com/redirect/comic/now

sh / coreutils

touch . && stat . -c %z

Affiche la date dans un format quelque peu non standard:
YYYY-MM-DD hh:mm:ss.nanoseconds +timezone
Bien que j'imagine que cela pourrait dépendre des paramètres régionaux.

PHP

Exploiter le fait que uniqid()renvoie un identifiant basé sur l'heure.

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

Au cours de mon test, il est revenu: Year=2014 Days=79 Hours=18 Minutes=9 Seconds=49.
Je ne sais pas si je peux utiliser datepour formater correctement, alors je l'ai converti manuellement.

DNS

Ne nous méfions que de notre propre machine? Si oui, cela compte-t-il?

ssh $othermachine date

Si cela ne compte pas, extraire le temps de la mise à jour DNS a certainement:

dig stackexchange.com | grep WHEN

Frapper

Juste pour être toujours absolument précis et correct:

echo "Now"

ou motivant:

echo "Now, do something useful today"

curl - précis quel que soit votre taux de ping

curl -s time.nist.gov:13

Python

Vous êtes sûr de ne pas savoir quelle heure il est?!? Voici un rappel:

print "It's Adventure Time!"

Python 2

Donc, l'horloge est correcte mais le temps API est fermé, non? Pourquoi ne pas vérifier l’horodatage d’un système de fichiers brut. Au lieu de créer un fichier de test, nous utilisons simplement notre propre horodatage d'accès, car le script doit être lu pour être exécuté (même s'il a été compilé). Précis à la seconde. *

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

Cela devrait être enregistré et exécuté en tant que t.py. Sinon, obtenez le nom du script au moment de l'exécution avecinspect.getfile(inspect.currentframe())

Remarque * Parfois précis à la seconde précédente .

Rubis

HTTP, mais en utilisant simplement les méta-données de réponse.

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

Vous ne pouvez pas psdire l'heure? Ça peut!

sleep 1&  ps -o lstart -p $!

Le processus est lancé en arrière-plan et psindique l'heure à laquelle le processus a démarré. Depuis que le processus a démarré en arrière-plan, l'heure de début du processus est à peu près identique à celle d'aujourd'hui.

De plus, l'avantage est que l'heure est obtenue dans le fuseau horaire local. Et vous n'avez pas besoin d'une connexion Internet non plus!

vba

parce que je ne devrais pas.

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

utiliser ?DateTimepour utiliser, ou si vous le mettez dans Excel, alors =DateTime()fonctionnera comme une formule.
La date / heure est renvoyée à l'heure GMT - je le laisse comme un exercice futile de le convertir d'une chaîne en heure locale

Bash + last+ head+cut

Précis à la seconde. lastutilise le fichier journal/var/log/wtmp

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

EDIT: ajouté headpour limiter à une seule ligne.

EDIT: Cela fonctionne sur Linux Mint 13 Cinnamon 64 bits, mais il semble que cela dépend de votre distribution. sysvinit-utils(qui fournit last) la version est 2.88dsf-13.10ubuntu11.1 lastlue /var/log/wtmp(dans mon cas), donc les résultats dépendent de ce fichier journal. Voir les commentaires ci-dessous.

EDIT: Apparemment, cela dépend du temps de disponibilité du système afin que vous puissiez voir la preuve ici http://imgur.com/pqGGPmE

Python

Obtenir une précision à la nanoseconde serait délicat à moins que l'heure renvoyée soit basée sur la fin du programme, et non sur son démarrage. Dans cet esprit, il est plus logique de calculer le temps en fonction de la fin du programme. Cela signifie que nous devons contrôler quand un programme cesse de fonctionner pour obtenir une précision supplémentaire.

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

Notez que cela suppose que tant que l'horloge python est bouchée, l'horloge bash ne l'est pas ou que l'horloge bash sait au moins quel jour elle est. Sinon, on peut plutôt utiliser ceci:

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

Peut-être un peu plus lent, cependant. Je ne l'ai pas testé.

Brainfuck

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

Sortie:

5PM

Je pense que cela affiche l'heure à Denver au moment de l'écriture. L'explication de l'algorithme ici par cette vidéo d'Alan Jackson .

Rubis

`date`

N'utilise pas l'API clock / time du langage.

J'ai aimé l'idée de "lire à partir d'un serveur de temps". Améliore sa mise en forme et ajoute quelques villes pour le plaisir.

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

Frapper

echo "It's eight o'clock."

Merci au Goon Show . (En outre, c'est juste deux fois par jour!)

C / WinAPI

Cela suppose que mes propres appels d'API d'interrogation de l'horloge sont rompus, mais que le système lui-même peut fonctionner correctement avec l'heure.

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

L'idée est de créer un fichier temporaire et de lire l'heure de création, ce qui, selon NTFS, est précis jusqu'à 10 ms. Notez que la mise en forme de la sortie est incertaine, mais c'est purement parce que je suis paresseux.

Sortie sur ma machine tout à l'heure: Time is 10:39:45.790

Lot

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

Écrit une ligne vierge dans le fichier de commandes (lui-même), puis vérifie la dernière heure d'écriture du fichier.

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

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

HTML, CSS et Javascript / jQuery

Ok, donc je sais que ce n’est pas techniquement un programme, et qu’il ne rentre probablement pas dans les critères, mais dans seulement quelques heures, ce sera l’horloge la plus précise au monde!

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

Au début, j'allais faire une while(true)boucle, mais ensuite je me suis rappelé que je ne voulais pas bloquer les navigateurs ...

En voici un violon en action: http://jsfiddle.net/E7Egu/

Emacs Lisp

Le truc Google a été fait mais pas dans 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())+''

Puisque l’API clock / time est cassée, j’utilise Performance API pour obtenir l’heure. Ensuite, Daten’est utilisé que pour l’analyser en chaîne.

PHP:

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

Ceci lira l'heure du système à partir de l'interface de ligne de commande disponible.

C'est ce que fait l'opérateur backtick: exécuter une commande.

Une autre façon serait:

$_SERVER['REQUEST_TIME'];

Qui contient l' heure actuelle à laquelle le script a été appelé.

Frapper

export PS1="(\t) $PS1"

Contourne un peu les règles, mais elle n'appelle jamais une fonction de temps. Cependant, il affichera l'heure actuelle à la sortie et chaque fois que vous appuierez sur Entrée.

C #

Cette méthode super exacte fonctionnera - à condition que vous exécutiez le programme à 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 plupart des shells, sur du matériel avec un RTC:

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

Java

Nous savons tous que l'API Java Date / Heure est inutilisable et endommagée. Il s'agit donc d'un correctif qui n'utilise (du moins directement) aucune des API existantes. Il prend même en charge les secondes intercalaires! :) La sortie 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());        
    }
}