28

आपकी चुनौती एक कार्यक्रम लिखने की है, जो एक वर्ष दिया जाता है, इसमें "शुक्रवार 13 वें" की संख्या को आउटपुट करता है।

नियम और विवरण:

आप इनपुट के माध्यम से STDIN, या अपने कार्यक्रम में दिए गए तर्क के रूप में ले सकते हैं ।
आपको परिणाम को आउटपुट करना चाहिए STDOUT।
आप मान सकते हैं कि इनपुट एक वैध वर्ष होगा, और ग्रेगोरियन कैलेंडर की पूर्व-तिथि नहीं है (इन मामलों में अपरिभाषित व्यवहार की अनुमति है)।
कैलेंडर / दिनांक पुस्तकालयों की अनुमति है।

यह एक कोड-गोल्फ है , इसलिए सबसे छोटा कोड (बाइट्स में) जीतता है।

code-golf date

7

इनपुट की आवश्यक सीमा क्या है? अगर यह 1800 से बहुत पहले चला जाता है, तो जूलियन से ग्रेगोरियन कैलेंडर में स्विचओवर के बारे में क्या धारणा बनाई जानी चाहिए?

— पीटर टेलर

@PeterTaylor मैंने इसके बारे में नहीं सोचा था। यदि एक तारीख gregorian पूर्व-तारीख करता है तो आपके पास अपरिभाषित व्यवहार हो सकता है।

— क्रंचर

1

ग्रेगोरियन कैलेंडर को अपनाने वाले पहले देशों ने अक्टूबर 1582 में ग्रेगरी के बैल का अनुसरण करते हुए ऐसा किया था। 20 वीं सदी के अंत तक नए कैलेंडर को अपनाने के लिए देशों में परिवर्तन नहीं हुआ, उदाहरण के लिए ग्रीस ने 1 मार्च 1923 को इसे पेश किया।

— जेपी स्टिग नीलसन

@JeppeStigNielsen मुझे कैलेंडर और इस तरह के बारे में ज्यादा जानकारी नहीं है। चाहे उन्होंने उन्हें अपनाया हो या नहीं बदला हो, लेकिन ग्रेगोरियन तिथियां क्या हैं। पुस्तकालयों को मेरे द्वारा मान लिए जाने वाले तरीकों से तारीखों की गणना करने में सक्षम होना चाहिए?

— क्रन्चर

3

मुझे लगता है कि मैं यहाँ पर अपमानित हो रहा हूँ। एंग्लो-अमेरिकन प्रोग्रामर्स द्वारा लिखी गई कई लाइब्रेरी सितंबर 1752 को कैलेंडर के "सही" समय के रूप में उपयोग करती हैं। यह तब था जब ब्रिटिश साम्राज्य बदल गया। जब संयुक्त राज्य अमेरिका की स्थापना की गई थी, निश्चित रूप से नया कैलेंडर रखा गया था। (एक जिज्ञासा के रूप में, कुछ एसक्यूएल सॉफ्टवेयर में 1753 न्यूनतम वर्ष होता है क्योंकि वे सितंबर 1752 के मुद्दे का सामना नहीं करना चाहते हैं।) हालांकि, सितंबर 1752 का उपयोग करना अत्यधिक कोणीय है। आप सही हैं ग्रेगोरियन तिथियाँ वही हैं जो ऐतिहासिक रूप से उपयोग किए गए थे या नहीं। यह तथाकथित प्रोलेप्टिक ग्रेगोरियन कैलेंडर है।

— जेपी स्टिग नीलसन

3

APL (Dyalog APL) dfns से कैल के साथ , 29 बाइट्स

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

इसे ऑनलाइन आज़माएं!

⍳ 12 पूर्णांक एक बारह के माध्यम से

⎕ ,¨ संख्यात्मक इनपुट लें और बारह संख्याओं में से प्रत्येक के लिए प्रस्तुत करें

{... }¨ प्रत्येक जोड़े पर, फ़ंक्शन लागू करें ...

cal⍵ उस वर्ष-माह के लिए एक कैलेंडर प्राप्त करें

2 ↓ दो पंक्तियों को छोड़ें (कैप्शन और दिन)

