Da heute der Anlass für die 26. Schaltsekunde aller Zeiten ist, besteht Ihre Herausforderung darin, das Datum und die Uhrzeit jeder Schaltsekunde in GMT oder UTC auszugeben, die bisher aufgetreten ist, sowie diejenige, die heute auftritt.

Eingang

Es erfolgt keine Eingabe.

Ausgabe

1972-06-30 23:59:60
1972-12-31 23:59:60
1973-12-31 23:59:60
1974-12-31 23:59:60
1975-12-31 23:59:60
1976-12-31 23:59:60
1977-12-31 23:59:60
1978-12-31 23:59:60
1979-12-31 23:59:60
1981-06-30 23:59:60
1982-06-30 23:59:60
1983-06-30 23:59:60
1985-06-30 23:59:60
1987-12-31 23:59:60
1989-12-31 23:59:60
1990-12-31 23:59:60
1992-06-30 23:59:60
1993-06-30 23:59:60
1994-06-30 23:59:60
1995-12-31 23:59:60
1997-06-30 23:59:60
1998-12-31 23:59:60
2005-12-31 23:59:60
2008-12-31 23:59:60
2012-06-30 23:59:60
2015-06-30 23:59:60

Regeln

Da ich bezweifle, dass es viele integrierte Funktionen gibt, die Schaltsekunden erlauben, werde ich sie zulassen.

Standardlücken sind nicht zulässig.

Kürzester Code gewinnt.

Das Datumsformat muss einen mit Nullen aufgefüllten Monat und ein vierstelliges Jahr sowie eine militärische Zeit und ein Leerzeichen enthalten, das die Zeit vom Datum trennt. Das Setzen UTCam Ende ist optional. Ihre Wahl der Gedankenstriche oder Schrägstriche.

EDIT: Ja, wie vorhergesagt, wurde dies eine Herausforderung für die Codierung. Wenn nur die Codierung das Schaltsekundenproblem beheben könnte, ... wäre unser gesamter Code viel praktischer. Vielleicht brauchen wir ein paar Ideen für lustige Herausforderungen mit praktischen Einsätzen?

CJam, 72 70 69 64 Bytes

26,"~g¼K&Béx¸¦­Ø"240bFbf{<1b2md\1972+'-@6X$4*-'-Z3$" 23:59:60"N}

Probieren Sie es online im CJam-Interpreter aus .

Idee

Wir beginnen mit der Codierung jede Schaltsekunde als 2 · (Y - 1972) + D , wobei D sind 1 , wenn es im Dezember und tritt 0 sonst.

Das Array aller codierten Schaltsekunden lautet:

[0 1 3 5 7 9 11 13 15 18 20 22 26 31 35 37 40 42 44 47 50 53 67 73 80 86]

Nennen wir dieses Array L .

Da das Array aufsteigend sortiert ist, können wir die aufeinander folgenden Differenzen anstelle der tatsächlichen Zahlen speichern:

[1 2 2 2 2 2 2 2 3 2 2 4 5 4 2 3 2 2 3 3 3 14 6 7 6]

Wenn Sie dieses Array als die Ziffern einer Zahl zur Basis 15 behandeln, erhalten Sie die Ganzzahl

19238985373462115979359619336

welche Ziffern in der Basis 240 (in Zeichen umgewandelt) sind

~g¼K&Béx¸¦­Ø

Code

26,             e# Push I := [0 ... 25].
"~g¼K&Béx¸¦­Ø"   e# Push the string from above.
240bFb          e# Convert from base 250 to base 15 to push L.
f{              e# For each J in I:
                e#   Push L.
  <             e#   Replace L with L[:J].
  1b            e#   Push the sum S of the integers in L[:J].
  2md           e#   Push (S / 2) and (S % 2).
  \1972+        e#   Add 1972 to (S / 2).
  '-@           e#   Push '-' and rotate (S % 2) on top.
  6X$4*-        e#   Compute (6 - 4 * (S % 2)).
  '-Z           e#   Push '-' and 3.
  3$            e#   Push a copy of (S % 2).
  " 23:59:60"   e#   Push that string.
  N             e#   Push a linefeed.
}

