तारीख गुणा करने की चुनौती

19

( फाइवटहाइट डॉट कॉम पर पिछले हफ्ते के रिडलर से प्रेरित । सैंडबॉक्स पोस्ट ।)

2001 और 2099 की गणना के बीच एक साल को देखते हुए और कहा कि कैलेंडर वर्ष के दौरान दिनों की संख्या लौट जहां mm * dd = yy(जहां yyहै 2 अंकों वर्ष)।

2018, उदाहरण के लिए, 5:

  • 18 जनवरी (1 * 18 = 18)
  • 9 फरवरी (2 * 9 = 18)
  • 6 मार्च (3 * 6 = 18)
  • 3 जून (6 * 3 = 18)
  • 2 सितंबर (9 * 2 = 18)

इनपुट 2 या 4 अंकों का संख्यात्मक वर्ष हो सकता है।

आउटपुट एक पूर्णांक होना चाहिए। वैकल्पिक अनुगामी स्थान या वापसी ठीक है।

पूरा इनपुट / आउटपुट सूची:

Input = Output
 2001 = 1     2021 = 3     2041 = 0     2061 = 0     2081 = 2
 2002 = 2     2022 = 3     2042 = 4     2062 = 0     2082 = 0
 2003 = 2     2023 = 1     2043 = 0     2063 = 3     2083 = 0
 2004 = 3     2024 = 7     2044 = 3     2064 = 2     2084 = 5
 2005 = 2     2025 = 2     2045 = 3     2065 = 1     2085 = 1
 2006 = 4     2026 = 2     2046 = 1     2066 = 3     2086 = 0
 2007 = 2     2027 = 3     2047 = 0     2067 = 0     2087 = 1
 2008 = 4     2028 = 4     2048 = 6     2068 = 1     2088 = 3
 2009 = 3     2029 = 1     2049 = 1     2069 = 1     2089 = 0
 2010 = 4     2030 = 6     2050 = 3     2070 = 3     2090 = 5
 2011 = 2     2031 = 1     2051 = 1     2071 = 0     2091 = 1
 2012 = 6     2032 = 3     2052 = 2     2072 = 6     2092 = 1
 2013 = 1     2033 = 2     2053 = 0     2073 = 0     2093 = 1
 2014 = 3     2034 = 1     2054 = 4     2074 = 0     2094 = 0
 2015 = 3     2035 = 2     2055 = 2     2075 = 2     2095 = 1
 2016 = 4     2036 = 6     2056 = 4     2076 = 1     2096 = 4
 2017 = 1     2037 = 0     2057 = 1     2077 = 2     2097 = 0
 2018 = 5     2038 = 1     2058 = 0     2078 = 2     2098 = 1
 2019 = 1     2039 = 1     2059 = 0     2079 = 0     2099 = 2
 2020 = 5     2040 = 5     2060 = 6     2080 = 4

यह एक कोड-गोल्फ चुनौती है, प्रत्येक भाषा की जीत में सबसे कम बाइट गिनती है।

पूर्व-गणना करना और केवल उत्तरों को देखना आमतौर पर हमारे खामियों के नियमों के अनुसार बाहर रखा गया है , लेकिन मैं स्पष्ट रूप से इस चुनौती के लिए अनुमति दे रहा हूं। हालांकि इसके नहीं होने की संभावना एक यह कुछ दिलचस्प वैकल्पिक रणनीतियों के लिए अनुमति देता है 98 99-आइटम देखने सूची सबसे छोटा होने जा रहा है।

code-golf  date 
— BradC
स्रोत
यदि यह आपकी भाषा में कोई भी आसान बनाता है, तो उत्तर शताब्दी की परवाह किए बिना समान होगा; 1924 और 2124 में 2024 के समान दिन हैं।
— ब्रैड
यदि mm * dd का परिणाम 100 से बड़ा है तो यह स्वतः ही फ़िल्टर हो जाता है?
— डैनियलइंडी
@DanielIndie सही, कोई "रैपपराउंड" तिथियां नहीं गिनी जानी चाहिए। दूसरे शब्दों में, 12 दिसम्बर, 2044 में नहीं गिना जाता, यहां तक कि 12 * 12 = 144, हालांकि
— BradC
जैसा कि हमें केवल सीमित संख्या में इनपुट को संभालने की आवश्यकता है, मैंने उन सभी को संपादित किया है।
— झबरा
1
@gwaugh बस आप तय कर सकते हैं कि वैध इनपुट के रूप में स्वीकार किया जाए (इसलिए आपको दोनों के बीच परिवर्तित होने वाले अतिरिक्त वर्ण खर्च करने की आवश्यकता नहीं है)।
— ब्राडकास्ट

जवाबों:

14

एक्सेल, 48 बाइट्स

हुर्रे! अंत में कुछ एक्सेल वास्तव में अच्छा है।

=COUNT(VALUE(ROW(1:12)&"/"&A1/ROW(1:12)&"/"&A1))

A1 से इनपुट लेता है एक पूर्णांक 1-99 के रूप में वर्ष का प्रतिनिधित्व करता है, और इस सूत्र में आप जहां भी प्रवेश करते हैं, वहां आउटपुट करता है। यह एक सरणी सूत्र है, इसलिए इसे दर्ज करने के लिए Enter के बजाय Ctrl-Shift-Enter का उपयोग करें।