⍉ स्थानान्तरण (इसलिए हम पंक्तियों के बजाय स्तंभों को संबोधित कर सकते हैं)

¯5 ↑ अंतिम पांच (शुक्रवार और शनिवार को एक-एक स्थान के लिए दो अंक) लें

3 ↑ पहले दो (शुक्रवार और एक स्थान के लिए दो अंक) लें

⍉ संक्रमण (इसलिए हमें पढ़ने का आदेश मिलता है)

, प्रसिद्ध हो जाना

⍎ एपीएल अभिव्यक्ति के रूप में निष्पादित करें (शुक्रवार की तारीखों की सूची देता है)

13 ∊ तेरह उस सूची का एक सदस्य है?

+/ राशि 12 बूलियन्स

@ Wrzlprmft के एल्गोरिथ्म का उपयोग करते हुए , हम इसे 53 बाइट्स के लिए पुस्तकालयों के बिना कर सकते हैं:

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

-∘0 1 शून्य और एक घटाएँ

400 100 4 ∘.| इन नंबरों (विभाजित) से विभाजित दो वर्षों के लिए विभाजन शेष तालिका (नीचे)

0 ≠.= आंतरिक "उत्पाद" 0 के साथ, लेकिन + × के बजाय ≠ और = का उपयोग करके

⊢ , अनमोल तर्क वर्ष प्रस्तुत करना

2 3 ¯1 +.× इन नंबरों के साथ आंतरिक उत्पाद

14 | चौदह से विभाजित होने पर विभाजन शेष

'21232211321211' ⌷⍨ सूचकांक इस स्ट्रिंग में

— एडम
स्रोत

यह 29 वर्ण है, लेकिन ये 1 से अधिक बाइट वर्ण हैं?

— क्रंचर

@ क्रंचर मैंने हेडिंग में एक व्याख्यात्मक लिंक जोड़ा है। यदि आप TIO लिंक खोलते हैं, तो आप देखेंगे कि यह दाईं ओर "29 चार्ट, 29 बाइट्स (SBCS)" कहता है, यानी सिंगल बाइट कैरेक्टर सेट।

— एडम

ठीक है, मुझे लगता है कि यह नया विजेता है, तो क्या इस एसई में मानक अभ्यास इस सवाल के लंबे समय बाद स्वीकृत उत्तर को बदलने के लिए है?

— क्रंचर

@ क्रंचर हाँ। और यहां तक कि ओपी के लंबे समय तक स्वीकार किए जाने के लिए भी बैज हैं।

— आदम

12

गणितज्ञ 49 46 45 44 42

एक शुद्ध कार्य के रूप में : 42 वर्ण

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

उदाहरण

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

2

एक नामित फ़ंक्शन के रूप में : 44 वर्ण

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

उदाहरण

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

२
३
२
१

— DavidC
स्रोत

एक पात्र छोटा:f=DayName@{#,m,6}~Table~{m,12}~Count~Friday&

— मि। छिपकली

@ Mr.Wizard हाँ। यह मुझे आश्चर्यचकित करता है कि गणितज्ञ इन्फिक्स नोटेशन के कई मामलों को पार्स कर सकता है।

— डेविड

डेविड ने मुझे आश्चर्यचकित किया कि आपने इस संकेतन संकेतन का मेरा (ओवर) उपयोग नहीं देखा है। : ^) (उदाहरण: (1) , (2) )

— Mr.Wizard

8

रूबी, ४ ९ ४y ४y ४६

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

संपादित करें: एक हफ्ते में वापस जाकर एक चरित्र को दिखाया, जनवरी के लिए धन्यवाद, और Time.new से समय पर स्विच करके एक और।

संपादित करें: इसे थोड़ा और बाधित करने की कीमत पर, मैं 46 के साथ मिल सकता हूं

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

— histocrat
स्रोत

5

एक-चार बचत अगर आप 6 की संख्या की गणना करते हैं

— जॉन ड्वोरक

2

@ जानदार चालाक!

— हिस्टोक्रेट

6 क्यों? मुझे नहीं मिला।

— NARKOZ

3

यदि 6 वाँ

— फ्रिडा

