Sprung für Sprung Sekunden!

28

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?

mbomb007
quelle
Muss die Ausgabe genau so verteilt sein, oder kann sie beliebig verteilt sein, solange die 26 Daten vorhanden sind?
Ismael Miguel
2
@IsmaelMiguel Sie müssen in dieser Reihenfolge sein.
mbomb007
Wenn ich mir die Liste anschaue, frage ich mich, warum wir heutzutage weniger Schaltsekunden benötigen als im vorigen Jahrhundert.
Mr Lister
@MrLister Siehe den verknüpften Wikipedia-Artikel. Ich denke, das hat mit der sich ändernden Drehzahl der Erde zu tun.
mbomb007

Antworten:

25

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.
}
Dennis
quelle
28
Dieses Gefühl, wenn Sie ein eingebautes haben, das das Problem fast vollständig löst, und doch ist die manuelle Lösung in CJam kürzer.
Alex A.
9
@AlexA. Es gibt einige eingebaute Funktionen in Mathematica , die ich in weniger Bytes neu implementieren kann in Mathematica .
Martin Ender
@ MartinBüttner: Brutal.
Alex A.
35

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 !

Alex A.
quelle
Wenn Sie einer Variablen "23:59:60" zuweisen können, können Sie einige Zeichen speichern
Nicht dass Charles
1
@NotthatCharles: Ich hatte darüber nachgedacht, aber die Methode von R zum Kombinieren von Zeichenfolgen ist nicht präzise genug, um die Erstellung des heutigen Datums und der Uhrzeit zu verkürzen. Vielen Dank für die Eingabe!
Alex A.
24

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

¯ \ _ (ツ) _ / ¯

vijrox
quelle
6
@ Vioz- Diese Frage ist markiert mit kolmogorov-Komplexität und daher ist dies eine vollkommen legale Antwort. Aber es ist unwahrscheinlich, dass er gewinnt ...
Digital Trauma
10
@mlepage Das ist eine der "Standardlücken".
Jacob Raihle
4
@Voitcus in Datei speichern, in einem Browser öffnen. Es ist ein workingHTML-Code
edc65
9
@ AntonyD'Andrea Ja, na und? Bei Herausforderungen wird keine Verfügbarkeit angefordert code golf.
Edc65
5
@ Anatolyg Sie sind kein Spaß für [Kolmogorov-Komplexität]
Vijrox
11

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;
}
mlepage
quelle
4
Willkommen bei PPCG. "Standardlücken" bezieht sich auf diesen Beitrag , bedeutet aber im Allgemeinen nur "gesunden Menschenverstand verwenden und nicht betrügen". :)
Martin Ender
1
Ich denke, mit einer forSchleife werden einige Bytes gespart. Übrigens, int main()-> main(). Sie finden dies möglicherweise sehr hilfreich.
Spikatrix
Also: X>>=1ist dasselbe wie X/=2, 6*(2-Z)ist dasselbe wie 12-6*Zund 4362608640ist ein Byte kürzer als 0x104082000. Das intvor main()ist nicht erforderlich, und wenn Sie zu wechseln main(), main(Z)können Sie die Deklaration entfernen Z=1.
zimperlich ossifrage
Wirklich schöne Lösung - eine andere Sache, über die Sie nachdenken sollten - Sie können ändern, if(X&1)printf(...);mit X&1?printf(...):1;der 1 Byte gespart wird
Euanjt
und anstatt while(X){...}Kommas zu verwenden, können Sie die geschweiften Klammern entfernen while(X)X&1?printf("%d-%02d-%d 23:59:60\n",Y,6*(2-Z),31-Z):1,Y+=Z^=1,X>>=1;und weitere 2 Bytes
sparen
9

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.

xnor
quelle
7

Brainfuck, 806

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

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

Peter Olson
quelle
6

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.

Sp3000
quelle
5

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*
Jens Erat
quelle
Vielen Dank, dass Sie mir beigebracht haben, wo ich die Schaltsekundendaten finde. Leider zeigt mein date(GNU 8.23) diese als erste Sekunde der nächsten Minute an. Was verwenden Sie, das die 60-Sekunden-Minute versteht?
Toby Speight
Mit GNU coreutils, habe ich es auf 76 nach unten, Byte Rasur mit dem -rFlag, unter Substitution datein dem s///eModifikator und Ersetzen %Y-%m-%dmit %Fin date: TZ = UTCsed -nr 's/^([0-9]+).*/date -d "1900-1-1 \1sec" "+%F %T"/ep' /u*/s*/z*/leap*
Toby Speight
Ich wusste, dass ich etwas verpasst habe. Es scheint, dass es keinen Weg gibt, dies manuell zu spezifizieren, zumindest nicht schlechter als die meisten anderen Lösungen. Mal sehen, ob sich jemand eine Date-Bibliothek einfallen lässt, um die Zahlen zu fummeln, die diese Sekunden unterstützen.
Jens Erat
Ich kam dorthin, indem ich 1899-12-31 \1secfür das Datum und die Hardcodierung 23:59:60als Uhrzeit verwendete:sed -nr 's/^([0-9]+).*/date -d "1899-12-31 \1sec" "+%F 23:59:60"/ep' /u*/s*/z*/leap*
Toby Speight
3

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`
`)

edc65
quelle
2

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

Voitcus
quelle
Sie können beide (int)entfernen und Leerzeichen entfernen. Datum wirft einen Fehler aus. Wenn die Standard-Zeitzone nicht festgelegt ist, schalten Sie sie mit einem ab @. 187 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=$d-ceil($d);echo@date("Y-m-d 23:59:60",mktime(0,0,0,-6*$h,31+$h,$d+1972))."\n";}
Octfx
2

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,'$'
anatolyg
quelle
Ich würde dies gerne testen, aber ich kann anscheinend nirgendwo einen einzigen Editor finden, mit dem Sie Hex einfügen und in einer Binärdatei speichern können.
Mr Lister
@ MrLister jeder normale Hex-Editor sollte das für Sie tun.
TheDoctor
1

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 .

Maltysen
quelle
1

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)
mbomb007
quelle
1

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.

mlepage
quelle
1

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.

hjk
quelle
1

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.

sudo rm -rf Schrägstrich
quelle
Überraschenderweise ist meine PHP-Antwort bei Verwendung eines ähnlichen Algorithmus kürzer. Ich habe immer erwartet, dass Python kompakter ist. Vielleicht könnten Sie ein bisschen mehr Golf spielen?
Voitcus,
Ich werde einen Blick darauf werfen. Ich denke, die beste Route ist die Komprimierung, und andere haben das bereits getan
sudo rm -rf slash
0

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

Pranzer
quelle
0

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.

damix911
quelle
1
Entfernen q=x%10und Ersetzen qmit x%10überall. Es ist kürzer. Ich gebe auch eine hilfreiche Beschreibung von einigen zusätzlichen Golf auf Ihrem Programm hier . Ich empfehle, die Seite Tipps zum Golfen in Python zu lesen.
mbomb007
Das ist Code-Golf , also sollten Sie versuchen, die Länge Ihres Codes auf irgendeine Weise zu verkürzen.
mbomb007
-1

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.

Stef Heyenrath
quelle