यह इस तथ्य का लाभ उठाता है कि COUNTत्रुटियों को नजरअंदाज करता है, इसलिए वर्ष को विभाजित नहीं करने वाले किसी भी त्रुटि के कारण होता है (कुछ को पार्स करने के लिए अग्रणी एक्सेल 2/12.5/25या जैसे तारीख मान्य नहीं हो रही है, जैसे 2/29/58, चुपचाप नजरअंदाज कर दिया जाता है।

— सोफिया लेचनर
स्रोत
1
बहुत अच्छा। संभवतः यह उल्लेख के लायक है कि इसमें 2-अंकीय वर्ष की आवश्यकता है A1। 4-अंकीय वर्ष में प्रवेश करने पर केवल रिटर्न मिलता है 0।
— ब्रैडेक
सच! मैं वर्णन में इसे संपादित करूँगा।
— सोफिया लेचनर
इसके अलावा मुझे यह उल्लेख करना चाहिए कि यह स्थानीय-विशिष्ट है; यह एक स्थानीयता पर निर्भर करता है जो मिमी / dd / yy ऑर्डर का उपयोग करता है। Dd / mm / yy ऑर्डर वाले लोकल में, उत्तर बाइट्स की समान संख्या होगी, निश्चित रूप से।
— सोफिया लेचनर
1
सुपर चालाक; मुझे पसंद है कि आप साल के हर दिन चलने के बजाय केवल 12 तारीख के उम्मीदवारों (प्रति माह एक) का परीक्षण कैसे कर रहे हैं।
— ब्रैडेक
एक गैर-छलांग बचाने के लिए वर्ष को ठीक करें?
— l4m2
6

पायथन 2 , 44 बाइट्स

[k/32%13*(k%32)for k in range(96,509)].count

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

अनाम वस्तु के रूप में दिया जाने वाला एक अनाम कार्य। के सभी उत्पादों का उत्पादन (month, day)जोड़े (m, d)के रूप में द्वारा इनकोडिंग k=32*m+dके साथ 0≤m≤12, 0≤d≤31, चारों ओर लपेटकर। फ़रवरी 29-31 को उन्हें सीमा से बाहर करके समाप्त कर देता है।

— XNOR
स्रोत
5

जावा (JDK 10) , 65 बाइट्स

y->{int m=13,c=0;for(;m-->1;)if(y%m<1&y/m<29+m%2*3)c++;return c;}

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

क्रेडिट

— ओलिवियर ग्रेजायर
स्रोत
कोई लीप वर्ष फिट नहीं होता है 29*n, इसलिए चेक की आवश्यकता नहीं है
— l4m2
आपके सहयोग के लिए धन्यवाद। मैं अन्य परिवर्तनों के एक समूह के साथ कुल मिलाकर 27 बाइट निकाल सकता था।
— ओलिवियर ग्रेजायर
1
बदलने (m==2?29:32)के लिए 29+m%2*3अभी भी सभी को देने के लिए लगता है OKका परिणाम है। क्रेडिट @AsoneTuhid के रूबी जवाब के लिए ।
— केविन क्रूज़सेन
4

पॉवरशेल , 94 बाइट्स

param($a)for($x=Date 1/1/$a;$x-le(Date 12/9/$a);$x=$x.AddDays(1)){$z+=$x.Month*$x.Day-eq$a};$z

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

इनपुट को दो अंकों के वर्ष के रूप में लेता है, फिर forसे एक लूप का निर्माण करता 1/1/yearहै 12/9/year(क्योंकि 12/10 और उसके बाद की गणना कभी नहीं होगी और यह बाइट बचाता है)। प्रत्येक पुनरावृत्ति, हम वृद्धि करते हैं $zयदि .Monthसमय .Dayहमारे इनपुट वर्ष के बराबर है। लूप के बाहर, $zपाइप लाइन पर छोड़ दिया जाता है और आउटपुट निहित है।

संपादित करें - यह संस्कृति पर निर्भर है। उपरोक्त कोड के लिए काम करता है en-us। अन्य संस्कृतियों के लिए तिथि प्रारूप को बदलने की आवश्यकता हो सकती है।

— AdmBorkBork
स्रोत
2
"संस्कृति"? क्या आपका मतलब "लोकेल" था? ...
— यूजर 202729
1
@ user202729 बोलचाल, हाँ, लेकिन PowerShell प्रलेखन इसे "संस्कृति" के
— AdmBorkBork
"कल्चर" एमएस आमतौर पर लोकेल के बारे में बात करने के लिए उपयोग किया जाने वाला शब्द है, जैसे। .NET में System.Globalization.CultureInfo ।
— सूंदर - मोनिका
4

जावास्क्रिप्ट (Node.js) , 48 44 43 बाइट्स

F=(x,h)=>h>12?0:F(x,-~h)+(x/h<3*h%6+28>x%h)

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

जावास्क्रिप्ट (Node.js) , 59 58 बाइट्स

x=>[a=0,...'030101001010'].map((k,m)=>x%m|x/m>31-k||a++)|a

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

— l4m2
स्रोत
मुझे पता था कि एक गणितीय समाधान कम होगा, लेकिन मैंने अपने संस्करण के साथ मज़े किए :) :)
— Shaggy
3

जावास्क्रिप्ट (ईएस 6), 91 बाइट्स

मैं यह जानने के लिए उत्सुक था कि हार्डकोडिंग एक पुनरावृत्त संगणना की तुलना कैसे करेगा। यह निश्चित रूप से लंबे समय तक है (देखें @ शैगी का जवाब है), लेकिन नहीं बहुत लंबे समय तक।

संपादित करें : यह, हालांकि, अधिक प्रत्यक्ष सूत्र से अधिक लंबा है ( @ l4m2 उत्तर देखें )।

[१.९९] में पूर्णांक के रूप में इनपुट लेता है ।

n=>(k=parseInt('8ijkskercdtbnqcejh6954r1eb2kc06oa3936gh2k0d83d984h'[n>>1],36),n&1?k>>3:k&7)

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

कैसे?

विषम वर्षों में मिमी * dd = yy सम वर्षों की तुलना में काफी कम होता है । अधिक समवर्ती, विषम वर्षों में 0 से 3 मैच होते हैं, जबकि वर्ष में भी 0 से 7 मैच होते हैं। यह हमें प्रत्येक जोड़ी को केवल 5 बिट्स के साथ कोड करने की अनुमति देता है, जिसे आसानी से बेस 36 में एकल चरित्र के रूप में दर्शाया जा सकता है।