R 78 75 Bytes

Eingebaute, sagst du? Gut...

message(paste(as.Date(.leap.seconds)-1,"23:59:60\n"),"2015-06-30 23:59:60")

R hat eine automatische Variable, .leap.secondsdie das Datum und die Uhrzeit jeder Schaltsekundeneinfügung enthält, angegeben in der Ortszeit des Systems. Ab R-Version 3.2.0 ist dies heute nicht mehr enthalten, daher habe ich das manuell hinzugefügt.

Ungolfed + Erklärung:

# Convert the datetime values to UTC dates. These will be a day past the
# expected output, so we can subtract 1 to get what we want.
dates <- as.Date(.leap.second) - 1

# Paste the UTC time and a newline onto the end of each date
datetimes <- paste(dates, "23:59:60\n")

# Print each time, including today, on its own line
message(datetimes, "2015-06-30 23:59:60")

Sie können es online ausprobieren !

HTML, 594 Bytes

1972-06-30 23:59:60<br>1972-12-31 23:59:60<br>1973-12-31 23:59:60<br>1974-12-31 23:59:60<br>1975-12-31 23:59:60<br>1976-12-31 23:59:60<br>1977-12-31 23:59:60<br>1978-12-31 23:59:60<br>1979-12-31 23:59:60<br>1981-06-30 23:59:60<br>1982-06-30 23:59:60<br>1983-06-30 23:59:60<br>1985-06-30 23:59:60<br>1987-12-31 23:59:60<br>1989-12-31 23:59:60<br>1990-12-31 23:59:60<br>1992-06-30 23:59:60<br>1993-06-30 23:59:60<br>1994-06-30 23:59:60<br>1995-12-31 23:59:60<br>1997-06-30 23:59:60<br>1998-12-31 23:59:60<br>2005-12-31 23:59:60<br>2008-12-31 23:59:60<br>2012-06-30 23:59:60<br>2015-06-30 23:59:60

¯ \ _ (ツ) _ / ¯

C 160, 146, 141, 140 Bytes

Erstmaliges Posten, nicht sicher, was "Standardlücken" sind. Ich habe natürlich Druckwarnungen.

160 Bytes:

Die ursprüngliche Idee ist, Schaltsekunden mit zwei Bits pro Jahr zu codieren: eine für Juni und eine für Dezember. Die Codierung wird jeweils ein Bit von der inneren while-Schleife verbraucht. Ohne eine 128-Bit-Ganzzahl ist die äußere while-Schleife erforderlich. Der Rest ist alles Buchhaltung und Mathe. :-)

int main(){long long X=0x2495288454AAAB,Y=1972,Z=1;while(Y<2000){while(X){if(X&1)printf("%d-%02d-%d 23:59:60\n",Y,6*(2-Z),31-Z);Y+=Z^=1;X>>=1;}X=0x104082000;}}

141 Bytes:

Durch Anwenden der vorgeschlagenen Tipps werden 146 Byte erreicht. Dann habe ich einen Weg gefunden, die äußere while-Bedingung (von Y <2000 bis nur Z) zu vereinfachen und auf 141 Bytes zu reduzieren. So nah an einem Tweet!

main(Z){long long X=0x2495288454AAAB,Y=1972;while(Z){while(X)X&1?printf("%d-%02d-%d 23:59:60\n",Y,12-6*Z,31-Z):1,Y+=Z^=1,X/=2;X=4362608640;}}

140 Bytes:

Ich bemerkte, dass der Gedankenstrich im Datum beseitigt werden konnte, indem der Tag negativ gemacht wurde. Kann es mit dem Monat auch nicht schaffen, da es im Juni eine führende Null gibt. Aber zumindest passt es jetzt in einen Tweet!

main(Z){long long X=0x2495288454AAAB,Y=1972;while(Z){while(X)X&1?printf("%d-%02d%d 23:59:60\n",Y,12-6*Z,Z-31):1,Y+=Z^=1,X/=2;X=4362608640;}}

Hübsche Version:

