Ihre Herausforderung besteht darin, ein Programm zu schreiben, das in einem Jahr die Anzahl der "Freitag-13-ten" ausgibt.

Regeln & Details:

• Sie können Eingaben über STDINoder als Argument an Ihr Programm übergeben.
• Sie sollten das Ergebnis an ausgeben STDOUT.
• Sie können davon ausgehen, dass die Eingabe ein gültiges Jahr ist und den gregorianischen Kalender nicht vorbelegt (undefiniertes Verhalten ist in diesen Fällen zulässig).
• Kalender- / Datumsbibliotheken sind zulässig.

Dies ist ein Code-Golf , also gewinnt der kürzeste Code (in Bytes).

(Link zur zugehörigen Herausforderung)

APL (Dyalog APL) mit cal von dfns , 29 Bytes

+/{13∊⍎,⍉3↑¯5↑⍉2↓cal⍵}¨⎕,¨⍳12

Probieren Sie es online!

⍳ 12 die ganzen Zahlen eins bis zwölf

⎕ ,¨ Nehmen Sie die numerische Eingabe und stellen Sie jede der zwölf Zahlen voran

{… Wende }¨ auf jedes der Paare die Funktion an…

 cal⍵ Holen Sie sich einen Kalender für das Jahr-Monat

 2 ↓ Füge zwei Zeilen ein (Beschriftung und Tage)

 ⍉ transponieren (damit wir Spalten statt Zeilen ansprechen können)

 ¯5 ↑ nimm die letzten fünf (jeweils zwei Ziffern für Freitag und Samstag plus ein Leerzeichen)

 3 ↑ nimm die ersten zwei (zwei Ziffern für Freitag plus ein Leerzeichen)

 ⍉ transponieren (so bekommen wir Lesereihenfolge)

 , ravel

 ⍎ Als APL-Ausdruck ausführen (Liste der Freitagsdaten)

 13 ∊ Ist 13 ein Mitglied dieser Liste?

+/ summiere die 12 Booleschen

Mit dem @ Wrzlprmft-Algorithmus können wir 53 Bytes lang ohne Bibliotheken arbeiten:

'21232211321211'⊃⍨14|2 3 ¯1+.×⊢,0≠.=400 100 4∘.|-∘0 1

-∘0 1 subtrahieren Sie null und eins

400 100 4 ∘.| Divisionsresttabelle für die zwei Jahre (quer) geteilt durch diese Zahlen (runter)

0 ≠.= inneres "Produkt" mit 0, aber mit ≠ und = anstelle von +. ×

⊢ , stellen Sie das nicht geänderte Argument Jahr voran

2 3 ¯1 +.× inneres Produkt mit diesen Zahlen

14 | Division Rest, wenn durch vierzehn geteilt

'21232211321211' ⌷⍨ Index in diese Zeichenfolge

Mathematica 49 46 45 44 42

Als reine Funktion : 42 Zeichen