— Arnauld
स्रोत
3

बैश + जीएनयू उपयोगिताओं , 57

  • 1 बाइट ने @SophiaLechner को धन्यवाद दिया
seq -f1/1/$1+%gday 0 365|date -f- +%m*%d-%y|bc|grep -c ^0

ध्यान दें कि seqकमांड हमेशा 366 तारीखों की एक सूची तैयार करता है - अगले साल की पहली जनवरी को गैर-लीप वर्ष के लिए शामिल किया जाएगा। हालाँकि, दिनांक २००१..२० ९९ में, एमएम * डीडी इन वर्षों में से किसी भी वर्ष के लिए अगले साल की १ जनवरी के लिए कभी भी वाईवाई नहीं होगा, इसलिए इस अतिरिक्त दिन का परिणाम पर असर नहीं पड़ेगा।

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

— डिजिटल आघात
स्रोत
बहुत अच्छा - मुझे यह भी पता नहीं था dateकि परसिंग करते समय डेट गणित भी ऐसा ही होगा। seqके बाद एक जगह की जरूरत नहीं है -f, तो आप वहाँ एक बाइट बचा सकते हैं।
— सोफिया लेचनर
3

टी-एसक्यूएल, 123 121 बाइट्स

हमारे IO नियमों के अनुसार , इनपुट को पूर्व-मौजूदा तालिका t के माध्यम से पूर्णांक फ़ील्ड y के साथ लिया जाता है , जिसमें 2-अंक वाला वर्ष होता है।

WITH c AS(SELECT 1m UNION ALL SELECT m+1FROM c WHERE m<12)
SELECT SUM(ISDATE(CONCAT(m,'/',y/m,'/',y)))FROM c,t WHERE y%m=0

लाइन ब्रेक केवल पठनीयता के लिए है। सोफिया के एक्सेल समाधान से काफी हद तक प्रेरित ।

  • शीर्ष पंक्ति 12-आइटम नंबर तालिका c उत्पन्न करती है जो इनपुट तालिका t में शामिल हो जाती है ।
  • यदि वह पास होने वाले डेट उम्मीदवार का एक साथ मैश CONCAT()करता है, जिसका अर्थ है varcharडेटाटाइप रूपांतरण। अन्यथा मुझे CASTया CONVERTबयानों का एक गुच्छा करना होगा ।
  • सही मूल्यांकन फ़ंक्शन मिला ISDATE(), जो वैध तिथियों के लिए 1 और अमान्य तारीखों के लिए 0 देता है।
  • इसे एक एसयूएम में लपेटें और मैं काम कर रहा हूं।
  • संपादित करें : 2 बाइट्स बचाने के y%m=0लिए WHEREक्लॉज में पूर्णांक डिवीजन चेक ( ) को स्थानांतरित किया , धन्यवाद @RazvanSocol।

दुर्भाग्य से, यह लुकअप टेबल संस्करण ( ओएसडाविसन के संस्करण से स्ट्रिंग का उपयोग करके) से बहुत कम नहीं है ):

टी-एसक्यूएल लुकअप, 129 बाइट्स

SELECT SUBSTRING('122324243426133415153317223416132126011504033106131204241006003213011306002122042005101305111014012',y,1)FROM t

संपादित करें : मेरा मूल ऊपर छोड़ रहा है, लेकिन हम कुछ नए कार्यों का उपयोग करके कुछ बाइट्स बचा सकते हैं:

  • STRING_SPLIT MS SQL 2016 और इसके बाद के संस्करण में उपलब्ध है।
  • CONCAT_WS MS SQL 2017 और इसके बाद के संस्करण में उपलब्ध है।
  • जैसा कि ऊपर, के IIFसाथ बदल दियाWHERE

MS-SQL 2017, 121 118 बाइट्स

SELECT SUM(ISDATE(CONCAT_WS('/',value,y/value,y)))
FROM t,STRING_SPLIT('1-2-3-4-5-6-7-8-9-10-11-12','-')
WHERE y%value=0

MS-SQL 2017, अतिरिक्त धोखा संस्करण: 109 बाइट्स

SELECT SUM(ISDATE(CONCAT_WS('/',number,y/number,y)))
FROM t,spt_values WHERE number>0AND y%number=0AND'P'=TYPE

आपको masterडेटाबेस में रहने की आवश्यकता होती है, जिसमें एक सिस्टम टेबल होता है spt_valuesजो (जब फ़िल्टर करके TYPE='P') होता है, आपको 0 से 2048 तक की गिनती देता है।

— BradC
स्रोत
अन्य उत्तरों के समान, मैं जिस क्रम में तारीख जमा m/d/yकरता हूं ( ) SQL इंस्टेंस के स्थानीयता सेटिंग्स पर निर्भर करता है। अन्य इलाकों को एक अलग आदेश, या एक अलग विभाजक की आवश्यकता हो सकती है, लेकिन मुझे नहीं लगता कि कोड की लंबाई प्रभावित होगी।
— ब्रैडेक
मुझे लगता है कि आपने महसूस किया है कि '2/29/64' को एक तारीख में परिवर्तित करने से 1964-02-29 (2064-02-29 नहीं) मिलता है, लेकिन यह देखते हुए कि वर्ष 2000 और 2100 को बाहर रखा गया है, यह एक छोटा तरीका है। कोड।
— रज़वान सोकोल
SPLIT_STRINGसीटीई के बजाय का उपयोग करके इसे 120 बाइट्स तक लाया जाता है। का उपयोग CONCAT_WSकरने के बजाय CONCATएक और चरित्र की बचत होती है, यह 119 बाइट्स के लिए हो रही।
— रज़वान सोकोल १५'१
@RazvanSocol हाँ, मुझे यकीन नहीं है कि 2-अंकों की तारीखों के बीच का ब्रेक 19xx बनाम 20xx तक है, लेकिन दोनों एक ही जवाब देते हैं। मैं अन्य दो सुझाव एक कोशिश दे दूँगा, धन्यवाद!
— ब्रैडेक
1
बदलें IIFके साथ WHERE।
— रज़वान सोकोल
3

