Wiesz, że interfejsy API zegara / czasu twojego języka są zepsute i wcale nie są wiarygodne.

Dlatego nie wolno używać żadnego wbudowanego interfejsu API do uzyskiwania dostępu do systemowej daty / godziny.

Ale wiesz również, że zdolność twojego języka do wykonywania obliczeń matematycznych i zachowywania wartości daty / godziny w zmiennej są prawidłowe.

Napisz program, który drukuje bieżącą datę / godzinę bez wywoływania interfejsów API daty / godziny / zegara. Na przykład DateTime.Now, GetDate()i podobne funkcje nie są dozwolone.

Odpowiedź z większością głosów wygranych.

W przypadku remisu wygrywa odpowiedź z większą precyzją (dokładność do sekund, potem milisekund, następnie mikrosekund i tak dalej).

Jawa

Prawie wszystkie obecne rozwiązania zakładają, że lokalny / zdalny komputer nie kłamie na temat aktualnego czasu (czy uważasz, że T-600 również?).
Kluczowym punktem w obliczaniu czasu jest zaufanie do czystej natury .
Ta aplikacja na Androida prosi użytkownika o zrobienie zdjęcia nieba i przewidywanie bieżącego czasu z wyjątkową precyzją:

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

Wyniki:

Rubin

Bądźmy szczerzy: czas zmienia się tylko wtedy, gdy coś jest publikowane na stackoverflow.com ;)

Skrypt wyodrębnia czas etykiety „XYs ago” w najwyższym pytaniu.

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

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

Wynik:

2014-03-10 18:40:05Z

Grzmotnąć

Lubię to? (wymaga wgeti grep)

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

Dane wyjściowe otrzymałem kilka minut temu:

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

Albo to? (wymaga wgeti eog)

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

Dane wyjściowe otrzymuję teraz: (Zdjęcie xkcd )

mapa świata ze strefą czasową http://c.xkcd.com/redirect/comic/now

sh / coreutils

touch . && stat . -c %z

Wypisuje datę w nieco niestandardowym formacie:
YYYY-MM-DD hh:mm:ss.nanoseconds +timezone
chociaż myślę, że może to zależeć od ustawień regionalnych.

PHP

Wykorzystaj fakt, że uniqid()zwraca identyfikator na podstawie czasu.

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

Podczas mojego testu, powrócił: Year=2014 Days=79 Hours=18 Minutes=9 Seconds=49.
Nie wiem, czy mogę datepoprawnie sformatować, więc przekonwertowałem go ręcznie.

DNS

Czy nie ufamy tylko własnej maszynie? Jeśli tak, czy to się liczy?

ssh $othermachine date

Jeśli to się nie liczy, wyodrębnienie czasu z aktualizacji DNS zdecydowanie:

dig stackexchange.com | grep WHEN

Grzmotnąć

Aby być zawsze absolutnie precyzyjnym i poprawnym:

echo "Now"

lub motywowanie:

echo "Now, do something useful today"

curl - z dokładnością do dowolnej częstotliwości pingowania

curl -s time.nist.gov:13

Pyton

Na pewno nie wiesz, która jest godzina?!? Oto przypomnienie:

print "It's Adventure Time!"

Python 2

Tak więc zegar jest poprawny, ale interfejs API czasu jest zamknięty, prawda? Dlaczego nie sprawdzić surowego znacznika czasu systemu plików. Zamiast tworzyć plik testowy, po prostu używamy własnego znacznika czasu dostępu, ponieważ skrypt musi zostać odczytany, aby uruchomić (nawet jeśli został skompilowany). Dokładnie do sekundy. *

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

Należy to zapisać i uruchomić jako t.py. Alternatywnie, pobierz nazwę skryptu w czasie wykonywania za pomocąinspect.getfile(inspect.currentframe())

Uwaga * Czasami dokładne do poprzedniej sekundy.

Rubin

HTTP, ale tylko przy użyciu metadanych odpowiedzi.

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

Nie możesz pspodać godziny? To może!

sleep 1&  ps -o lstart -p $!

Proces jest uruchamiany w tle i pswskazuje godzinę rozpoczęcia procesu. Ponieważ proces rozpoczął się w tle, czas rozpoczęcia procesu jest prawie taki sam jak teraz.

Ponadto zaletą jest to, że czas jest uzyskiwany w lokalnej strefie czasowej. Nie potrzebujesz też połączenia z Internetem!

vba

ponieważ nie powinienem.

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

użyj, ?DateTimeaby użyć lub jeśli umieścisz go w programie Excel, a następnie =DateTime()będzie działać jako formuła.
Data / czas są zwracane w GMT - pozostawiam to jako ćwiczenie na próżno, aby przekonwertować go z ciągu na czas lokalny

