Quindi, ora che è il 2015 e un sacco di risposte dal puzzle dell'anno scorso stanno iniziando a produrre risultati non validi , è tempo di una domanda che coinvolga il numero 2015.

Tranne ... perché? Non ti piacerebbe se le tue risposte basate sulla data al problema dell'anno scorso fossero valide? Perché non cambiamo il nostro calendario in modo che non sia mai il 2015 e continuiamo semplicemente a vivere nel 2014, nei secoli dei secoli?

Definiamo una nuova notazione della data, chiamata Notazione Eternal 2014 , come segue:

• Per le date 2014 e precedenti, le date saranno le stesse del proletico calendario gregoriano .
• Per le date degli anni 2015 e successivi, l'anno rimarrà il 2014 e il mese sarà il numero che sarebbe se lo stesso ciclo del mese nel 2014 dovesse continuare per sempre oltre il mese 12. Così 2015-02-08sarebbe 2014-14-08, e 2020-12-31sarebbe 2014-85-02. Si noti che i giorni bisestili non sono contabilizzati perché il 2014 non è un anno bisestile.

Il tuo compito è costruire un programma o una funzione che prenderà una data astronomica giuliana come input e restituisca una stringa con la data corrispondente a quella data giuliana nella notazione Eternal 2014, in uno YYYY-MM-DDo in entrambi i DD/MM/YYYYformati.

Puoi presumere che il giorno giuliano inserito sarà sempre un numero intero dal 1721426(1 gennaio 1) al 2914695(23 gennaio 3268) incluso. Gli anni possono contenere zeri iniziali da pad a 4 cifre o meno, ma mesi e giorni devono sempre avere zeri iniziali da pad a due cifre (e gli anni non possono contenere zeri iniziali da pad a un numero qualsiasi di cifre diverse da 4).

Ecco alcuni esempi di input e relativi output, in tutti i formati accettabili:

> 1721426
1-01-01
01/01/1
0001-01-01
01/01/0001

> 2086302
999-12-31
31/12/999
0999-12-31
31/12/0999

> 2456659
2014-01-01
01/01/2014

> 2456789
2014-05-11
11/05/2014

> 2457024
2014-13-01
01/13/2014

> 2457389
2014-25-01
01/25/2014

> 2469134
2014-411-07
07/411/2014

> 2567890
2014-3657-29
29/3657/2014

> 2914695
2014-15059-23
23/15059/2014

Non è possibile utilizzare alcuna libreria di elaborazione delle date integrata nella propria lingua. Tutti i calcoli devono essere eseguiti in modo algoritmico all'interno del codice sorgente del programma stesso.

Vince il programma più breve (in byte) per raggiungere questo obiettivo in qualsiasi lingua.

Python 2, 166 byte

n=input()
d=m=y=1
M=([3]+[3,2]*3)*2
while n>1721426:
 n-=1;d+=1;M[2]=y%400<1or y%4<1<y%100
 if d>M[m%12]+28:m+=1;d=1
 if m>12<2014>y:y+=1;m=1
print'%02d/'*2%(d,m)+`y`

Questo passa da un giorno all'altro dal 1 ° gennaio 1 (1721426) alla data specificata, aumentando il giorno, il mese e l'anno in corso. L'ultimo test case dura circa un secondo sul mio computer.

L'output viene stampato nel secondo formato:

01/01/1
31/12/999
23/15059/2014

Struzzo 0,5,0 , 197 byte

G~:J1401+4J*274227+146097/F3*4/F+38~+:f4*3+:e1461:p%4/F:g5*2+:h153:s%5/F1+:D;hs/F2+12:n%1+:M;ep/F4716-n2+M-n/F+:Y;{2014:Y;D365+:D;{M1-12%[31:x28x 30:yxyxxyxyx]=:dD<.{Dd-:D;M1+:M;}*}(}Y2014-*D"/M"/Y

Ungolfed (ha):

G~:J;
4716:y;1401:j;2:m;12:n;4:r;1461:p;3:v;5:u;153:s;2:w;274277:B;38~:C;
Jj+4J*B+146097/F3*4/F+C+:f;
rf*v+:e;
ep%r/F:g;
ug*w+:h;
hs%u/F1+:D;
hs/Fm+n%1+:M;
ep/Fy-nm+M-n/F+:Y;
{
2014:Y;
D365+:D;
{
M1-12%[31 28 31 30 31 30 31 31 30 31 30 31]=:d
D<.{Dd-:D;M1+:M;}*
}(
}Y2014-*
D"/M"/Y

Sono ... davvero sfinito da tutta la felicità del nuovo anno e cosa no. Ecco perché non ho giocato a golf così tanto. Potrei o meno tornare per renderlo migliore in seguito.

Algoritmo da https://en.wikipedia.org/wiki/Julian_day#Gregorian_calendar_from_Julian_day_number

PHP (278)

Esegui dalla riga di comando utilizzando php -R '<code>'. (La bandiera conta come un personaggio.)

if(0<$N=($n=$argn-1721426)-735233){$n=$N%365+735233;$o=12*($N/365|0);}for($y=1+400*($n/146097|0)+100*(($n%=146097)/36524|0)+(($n%=36524)/1461<<2)+(($n%=1461)/365|0);($n%=365)>=$d=@++$m-2?30+($m+($m>>3)&1):29-($y%4||!($y%100)&&$y%400);)$n-=$d;printf("$y-%02d-%02d",$m+@$o,$n+1);

Versione più leggibile (eseguita utilizzando il nome file e senza -R):

<?php

// step 1: read the input and fix up 2014 dates
if (0 < $N = ($n = fgets(STDIN) - 1721426) - 735233) {
    $n = $N % 365 + 735233; // wrap around to 2014-01-01
    $o = 12 * ($N / 365 | 0); // compute month offset
}

for (

// step 2: extract year
$y = 1
    + 400 * ($n / 146097 | 0)
    + 100 * (($n %= 146097) / 36524 | 0)
    + (($n %= 36524) / 1461 << 2)
    + (($n %= 1461) / 365 | 0);

// step 3: extract month and day
($n %= 365) >= $d = @++$m - 2
    ? 30 + ($m + ($m >> 3) & 1)
    : 29 - ($y % 4 || !($y % 100) && $y % 400);

) $n -= $d;

// step 4: print date string, adding the month offset
// previously computed in step 1.
printf("$y-%02d-%02d", $m + @$o, $n + 1);

C (tipo di ... gcc lo consente) 183

Un sacco di avvertimenti per non-standardità e probabilmente incredibilmente non portabili, ma funziona oggi sulla mia macchina.

y=1;m;d;main(n,a){for(n=atoi(a[1]);n-->1721426;)++d>((m%12<7?m%2==0:m%2!=0)?30:m%12-1?29:y%(y%100?4:400)?27:28)&&(++m,d=0,m>11&&y<2014)&&(++y,m=0);printf("%d-%02d-%02d\n",y,m+1,d+1);}

Utilizza lo stesso algoritmo della risposta Python 2 di @grc

L'output dopo la compilazione è

test2014 2086302
999-12-31

test2014 2456659
2014-01-01

test2014 2456789
2014-05-11

test2014 2457024
2014-13-01

test2014 2457389
2014-25-01

test2014 2469134
2014-411-07

test2014 2567890
2014-3657-29

test2014 2914695
2014-15059-23