यदि 8 वां रविवार है, तो 1 भी है, और इसलिए आप उपयोग कर सकते हैं Time.gm(m,i).wday<1। इसके अलावा, मुझे नहीं पता कि आप फ़ंक्शन का नाम क्यों दे रहे हैं।

— ली डब्ल्यू

8

पॉवरशेल, 68 63 58 52 50

टिप के लिए धन्यवाद इज़ी।

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

इस तथ्य का उपयोग करते हुए कि यदि महीने में 1 दिन रविवार है, तो 13 वां शुक्रवार होगा।

मैंने भी कोशिश की है:

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

लेकिन यह $argsस्क्रिप्ट ब्लॉक के अंदर समान नहीं है ।

— डैंको डर्बीक
स्रोत

1

मुझे महीने के पहले दिन का उपयोग करने का विचार पसंद है।

— क्रंचर

अच्छी चाल, वहाँ। @ अनावश्यक है, हालांकि।

— इसिज़ी

एक और बात, हालाँकि मैं अपनी बहुत सी लिपियों में उसी का दोषी हूँ। चुनौती निर्दिष्ट करती है कि इनपुट एक तर्क से आ सकता है। बदलें $nके साथ $argsपाश में, और आप बिना कर सकते हैं $n=read-host;पूरी तरह से। सहेजता है 8. निकालें @, जैसा कि ऊपर उल्लेख किया गया है, और आप 54 से नीचे हैं।

— इज़्ज़ी

सुधार: 52 तक आता है!

— इज़्ज़ी

यह जानने की कोशिश करना कि आपकी दूसरी स्क्रिप्ट काम क्यों नहीं करेगी और मैं नुकसान में हूँ। क्या दिलचस्प है कि मैं इस तरह से पाइप लाइन से साल खिलाने के $argsलिए बाहर बदल सकता हूं $input, और स्क्रिप्ट चलेगी, लेकिन यह हमेशा आउटपुट करता है 3.

— इस्सी

5

आर 76 72 57

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

— flodel
स्रोत

आसानी से अपने बदल कर भी इस नीचे 4 प्राप्त कर सकते हैं "%a %d")=="Fri 13"के साथ "%w%d)=="513")डो एक संख्या के रूप का उपयोग कर, और रिक्त स्थानों को हटाकर।

— चुमलीग

बहुत सराहना की!

— फ्लोडेल

+1 हालांकि seqमहीने पर एकमात्र करना वास्तव में यहाँ कम है! sum(format(as.Date(paste(scan(),1:12,13,sep="-")),"%w%d")=="513")केवल 65 वर्ण है!

— प्लेनैपस

वाह, मैंने अनुमान नहीं लगाया है कि <एक चरित्र को एक पूर्णांक तक ले जाएगा। अच्छी चाल!

— प्लेनैपस

@plannapus यह बल्कि आम है। चूँकि चरित्र कोड सभी संख्याएँ हैं। यहां तक कि जावा int और char की तुलना कर सकता है

— Cruncher

5

पायथन 2.7 90 86

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

सोमवार 9 वीं को इसके लिए एक ही अंगूठी नहीं हो सकती है, लेकिन यह भी काम करता है।

संपादित करें: एक डेढ़ साल जो नोटिस करने के dateलिए छोटा है datetime:)

— ejrb
स्रोत

वास्तव में अच्छा समाधान!

— लीनोज

2

आप कर सकते हैं एक char बचा सकते हैंfrom datetime import*

— user80551

अच्छा! मैं प्रभावी रूप से समान कुछ के साथ समाप्त हो गया, लेकिन निष्पादन से परहेज: f=lambda y:sum([date(y,m,13).weekday()==4 for m in range(1,13)]).... आयात के साथ एक ही आकार समाधान (86 बाइट्स), हालांकि।

— इवासेनबीबाग्रे

5

किसी लाइब्रेरी या बिल्ट-इन डेट फंक्शन का उपयोग नहीं करना:

गोल्फस्क्रिप्ट - 51

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

' [3/=RI[)a%:*.' साथ ही हो सकता है 'feefefgeeffgfe'

अजगर - 82 79

अनिवार्य रूप से एक ही एल्गोरिथ्म।

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

इस ट्रिक का उपयोग करते हुए , इसे नीचे और आगे बढ़ाया जा सकता है:

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

