Schreiben Sie eine Funktion, die ein Datum annimmt und den Wochentag des nächsten 29. Februar nach diesem Datum zurückgibt.

• Die Eingabe ist eine Zeichenfolge im erweiterten ISO-Format: JJJJ-MM-TT (z. B. 27. Mai 2010 wäre "2010-05-27").

• Die Ausgabe ist eine Zeichenfolge, die den Namen des Wochentags enthält (z. B. "Montag"). Die Groß- und Kleinschreibung spielt keine Rolle, aber geben Sie den vollständigen Namen auf Englisch an.

• Wenn das angegebene Datum der 29. Februar ist, geben Sie den Wochentag des nächsten 29. Februar zurück.

• Verwenden Sie die Berechnungen für den proleptischen Gregorianischen Kalender (also verwendet er die Gregorianischen Schaltjahrberechnungen für die gesamte Länge). Machen Sie sich keine Sorgen um den Julianischen Kalender oder wann der Wechsel von Julianisch zu Gregorisch stattgefunden hat. Nehmen Sie einfach Gregorian für alles an.

• Die Funktion sollte für mindestens den Bereich "0001-01-01" - "2100-01-01" funktionieren.

• Sie können alle Standardbibliotheken verwenden, die in der Sprache Ihrer Wahl verfügbar sind. Verwenden Sie jedoch keine Bibliotheken von Drittanbietern, es sei denn, Sie möchten diesen Code als Teil Ihrer Lösung verwenden.

• Kürzester Code (wenigste Zeichen) gewinnt.

Beispiele:

• func("0001-01-01") -> "Sunday"
• func("1899-12-03") -> "Monday"
• func("1970-01-01") -> "Tuesday"
• func("1999-07-06") -> "Tuesday"
• func("2003-05-22") -> "Sunday"
• func("2011-02-17") -> "Wednesday"
• func("2100-01-01") -> "Friday"

(und nein, Sie müssen die Funktion nicht benennen func)

Hinweise:

• Denken Sie daran, dass Jahre, die mit 00 enden und nicht durch 400 teilbar sind, keine Schaltjahre sind.
• Der 1. Januar 0001 ist ein Montag.

Windows PowerShell, 65

Ziemliech direkt.

filter f{for($d=date $_;($d+='1').day*$d.month-58){}$d.dayofweek}

Wie üblich können wir zwei Bytes abschneiden, wenn wir bereit sind, lange bis zur Fertigstellung zu warten:

filter f{for($d=date $_;($d+=9).day*$d.month-58){}$d.dayofweek}

Prüfung:

> '0001-01-01','1899-12-03','1970-01-01','1999-07-06','2003-05-22','2011-02-17','2100-01-01'|f
Sunday
Monday
Tuesday
Tuesday
Sunday
Wednesday
Friday

Geschichte:

• 2011-02-18 00:06 (65) Erster Versuch.

Ruby 1.9, 85 Zeichen

f=->a{require"date";d=Date.parse(a,0,0)+1;d+=1until d.day*d.month==58;d.strftime"%A"}

Einfache Lösung. Rufen Sie die Funktion mit auf f[args].

• Bearbeiten: (87 -> 97) Der 0001-01-01Testfall wurde behoben.
• Bearbeiten 2: (97 -> 91) Mit Date.parse können Sie auch das Datum der Kalenderreform angeben.
• Edit 3: (91 -> 87) Verwenden Sie ein Lambda anstelle einer Funktion. Danke Dogbert !
• Edit 4: (87 -> 85) Entferne unnötige Leerzeichen. Nochmals vielen Dank, Dogbert !

T-SQL 166 185 Zeichen

CREATE PROCEDURE f29 (@d DATETIME) AS
DECLARE @i int
SET @i=YEAR(DATEADD(M,-2,@d)+3)
SET @i=@i+(4-@i%4)
IF @i%100=0 AND @i%400<>0 SET @i=@i+4
SELECT DATENAME(W,CAST(@i AS CHAR)+'-2-29')

Ich habe bereits mit T-SQL-Datumsfunktionen rumgespielt und mir überlegt, warum nicht ...

Die ursprüngliche Lösung war falsch ...

Folgendes muss ich tatsächlich tun, damit diese Strategie funktioniert:

CREATE PROCEDURE f29 (@d DATE) AS
DECLARE @i int
SET @i = YEAR(@d)
BEGIN TRY 
SET @i=YEAR(DATEADD(D, 3, DATEADD(M,-2,@d)))
END TRY
BEGIN CATCH
END CATCH
SET @i=@i+(4-@i%4)
IF @i%100=0 AND @i%400<>0 SET @i=@i+4
SELECT DATENAME(W,CAST(@i AS CHAR)+'-2-29')

C #, 176

Func<String,String>f=(d)=>{DateTime n;for(n=DateTime.Parse(d).AddDays(307);!(DateTime.IsLeapYear(n.Year));n=n.AddYears(1)){}return new DateTime(n.Year,2,29).ToString("dddd");};

Bash, 96 Bytes

Danke Peter ... Sehr gute Version, 96 Bytes:

i=1;until [ `date -d"$1 $i days" +%m-%d` = "02-29" ];do((i++));done
date -d "${1} ${i} days" +%A

Alte Version, 229 Bytes

#!/bin/bash
from=$1
i=1
while [ "$isFeb" = "" ] || [ "$is29" = "" ]
do
isFeb=`date -d "${from} ${i} days" | grep Feb`
is29=`date -d "${from} ${i} days" +%Y-%m-%d | grep "\-29"`
((i++))
done
((i--))
date -d "${from} ${i} days" +%A