main(Z) {
    long long X = 0x2495288454AAAB, Y = 1972;
    while (Z) {
        while (X)
            X&1 ? printf("%d-%02d%d 23:59:60\n", Y, 12-6*Z, Z-31) : 1,
            Y += Z ^= 1,
            X /= 2;
        X = 4362608640;
    }
}

Bonusversion:

Ich habe die äußere Schleife beseitigt, indem ich eine 64-Bit-Ganzzahl in eine andere verschoben habe, aber es sind 150 Bytes, aufgrund der ziemlich langen "vorzeichenlosen langen Länge". Wenn ich etwas wie "uint64" verwenden könnte, wären es 138 Bytes.

main(Z) {
    unsigned long long Y = 1972, X = 0x2495288454AAAB, W = 8520720;
    while (X)
        X&1 ? printf("%d-%02d-%d 23:59:60\n", Y, 12-6*Z, 31-Z) : 1,
        Y += Z^= 1,
        X = X/2 | (W>>=1)<<63;
}

Python 3, 91

Verwendet die Codierung und Zeichenfolgenformatierung von Sp3000 , speichert die Werte jedoch in einem Python 3-Byte-Objekt und nicht in einer magischen Zahl.

for n in b'()+-/1357:<>BGKMPRTWZ]kqx~':print('%d-%02d-3%d 23:59:60'%(1952+n/2,n%2*6+6,n%2))

Die Codierung benötigt nur 86 der 256 möglichen Werte eines Bytes, daher wird ein Bereich druckbarer Zeichen verwendet, um das Erscheinungsbild zu verbessern.

Brainfuck, 806

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

Sie können es auf diesem Online-Interpreter ausführen.

Python 2, 111 104 Bytes

n=0x6697f252225354422533333330;y=1972
while n:print'%d-%02d-3%d 23:59:60'%(y,n%2*6+6,n%2);y+=n/2%8;n/=16

Basiscodierung und mehr Basiscodierung.

GNU sed + date: 112

Gängige Linux-Distributionen haben ebenfalls die Schaltsekunden eingebaut. Verwendung von GNU sed und date:

sed -n 's/^\([0-9]\+\).*/1899-12-31 \1sec/p' /usr/share/zoneinfo/leap-seconds.list|date -f- +"%Y-%m-%d 23:59:60"

GNU sed + Datum: 90

Ein paar Zeichen sichern, indem der Pfad gekürzt wird:

sed -n 's/^\([0-9]\+\).*/1899-12-31 \1sec/p' /u*/s*/z*/leap*|date -f- +'%Y-%m-%d 23:59:60'

GNU sed + date von Toby Speight: 84

Tiefgolf-Version in den Kommentaren vorgeschlagen:

sed -nr 's/^([0-9]+).*/date -d "1899-12-31 \1sec" "+%F 23:59:60"/ep' /u*/s*/z*/leap*

JavaScript ( ES6 ) 125

Der Zeilenumbruch innerhalb von `` ist signifikant und wird gezählt.

Führen Sie zum Testen das folgende Snippet aus (nur EcmaScript 6, Firefox).

alert([..."09:;=DEFIX[01234567?ABGJQS"].map((c,i)=>c.charCodeAt()+1924+(i>10?'-12-31':'-06-30')+' 23:59:60').sort().join`
`)

PHP, 198 Bytes

foreach([.5,1,2,3,4,5,6,7,8,9.5,10.5,11.5,13.5,16,18,19,20.5,21.5,22.5,24,25.5,27,34,37,40.5,43.5] as$d){$h=(int)$d-ceil($d);echo date("Y-m-d 23:59:60",mktime(0,0,0,-6*$h,31+$h,(int)$d+1972))."\n";}

Leider weiß ich nicht, ob ich \nin die Datumsfunktion einfügen kann . Wenn ja, ist dies wegen 3 Bytes weniger ."".

8086 Maschinencode + DOS, 92 Bytes

Hexdump des Codes:

BE 3A 01 B1 57 D1 E0 75 03 AD EB F9 72 09 50 BA
47 01 B4 09 CD 21 58 BB 50 01 81 77 FC 01 04 80
37 01 80 3F 31 74 10 83 EB 05 4B FE 07 80 3F 3A
75 05 C6 07 30 EB F3 E2 CC C3 AA 2A 77 B5 6A DD
DF B6 BE FF 7D BF 31 39 37 32 2D 30 36 2D 33 30
20 32 33 3A 35 39 3A 36 30 0D 0A 24