यह इस तथ्य का शोषण करता है कि, कैलेंडर-वार, केवल 14 अलग-अलग वर्ष हैं, जो उनके अंतिम दिन और चाहे वे छलांग लगा रहे हों, से अलग हैं। lलीप वर्ष की संख्या की गणना अपने तर्क (यदि ग्रेगोरियन कैलेंडर को पीछे की ओर वर्ष 1 तक बढ़ा दिया जाए) से की जाती है। (2*i+3*l(i)-l(i-1))%14के लिए कम है l(i)-l(i-1)+(i+l(i))%7*2, जहां l(i)-l(i-1)हमें बताता है कि क्या तर्क एक लीप वर्ष है और i+l(i)अंतिम दिन (एक सामान्य वर्ष में एक, एक लीप वर्ष में दो) की पारियों को समेटता है।

— Wrzlprmft
स्रोत

चूँकि यह मेरी पहली गोल्फ गोल्फ है, इसलिए मैं इसे नीचे गोल्फिंग पर किसी संकेत की सराहना करूँगा।

— Wrzlprmft

मैं इस तरह के समाधान का उपयोग इस तथ्य के बारे में सोच रहा था कि वास्तव में केवल 14 अद्वितीय वर्ष हैं, लेकिन यह सुनिश्चित करने के लिए सबसे अच्छी भाषा सुनिश्चित नहीं थी। मुझे लगता है कि यह बिना पुस्तकालयों के साथ सबसे छोटा जवाब है। यदि लीप वर्ष हर 4 साल में समान रूप से होते हैं, तो आप इस के साथ जीतने में सक्षम हो सकते हैं

— Cruncher

4

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

सबसे छोटा उत्तर नहीं है, लेकिन कोई पुस्तकालयों का उपयोग नहीं करता है।

— विलीहम टटलैंड
स्रोत

अरे, क्या आप एक स्पष्टीकरण के साथ असंगठित उत्तर देने के लिए तैयार होंगे? मुझे इस बात में दिलचस्पी है कि आपने वास्तव में क्या किया है

— Cruncher

1

@ क्रंचर, यह इस आधार पर एक लुकअप टेबल है कि ग्रेगोरियन कैलेंडर 400 साल के चक्र का अनुसरण करता है।

— पीटर टेलर

1

अधिक स्पष्ट रूप से (और लंबा), C #

static char GetNumberOfFriday13s(int year) { const string perpetualCalendar = "1221212213113213122221122131122121221311321312222112213112212122131132131222211221311221212213113213112213113213122221122131122121221311321312222112213112212122131132131222211221311221212213113213122213113213122221122131122121221311321312222112213112212122131132131222211221311221212213113213122221122213122221122131122121221311321312222112213112212122131132131222211221311221212213113213122221122131"; return perpetualCalendar[year % 400];

:। नकारात्मक वर्षों के लिए काम नहीं करेंगे।

— जेपी स्टिग नीलसन

प्यारा! एक छोटी बग के रूप में, v[0]होना चाहिए v[1]। आप इसे थोड़ा गोल्फ भी कर सकते हैं; strcatचरित्र a[]स्थिरांक के बजाय सीधे प्रिंट करने के लिए और संख्यात्मक स्थिरांक को हटाने, वर्णों का उपयोग करने पर विचार करें । :)

— user1354557

1

मैंने संपीड़न में भी सुधार किया:

main(int x,char**v){char p[400],*a[]={"1221212213113213","2131222","21122131","1222","112213113","122223113","122221122"},*b="adcadcadcaebcadcadcafbcadcadcagbcadcadcadc";*p=0;for(;*b;b++)strcat(p,a[*b-97]);putchar(p[atoi(v[1])%400]);}