जूलिया 0.6 , 49 44 42 बाइट्स

y->sum(y/i∈1:28+3(i%2⊻i÷8)for i=1:12)

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

-5 बाइट्स असोन तुहिद के रूबी जवाब से प्रेरित हैं।
-2 बाइट्स की गिनती के साथ योग

स्पष्टीकरण:

i1 से 12 तक प्रत्येक महीने के लिए, गणना y/iकरें और जांचें कि क्या यह उस महीने के दिनों में से एक है। 31 दिनों के साथ महीने कर रहे हैं 1, 3, 5, 7, 8, 10, 12 - तो वे 8 से नीचे कर रहे हैं और यहां तक कि अजीब पर और तो या तो 8. ऊपर i%2या i÷8(जो <i के लिए 8 और 1> मैं के लिए 0 = 8 यहाँ) 1 होना चाहिए, लेकिन दोनों नहीं - तो हम उन्हें XOR करें। यदि XOR परिणाम सच है, हम जांच दिनांकों 1:28+3यानी 1:31, नहीं तो हम सिर्फ तारीखों की जाँच 1:28।

1:28बाकी महीनों के लिए पर्याप्त है (यह सुधार असोन तुहिद के रूबी जवाब से प्रेरित है ):

  • फरवरी के लिए, एकमात्र संभावना रही होगी 2*29 = 58, लेकिन 2058एक लीप वर्ष नहीं है, इसलिए हम यह मान सकते हैं कि फरवरी हमेशा 28 दिनों का होता है।

  • 30 दिनों के साथ अन्य महीने 4 महीने और उससे अधिक हैं - जिसके लिए i*29(और i*30) 100 से ऊपर होगा, जिसे अनदेखा किया जा सकता है।

अंत में, हम गिनते हैं कि y/iइस बार की सूची में कितनी बार संख्या है ( sumयहाँ बूलियन का उपयोग करके ), और वापस लौटें।

— sundar - मोनिका को बहाल करना
स्रोत
3

जावास्क्रिप्ट, 91 85 82 81 77 बाइट्स

इनपुट को 2-अंकीय स्ट्रिंग (या 1 या 2 अंक पूर्णांक) के रूप में लेता है।

इस तथ्य का लाभ उठाता है कि new Dateअगले महीने तक रोलओवर करेगा, और ऐसा करना जारी रखेगा, यदि आप इसे एक दिन का मूल्य देते हैं जो उस महीने में दिनों की संख्या से अधिक है जो आप इसे पास करते हैं, तो पहले पुनरावृत्ति पर, यह निर्माण करने की कोशिश करता है। वह तिथि yyyy-01-345जो लीप वर्ष पर yyyy-12-11या बन जाती है yyyy-12-10। 12*11+3-अंकीय संख्या के परिणाम के बाद हमें तारीखों की जाँच करने की आवश्यकता नहीं है ।

y=>(g=d=>d&&([,M,D]=new Date(y,0,d).toJSON().split(/\D/),D*M==y)+g(--d))(345)

3 बाइट्स ने अरनौलड को धन्यवाद दिया ।

झसे आज़माओ

f=
y=>(g=d=>d&&([,M,D]=new Date(y,0,d).toJSON().split(/\D/),D*M==y)+g(--d))(345)
o.innerText=[...Array(99)].map((_,x)=>(2001+x++)+` = `+f(x)).join`\n`
pre{column-count:5;width:480px;}
<pre id=o></pre>
स्निपेट का विस्तार करें

— झबरा
स्रोत
2

एक्सेल, 83 बाइट्स

{=SUM(IF(MONTH(DATE(A1,1,0)+ROW(1:366))*DAY(DATE(A1,1,0)+ROW(1:366))=A1-2000,1,0))}

इनपुट A1प्रारूप में सेल में है yyyy। यह एक सरणी सूत्र है और साथ दर्ज किया गया है Ctrl+ Shift+ Enterकर्ली कोष्ठक प्राप्त करने के लिए {}। यह काफी सीधा और बिना किसी चालाकी के है।

जब एक सरणी सूत्र में, DATE(A1,1,0)+ROW(1:366)हमें 366 दिनांक मानों की एक सरणी देता है। गैर-लीप वर्ष पर, इसमें अगले वर्ष की 1 जनवरी शामिल होगी लेकिन यह कोई समस्या नहीं है क्योंकि 1*1=1यह केवल एक गलत सकारात्मक के रूप में गिना जाएगा यदि अगले वर्ष है 2001, लेकिन चूंकि आवश्यक वर्ष सीमा है 2001 - 2099, तो यह कभी भी उत्पन्न नहीं होगा मुद्दा।

यदि आपने उस बिट को सरलता से छोटा कर दिया है ~, तो सूत्र क्योंकि पालन करना बहुत आसान है:

{=SUM(IF(MONTH(~)*DAY(~)=A1-2000,1,0))}

मैंने COUNTIF()इसके बजाय उपयोग करने की कोशिश की, SUM(IF())लेकिन एक्सेल ने मुझे इसे एक सरणी सूत्र के रूप में दर्ज करने की अनुमति नहीं दी, बहुत कम मुझे एक परिणाम देता है। मैं किया था एक खोजने के Google शीट का उपयोग कर समाधान CountIf()ज्यादातर क्योंकि यह का उपयोग करता है पता चला 91 बाइट्स होने के लिए नहीं तो, लेकिन एक ही विधि, ArrayFormula()बजाय बस { }।