BEISPIEL E / A

:~/aman>./29Feb.sh 0001-01-01
Sunday
:~/aman>./29Feb.sh 1899-12-03
Monday
:~/aman>./29Feb.sh 1970-01-01
Tuesday

Perl, keine Datumsbibliothek: 160 159 155

sub f {($ y, $ m) = split / - /, @ _ ​​[0], 2; $ y ++ if ($ m> '02 -28 '); $ y = ($ y + 3)% 400 >> 2; $ y + = $ y &&! ($ Y% 25); @ r = (Dienstag, Mittwoch, Donnerstag, Freitag, Samstag, Sonntag, Montag); @ r [(5 * $ y - ($ y / 25 & 3))% 7]. "Tag";}

Der eigentliche Vorteil dieser Datumsbibliotheken besteht darin, dass die Länge der Namen der Tage an andere weitergegeben wird.

Andererseits denke ich, dass dies die einzige Lösung ist, die bisher funktioniert, unabhängig vom Gebietsschema.

DATUM und etwas BASHY-Kleber (90)

Die Funktion:

f(){ while :;do $(date -d$1+1day +'set - %F %A 1%m%d');(($3==10229))&&break;done;echo $2;}

Testen:

$ for x in 0001-01-01 1899-12-03 1970-01-01 1999-07-06 2003-05-22 2011-02-17 2100-01-01 ; do f $x ; done
Sunday
Monday
Tuesday
Tuesday
Sunday
Wednesday
Friday

D: 175 Zeichen

S f(S)(S s){auto d=Date.fromISOExtString(s)+days(1);while(d.month!=Month.feb||d.day!=29)d+=days(1);return["Sun","Mon","Tues","Wednes","Thurs","Fri","Sat"][d.dayOfWeek]~"day";}

Mehr leserlich:

S f(S)(S s)
{
    auto d = Date.fromISOExtString(s) + days(1);

    while(d.month != Month.feb || d.day != 29)
        d += days(1);

    return ["Sun", "Mon", "Tues", "Wednes", "Thurs", "Fri", "Sat"][d.dayOfWeek] ~ "day";
}

Es ist sehr einfach, in D zu schreiben, aber es wird definitiv keinen Code-Golfwettbewerb gewinnen. Abgesehen vom Code-Golfen wäre es mir viel lieber, wenn ich es einfach schreiben und verstehen könnte, aber lange nicht knapp, aber schwer zu schreiben und zu verstehen.

Java 8 - 252 Zeichen

Golf gespielt:

import java.time.*;
import java.time.format.*;
public class S{public static void main(String[] a){LocalDate d=LocalDate.parse(a[0]).plusDays(1);while(d.getMonthValue()!=2||d.getDayOfMonth()!=29){d=d.plusDays(1);}System.out.println(d.getDayOfWeek());}}

Ungolfed:

import java.time.*;
import java.time.format.*;
public class S {
    public static void main(String[] a) {
        LocalDate d = LocalDate.parse(a[0]).plusDays(1);

        while(d.getMonthValue()!=2 || d.getDayOfMonth()!=29) {
            d = d.plusDays(1);
        }
        System.out.println(d.getDayOfWeek());
    }
}

Rebol - 78

f: func[d][system/locale/days/(until[d: d + 1 d/day * d/month = 58]d/weekday)]

Ungolfed:

f: func [d] [
    system/locale/days/(
        until [
            d: d + 1
            d/day * d/month = 58
        ]
        d/weekday
    )
]

Anwendungsbeispiel (in der Rebol-Konsole):

>> f 0001-01-01
== "Sunday"

>> f 2100-01-01
== "Friday"

PHP, 104 Bytes

function f($s){for($y=$s-(substr($s,5)<"02-29");!date(L,$t=strtotime(++$y."-2-1")););return date(l,$t);}

Nervenzusammenbruch

for($y=$s-;                 // "-" casts the string to int; decrement year if ...
    (substr($s,5)<"02-29")  // ... date is before feb 29
    !date(L,                        // loop while incremented $y is no leap year
        $t=strtotime(++$y."-2-1")   // $t=feb 01 in that year (same weekday, but shorter)
    );
);
return date(l,$t);          // return weekday name of that timestamp

date(L): 1für Schaltjahr, 0sonst
date(l): vollständige Textdarstellung des Wochentags

GNU Coreutils, 71 Bytes

f(){
seq -f "$1 %gday" 2921|date -f- +'%m%d%A'|sed 's/0229//;t;d;:;q'
}

Lineare Suche der nächsten 8 Jahre (schlimmster Fall, gegeben am 29.02.2096). Sed findet und gibt die erste Zeile aus, die dem 29. Februar entspricht.

Ich war überrascht festzustellen, dass dies t;d;:;qkürzer war als das Testen, um festzustellen, ob die Ziffern ( /[01]/d;q) blieben , obwohl es doppelt so viele Befehle gab.

Tests

Ich habe eine zusätzliche Reihe von Tests für schwierige Eckfälle hinzugefügt:

for i in 0001-01-01.Sunday 1899-12-03.Monday \
    1970-01-01.Tuesday     1999-07-06.Tuesday \
    2003-05-22.Sunday      2011-02-17.Wednesday 2100-01-01.Friday \
    2000-02-28.Tuesday     2000-02-29.Sunday    2000-03-01.Sunday   2096-02-29.Friday
do
    printf "%s => %s (expected %s)\n" ${i%.*} $(f ${i%.*}) ${i#*.}
done