(215

— चार्ट

4

सी ( 151 145 137 131 130 चार्ट)

मुझे यह देखकर आश्चर्य हुआ कि केवल एक अन्य समाधान है जो अंतर्निहित कैलेंडर टूल का उपयोग नहीं करता है। यहाँ गणितीय दृष्टिकोण है (सी में अत्यधिक)

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

(बिना किसी त्रुटि के जीसीसी में उपरोक्त संकलन)

वैकल्पिक समाधान: C (287-> 215 वर्ण)

मैंने बल्कि विलीहैम टोटलैंड के समाधान और संपीड़न के अपने उपयोग का आनंद लिया । मैंने दो छोटे कीड़े तय किए और इसकी लंबाई को छोटा करने के लिए कोड को घुमाया:

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

— user1354557
स्रोत

4

PHP, 82

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

पर आधारित

"रविवार को शुरू होने वाले किसी भी महीने में शुक्रवार 13 तारीख होता है, और हर कैलेंडर वर्ष में कम से कम एक शुक्रवार 13 वां होता है।"

से http://en.wikipedia.org/wiki/Friday_the_13th

— दामिर कासिपोविक
स्रोत

4

बैश 47 36

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

seqडिफ़ॉल्ट शुरुआत के साथ उपयोग करके 10 वर्णों को बचाने के लिए @DigitalTrauma धन्यवाद 1।

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

(का उपयोग कर पिछला संस्करण echoखाली पंक्ति की वजह से वर्तमान एक बग जब <(echo $1-{1..12}-6$'\n')। इसलिए इस समारोह ठीक काम किया आज तक है एक शुक्रवार।

चलो देखते हैं:

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

क्या लोकेल डिपेंडेंट है, सी अगर यह काम नहीं करता है, तो आपको करना पड़ सकता है

export LANG=C

या

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

एक समारोह में; +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

बोनस: +78 -> 121

वहाँ से, यदि मेरा कार्य बन गया:

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

या

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

— एफ। होरी
स्रोत

यह स्थानीय-निर्भर प्रतीत होता है।

— पीटर टेलर

हां, यह डिफ़ॉल्ट पर आधारित है C। लेकिन एक बग है ...

— एफ। होरी

अपने प्रिंटफ़ प्रारूप स्ट्रिंग को हटाकर और इसके बजाय \ _ से बचकर एक चार्ट सहेजें:%s\\n

— डिजिटल ट्रामा

1

या seq8 चरों को गिराने के लिए उपयोग करें:date -f<(seq -f$1-%g-6 1 12)|grep -c ^F

— डिजिटल ट्रामा

1

असल में, आप 2 और चार्ट शेव कर सकते हैं। यदि आप आरंभिक क्रम संख्या को छोड़ देते हैं, तो seq डिफ़ॉल्ट रूप से 1 पर शुरू हो जाएगा, जो कि आप क्या चाहते हैं:seq -f$1-%g-6 12|date -f-|grep -c ^F

— डिजिटल ट्रॉमा

4

जावास्क्रिप्ट, 70

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

— guy777
स्रोत

और यह -1 क्यों है?

— लुकाज़ 'सेवेरियन' ग्रीला

1

अछा लगता है! तुम्हें पता है, कुछ और बाइट्स बचा सकता है को हटाने के द्वारा ,b,cसमारोह घोषणा से (! यह रिसाव को ठीक गोल्फ के लिए वार्स) के रूप में भी bडाला जाता है के रूप में एक Numberआप कर सकते हैं +=के बजाय परीक्षण के परिणाम &&b++: b+=/^F/.test(new Date(a,c,6))। हालाँकि, आप एक अन्य बाइट को बचा सकते हैं, !new Date(a,c,1).getDay()(यह काम करता है क्योंकि getDayरविवार के लिए 0 देता है, और यदि 13 वां शुक्रवार है, तो 1 रविवार होगा), testजिसके बजाय पूरी तरह से आपको 7 बाइट्स बचानी चाहिए!

— डोम हेस्टिंग्स

@DomHastings: अपने सुझावों के लिए thx !!!

— guy777

3

कश्मीर

64 अक्षर

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

स्टड से पढ़ता है

— skeevey
स्रोत

ठीक है, बस यहाँ क्या हो रहा है? : पी

— विलीहैम टोटलैंड

वर्ष में पढ़ें, हर महीने के 13 वें दिन की तारीखों की सूची

— बनाएं

3

आम लिस्प (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))))))

— Pål जी.डी.
स्रोत

हे भगवान, मैं कभी लिस्प नहीं पढ़ सका ..

— क्रन्चर

2

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