Schreiben Sie zum Ausführen die 92 Bytes in eine com-Datei und führen Sie sie unter 32-Bit-Windows oder DOSBox aus.

Der Code verwendet eine Bitmap mit 87 Bits, eine pro halbes Jahr. Die Bits sind ausgehend von MSB in Gruppen von 16 angeordnet.

Bitmap dekodieren:

                 ; when the program starts, ax=0 (tested on DOSBox)
myloop:
    shl ax, 1    ; shift the MSB left into the carry flag
    jnz mywork   ; if some bits are left in the register, work normally
    lodsw        ; if all bits were shifted out, load the next 16 bits
    jmp myloop   ; and check the MSB again

Aufgrund der Codestruktur gehen beim Dekodieren einige Bits verloren, so dass ich sie wiederholen musste. Durch diese Wiederholung wird die Bitmap nicht aufgebläht, da ich sowieso 87 Bit bis 96 Bit auffüllen musste.

Nach dem Drucken (oder Nicht-Drucken) der Schaltsekunde erhöht der Code das Datum um ein halbes Jahr, indem er die ASCII-Codes der ausgegebenen Nachricht bearbeitet.

Quellcode (zusammenstellbar mit tasm):

    mov si, offset mydata
    mov cl, 57h ; number of iterations

myloop:
    shl ax, 1   ; shift the MSB left into the carry flag
    jnz mywork  ; if some bits are left in the register, work normally
    lodsw       ; if all bits were shifted out, load the next 16 bits
    jmp myloop  ; and check the MSB again
mywork:
    jc myinc_date ; shifted bit 1? - skip printing the message

    push ax
    mov dx, offset mymsg
    mov ah, 9
    int 21h     ; print the message
    pop ax

myinc_date:
    mov bx, offset mymsg + 9 ; pointer to the middle of the message
    xor word ptr [bx - 4], 401h ; change month 06<->12
    xor byte ptr [bx], 1 ; change day 30<->31
    cmp byte ptr [bx], '1'
    je myloop_end ; if 31 December, no need to increase the year
    sub bx, 5 ; pointer beyond the last digit of the year

myinc_year:
    dec bx
    inc byte ptr [bx] ; increase the digit
    cmp byte ptr [bx], '0' + 10
    jne myloop_end ; if the digit was less than 9, done
    mov byte ptr [bx], '0' ; set the digit to 0
    jmp myinc_year ; continue increasing other digits

myloop_end:
    loop myloop
    ret ; terminate the program

; In the following bitmap, the spaces before some LSBs
; show that the least significant 1-bit and all
; following 0-bits are lost during decoding.
mydata:
    dw 02aaah ; 00101010101010     10
    dw 0b577h ; 101101010111011    1
    dw 0dd6ah ; 11011101011010     10
    dw 0b6dfh ; 101101101101111    1
    dw 0ffbeh ; 11111111101111     10
    dw 0bf7dh ; 101111110111110    1

mymsg:
    db '1972-06-30 23:59:60',13,10,'$'

Pyth - 88 84 Bytes

Konvertiert in ein Zeichen, um die Daten zu komprimieren, und speichert die 06-30Versus- 12-31Daten als Binärzahl.

jbm++-2047ed?"-06-30"hd"-12-31"" 23:59:60"C,j33678243 2CM"KKJIHGFEDBA@><:9765421*'# 

(dort ist am Ende ein Leerzeichen)

Probieren Sie es hier online .

Python 2, 123 121 116 114 111

Ich habe es geschafft, es ziemlich kurz zu machen, aber ich bin mir nicht sicher, wie viel kürzer es werden kann. Ich habe versucht, mit exec, aber die Formatierung wird zu teuer.

Ich habe eine Base-16-Codierung der Tabelle von der verknüpften Wikipedia-Seite verwendet.

Bearbeiten: Verwenden von Hex-Codierung ist kürzer als Basis 36 (siehe die weniger Golf-Version.)

