Votre défi est d'écrire un programme qui, compte tenu d'une année, affiche le nombre de "vendredi 13".

Règles et détails:

• Vous pouvez saisir des informations via STDINou comme argument transmis à votre programme.
• Vous devez afficher le résultat dans STDOUT.
• Vous pouvez supposer que la saisie sera une année valide et ne date pas d'avant le calendrier grégorien (un comportement indéfini est autorisé dans ces cas).
• Les bibliothèques de calendrier / date sont autorisées.

Il s'agit d'un code-golf , donc le code le plus court (en octets) l'emporte.

(Lien de défi connexe)

APL (Dyalog APL) avec cal des dfns , 29 octets

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

Essayez-le en ligne!

⍳ 12 les entiers un à douze

⎕ ,¨ prendre une entrée numérique et ajouter à chacun des douze nombres

{… }¨ Sur chacune des paires, appliquez la fonction…

 cal⍵ obtenir un calendrier pour cette année-mois

 2 ↓ déposer deux lignes (légende et jours)

 ⍉ transposer (afin que nous puissions adresser des colonnes au lieu de lignes)

 ¯5 ↑ prendre les cinq derniers (deux chiffres pour chacun des vendredis et samedis plus un espace)

 3 ↑ prendre les deux premiers (deux chiffres pour vendredi plus un espace)

 ⍉ transposer (donc on obtient l'ordre de lecture)

 , effilochage

 ⍎ exécuter comme expression APL (donne la liste des dates du vendredi)

 13 ∊ treize est-il membre de cette liste?

+/ additionner les 12 booléens

En utilisant l'algorithme de @ Wrzlprmft , nous pouvons le faire sans bibliothèques pour 53 octets:

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

-∘0 1 soustraire zéro et un

400 100 4 ∘.| tableau des divisions restantes pour les deux années (dans l'ensemble) divisé par ces chiffres (vers le bas)

0 ≠.= "produit" intérieur avec 0, mais en utilisant ≠ et = au lieu de +. ×

⊢ , ajouter l'année de l'argument non modifié

2 3 ¯1 +.× produit intérieur avec ces chiffres

14 | reste de division divisé par quatorze

'21232211321211' ⌷⍨ indexer dans cette chaîne

Mathematica 49 46 45 44 42

En tant que fonction pure : 42 caractères

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

Exemple

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

2

En tant que fonction nommée : 44 caractères

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

Exemples

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

2
3
2
1

Rubis, 49 48 47 46

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

Edit: Rasé un personnage en remontant une semaine, grâce à Jan, et un autre en passant de Time.new à Time.gm

Edit: Au détriment de l'obscurcir un peu plus, je peux arriver à 46 avec

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

Powershell, 68 63 58 52 50

Merci Iszi pour l'astuce.

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

En utilisant le fait que si le 1er jour du mois est dimanche, le 13 sera vendredi.

J'ai aussi essayé:

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

mais ce n'est pas la même chose $argsà l'intérieur du bloc de script.

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

Lundi 9 mai ne pas avoir la même sonnerie, mais fonctionne aussi bien.

Edit: Un an et demi pour remarquer que datec'est plus court que datetime:)

Ne pas utiliser de bibliothèques ou de fonctions de date intégrées:

Golfscript - 51

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

' [3/=RI[)a%:*.' pourrait aussi bien être 'feefefgeeffgfe'

Python - 82 79

Essentiellement le même algorithme.

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

En utilisant cette astuce , cela peut être approfondi pour:

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

Cela exploite le fait que, par calendrier, il n'y a que 14 années différentes, qui se distinguent par leur dernier jour et si elles sautent. lcalcule le nombre d'années bissextiles jusqu'à son argument (si le calendrier grégorien s'étendait en arrière jusqu'à l'année 1). (2*i+3*l(i)-l(i-1))%14est l'abréviation de l(i)-l(i-1)+(i+l(i))%7*2, où l(i)-l(i-1)nous indique si l'argument est une année bissextile et i+l(i)résume les changements du dernier jour (un dans une année normale, deux dans une année bissextile).

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]-'`');}

Pas la réponse la plus courte, mais n'utilise aucune bibliothèque.

C ( 151 145 137 131 131 130 car.)

Je suis surpris de voir qu'il n'y a qu'une seule autre solution qui n'utilise pas d'outils de calendrier intégrés. Voici une approche mathématique (très obscure), également en 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));}

(Ce qui précède se compile dans GCC sans erreur)

Solution alternative: C (287-> 215 caractères)

J'ai plutôt apprécié la solution de Williham Totland et son utilisation de la compression. J'ai corrigé deux petits bugs et ajusté le code pour raccourcir sa longueur:

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;

Basé sur

"Tout mois qui commence un dimanche contient un vendredi 13 et il y a au moins un vendredi 13 dans chaque année civile."

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

bash 47 36

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

Merci à @DigitalTrauma d'avoir enregistré 10 caractères en utilisant seqle démarrage par défaut de 1.

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