सी # लिनक 88

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

8 वें दिन रविवार के लिए चेक और सुझाव के लिए जेपी स्टिग नीलसन का धन्यवाद।

>इसके बजाय सुझाव देने के लिए डैंको डर्बीक को धन्यवाद ==।

— कामी
स्रोत

इसके बजाय c+=(int)new DateTime(y,i,13).DayOfWeek==5?1:0;, समकक्ष का उपयोग करें c+=new DateTime(y,i,8).DayOfWeek==0?1:0;। चाल को घटाना है 5, क्योंकि तब आप कलाकारों से छुटकारा पा सकते हैं int, और यह भी संख्या 8की तुलना में एक अंक कम है 13। रविवार को आठवां!

— जेपी स्टिग नीलसन

लिनक के साथ int g(int y){return Enumerable.Range(1,12).Count(m=>new DateTime(y,m,8).DayOfWeek==0);}:। बेशक एक मेमने के रूप में यह है y=>Enumerable.Range(1,12).Count(m=>new DateTime(y,m,8).DayOfWeek==0)।

— जेपी स्टिग नीलसन

आप तुलना करके एक चरित्र को बचा सकते हैं .DayOfWeek<1।

— डेंको डर्बिएक

@ DankoDurbić यह c#उत्तर पर लागू हो सकता है लेकिन यह सुनिश्चित नहीं है कि इसे कैसे लागू किया जाए linq।

— कामी

मेरी गलती; स्पष्ट रूप से आप DayOfWeekकिसी भी अन्य पूर्णांक के साथ तुलना नहीं कर सकते 0- error CS0019: Operator '<' cannot be applied to operands of type 'System.DayOfWeek' and 'int'।

— डेंको डर्बिएक

2

PHP, 55 बाइट्स

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

के साथ भागो echo <year> | php -nR '<code>'।

मूल रूप से वही है जो ओलेग है ने कोशिश की और दमिर कासिपोविक ने बेहतर गोल्फिंग के साथ किया:
हर महीने जो एक रविवार से शुरू होता है, शुक्रवार को 13 वां होता है।
इसलिए मैं महीनों से गुजरता हूं और पहले दिन गिनता हूं जो रविवार हैं।

टूट - फूट

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

— टाइटस
स्रोत

1

के, ४२

{+/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

— tmartin
स्रोत

1

बैश ( 52 47 अक्षर)

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

— jerous
स्रोत

1

प्रतिबल, ६३

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

Rebol कंसोल में उपयोग उदाहरण:

>> y: 2012
== 2012

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

वैकल्पिक समाधान जो दिए गए वर्ष में सभी शुक्रवार 13 को एकत्रित करता है:

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

— draegtun
स्रोत

1

बैश और सैड, 39

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

ncal बाईं ओर सप्ताह के दिनों के साथ दिए गए वर्ष के लिए एक कैलेंडर प्रिंट करता है।

sed के साथ /g झंडे के सभी 13s को नई सुर्खियों में लाना

grep -c "2" से शुरू होने वाली रेखाओं को गिनाता है (20 हमेशा 13 का अनुसरण करता है)

मेरे पुराने संस्करण में बग ढूंढने और समाधान का प्रस्ताव देने के लिए @DigitalTrauma का धन्यवाद!

— चार्ल्स नहीं
स्रोत

मेरे लिए काफी काम नहीं करता है - शुक्रवार की लाइनें केवल एक बार मुद्रित होती हैं, भले ही वे एक से अधिक 13 हों।

— डिजिटल ट्रामा

1

मुझे लगता है कि सबसे अच्छा मैं इस तरह से कुछ कर सकता हूं 38: ncal $1|sed /F/s/13/\\n/g|grep -c ^\ 2

— डिजिटल ट्रामा

1

@DigitalTrauma तुम सही हो। किसी समय यह स्क्रिप्ट काम कर रही थी। मुझे इसे ठीक करने दो।

— नहीं कि

1

@DigitalTrauma से लगता है कि कुछ ज्यादा लंबे संस्करण काम कर रहे थे। ठीक करने के लिए धन्यवाद!

— नहीं है कि चार्ल्स

दिलचस्प है, अनक्वॉटेड सेड एक्सप्रेशन जो मैंने प्रस्तावित किया है वह GNU sed (Linux) के साथ काम करता है, लेकिन BSD sed (OSX) के साथ नहीं। मुझे लगता है कि यदि आप GNU संस्करण चुनते हैं तो आप पोर्टेबिलिटी की लागत पर 1 char प्राप्त कर सकते हैं।

— डिजिटल ट्रामा

1

स्काला, 76 68 वर्ण

78 वर्णों में:

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

साधारण से बाहर कुछ भी नहीं है, के लिए जादुई नंबर का उपयोग कर के अलावा DAY_OF_WEEK = 7औरFRIDAY = 6 ।

68 चरित्र संस्करण:

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

हां, जावा ने एपीआई के बीच सप्ताह के स्थिरांक के मूल्यों को बदल दिया।

— करोल एस
स्रोत

शर्म new java.util.GregorianCalendarकी बात है इतना लंबा होना चाहिए :(

— क्रंचर

1

पायथन 195/204

केवल पिछले वर्षों के लिए काम करता है, क्योंकि अबmonthdatescalendar तक दिए गए वर्ष के लिए एक कैलेंडर लौटाता है । मुझे लगता है कि संभावित रूप से बहुत कुछ बचा हुआ है :)।

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)