=CountIf(ArrayFormula(Month(Date(A1,1,0)+Row(1:366))*Day(Date(A1,1,0)+Row(1:366))),A1-2000)
— इंजीनियर टोस्ट
स्रोत
मैंने आम सहमति नहीं देखी है, लेकिन मैं आमतौर पर एक्सेल के लिए मेरी बाइट की गिनती में बाहरी घुंघराले कोष्ठक को शामिल नहीं करता हूं। वे एक तरह से अधिक महसूस करते हैं कि एक्सेल सूत्र के भाग की तुलना में अपने प्रदर्शन को स्वरूपित कर रहा है। राय?
— सोफिया लेचनर
@SophiaLechner मैंने यह तय करने के बजाय उन्हें शामिल किया है कि एक अतिरिक्त सूत्र के रूप में दर्ज करने के लिए आवश्यक अतिरिक्त कीस्ट्रोक्स को कैसे शामिल किया जाए। इसके बारे में एक मेटा सवाल है और एकमात्र उत्तर कहता है कि CTRL + ALT + ENTER कमांड 1 कीस्ट्रोके के रूप में गिना जाएगा। यदि आप विम ( प्रति मेटा ) के समान उपयोग करते हैं , तो उस कीस्ट्रोके को 1 बाइट के रूप में गिना जाएगा। हालाँकि, मैं आमतौर पर एक सूत्र को अन्य उत्तरों में 1 बाइट के रूप में दर्ज करने के अंत में ENTER की गणना नहीं करता हूं।
— इंजीनियर टोस्ट
2

रेटिना 0.8.2 , 55 बाइट्स

..
$*
(?<=^(1{1,12}))(?=(?(?<=^11$)\1{0,27}|\1{0,30})$)

इसे ऑनलाइन आज़माएं! दो अंकों का वर्ष लेता है; 4 अंकों के वर्षों का समर्थन करने के लिए 1 बाइट जोड़ें। स्पष्टीकरण: पहला चरण केवल एकात्मक में परिवर्तित होता है। दूसरा चरण मैच की स्थिति से पहले 1 से 12 वर्णों के मेल से शुरू होता है, महीने का प्रतिनिधित्व करता है, और फिर उस महीने की पूरी पुनरावृत्ति के लिए आगे देखने का प्रयास करता है। हालाँकि, लुकहेड में एक सशर्त होता है, जो महीने के आधार पर 27 या 30 तक दोहराव के बीच चुनता है। मैच के पदों की गिनती तो वांछित परिणाम है।

— नील
स्रोत
2

आर , 22 122 बाइट्स

x=scan();substr("122324243426133415153317223416132126011504033106131204241006003213011306002122042005101305111014012",x,x)

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

लुकअप टेबल अप्रोच के साथ जाने का फैसला किया। इनपुट वर्ष 2 अंकों का होना चाहिए।

— रॉबर्ट एस।
स्रोत
1
इसके अलावा TIO पर आप "लिंक" बटन को हिट कर सकते हैं और यह आपके लिए उत्तर को ऑटो-स्वरूपित करेगा। डेनिस को इसे स्थापित करने के लिए धन्यवाद!
— ग्यूसेप
आप प्रारंभिक को हटा सकते हैं if, क्योंकि इनपुट या तो 2-अंक या 4-अंक हो सकता है, आपकी पसंद (ताकि आप केवल 2-अंकीय इनपुट को स्वीकार करना चुन सकें)। लेकिन ऐसा लगता है कि कोड हर महीने को 31 दिन सम्‍मिलित करता है, इसलिए उदाहरण के लिए। 62 (2062 के लिए) रिटर्न 1 जहां उसे वापस लौटना चाहिए 0.
— सूंदर - मोनिका
2
मैंने गलत समझा। कहा जा रहा है, मुझे पूरा यकीन है कि लुकअप टेबल को बाइट की गिनती में शामिल करना होगा।
— एन जी एम
@ngm मुझे यह भी पक्का नहीं था कि लुकअप टेबल को शामिल करने की जरूरत है, लेकिन मैं इसे सुरक्षित रखने के लिए बाइट की गिनती में जोड़ दूंगा।
— रॉबर्ट एस।
मुझे अभी भी यकीन नहीं है कि सभी नियम क्या हैं!
— एनजी
2

सी (जीसीसी), 65 60 59 बाइट्स

d(a,t,e){for(t=0,e=13;e-->1;)t+=a%e<1&a/e<(e-2?32:29);a=t;}

उपयोगकर्ता 202029 के जावा उत्तर का पोर्ट । इसे यहाँ ऑनलाइन आज़माएँ । 1 बाइट गोल्फिंग के लिए जोनाथन फ्रेच को धन्यवाद ।

— OOBalance
स्रोत
a=0,m=13;for(;~> for(a=0,m=13;।
— जोनाथन फ्रीच
@JonathanFrech कि बाहर इशारा करने के लिए धन्यवाद, मैंने संपादित किया है।
— OOBalance
2

जे , 29 बाइट्स

1#.(,x*i."+29+3*2~:x=.i.13)=]

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

यह काम किस प्रकार करता है

1#.(,x*i."+29+3*2~:x=.i.13)=]    Input: year (2-digit, 1..99)
                   x=.i.13       array of 0..12; assign to x
                2~:              1 1 0 1 .. 1
              3*                 3 3 0 3 .. 3
           29+                   32 32 29 32 .. 32
       i."+                      for each item of above, generate a row 0 .. n
    ,x*                          each row times 0 .. 12 and flatten
                           =]    1 for each item == input, 0 otherwise
1#.                              sum

2 बार जेली समाधान के तहत पाने के लिए कठिन प्रयास किया :)

पक्षीय लेख

अगर कोई वास्तव में 99 अंकों के डेटा को हार्डकोड करना चाहता है, तो यहां थोड़ी जानकारी है:

99 अंकों को 2 अंकों के भाग में विभाजित करें। फिर पहला अंक है <4और दूसरा <8, जिसका अर्थ है पांच बिट्स दो संख्याओं को एन्कोड कर सकते हैं। फिर पूरे डेटा को 250 बिट्स, या 32 बाइट्स में एन्कोड किया जा सकता है।