(La version précédente utilisant echoprésentait un bogue à cause de la ligne vide quand <(echo $1-{1..12}-6$'\n'). Donc, cette fonction a bien fonctionné jusqu'à aujourd'hui est un vendredi.

Voyons voir:

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

Est dépend des paramètres régionaux , si cela ne fonctionne pas, vous devrez peut-être

export LANG=C

ou

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

Dans une fonction; +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

De là, si ma fonction devient:

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[@]};}

ou

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 caractères

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

Lit à partir de stdin

Lisp commun (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);}

Merci à Jeppe Stig Nielsen pour linq et suggestion de vérifier dimanche le 8.

Merci à Danko Durbić d'avoir suggéré à la >place de ==.

PHP, 55 octets

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

Courez avec echo <year> | php -nR '<code>'.

Fondamentalement, la même chose qu'Oleg a essayé et Damir Kasipovic a fait, juste avec un meilleur golf:
chaque mois qui commence par un dimanche, a un vendredi 13.
Je passe donc en revue les mois et compte les premiers jours qui sont des dimanches.

panne

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 caractères)

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

Exemple d'utilisation dans la console Rebol:

>> y: 2012
== 2012

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

Une solution alternative qui recueille tous les vendredis 13 dans une année donnée est:

>> 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 et Sed, 39 ans

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

ncal imprime un calendrier pour l'année donnée avec les jours de la semaine en bas à gauche.

sedavec un /gdrapeau sous-marin tous les 13 avec des nouvelles lignes

grep -c compte les lignes commençant par "2" (20 suit toujours 13)

Merci à @DigitalTrauma d'avoir trouvé un bug dans mon ancienne version et d'avoir proposé une solution!

Scala, 76 68 caractères

En 78 caractères:

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

Rien d'extraordinaire, sauf pour utiliser des nombres magiques pour DAY_OF_WEEK = 7et FRIDAY = 6.

Version 68 caractères:

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

Oui, Java a changé les valeurs des constantes du jour de la semaine entre les API.

Python 195/204

Fonctionne uniquement pour les années précédentes, car monthdatescalendarrenvoie un calendrier pour l'année donnée jusqu'à présent . Je pense qu'il reste encore beaucoup de potentiel d'optimisation :).

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)

Une autre solution, fonctionne pour chaque date mais elle n'est pas plus petite:

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}}

Ancienne réponse:

{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

Avec l'idée de ne pas chercher 13thmais d'abord, et comme sundayc'est le cas, 0économisons 3 caractères! Merci @ Iszi et Danko Durbić!

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

Pourrait calculer 2010 à 2017 (pour exemple) de cette façon:

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

(Ok, il n'y a pas de nouvelle ligne , mais cela n'a pas été demandé;)

Ancien poste: 63

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

En action:

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

Dans Smalltalk (saveur Squeak / Pharo), implémentez cette méthode dans Integer ( 86 caractères)

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

Puis l' utiliser comme ceci: 2014countFriday13.

Bien sûr, nous pourrions utiliser un nom plus court, mais ce ne serait pas Smalltalk

C ++ - Trop d'octets :(

J'ai essayé une solution qui n'utilise aucune bibliothèque de dates.

J'ai trouvé une solution plutôt sympa (si je puis dire moi-même). Malheureusement, je ne peux pas le raccourcir, ce qui me dérange vraiment car il me semble qu'il devrait y avoir une meilleure solution.

La solution repose sur cet algorithme qui ne fait que 44 octets en soi. Malheureusement, j'ai besoin de 100 autres octets pour bien envelopper ...

#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;}

Sortie via le code retour (en C ++, utiliser coutou printfou quelque chose comme ça en nécessite un autre #include, ce qui ferait exploser encore plus la solution).

Pilote / programme de test:

# 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

Sortie du programme pilote:

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

Clojure, 207 187 octets

-20 octets en se débarrassant de la import, et des espaces blancs que j'ai manqués.

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

À partir du 1er janvier de l'année donnée, il se boucle chaque jour. Si le jour est le vendredi 13, il incrémente le décompte. Il continue de boucler jusqu'à ce qu'il atteigne l'année prochaine.

(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, pas de code intégré, 81 octets

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

Courez avec echo <year> | php -nR '<code>'.

panne

Les jours de la semaine se répètent tous les 400 ans.
Dans les résultats de 1600 à 1999 (par exemple), il y a une période de 28 longueurs avec seulement trois lacunes:

  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

Après avoir ajusté l'année pour ces écarts, nous pouvons obtenir le résultat avec un hachage simple:

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

Pas court (95 octets) mais joli. Et nous pouvons jouer au golf

• 4 octets en utilisant une chaîne ternaire pour le décalage,
• 8 octets en convertissant la carte de hachage d'une chaîne base4 en entier,
• un de plus en utilisant la représentation hexadécimale,
• et un en fusionnant les expressions.

Japt -x , 10 octets

CÆ5¥ÐUXD e

Essayez-le

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