DayName@{#,m,6}~Table~{m,12}~Count~Friday&

Beispiel

DayName@{#,m,6}~Table~{m,12}~Count~Friday&[2013]

2

Als benannte Funktion : 44 Zeichen

f=DayName@{#,m,6}~Table~{m,12}~Count~Friday&

Beispiele

f[1776]
f[2012]
f[2013]
f[2014]

2
3
2
1

Ruby, 49 48 47 46

f=->m{(1..12).count{|i|Time.gm(m,i,6).friday?}}

Bearbeiten: Rasierte einen Charakter, indem er dank Jan eine Woche zurückging, und einen anderen, indem er von Time.new zu Time.gm wechselte

Edit: Auf Kosten der Verschleierung ein bisschen mehr, kann ich mit bis 46 bekommen

f=->m{(1..12).count{|i|Time.gm(m,i,8).wday<1}}

Powershell, 68 63 58 52 50

Danke Iszi für den Tipp.

$n=$args;(1..12|?{!+(date $n-$_).DayOfWeek}).Count

Wenn der erste Tag im Monat der Sonntag ist, ist der 13. der Freitag.

Ich habe auch versucht:

(1..12|?{!+(date $args-$_).DayOfWeek}).Count

Aber es ist nicht dasselbe $argsinnerhalb des Skriptblocks.

R 76 72 57

sum(format(as.Date(paste(scan(),1:12,1,sep="-")),"%w")<1)

Python2.7 90 86

from datetime import*
s=c=0
exec's+=1;c+=date(%d,s,9).weekday()<1;'%input()*12
print c

Montag, der 9., hat vielleicht nicht ganz den gleichen Klang, funktioniert aber genauso gut.

Edit: Anderthalb Jahre zu bemerken, dass dateist kürzer als datetime:)

Keine Bibliotheken oder integrierten Datumsfunktionen verwenden:

Golfscript - 51

~..({4/.25/.4/--@}2*2*\3*+-
14%' [3/=RI[)a%:*.'\=5%

' [3/=RI[)a%:*.' könnte genauso gut sein 'feefefgeeffgfe'

Python - 82 79

Im Wesentlichen derselbe Algorithmus.

l=lambda y:y/4-y/100+y/400
i=input()
print"21232211321211"[(2*i+3*l(i)-l(i-1))%14]

Mit diesem Trick können Sie weiter spielen, um:

l=lambda y:y/4-y/100+y/400
i=input()
print 94067430>>(4*i+6*l(i)-2*l(i-1))%28&3

Dies nutzt die Tatsache aus, dass es kalenderweise nur 14 verschiedene Jahre gibt, die an ihrem letzten Tag erkennbar sind und ob sie springen. lberechnet die Anzahl der Schaltjahre bis zu seinem Argument (wenn der Gregorianische Kalender rückwärts auf das Jahr 1 ausgedehnt wurde). (2*i+3*l(i)-l(i-1))%14steht für l(i)-l(i-1)+(i+l(i))%7*2, wo steht l(i)-l(i-1), ob das Argument ein Schaltjahr ist und i+l(i)fasst die Schichten des letzten Tages zusammen (eine in einem normalen Jahr, zwei in einem Schaltjahr).

C 301+ 287

main(int x,char**v){char p[400],*a[]={"abbababbacaacbac","bacabbb","baabbaca","abbb","aabbacaac","abbbbcaac","abbbbaabb"},*b="adcadcadcaebcadcadcafbcadcadcagbcadcadcadc";int c=0,i,y=atoi(v[0]);for(i=0;i<42;i++)strcpy(&p[c],a[b[i]-'a']),c+=strlen(a[b[i]-'a']);printf("%d",p[y%400]-'`');}

Nicht die kürzeste Antwort, verwendet aber keine Bibliotheken.

C ( 151 145 137 131 130 Zeichen)

Ich bin überrascht zu sehen, dass es nur eine andere Lösung gibt, die keine integrierten Kalender-Tools verwendet. Hier ist ein (stark verschleierter) mathematischer Ansatz, auch in C:

f(x){return(x+(x+3)/4-(x+99)/100+!!x)%7;}main(int x,char**v){int y=atoi(v[1])%400,a=f(y+1);putchar('1'+((f(y)&3)==1)+(a>2&&a-5));}

(Die oben genannten kompiliert in GCC ohne Fehler)

Alternative Lösung: C (287-> 215 Zeichen)

Mir hat die Lösung von Williham Totland und die Komprimierung sehr gut gefallen . Ich habe zwei kleine Fehler behoben und den Code angepasst, um seine Länge zu verkürzen:

main(int x,char**v){char p[400],*a[]={"1221212213113","213122221122131","12213113","22213113","22221122","2131"},*b="abababafcbababafdbababafebababab";*p=0;for(;*b;b++)strcat(p,a[*b-97]);putchar(p[atoi(v[1])%400]);}

PHP, 82

<?for($i=1,$c=0;$i<13;$i++)$c+=(date("N",mktime(0,0,0,$i,1,$argv[1]))==7);echo $c;

Beyogen auf

"Jeder Monat, der an einem Sonntag beginnt, enthält einen Freitag, den 13., und es gibt mindestens einen Freitag, den 13., in jedem Kalenderjahr."

Aus http://en.wikipedia.org/wiki/Friday_the_13th

Bash 47 36

seq -f$1-%g-6 12|date -f-|grep -c ^F

Vielen Dank an @DigitalTrauma für das Speichern von 10 Zeichen seqmit der Standardeinstellung start to 1.

date -f<(printf "%s\n" $1-{1..12}-6)|grep -c ^F

(Vorherige Version mit echogegenwärtig einen Fehler wegen der leeren Zeile , wenn <(echo $1-{1..12}-6$'\n'). Also diese Funktion funktionierte gut , bis heute ist ein Freitag.

Wir werden sehen:

set -- 2013
seq -f$1-%g-6 1 12|date -f-|grep -c ^F
2

date -f<(printf "%s\n" $1-{1..12}-13)|grep -c ^F
2

Ist abhängig vom Gebietsschema , und wenn es nicht funktioniert, müssen Sie es möglicherweise tun

export LANG=C

oder

LANG=C date -f<(printf "%s\n" $1-{1..12}-13)|grep -c ^F

In eine Funktion; +7 -> 43

f(){ seq -f$1-%g-6 12|date -f-|grep -c ^F;}

f 2013
2

for i in {2010..2017};do echo $i $(f $i) ;done
2010 1
2011 1
2012 3
2013 2
2014 1
2015 3
2016 1
2017 2

Bonus: +78 -> 121

Von dort, wenn meine Funktion wird:

f(){ o=();for t in $(seq -f$1-%g-6 12|date -f- +%a,%b);do [ "${t:0:1}" = "F" ]&&o+=(${t#*,});done;echo ${#o[@]} ${o[@]};}

oder

f(){ o=();
     for t in $(seq -f$1-%g-6 1 12|date -f- +%a,%b);do
         [ "${t:0:1}" = "F" ]&&o+=(${t#*,})
       done
     echo ${#o[@]} ${o[@]}
}

for i in {2010..2017};do echo $i $(f $i) ;done
2010 1 Aug
2011 1 May
2012 3 Jan Apr Jul
2013 2 Sep Dec
2014 1 Jun
2015 3 Feb Mar Nov
2016 1 May
2017 2 Jan Oct

JavaScript, 70

f=function(a){b=0;for(c=12;c--;)b+=!new Date(a,c,1).getDay();return b}

k

64 Zeichen

{+/6={x-7*x div 7}(.:')x,/:(".",'"0"^-2$'$:1+!:12),\:".13"}[0:0]

Liest von stdin

Common Lisp (CLISP), 149

(print 
    (loop for i from 1 to 12 count 
        (= 4 (nth-value 6 
            (decode-universal-time
                (encode-universal-time 0 0 0 13 i
                    (parse-integer (car *args*)) 0))))))

C # 110 101 93 92

int f(int y){int c=0;for(int i=1;i<13;i++)c+=new DateTime(y,i,8).DayOfWeek>0?0:1;return c;}

C # Linq 88

int g(int y){return Enumerable.Range(1,12).Count(m=>new DateTime(y,m,8).DayOfWeek==0);}

Vielen Dank an Jeppe Stig Nielsen für den Link und den Vorschlag, sich am 8. für den Sonntag zu melden.

Vielen Dank an Danko Durbić für den Vorschlag >statt ==.

PHP, 55 Bytes

for(;++$i<13;)$c+=!date(w,strtotime($argn.-$i));echo$c;

Laufen Sie mit echo <year> | php -nR '<code>'.

Im Grunde dasselbe wie Oleg und Damir Kasipovic , nur mit besserem Golfspiel:
Jeder Monat, der mit einem Sonntag beginnt, hat einen Freitag, den 13 ..
Also durchlaufe ich die Monate und zähle die ersten Tage, die Sonntage sind.

Nervenzusammenbruch

for(;++$i<13;)          // loop $i from 1 to 12
    $c+=!                   // 4. if result is not truthy (weekday==0), increment $c
        date(w,             // 3. get weekday (0 stands for Sunday)
            strtotime(      // 2. convert to timestamp (midnight 1st day of the month)
                $argn.-$i   // 1. concatenate year, "-" and month
            )
        )
    ;
echo$c;                 // output

K, 42

{+/1={x-7*x div 7}"D"$"."/:'$+(x;1+!12;1)}

.

k){+/1={x-7*x div 7}"D"$"."/:'$+(x;1+!12;1)}'1776 2012 2013 2014
2 3 2 1

Bash ( 52 47 Zeichen)

for m in {1..12};do cal $m $Y;done|grep -c ^15

Rebol, 63

f: 0 repeat m 12[d: do ajoin["6-"m"-"y]if d/weekday = 5[++ f]]f

Anwendungsbeispiel in der Rebol-Konsole:

>> y: 2012
== 2012

>> f: 0 repeat m 12[d: do ajoin["6-"m"-"y]if d/weekday = 5[++ f]]f
== 3

Alternative Lösung, die den ganzen Freitag, den 13. im gegebenen Jahr sammelt, ist:

>> collect[repeat m 12[d: do ajoin["13-"m"-"y]if d/weekday = 5[keep d]]]
== [13-Jan-2012 13-Apr-2012 13-Jul-2012]

Bash und Sed, 39

ncal $1|sed '/F/s/13/\
/g'|grep -c ^\ 2

ncal druckt einen Kalender für das angegebene Jahr mit Wochentagen links unten.

sedmit einer /gFlagge werden alle 13er mit Zeilenumbrüchen unterlegt

grep -c zählt die Zeilen, die mit "2" beginnen (20 folgt immer 13)

Vielen Dank an @DigitalTrauma, dass Sie einen Fehler in meiner alten Version gefunden und eine Lösung vorgeschlagen haben!

Scala, 76 68 Zeichen

In 78 Zeichen:

def f(y:Int)=0 to 11 count(new java.util.GregorianCalendar(y,_,6).get(7)==6)

Nichts Außergewöhnliches, außer magische Zahlen für DAY_OF_WEEK = 7und zu verwenden FRIDAY = 6.

Version mit 68 Zeichen:

def f(y:Int)=0 to 11 count(new java.util.Date(y-1900,_,6).getDay==5)

Ja, Java hat die Werte der Wochentagskonstanten zwischen den APIs geändert.

Python 195/204

Funktioniert nur für frühere Jahre, da monthdatescalendarbis jetzt ein Kalender für das angegebene Jahr zurückgegeben wird . Ich denke, es gibt noch viel Optimierungspotential :).

import calendar, sys
c=calendar.Calendar()
f=0
for m in range(1,12):
 for w in c.monthdatescalendar(int(sys.argv[1]),m):
  for d in w:
   if d.weekday() == 4 and d.day == 13:
    f=f+1
print(f)

Eine andere Lösung, die für jedes Datum geeignet ist, aber nicht kleiner ist:

import datetime,sys
y=int(sys.argv[1])
n=datetime.date
f=n(y,1,1)
l=n(y,12,31)
i=0
for o in range(f.toordinal(), l.toordinal()):
 d=f.fromordinal(o)
 if d.day == 13 and d.weekday() == 4:
  i=i+1
print(i)

Perl 6, 55 53

{sum (1..12).map: {Date.new($_,$^a,1).day-of-week>6}}

Alte Antwort:

{sum (1..12).map: {Date.new($_,$^a,13).day-of-week==5}}

Python (v2) 120

import datetime as d,sys
s=0
for m in range(1, 13):
    if d.datetime(int(sys.argv[1]),m,6).weekday()==4: s=s+1
print s

Perl + lib POSIX 55

Mit dem Gedanken, nicht erst zu suchen 13th, und wie es sundayist, 0lassen Sie 3 Zeichen sparen! Danke @ Iszi und Danko Durbić!

$==$_;$_=grep{!strftime"%w",0,0,0,1,$_,$=-1900}(0..11)

Könnte 2010 bis 2017 (als Beispiel) folgendermaßen berechnen:

perl -MPOSIX -pE '$==$_;$_=grep{!strftime"%w",0,0,0,1,$_,$=-1900}(0..11)' <(
    printf "%s\n" {2010..2017})
11321312

(Ok, es gibt kein Newline , aber das wurde nicht gefragt;)

Alter Beitrag: 63

$==grep{5==strftime"%w",0,0,0,13,$_,$ARGV[0]-1900}(0..11);say$=

In Aktion:

for i in {2010..2017};do
    echo $i $(
        perl -MPOSIX -E '
            $==grep{5==strftime"%w",0,0,0,13,$_,$ARGV[0]-1900}(0..11);say$=
            ' $i );
  done
2010 1
2011 1
2012 3
2013 2
2014 1
2015 3
2016 1
2017 2

In Smalltalk (Squeak / Pharo Aroma), implementieren diese Methode in Integer ( 86 Zeichen)

countFriday13^(1to:12)count:[:m|(Date year:self month:m day:13)dayOfWeekName='Friday']

Dann verwenden Sie es wie folgt aus : 2014countFriday13.

Natürlich könnten wir einen kürzeren Namen verwenden, aber dann wäre es nicht Smalltalk

C ++ - Zu viele Bytes :(

Ich habe eine Lösung ausprobiert, die keine Datumsbibliotheken verwendet.

Ich fand eine ziemlich coole (wenn ich so sagen darf) Lösung. Leider kann ich es nicht kürzer machen, was mich wirklich nervt, weil ich das Gefühl habe, dass es einen besseren Weg geben sollte.

Die Lösung hängt von diesem Algorithmus ab, der nur 44 Byte umfasst. Leider brauche ich noch 100 Bytes, um es schön zu verpacken ...

#include<stdlib.h>
main(int,char**v){int f=0,d,m,y;for(m=1;m<13;++m)d=13,y=atoi(v[1]),(d+=m<3?y--:y-2,23*m/9+d+4+y/4-y/100+y/400)%7-5||++f;return f;}

Ausgabe über den Rückkehrcode (in C ++ erfordert die Verwendung von coutoder printfetwas Ähnliches ein anderes #include, was die Lösung noch mehr in die Luft jagen würde).

Treiber / Testprogramm:

# Make sure we're not running an old version
rm doomsday.exe

gcc doomsday.cpp -o doomsday.exe

./doomsday.exe 1776
echo 1766: $?

./doomsday.exe 2012
echo 2013: $?

./doomsday.exe 2013
echo 2013: $?

./doomsday.exe 2014
echo 2014: $?

echo `wc doomsday.cpp -c` characters

Ausgabe des Treiberprogramms:

$ ./test_doomsday 
1766: 2
2013: 3
2013: 2
2014: 1
150 doomsday.cpp characters

Clojure, 207 187 Bytes

-20 Bytes durch das Loswerden der importund einige Leerzeichen, die ich verpasst habe.

(import '[java.time LocalDate DayOfWeek])#(loop[d(LocalDate/parse(str %"-01-01"))c 0](if(=(.getYear d)%)(recur(.plusDays d 1)(if(and(=(.getDayOfMonth d)13)(= (.getDayOfWeek d) DayOfWeek/FRIDAY))(inc c)c))c))

Ab dem 1. Januar des jeweiligen Jahres durchläuft es jeden Tag eine Schleife. Wenn der Tag Freitag der 13. ist, wird die Anzahl erhöht. Die Schleife wird fortgesetzt, bis sie das nächste Jahr erreicht.

(import '[java.time LocalDate DayOfWeek])

(defn count-friday-13ths [year]
  (loop [d (LocalDate/parse (str year "-01-01")) ; Starting date
         c 0] ; The count
    (if (= (.getYear d) year) ; If we haven't moved onto the next year...
      (recur (.plusDays d 1) ; Add a day...
             (if (and (= (.getDayOfMonth d) 13) ; And increment the count if it's Friday the 13th
                      (= (.getDayOfWeek d) DayOfWeek/FRIDAY))
               (inc c) c))
      c))) ; Return the count once we've started the next year.

PHP, keine eingebauten, 81 Bytes

echo 0x5da5aa76d7699a>>(($y=$argn%400)+($y>102?$y>198?$y>299?48:32:16:0))%28*2&3;

Laufen Sie mit echo <year> | php -nR '<code>'.

Nervenzusammenbruch

Die Wochentage wiederholen sich alle 400 Jahre.
In den Ergebnissen für 1600 bis 1999 (zum Beispiel) gibt es einen Zeitraum von 28 Jahren mit nur drei Lücken:

  0:2212122131132131222211221311
 28:2212122131132131222211221311
 56:2212122131132131222211221311
 84:2212122131132131122
103:       131132131222211221311
124:2212122131132131222211221311
152:2212122131132131222211221311
180:2212122131132131222
199:       131132131222211221311
220:2212122131132131222211221311
248:2212122131132131222211221311
276:221212213113213122221122
300:            2131222211221311
316:2212122131132131222211221311
344:2212122131132131222211221311
372:2212122131132131222211221311

Nachdem wir das Jahr für diese Lücken angepasst haben, können wir das Ergebnis mit einem einfachen Hash erhalten:

$y=$argn%400;foreach([300,199,103]as$k)$y<$k?:$y+=16;
echo"2212122131132131222211221311"[$y%28];

Nicht kurz (95 Bytes), aber hübsch. Und wir können Golf spielen

• 4 Bytes unter Verwendung einer ternären Kette für den Offset,
• 8 Bytes durch Konvertieren der Hash-Map von einer Base4-Zeichenfolge in eine Ganzzahl,
• eine weitere unter Verwendung der Hex-Darstellung,
• und eine durch Zusammenführen der Ausdrücke.

Japt -x , 10 Bytes

CÆ5¥ÐUXD e

Versuch es

CÆ5¥ÐUXD e     :Implicit input of integer U
C              :12
 Æ             :  Map each X in the range [0,C) (months are 0-indexed in JavaScript)
  5¥           :  Check if 5 is equal to
    ÐUXD       :  new Date(U,X,13)
         e     :  0-based index of day of the week
               :Implicitly reduce by addition and output