— bubbler
स्रोत
2

पायथन 3 , 158 162 215 241 बाइट्स

सशर्त गोल्फिंग के लिए स्टीफन के लिए 4 धन्यवाद हटा दिया गया।

सफेद स्थान को इंगित करने के लिए 53 धन्यवाद स्टीफन को हटा दिया

26 सीडर्ड द्वारा प्रदान की गई लिंक के लिए धन्यवाद

मैं इस पर बहुत नया हूँ। एक महीने में दिनों का वर्णन किए बिना ऐसा करने के बारे में सोच भी नहीं सकते।

r=range
def n(Y):
 a,b,c=31,30,0
 for x in r(12):
  for y in r([a,(28if Y%4else 29),a,b,a,b,a,a,b,a,b,a][x]):
   if(x+1)*(y+1)==int(str(Y)[2:]):c+=1
 return c

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

— akozi
स्रोत
5
साइट पर आपका स्वागत है, और अच्छी पहली पोस्ट! वहाँ कुछ तरीके हैं जो आप इसे गोल्फ कर सकते हैं, जैसे कि कुछ
— व्हाट्सएप
@ cairdcoinheringaahing सलाह के लिए धन्यवाद लिंक बहुत उपयोगी था!
— एकोजी
1
158 बाइट्स - कुछ दूर गोल्फिंग की गई, लेकिन ज्यादातर आपके पास अपनी तीसरी लाइन पर एक बड़ी लंबी लाइन थी, डननो वहां कैसे पहुंची
— स्टीफन
@Stephen धन्यवाद :) मैंने आपका दो संपादन के रूप में जोड़ा। एक सफेद स्थान के लिए और दूसरा गोल्फिंग के रूप में।
— एकोजी
(28if Y%4else 29)को छोटा किया जा सकता है [29,28][Y%4>0]। साथ ही, लंबी सूची को छोटा किया जा सकता है [a,...]+2*[a,b,a,b,a]। a,b,cएक पंक्ति को बचाने के लिए पैरामीटर सूची में जोड़ा जा सकता है। int(str(Y)[2:])को छोटा किया जा सकता है Y%100। अंत में, काउंटर चर को ज्यादातर lenसूची समझ के लिए छोटा किया जा सकता है , यह भी nएक बनाने की अनुमति देता है lambda। यह 118 बनाता है ।
— काला उल्लू काई
2

फोर्थ (gforth) , 60 59 बाइट्स

: f 0 13 1 do over i /mod swap 32 i 2 = 3 * + 0 d< - loop ;

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

यह संस्करण इस तथ्य का लाभ उठाता है कि प्रति माह 1 से अधिक मिलान दिवस नहीं हो सकता है, और इस वर्ष को मैच के लिए महीने से विभाज्य होना चाहिए।

व्याख्या

महीने से अधिक हो जाता है, अगर महीने के हिसाब से वर्ष विभाज्य है, और यदि मार्च के बाद माह 31 (फरवरी के लिए 28) है, तो चेक 25 दिनों से अधिक दिनों तक मेल नहीं खा सकता है, इसलिए हम सिर्फ सभी महीने (फरवरी के अलावा) मान सकते हैं पहेली के उद्देश्य के लिए 31 दिन हैं।

कोड स्पष्टीकरण

: f                   \ start new word definition
  0                   \ set up counter
  13 1 do             \ start a counted loop from 1 to 12
    over i /mod       \ get the quotient and remainder of dividing year by month
    swap              \ default order is remainder-quotient, but we want to swap them
    32 i 2= 3 * +     \ we want to compare to 32 days unless month is Feb
    0 d<=             \ treat the 4 numbers on the stack as 2 double-length numbers
                      \ and compare [1]
    -                 \ subtract result from counter (-1 is true in Forth)
  loop                \ end loop
;                     \ end word definition

] y * 2^(l) + x जहाँ l एक एकल के बिट में आकार है) के है आगे कार्यान्वयन आप के साथ काम कर रहे हैं)।

इस मामले में, मैंने भागफल की तुलना की और 32 (या 29) तक शेष है। 0. यदि शेष 0 से अधिक था (वर्ष महीने से विभाजित नहीं), तो पहला डबल स्वचालित रूप से 32 (या 29) 0 से बड़ा होगा और परिणाम झूठा होगा। यदि शेष 0 है, तो यह भागफल <= 32 (या 29) की नियमित जांच को प्रभावी ढंग से हल करता है।

फोर्थ (gforth) , 61 बाइट्स

: f 0 13 1 do i 2 = 3 * 32 + 1 do over i j * = - loop loop ;

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

महीने में दिनों की सही संख्या होने के संदर्भ में फरवरी के मामलों को महसूस करके कुछ बाइट्स को बचाया

व्याख्या

फोर्थ (कम से कम gforth) तुलना सच के लिए -1 और असत्य के लिए 0 लौटाता है

0                     \ place 0 on top of the stack to use as a counter
13 1 do               \ begin the outer loop from 1 to 12
  i 2 = 3 *           \ if i is 2 place -3 on top of the stack, otherwise 0
  32 + 1 do           \ begin the inner loop from 1 to 31 (or 28)
    over              \ copy the year from stack position 2 and place it on top of the stack
    i j * = -         \ multiply month and day compare to year, subtract result from counter 
  loop                \ end the inner loop
loop                  \ end the outer loop
— reffu
स्रोत
1

जावा (JDK 10) , 79 72 70 बाइट्स

y->{int a=0,m=13;for(;m-->1;)a+=y%m<1&&y/m<(m==2?29:32)?1:0;return a;}

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