Probieren Sie es hier aus

n=0x410208002495288454aaab
for i in range(88):
    if n%2:print"%d-%02d-3%d 23:59:60"%(1972+i/2,i%2*6+6,i%2)
    n/=2

Weniger golfen:

s=bin(int('WELD24ZDGIMBWWLFM',36))[2:]
for i in range(44):
    t,s=int(s[0]),s[1:]
    if t:print"%d-06-30 23:59:60"%(i+1972)
    t,s=int(s[0]),s[1:]
    if t:print"%d-12-31 23:59:60"%(i+1972)

C 155, 149, 147 Bytes

Hier ist ein weiterer Ansatz in C, bei dem Zeichenfolgen und Lauflängencodierung verwendet werden. Nicht ganz so knapp wie meine andere C-Lösung, aber vielleicht kann sie verbessert werden?

155 Bytes:

Verwenden Sie eine Zeichenfolge, um den Monat / Tag zu halten.

main(Y){Y=1972;char*M="06-3012-31",*B="#@DGCDF7D3daTdS#!",b,c;while(b=*B++-33){c=b>>1&7;while(c--)printf("%d-%.5s 23:59:60\n",Y++,M+b%2*5);Y+=(b>>4&7)-1;}}

149 Bytes:

Beseitigen der Monats- / Tageszeichenfolge.

main(Y){Y=1972;char*B="#@DGCDF7D3daTdS#!",b,c;while(b=*B++-33){c=b>>1&7;while(c--)printf("%d-%02d-%d 23:59:60\n",Y++,6+b%2*6,30+b%2);Y+=(b>>4&7)-1;}}

147 Bytes:

Eliminierung der Jahresinitialisierung.

main(Y){char*B="#@DGCDF7D3daTdS#!",b,c;while(b=*B++-33){c=b>>1&7;while(c--)printf("%d-%02d-%d 23:59:60\n",1971+Y++,6+b%2*6,30+b%2);Y+=(b>>4&7)-1;}}

144 Bytes:

Wenn ich den Puffer neu verschlüsselt habe, damit die Anzahl der Auslassungen vor (nicht nach) dem Lauf angewendet wird, könnte ich die Anweisungen in der äußeren while-Schleife neu anordnen, den Kommaoperator verwenden und die geschweiften Klammern entfernen und 2 Bytes einsparen.

Ich kann ein weiteres Byte speichern, indem ich den Tag negativ schreibe (wie bei meiner anderen Lösung).

Ziemlich:

main(Y) {
    char *B = "#@DGCDF7D3daTdS#!", // buffer of bytes encoding runs
         b, // current byte
         c; // current count
    while (b = *B++-33) { // get byte
        c = b>>1&7; // get count
        while (c--) printf("%d-%02d-%d 23:59:60\n", 1971+Y++, 6+b%2*6, 30+b%2); // run
        Y += (b>>4&7)-1; // skip years
    }
}

Erläuterung:

Läufe werden in Bytes codiert. Jedes Byte hat ein Bit, das angibt, ob es sich um Juni oder Dezember handelt, 3 Bits für eine Längenzählung, 3 Bits für eine Sprungzählung und 1 nicht verwendetes hohes Bit.

Die Anzahl der zu überspringenden Jahre ist die Anzahl der Jahre, die nach einem Durchlauf übersprungen werden müssen. Es ist um -1 versetzt, um 1972 zwei Schaltsekunden zu ermöglichen. Die Länge ist wie viele Jahre in einem Lauf; es könnte wahrscheinlich um +1 versetzt werden, ist es aber derzeit nicht.

Ein Byte bedeutet also: "Machen Sie LÄNGENJAHREN (oder DEZEMBER) Schaltsekunden und überspringen Sie dann SKIP-1 Jahre", bevor Sie mit dem nächsten Byte fortfahren.

Die Bytes sind um 33 versetzt, um sie lesbar zu machen und um eine ausgefallene Codierung zu vermeiden.