Bash + last+ head+cut

Dokładnie do drugiego. lastużywa pliku dziennika/var/log/wtmp

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

EDYCJA: Dodano, headaby ograniczyć tylko do jednej linii.

EDYCJA: Działa na Linux Mint 13 Cinnamon 64-bit, ale wygląda na to, że zależy to od twojej dystrybucji. sysvinit-utils(która zapewnia last) wersja jest 2.88dsf-13.10ubuntu11.1 lastodczytywana z /var/log/wtmp(w moim przypadku), więc wyniki zależą od tego pliku dziennika. Zobacz komentarze poniżej.

EDYCJA: Najwyraźniej zależy to od czasu pracy systemu, więc możesz zobaczyć dowód tutaj http://imgur.com/pqGGPmE

Pyton

Uzyskanie precyzji nanosekundowej byłoby trudne, chyba że zwracany czas był oparty na tym, kiedy program kończy działanie, a nie na początku. Mając to na uwadze, bardziej sensowne jest obliczanie czasu na podstawie zakończenia programu. Oznacza to, że powinniśmy kontrolować, kiedy program przestanie działać, aby uzyskać dodatkową precyzję.

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

Zauważ, że zakłada to, że podczas gdy zegar pytona jest przerywany, zegar uderzenia nie jest, lub że zegar uderzenia przynajmniej wie, jaki jest dzień. Jeśli nie, możemy zamiast tego użyć tego:

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

Może być jednak nieco wolniejszy. Nie testowałem tego.

BrainFuck

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

Wynik:

5PM

Myślę, że wyświetla czas w Denver w momencie pisania. Wyjaśnienie algorytmu tutaj w tym filmie Alana Jacksona .

Rubin

`date`

Nie używa interfejsu API zegara / czasu języka.

Podobał mi się pomysł „czytania z serwera czasu”. Poprawiłem jednak formatowanie i dodałem kilka miast dla zabawy.

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

Grzmotnąć

echo "It's eight o'clock."

Dzięki dzięki The Goon Show . (Również ma rację dwa razy dziennie!)

C / WinAPI

To powoduje założenie, że moje własne wywołania API do zapytania zegara są zepsute, ale sam system może poprawnie pracować z czasem.

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

Pomysł polega na utworzeniu pliku tymczasowego i odczytaniu czasu utworzenia, który moim zdaniem w systemie plików NTFS jest dokładny do 10 ms. Zauważ, że formatowanie danych wyjściowych jest niepewne, ale dzieje się tak, ponieważ jestem leniwy.

Dane wyjściowe na moim komputerze właśnie teraz: Time is 10:39:45.790

Partia

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

Zapisuje pustą linię do pliku wsadowego (samego), a następnie sprawdza czas ostatniego zapisu pliku.

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

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

HTML, CSS i JavaScript / jQuery

Ok, więc wiem, że technicznie nie jest to program i prawdopodobnie nie spełnia kryteriów, ale za kilka godzin będzie to najdokładniejszy zegar na świecie!

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

Na początku miałem zamiar zrobić while(true)pętlę, ale potem przypomniałem sobie, że nie chcę zawieszać żadnych przeglądarek ...

Oto skrzypce w akcji: http://jsfiddle.net/E7Egu/

Emacs Lisp

Sprawa google została wykonana, ale nie w 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())+''

Ponieważ interfejs API zegara / czasu jest zepsuty, używam interfejsu API Performance, aby uzyskać czas. Następnie Datesłuży tylko do parsowania go do łańcucha.

PHP:

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

Spowoduje to odczytanie czasu systemowego z dostępnego interfejsu wiersza poleceń.

Do tego celu służy operator wsteczny: uruchom polecenie.

Innym sposobem byłoby:

$_SERVER['REQUEST_TIME'];

Który zawiera aktualny czas, w którym skrypt został wywołany.

Grzmotnąć

export PS1="(\t) $PS1"

Trochę omija zasady, ale nigdy nie wywołuje funkcji czasu. Będzie jednak wyświetlać aktualny czas na wyjściu, a za każdym razem, gdy naciśniesz, wprowadź.

DO#

Ta bardzo dokładna metoda będzie działać - pod warunkiem, że uruchomisz program o godzinie 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, większość powłok, na sprzęcie z RTC:

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

Jawa

Wszyscy wiemy, że Java Date / Time API jest bezużyteczny i uszkodzony. Oto poprawka, która nie używa (przynajmniej bezpośrednio) żadnego z istniejących API. Obsługuje nawet sekundy przestępne! :) Dane wyjściowe są w 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());        
    }
}