एक और समाधान, हर तारीख के लिए काम करता है लेकिन यह छोटा नहीं है:

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)

— klingt.net
स्रोत

आपके पहले उदाहरण में रेंज (1,13) होनी चाहिए अन्यथा आप 2013 की तरह दिसंबर 13 शुक्रवार को याद करेंगे।

— लीनोज

1

आपने गोल्फ को परेशान नहीं किया। उनमें से कुछ रिक्त स्थान निकालें।

— mbomb007

1

पर्ल 6, 55 53

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

पुराना उत्तर:

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

— bb94
स्रोत

48 बाइट्स

— जो किंग

0

अजगर (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

— leancz
स्रोत

0

Perl + lib POSIX 55

नहीं 13thबल्कि पहले की तलाश के विचार के साथ , और इस तरह sundayसे 03 वर्णों को बचाने के लिए है! धन्यवाद @ इज़्ज़ी और डैंको डर्बिएक!

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

इस तरह से (नमूना के लिए) 2010 से 2017 की गणना कर सकते हैं:

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

(ठीक है, कोई नई रेखा नहीं है , लेकिन यह नहीं पूछा गया था;)

पुरानी पोस्ट: 63

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

कार्रवाई में:

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

— एफ। हौरी
स्रोत

0

में स्मालटाक (स्क्वीक / Pharo स्वाद), पूर्णांक में इस विधि को लागू ( 86 वर्ण)

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

फिर इसे इस तरह उपयोग करें: 2014countFriday13।

बेशक, हम एक छोटे नाम का उपयोग कर सकते हैं, लेकिन तब यह स्मालटाक नहीं होगा

— aka.nice
स्रोत

0

C ++ - बहुत सारे बाइट्स :(

मैंने एक समाधान की कोशिश की, जो किसी भी तारीख पुस्तकालयों का उपयोग नहीं करता है।

मैं एक बहुत अच्छा पाया (अगर मैं ऐसा खुद कह सकता हूँ) समाधान। दुर्भाग्य से मैं इसे इससे छोटा नहीं कर सकता, जो वास्तव में मुझे परेशान करता है क्योंकि ऐसा लगता है कि एक बेहतर तरीका होना चाहिए।

समाधान इस एल्गोरिथ्म पर टिका है जो अपने आप में केवल 44 बाइट्स है। दुर्भाग्य से मुझे अच्छी तरह से लपेटने के लिए एक और 100 बाइट्स की आवश्यकता है ...

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

रिटर्न कोड के माध्यम से आउटपुट (सी ++ में, उपयोग coutया printfउस तरह की किसी अन्य चीज की आवश्यकता होती है #include, जो समाधान को और भी अधिक उड़ा देगा)।

चालक / परीक्षण कार्यक्रम:

# 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

चालक कार्यक्रम का आउटपुट:

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

— कम्पयूसीशिप
स्रोत

मैं एल्गोरिथ्म के लिए 88 की गिनती करता हूं, 44 की नहीं। एल्गोरिथ्म क्या है और युद्धरत क्या है? ($m<3?$y--:$y-2)+3इसके बजाय d=13,, d+=m<3?y--:y-2,और d+4साथ ही काम करना चाहिए और बहुत कुछ बचाता है। +5के बजाय +3और -5भी काम करना चाहिए और 2 बाइट्स बचाता है। for(m=0;++m<13;)एक बाइट बचाता है। चलती m=0समारोह सिर करने के लिए एक और बाइट की बचत होती है; और ()%7||++fलूप सिर पर जाने से एक और बचत होती है। डाउन डाउन 149 से 136 बाइट्स।

— टाइटस

0

क्लोजर, 207 187 बाइट्स

-20 बाइट्स से छुटकारा पाने के लिए import, और कुछ व्हाट्सएप मैं याद किया।

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

दिए गए वर्ष के जनाधिकार 1 से शुरू होकर, यह प्रत्येक दिन पर लूप करता है। यदि दिन 13 वें शुक्रवार है, तो यह गणना में वृद्धि करता है। यह अगले वर्ष तक पहुंचने तक लूप जारी रखता है।

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

— कैरिजेनिकेट
स्रोत

0

PHP, कोई बिलिन नहीं, 81 बाइट्स

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

के साथ भागो echo <year> | php -nR '<code>'।

टूट - फूट

हर 400 साल में सप्ताहांत दोहराते हैं।
1600 से 1999 के परिणामों में (उदाहरण के लिए), केवल तीन अंतराल के साथ 28-अवधि की अवधि है:

  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

इन अंतरालों के लिए वर्ष समायोजित करने के बाद, हम एक साधारण हैश के साथ परिणाम प्राप्त कर सकते हैं:

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

कम नहीं (95 बाइट्स) लेकिन सुंदर। और हम गोल्फ कर सकते हैं

ऑफसेट के लिए एक टर्नरी श्रृंखला का उपयोग करके 4 बाइट्स,
हैश मैप को बेस 4 स्ट्रिंग से पूर्णांक में परिवर्तित करके 8 बाइट्स,
हेक्स प्रतिनिधित्व का उपयोग करके एक और,
और भावों के विलय से।

— टाइटस
स्रोत

CompuChip´s C ++ उत्तर का एक पोर्ट 84 बाइट्स तक नीचे हो सकता है:for(;++$m<13;23*$m/9+($m<3?$y--:$y-2)+5+$y/4-$y/100+$y/400)%7?:$f++)$y=$argn;echo$f;

— टाइटस

0

जाप `-x` , 10 बाइट्स

CÆ5¥ÐUXD e

कोशिश करो

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

— झबरा
स्रोत

एक वर्ष में 13 वें कितने शुक्रवार?

APL (Dyalog APL) dfns से कैल के साथ , 29 बाइट्स

गणितज्ञ 49 46 45 44 42

रूबी, ४ ९ ४y ४y ४६

पॉवरशेल, 68 63 58 52 50

आर 76 72 57

पायथन 2.7 90 86

गोल्फस्क्रिप्ट - 51

अजगर - 82 79

सी 301+ 287

सी ( 151 145 137 131 130 चार्ट)

वैकल्पिक समाधान: C (287-> 215 वर्ण)

PHP, 82

बैश 47 36

चलो देखते हैं:

एक समारोह में; +7 -> 43

बोनस: +78 -> 121

जावास्क्रिप्ट, 70

कश्मीर

आम लिस्प (CLISP), 149

सी# 110 101 93 92

सी # लिनक 88

PHP, 55 बाइट्स

के, ४२

बैश ( 52 47 अक्षर)

प्रतिबल, ६३

बैश और सैड, 39

स्काला, 76 68 वर्ण

पायथन 195/204

पर्ल 6, 55 53

Perl + lib POSIX 55

पुरानी पोस्ट: 63

कार्रवाई में:

C ++ - बहुत सारे बाइट्स :(

क्लोजर, 207 187 बाइट्स

PHP, कोई बिलिन नहीं, 81 बाइट्स

जाप -x , 10 बाइट्स

जाप `-x` , 10 बाइट्स