Das heißt, wir haben zwar genügend Sprungbits, um 1998-2005 abzudecken, aber wir befinden uns außerhalb des ASCII-Bereichs, sodass wir einen zusätzlichen Lauf mit der Länge Null haben. 1979 erscheint auch für sich allein, weil die Länge 1972-1979 zu lang ist.

Die Bytes enthalten genügend Bits, sodass diese Probleme möglicherweise endgültig behoben werden können.

q / kdb +, 95 94 93 Bytes

asc 1_" "0:([]raze("DEFGHIJKSUV[^eh";"DMNOQXYZ]lo"){("d"$"m"$-12*95-6h$x)-y}'1 185;`23:59:60)

Erläuterung

Codieren Sie für jedes Jahr + 1 für Jahre seit 1905 als ASCII-Zeichen, z.

1972 -> 1973 -> 68 -> D

6h$xdreht sich "D"zurück zu 68. Da qdie Datumsepoche ist 2000.01.01, subtrahieren wir 95die Ganzzahl-zu-Datum-Konvertierung und führen sie durch "d"$"m"$-12*95-6h$x.

Der Grund, warum wir oben +1 geben, ist, die Anzahl der Tage vom Beginn des nächsten Jahres zu subtrahieren , um den 31. Dezember oder 30. Juni des aktuellen Jahres zu erhalten , nämlich 1 oder 185 Tage. Daher steht "DEFGHIJKSUV[^eh"die Jahreszahl mit einer Schaltsekunde im Dezember und "DMNOQXYZ]lo"für die im Juni. Die Pairing-Subtraktion erfolgt über (a;b){x-y}'(c;d), wobei aund bsind die Jahre, die jeweils um cund die dAnzahl der Tage subtrahiert werden .

" "0:([]...)bereitet die Ergebnisse so auf, dass wir die richtige Formatierung erhalten, mit einer kleinen Einschränkung, dass eine Spaltenüberschrift generiert wird. 1_löscht diesen Header und wendet ihn schließlich ascan, um die richtige Reihenfolge zu erhalten.

edit : 're-base' um 95 Jahre anstatt 100 zu subtrahieren (1 Zeichen wird gespeichert).

edit 2 : Die Positionierung der Operanden innerhalb der Funktion zur Konvertierung von Ganzzahlen auf Datum neu anordnen.

Python, 204 201

e,g,h=0,1972,0
for i in range(1,27):e,g,h={2:1,9:2,10:1,12:2,15:1,16:2,17:1,20:2,21:1,22:7,23:3,24:4,25:3}.get(i,e),g+e,(h,1-h)[i in[2,10,14,17,20,21,22,25]];print`g`+("-06-30","-12-31")[h]+" 23:59:60"

Du kannst damit auf repl.it spielen .

Edit: Gründlich geschlagen! Die Kompressionsantworten sind erstaunlich kurz.

PHP, 164 Bytes

foreach([.5,1,2,3,4,5,6,7,8,9.5,10.5,11.5,13.5,16,18,19,20.5,21.5,22.5,24,25.5,27,34,37,40.5,43.5]as$d){echo(ceil($d)+1971).($d%2?'-12-31':'-06-30')." 23:59:60\n";}

Dies ist nur eine kleine Änderung der Idee von @ Voitcus

Python, 221 217

def d(x):
 q=x%10
 if x%2==0:
  p,r=q/2,"06-30"
 else:
  p,r=(q-1)/2,"12-31"
 return"%d%d-%s 23:59:60"%(p+197,x/10,r)
for x in [20,21,31,41,51,61,71,81,91,12,22,32,52,73,93,5,24,34,44,55,74,85,57,87,28,58]:print(d(x))

Einige Einblicke

Grundsätzlich d(x)dekomprimiert einen Vektor von ganzen Zahlen 3 von einer einzigen 2-stellige ganzen Zahl ist . d(x)wird als die Umkehrfunktion (über die 26 Schaltsekunden-Datenzeiten) von konstruiert c(v), die wiederum eine Komprimierungsfunktion ist, die ein 3-uple wie (1998, 12, 31) in eine Zahl wie 85 umwandelt. Um die Liste abzuleiten [20 , 21 ... 28,58] Ich habe einen anderen Algorithmus entworfen, um zu überprüfen, ob die Komprimierungsfunktion über die Domäne bijektiv ist. Das heißt, ich habe sichergestellt, dass das folgende Programm keine Duplikate erzeugt, und ich habe seine Ausgabe als Liste des obigen Programms verwendet.

dates = [(1972,06,30),
    (1972,12,31),
    (1973,12,31),
    (1974,12,31),
    (1975,12,31),
    (1976,12,31),
    (1977,12,31),
    (1978,12,31),
    (1979,12,31),
    (1981,06,30),
    (1982,06,30),
    (1983,06,30),
    (1985,06,30),
    (1987,12,31),
    (1989,12,31),
    (1990,12,31),
    (1992,06,30),
    (1993,06,30),
    (1994,06,30),
    (1995,12,31),
    (1997,06,30),
    (1998,12,31),
    (2005,12,31),
    (2008,12,31),
    (2012,06,30),
    (2015,06,30)]

def c(v):
    x = (v[0] % 10) * 10
    x += v[2] % 30
    x += 2 * (int(v[0] / 10) - 197)
    return x

for v in dates:
    print(c(v))

Die Komprimierungsfunktion c(v)wurde unter Verwendung eines sehr einfachen Schemas als bijektiv konzipiert. Nehmen wir als Beispiel (1998, 12, 31).

• Der Ausdruck (v [0]% 10) * 10 wählt die Einheiten des Jahres aus (z. B. 1 9 9 8 -> 8) und macht es zur zehnten Stelle der Ausgabe (jetzt x = 80).
• Es gibt nur eine Kombination von zwei Monaten und einem Tag, in der die Schaltsekunde auftritt. Daher habe ich beschlossen, die Tageskomponente zu verwenden, um zwischen dem Fall 06,30 und dem Fall 12,31 zu unterscheiden. Der Ausdruck v [2]% 30 ist 0, wenn der Tag 30 ist, und ist 1, wenn der Tag 31 ist. In unserem Beispiel addieren wir 1 zu x (daher ist jetzt x = 81).
• Schließlich stellte ich fest, dass dieses Rätsel nur fünf Jahrzehnte umfasst; Wenn ich also das erste Jahrzehnt (die siebziger Jahre) auf 0 und das letzte Jahrzehnt (die 2010er) auf 4 abbilde, kann ich coole Sachen machen. Genauer gesagt, wenn ich anstatt auf 0,1,2,3,4 I auf 0,2,4,6,8 abzubilden, kann ich diesen Wert zu den Einheiten von x addieren, die aufgrund der vorherigen Regel entweder 0 oder 0 sind 1. Am Ende haben wir also, dass auch dieser letzte Schritt nicht die Bijektion verdreht, und wir bekommen, dass die Einheiten eines 06,30-Falls eine von 0,2,4,6,8 sind und dass die Einheiten von a 12,31 Fall sind einer von 1,3,5,7,9. Daher ist die Bijektion offensichtlich. In unserem Beispiel liegt 1998 im dritten Jahrzehnt (70 -> 0, 80 -> 1, 90 -> 2), also addieren wir 2 * 2 = 4. Also bekommen wir x = 85.

Ich habe das Programm geschrieben, um zu überprüfen, ob dies wahr ist, und dann habe ich es d(x)als das Gegenteil von definiert c(v). In unserem Beispiel wird c ((1998,12,31)) mit 85 und d (85) korrekt gedruckt 1998-12-31 23:59:60.

gzip, 114 bytes

Hexdump:

1f8b080853f9975502006c006dd04b0a80300c84e1bde01dbc40218fa6697aff8309e2a6fa6f3f86cc10adb426a3b95ce62b6a0d398f07d59aeb8e4ed80983701026e1242cc0a9307e1aa11306615211b59710527b3961270cba9994fc7fc944829092faeedc313e7803993cfafb20020000

Erstellen Sie eine Datei mit den oben beschriebenen Bytes.

Mit gunzip oder einem anderen Dekomprimierungsprogramm extrahieren, um eine neue Datei mit dem Namen "l" zu erhalten. Diese Datei enthält die gewünschte Ausgabe.