— user202729
स्रोत
@ शगुन थैंक्स! (पिछले संस्करण से बचे हुए हैं, जहां मैं सभी d
— बीमारियों से बचता हूं
आप को बदलते हैं &&करने के लिए &हालांकि वह 19 मिनट पहले उत्तर दिया है यह, OlivierGrégoire के जावा जवाब के रूप में एक ही जवाब है।
— केविन क्रूज़सेन
@ केविनक्रूजसेन यादृच्छिक संयोग। हालांकि मेरा संस्करण थोड़ा खराब है (टर्नरी का अनावश्यक उपयोग)।
— user202729
1

जावास्क्रिप्ट (Node.js) , 108 बाइट्स

a=>'0122324243426133415153317223416132126011504033106131204241006003213011306002122042005101305111014012'[a]


f=a=>'0122324243426133415153317223416132126011504033106131204241006003213011306002122042005101305111014012'[a]
o.innerText=[...Array(99)].map((_,x)=>(2001+x++)+` = `+f(x)).join`\n`
pre{column-count:5;width:480px;}
<pre id=o></pre>
स्निपेट का विस्तार करें

जानवर बल खोज, अच्छा!
— ब्रैडेक
PPCG में आपका स्वागत है!
— झबरा
1

पायथन 3, 132 बाइट्स

यह वास्तव में एक कार्यक्रम के लिए काफी लंबा है लेकिन मुझे लगा कि यह रुचि का हो सकता है।

सभी मान 0-4 के बीच हैं इसलिए मैं प्रत्येक संख्या को 3 बिट्स के साथ एक लंबी बाइनरी स्ट्रिंग में एनकोड करता हूं। मैंने अपने अजगर कार्यक्रम में एक कच्चे बाइनरी स्ट्रिंग को चिपकाने की कोशिश की, लेकिन मैं इसे काम करने के लिए नहीं मिला, इसलिए मैं फ़ाइल में बेस 64 पर बस गया।

मैंने लुकिंग टेबल के रूप में निम्नलिखित स्ट्रिंग का इस्तेमाल किया (पैडिंग के लिए इस्तेमाल किया गया 7 समाप्त) 01223242434261334151533172234161321260115040331061312042410060032130113060021220420051013051110140127

कार्यक्रम इस स्ट्रिंग को लेता है और इसे संख्या के रूप में डिकोड करता है, फिर परिणाम निकालने के लिए बिट शिफ्टिंग का उपयोग करता है। 

import base64
lambda n:int.from_bytes(base64.b64decode(b'pNRRxYtw01s9Jw4tFYE0QNkYsoRQgYBosEsYBFIRAUgsUkgwFQM='),'big')>>(6306-3*n)&7

66 बाइट्स + 37 बाइट फ़ाइल = 103 बाइट्स

यह नामक एक बाइनरी फ़ाइल पढ़ता है eऔर बेस 64 का उपयोग करने से बचता है।

lambda n:int.from_bytes(open('e','rb').read(),'big')>>(6306-3*n)&7

यहाँ पढ़ी गई फ़ाइल (बिना गद्दी के) हेक्सडंप है:

00000000  a4 d4 51 c5 8b 70 d3 5b  3d 27 0e 2d 15 81 34 40  |..Q..p.[='.-..4@|
00000010  d9 18 b2 84 50 81 80 68  b0 4b 18 04 52 11 01 48  |....P..h.K..R..H|
00000020  2c 52 48 30 0a                                    |,RH0.|
— qwr
स्रोत
1

Oracle SQL, 115 बाइट्स

select count(decode(sign(decode(l,2,29,32)-y/l),1,1))from t,
xmltable('1to 12'columns l int path'.')where mod(y,l)=0

हम ध्यान दें कि यह वास्तव में 100/4 <28 के बाद से अप्रैल (और बाद के महीनों) में कितने दिनों तक कोई फर्क नहीं पड़ता है। यह भी जांचना आवश्यक नहीं है कि वर्ष लीप है या नहीं। हमें केवल यह बताना होगा कि फरवरी में 28 दिन हैं (29 नहीं क्योंकि यह मान्यता केवल 2058 के लिए निष्पादित की जाएगी जो लीप नहीं है) अन्यथा यह किसी भी महीने के लिए सिर्फ 31 हो सकता है।

अन्य दृष्टिकोण

Oracle SQL (12c रिलीज़ 2 और बाद में), 151 बाइट्स

select count(to_date(y/l||'-'||l||'-1' default '' on conversion error,'dd-mm-y'))from t,
(select level l from dual connect by level<=12)where mod(y,l)=0

Oracle SQL (12c रिलीज़ 2 और बाद में), 137 बाइट्स

select sum(validate_conversion(y/l||'-'||l||'-1'as date,'dd-mm-y'))from t,
(select level l from dual connect by level<=12)where mod(y,l)=0

दोनों समाधान 8 बाइट्स छोटे हो सकते हैं यदि हम (select level l from dual connect by level<=12)साथ बदलते हैं , xmltable('1to 12'columns l int path'.')लेकिन बग के कारण ओरेकल एक अपवाद फेंकता है (संस्करण 12.2.0.1.0, 18.3.0.0.0 पर परीक्षण किया गया)।

SQL> select count(to_date(y/l||'-'||l||'-1' default '' on conversion error,'dd-mm-y'))from t,
  2  xmltable('1to 12'columns l int path'.')where mod(y,l)=0
  3  /
select count(to_date(y/l||'-'||l||'-1' default '' on conversion error,'dd-mm-y'))from t,
*
ERROR at line 1:
ORA-00932: inconsistent datatypes: expected DATE got DATE


SQL> select sum(validate_conversion(y/l||'-'||l||'-1'as date,'dd-mm-y'))from t,
  2  xmltable('1to 12'columns l int path'.')where mod(y,l)=0
  3  /
select sum(validate_conversion(y/l||'-'||l||'-1'as date,'dd-mm-y'))from t,
*
ERROR at line 1:
ORA-43909: invalid input data type

दोनों समाधानों में एकमात्र मामला जब वर्ष मायने रखता है 2058 जो गैर-लीप है इसलिए शाब्दिक '-1' का उपयोग गैर-लीप वर्ष को निर्दिष्ट करने के लिए किया गया था।

Oracle SQL, 128 बाइट्स

select count(d)from t,(select date'1-1-1'+level-1 d from dual connect by level<365)
where to_char(d(+),'mm')*to_char(d(+),'dd')=y

Oracle SQL, 126 बाइट्स

select substr('122324243426133415153317223416132126011504033106131204241006003213011306002122042005101305111014012',y,1)from t

अपडेट करें

Oracle SQL, 110 बाइट्स

select-sum(least(sign(y/l-decode(l,2,29,32)),0))from t,
xmltable('1to 12'columns l int path'.')where mod(y,l)=0

Oracle SQL, 108 बाइट्स

select sum(decode(sign(decode(l,2,29,32)-y/l)*mod(y+1,l),1,1))from t,
xmltable('1to 12'columns l int path'.')

स्पार्क एसक्यूएल, 137 बाइट्स

select count(cast(regexp_replace(concat_ws('-','2001',l,y/l),'.0$','')as date))
from(select explode(array(1,2,3,4,5,6,7,8,9,10,11,12))l),t

स्पार्क 2.3+ एसक्यूएल, 126 बाइट्स

( replaceफ़ंक्शन उपलब्ध हो जाता है)

select count(cast(replace(concat_ws('-','2001',l,y/l),'.0')as date))
from(select explode(array(1,2,3,4,5,6,7,8,9,10,11,12))l),t
— डॉ। वाई विट
स्रोत
1

पीएचपी , 73 बाइट्स

पाइप इनपुट का उपयोग करना और php -nR:

for(;++$m<13;$d=1)while($d<25+($m-2?$m>4?:7:4))$c+=$argn==$m*$d++;echo$c;

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

पीएचपी , 76 बाइट्स

कमांड लाइन आर्ग इनपुट का उपयोग करना php dm.php 18:

for(;++$m<13;$d=1)while($d<25+($m-2?$m>4?:7:4))$c+=$argv[1]==$m*$d++;echo$c;

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

Iterative दृष्टिकोण। चूँकि देखने के लिए केवल लीप वर्ष 2 * 29 = 58 है, और 2058 एक लीप वर्ष नहीं है इसलिए फ़रवरी के दिनों में लीप वर्ष पर विचार करने की कोई आवश्यकता नहीं है। और चूंकि रैपराउंड एक चिंता का विषय नहीं है - अप्रैल से, 25 से अधिक किसी भी दिन 100 से अधिक हो जाएगा हम कहते हैं कि बाकी महीनों में केवल 25 दिन हैं।

इनपुट कमांड लाइन के माध्यम से 2 अंकों का वर्ष है (-10 बाइट्स प्रोग्राम के रूप में, @Titus से सुझाव के लिए)।

या:

PHP , 101 बाइट्स

$y=$argv[1];for($d=strtotime("$y-1");date(Y,$d)==$y;$d+=86400)eval(date("$\x+=j*n=='y';",$d));echo$x;

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

फिर भी पुनरावृत्त लेकिन PHP के टाइमस्टैम्प कार्यों का उपयोग करना। वर्ष को चार अंकों की संख्या के रूप में स्वीकार करता है। strtotime()इसके बजाय उपयोग करने के सुझाव के लिए Thx से @Titus mktime()।

— 640KB
स्रोत
पहला संस्करण 4 अंकों के वर्षों के लिए विफल रहता है, दूसरा दो अंकों के लिए विफल रहता है। लेकिन अच्छी सोच है। $m<5?$m-2?31:28:25पहले और $d=strtotime("$y-1")दूसरे के लिए प्रयास करें
— टाइटस
उम्म ... आपने yउद्धरणों में eval क्यों डाला ?
— टाइटस
@ टिट्स क्योंकि PHP7 अब 0 से पहले के अंकों को अष्टक के रूप में मानता है, इसलिए 08 और 09 वास्तव में मान्य नहीं हैं। tio.run/##K8go@G9jXwAkU5Mz8hUMFWxtFQwsrP//BwA दिनांक () फ़ंक्शन का उपयोग करके आप केवल 2 अंक, शून्य-गद्देदार वर्ष प्राप्त कर सकते हैं।
— 640KB
क्षमा! बेशक।
— टाइटस
1
@ टिट्स, अद्यतन के strtotime()बजाय दूसरे संस्करण का उपयोग कर mktime()और कार्यक्रम के रूप में फिर से लागू किया गया, -7 बाइट्स। इसके अलावा, मैंने शीर्ष मतदाताओं सहित अधिकांश सबमिशन को देखा, जो केवल वर्ष को 2 या 4 अंकों के रूप में स्वीकार करेगा, इसलिए मैं इसे लेने जा रहा हूं। सुझाव के लिए फिर से Thx!
— 640KB
0

PHP, 74 70 बाइट्स

while(++$m<13)for($d=$m<5?$m-2?31:28:25;$d;)$n+=$d--*$m==$argn;echo$n;

केवल दो अंकों का वर्ष स्वीकार करता है।

मैंने gwaughs के विचारों को अपनाया और उन्हें गोल्फ दिया; मेरा पहला दृष्टिकोण उनके (92 बाइट्स) से अधिक लंबा था:

for($y=$argn%100;++$m<13;)for($d=$m-2?30+($m+$m/8)%2:29-($y%4>0);$d;)$n+=$d--*$m==$y;echo$n;

%100 4-अंकीय वर्षों का उपयोग करने की अनुमति देता है।

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया उन्हें आज़माएं ।

— टाइटस
स्रोत
आप% 100 को हटाकर 4 बाइट बचा सकते हैं और केवल 2 अंक का इनपुट ले सकते हैं, जो ठीक है: codegolf.stackexchange.com/questions/162137/…
— 640KB
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.