41

यह चुनौती काफी सरल है। आप एक इनपुट लेंगे जो 1801 से 2400 तक का वर्ष होगा, और आउटपुट यदि यह एक लीप वर्ष है या नहीं।

आपके इनपुट में कोई नई सीमा या अनुगामी स्थान नहीं होगा:

आप किसी भी तरह से आउटपुट करेंगे जो आपको पसंद है वह स्पष्ट रूप से उपयोगकर्ता को बताता है कि यह लीप वर्ष है या नहीं (मैं हाँ / नहीं के लिए y या n स्वीकार करूंगा)

आप यहां लीप वर्ष की सूची प्राप्त कर सकते हैं: http://kalender-365.de/leap-years.php मैं ध्यान दूंगा कि लीप वर्ष हमेशा चार साल नहीं होते हैं। 1896 एक लीप वर्ष है, लेकिन 1900 नहीं है। इस "छोड़ें" का पालन करने वाले वर्ष हैं:

परीक्षण के मामलों:

1936 ->  y
1805 ->  n
1900 ->  n
2272 ->  y
2400 ->  y

संपादित करें: यह एक मानक ग्रेगोरियन कैलेंडर पर आधारित है: http://www.epochconverter.com/date-and-time/daynumbers-by-year.php

code-golf date decision-problem

— केविन क्रूज़सेन
स्रोत

9

आपको अधिक स्पष्ट होना चाहिए: एक दिया गया वर्ष एक लीप वर्ष है यदि और केवल यदि यह है (divisible by 4)∧((divisible by 100)→(divisible by 400))।

— लेजियम मैमल 978

आपके इनपुट में कोई नया लिंक या अनुगामी स्थान नहीं होगा। इसे डांग, कि मुझे 2 बाइट्स बचा होगा ...

— डेनिस

2

आपको स्वीकृत इनपुट रेंज को 1601 ई। 2400 ईस्वी तक बढ़ाया जाना चाहिए। यह दो 400-वर्षीय ग्रेगोरियन चक्र (जो सोमवार को शुरू होता है) को कवर करता है।

— डेविड आर ट्रिबल

2

क्या गलत है अगर लीप वर्ष और सत्य नहीं है यदि एक लीप वर्ष की गिनती नहीं है जैसा कि "स्पष्ट रूप से उपयोगकर्ता को बताता है कि यह है या नहीं"?

— 21

@lirtosiast मुझे ऐसा लगता है। बहुत सारे उपयोगकर्ता ऐसा मानते हैं।

— aloisdg

22

एपीएल, १६ १४ १२ अक्षर

0एक लीप वर्ष के लिए रिटर्न , 1एक गैर-लीप वर्ष के लिए।

≥/⌽×4 25 4⊤⎕

इस समाधान को tryapl.org पर देखें । ध्यान दें कि मैंने dfn के समाधान को बदल दिया है {≥/⌽×4 25 4⊤⍵}क्योंकि tryapl.com समर्थन नहीं करता है ⎕(उपयोगकर्ता इनपुट लें)। ध्यान दें कि ⎕एक खाली बॉक्स है, एक गायब चरित्र नहीं है।

जम्मू में एक ही समाधान:

4 25 4>:/@|.@:*@#:]

व्याख्या

डायएडिक ⊤(एनकोड) अपने बाएं तर्क द्वारा निर्दिष्ट आधार में अपने सही तर्क का प्रतिनिधित्व करता है। मैं 4 25 4इस समाधान में आधार का उपयोग करता हूं । यह एक बहुपद के रूप में वर्ष y का प्रतिनिधित्व करता है

y mod 400 = 100 a + 4 b + c जहां b <100 और c <4 है।

प्रस्ताव करते हैं अल्फा, बीटा, और गामा का प्रतिनिधित्व करता है, तो एक, ख, और ग गैर शून्य हैं: प्रस्ताव γ झूठी है अगर y 4 से विभाज्य है, बीटा ∧ γ झूठी है अगर y 100 और से विभाज्य है अल्फा ∧ बीटा ∧ γ है गलत है अगर y 400 से विभाजित करने योग्य है।

एक सत्य सारणी ( *"परवाह न करें" का प्रतिनिधित्व) प्रस्ताव था y यदि एक लीप-ईयर प्राप्त होता है तो प्रतिनिधित्व करता है:

α β γ | Δ
0 0 0 | 1
1 0 0 | 0
* 1 0 | 1
* * 1 | 0

निम्नलिखित बयान में Δ व्यक्त करता α , β , और γ :

Δ = ¬ (( अल्फा → बीटा ) → गामा ))।

इस कथन की संरचना के कारण, व्यक्ति where को कमी के रूप में व्यक्त कर सकता है ≥/⌽α β γजहां this लागू होता है this । इस जवाब के लिए मैं अभी समझा रहा हूँ।

— FUZxxl
स्रोत

16

अजगर, 11 बाइट्स

!%|F_jQ*TT4

यह पूरा कार्यक्रम एसटीडीआईएन से पढ़ा गया है और यह लीप इयर्स के लिए ट्रू प्रिंट करता है और अन्यथा गलत है।

पायथ का सुझाव देने और मूल रूप से मेरे CJam कोड को पोर्ट करने के लिए @Jakube का धन्यवाद।

Pyth Compiler / Executor में परीक्षण मामलों को स्वयं सत्यापित करें ।

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

     jQ*TT   Returns the evaluated input in base 10 × 10.
  |F_        Swaps the digit order and reduces using logical OR.
             So far, we've achieved 1954 -> [19, 54] -> 54 || 19.
!%        4  Returns the logical NOT of the result modulo 4.
             This prints True for multiples of 4 and False otherwise.

— डेनिस
स्रोत

15

CJam, 12 बाइट्स

rS+2m<~e|4%!

यह पूरा कार्यक्रम एसटीडीआईएन से पढ़ा जाता है और 1 लीप वर्ष के लिए प्रिंट करता है और 0 अन्यथा।

CJam दुभाषिया में परीक्षण मामलों को स्वयं सत्यापित करें ।

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

r   e# Read from STDIN.
S+  e# Append a space.
2m< e# Rotate two characters to the left.
~   e# Evaluate.
    e# So far, we achieved "1954" -> "54 19" -> 54 19.
e|  e# Logical OR; keep the leftmost non-zero integer.
4%! e# Logical NOT of the kept integer modulo 4.
    e# This pushes 1 for multiples of 4 and 0 otherwise.

— डेनिस
स्रोत

मुझे कुछ और 12 बाइट विकल्प मिल गए हैं। हो सकता है कि आप इसे 11 तक लाने के लिए उनमें कुछ खोज सकें? r2/~~\e|i4%!, r2/~~\~e|4%!, r2/:~~\e|4%!, r2/S*~\e|4%!और 13 बाइटr2/:~W%:e|4%!

— मार्टिन Ender

@ मार्टिनबटनर: r2/:i:\e|4%!(12) और r2/:i(fe|~4%!(13) भी हैं। मैंने भी गोल्फ की कोशिश की है (जिसकी आवश्यकता नहीं है r), लेकिन or4एक एकल टोकन के रूप में व्याख्या की गई है। यदि केवल इनपुट में एक अनुगामी न्यूलाइन थी ...

— डेनिस

14

जावास्क्रिप्ट (ईएस 6), 21 अक्षर

मानक नियम यह है कि yएक लीप वर्ष है यदि 4 विभाजित होता है yऔर यदि 100 विभाजित नहीं होता है yया 400 विभाजित नहीं होता है y। कोड में,

y%4 == 0 && (y%100 != 0 || y%400 == 0)

इसके लिए 100 और 400 की कोई आवश्यकता नहीं है। इसके बजाय यह जांचने के लिए पर्याप्त है कि क्या 16 या 4 को विभाजित किया गया है, 16 के साथ अगर 25 को विभाजित किया जाए, तो 4। गोल्फ, यह बन जाता है

!(y%(y%25?4:16))

एक जावास्क्रिप्ट फ़ंक्शन जो इसे लागू करता है वह 21 वर्ण लंबा है:

l=y=>!(y%(y%25?4:16))

पर्ल, २ characters २६ अक्षर

एक ही विचार है, लेकिन पर्ल में।

$_=$_%($_%25?4:16)?"n":"y"

-lpविकल्पों का उपयोग करके चलाएं । उदाहरण के लिए,

perl -lpe '$_=$_%($_%25?4:16)?"n":"y"'

इनपुट के रूप में परीक्षण सेट के साथ, यह पैदा करता है

— डेविड हैमेन
स्रोत

मैंने अपने उत्तर में आपके सुझाव का उपयोग किया था, आपका नहीं देखा। अब मैं पीछे हट गया हूं। नोट: आपको EcmaScript 6 को निर्दिष्ट करना चाहिए, अन्यथा किसी को 'Chrome में काम नहीं करने' की शिकायत होगी

— edc65

@ edc65: क्योंकि यह ठीक है, वह ECMAScript 6 निर्दिष्ट करना चाहिए है ECMAScript 6. तीर समारोह संकेतन ( y=>...) एक ES6 सुविधा है।

— टिम Timस

यह दो जवाब नहीं होना चाहिए?

— dfeuer

9

पिप , 13 बाइट्स

यह पहले की तुलना में अधिक दिलचस्प था। इसमें कुछ परिमार्जन हुआ, लेकिन मैं आखिरकार उन लंबे संदर्भों को चर और (= 100) के 400साथ बदलने में सक्षम था ।4h

!(a%h?aa/h)%4

1लीप वर्ष के लिए आउटपुट , 0गैर-लीप वर्ष के लिए। स्पष्टीकरण:

               a is command-line argument (implicit)
  a%h?aa/h     If a is divisible by 100, divide it by 100; otherwise, leave it alone
 (        )%4  The result mod 4 is 0 if it's a leap year, nonzero otherwise
!              Negate and (implicitly) print

— DLosc
स्रोत

9

पायथ, 19 15 14 बाइट्स

xFm!%Q^d2[2TyT

रास्ता बहुत आसान है। इसे ऑनलाइन आज़माएं: प्रदर्शन या टेस्ट हार्नेस

संपादित करें: याद किया, कि आप इसके बजाय ट्रू / फाल्सी वैल्यूज़ प्रिंट कर सकते हैं n/y। -4 बाइट

संपादन 2: मार्टिन के वर्गमूल विचार का इस्तेमाल किया। -1 बाइट

व्याख्या

                 implicit: Q = input number
         [         generate a list with the numbers:
          2          2
           T         10
            yT       2*10 = 20
  m              map each number d to:
   !%Q^d2          not(Q mod d^2) // True if Q % d^2 == 0 otherwise False
xF               fold by xor

— Jakube
स्रोत

9

रेगेक्स, 83 62 38

रेबेक्स के दोनों हिस्सों के संयोजन के बारे में सुझावों के लिए टोबी का धन्यवाद।

अगर हम 1801..2400 रेंज पर ध्यान केंद्रित करते हैं और मान लें कि इनपुट पूर्णांक हैं:

(?!00)([02468][048]|[13579][26])(00)?$

रूबी में टेस्ट ( ^= \Aऔर $= \Zक्योंकि रूबी) वांछित रेंज के लिए:

r = /(?!00)([02468][048]|[13579][26])(00)?\Z/
(1801..2401).each do |year|
  leap = year % 4 == 0 && ((year % 100 != 0) || (year % 400 == 0))
  leap_regex = !year.to_s[r].nil?
  if leap != leap_regex
    print 'Assertion broken:', year, " ", leap, " ", leap_regex, "\n"
  end
end

(बोनस) उस चीज के लिए जो न केवल 1801..2400 के लिए काम करना चाहिए, बल्कि किसी भी गैर-नकारात्मक वर्ष के लिए:

^\d*(0000|(?!00)([13579][26]|(^|[02468])[048])(00)?)$

रूबी में टेस्ट ( ^= \Aऔर $= \Zरूबी क्योंकि) पहले 100000 वर्षों के लिए:

r = /\A\d*(0000|(?!00)([13579][26]|(\A|[02468])[048])(00)?)\Z/
100000.times do |year|
  leap = year % 4 == 0 && ((year % 100 != 0) || (year % 400 == 0))
  leap_regex = !year.to_s[r].nil?
  if leap != leap_regex
    print 'Assertion broken:', year, " ", leap, " ", leap_regex, "\n"
  end
end

— rr-
स्रोत

1

यदि आपके पास (?!)आप दो हिस्सों को जोड़ सकते हैं: (?!00)([02468][048]|[13579][26])(00)?$- 38 के लिए। हालांकि यह एक-अंकों के वर्षों के लिए काम नहीं करेगा।

— टोबी स्पाईट

9

जावास्क्रिप्ट ( ईएस 6 ) 27

नियम: (y%4==0) && (y%100!=0 || y%400==0)

गोल्फ: !(y%100<1&&y%400||y%4)(मुख्य रूप से डी मोर्गन्स के कानून का उपयोग करते हुए )

नियम को लागू करने वाला एक कार्य:

l=y=>!(y%100<1&&y%400||y%4)

एक परीक्षण (फ़ायरफ़ॉक्स में चलाने के लिए) बस सुनिश्चित करें:

l=y=>!(y%100<1&&y%400||y%4)

for(o=[],i=0;i<700;i++)
  y=i+1800,
  x=l(y),
  o[i/100|0]=(o[i/100|0]||'')+y+(x?' <b>Y</b>':' <i>N</i>')+'\n'
    
R.innerHTML='<td>'+o.join('</td><td>')+'</td>'
console.log(o[1])

td { white-space: pre; font-family: monospace; padding: 8px}

b { color: red; }
i { color: blue; }

<table>
  <tr id=R></tr>
</table>

स्निपेट का विस्तार करें

— edc65
स्रोत

3

यदि आप !(y%(y%25?4:16))इसके बजाय उपयोग करते हैं तो आप इसे छह वर्णों तक कम कर सकते हैं !(y%100<1&&y%400||y%4)। टर्नरी ऑपरेटर द्वारा परेशान लोगों के लिए, आप उपयोग कर सकते हैं !(y%(4<<2*!(y%25)))और फिर भी तीन अक्षरों को बचा सकते हैं !(y%100<1&&y%400||y%4)।

— डेविड हैमेन

1

डेविड हैमेन का सुझाव उनके उत्तर के समान है, इसलिए मुझे लगता है कि आपको लंबाई 27 तक रखनी चाहिए।

— lirtosiast

9

TI-BASIC, 20 17 16 13

क्योंकि यह टोकन है, TI-BASIC अक्सर सरल गणित चुनौतियों पर प्रतिस्पर्धी होता है, लेकिन यह नहीं है क्योंकि कोई "विभाज्य" कमांड नहीं है। शायद यह सब के बाद है, लेकिन यह अभी भी सीजम और पायथ की तुलना में लंबा है।

यह डेविड हैमंड की विधि का उपयोग करता है।

not(fPart(Ans/4/4^not(fPart(sub(Ans

16 बाइट्स पर पुराना कोड:

not(fPart(Ans/16not(fPart(sub(Ansnot(fPart(Ans/4

Ungolfed:

not(fPart(Ans/16) and not(fPart(Ans/100) and not(fPart(Ans/4))))

fPart("आंशिक अंश" है; विभाजन की तुलना में घातांक की उच्च प्राथमिकता है। TI-BASIC में, क्लोज-पैरेंस वैकल्पिक हैं।

मैं sub(कमांड के अनजाने व्यवहार का उपयोग करता हूं , आमतौर पर एक विकल्प प्राप्त करने के लिए उपयोग किया जाता है: जब इसका तर्क एक स्ट्रिंग के बजाय एक संख्या है, तो यह संख्या को 100 से विभाजित करता है। यह TI-83 या 84 श्रृंखला कैलकुलेटर पर काम करेगा।

20 -> 17 पास-कोड हटाने के लिए कोड को फिर से व्यवस्थित करके; 17 -> 16 के साथ 400 को 16 से बदलकर; 16 -> 13 डेविड हैमंड के विचार का उपयोग करके।

— lirtosiast
स्रोत

9

स्टैकलॉजिक, 226 बाइट्स (गैर-प्रतिस्पर्धात्मक)

हाँ यह सही है। मैंने यहां मिलने वाली चुनौती के लिए हेलका होम्बा द्वारा आविष्कार किए गए स्टैकलॉजिक (गैर-टीसी) में एक कार्यक्रम बनाया । यह चुनौती के बाद बनाया गया है, इसलिए गैर-प्रतिस्पर्धात्मक है।

Stackylogic में केवल बाइनरी इनपुट होता है, इसलिए 10 (या अधिक, किसी भी अधिक अंक को अनदेखा किया जाएगा) बिट बाइनरी का उपयोग किया जाना चाहिए (कम से कम महत्वपूर्ण बिट इनपुट पहले)। निर्दिष्ट सीमा से बाहर की कोई भी तारीख विफल हो सकती है, क्योंकि यह केवल यह जांचता है कि इनपुट नंबर क्या है: यह अनावश्यक तिथियों को कवर नहीं करता है

स्टैकलॉजिक के साथ न केवल यह मेरी पहली चुनौती है, बल्कि स्टैकलॉजिक के साथ पहली चुनौती है।

इस गंदगी के लिए तैयार हो जाओ:

इसे बनाने में मुझे इतना लंबा समय लगा, क्योंकि स्टैकेग्लॉजिक मेरे द्वारा सामना की गई सबसे भ्रामक भाषा है, और बेहद अपठनीय: आपको यह जानना होगा कि आपके द्वारा संपादित किए जा रहे करंट सेक्शन को पढ़ने से पहले बाकी प्रोग्राम ने कैसे निष्पादित किया है। मुझे भी इसे बनाते समय पठनीयता के लिए स्थान जोड़ना पड़ा।

अल्प व्याख्या

यह एक सरल स्पष्टीकरण है कि यह क्या करता है।

स्टैकलॉजिक में कोई गणितीय कार्य नहीं है, जिससे यह कठिन हो गया। मुझे यह जांचने के लिए कि क्या यह एक विशिष्ट संख्या है, इसे सबसे अधिक हार्डकोड करना था।

सबसे पहले, यह कार्यक्रम कम से कम महत्वपूर्ण बिट्स का एक एनओआर करेगा, जो उन्हें प्रक्रिया में छोड़ देगा। इसका मतलब यह है कि यदि यह 4 से विभाज्य है, तो यह कार्यक्रम के मुख्य भाग पर आगे बढ़ेगा, अन्यथा आउटपुट 0।

दूसरा, सूचक को स्टैकलॉजिक के भूलभुलैया तक ले जाया जाता है, यहां से, यदि अगले दो बिट शून्य हैं, तो यह तुरंत 1 आउटपुट करेगा (तब तक यह 16 से विभाज्य है, और इसलिए किसी भी अन्य स्थितियों के बावजूद एक लीप वर्ष है), अन्य वार यह जाँच करेगा कि क्या यह संख्याओं में से कोई 4 से विभाज्य नहीं है, बल्कि 1801 और 2400 के बीच एक लीप वर्ष नहीं है।

विस्तार से समझाने के लिए, इस पोस्ट को पहले से कई गुना अधिक लंबा बनाना होगा

— विनाशकारी नींबू
स्रोत

8

आईबीएम सिस्टम जेड असेंबलर - 56 बाइट्स।

(स्रोत के 96 बाइट्स। पहले 712 384 202 स्रोत के बाइट्स, 168 बाइट निष्पादन योग्य)।

अभी भी छोटा संस्करण। अब कॉलर के रजिस्टर, शाब्दिक भंडारण में परिवर्तन, एड्रेसिंग मोड में परिवर्तन नहीं करता है।

 l        CSECT      
         using l,15 
         l  5,y     
         n 5,f      
         bnz r      
         xr 4,4     
         l 5,y      
         d 4,c      
         ch 4,i     
         bne i      
         n 5,f      
         bnz r      
i        dc h'0'    
r        b  *       
y        dc f'2004' 
f        dc f'3'    
c        dc f'100'  
         end

नया संस्करण। यदि यह एक लीप वर्ष है, और लूप नहीं है तो यह S0C1 के साथ ABEND होगा। उम्मीद है कि परिणाम को इंगित करने की आवश्यकता को पूरा करता है।

l        CSECT             
         ASMDREG           
         SYSSTATE archlvl=2
         IEABRCX  DEFINE   
         save  (14,12)     
         larl  r9,s        
         using s,r9        
         st 13,w+4         
         la 13,w           
         st 13,w+8         
         la 5,2004         
         st 5,y            
         n 5,=f'3'         
         bnz r             
         xr r4,r4          
         l 5,y             
         d r4,=f'100'      
         ch r4,=h'0'       
         bne i             
         n 5,=f'3'         
         bnz r             
i        dc h'0'           
r        b  0              
s        dc 0d'0'          
y        ds f              
w        ds 18f            
         ltorg             
         end

ठीक है, इसलिए कम से कम नहीं (हालांकि यह एक बार हो सकता है जब हम वास्तविक निष्पादित कोड और दुभाषिया आकार को देखें ...)

leapyear CSECT                                                
         ASMDREG                                              
         SYSSTATE archlvl=2                                   
         IEABRCX  DEFINE                                      

         save  (14,12)                                        

         larl  r9,staticArea                                  
         using staticArea,r9                                  
         st r13,w_savea+4       .Save callers savearea        
         la r13,w_savea         .Address my savearea          
         st r13,w_savea+8         . and save it               

         open  (O,OUTPUT)             .open file              

         la r5,1936             .r5 = input year              
         st r5,years            .Save year                    

         cvd r5,double          .Convert year to p-decimal    
         mvc edarea,=xl8'4020202020202120' .Move in edit mask 
         ed edarea,double+4      .Make packed decimal year printable                              
         mvc outrec(4),edarea+4  .Move year string to output area                             
         bas r10,isitleap       .Call leap year routine       

         close (O)              .Close files            
         b return               .Branch to finish

isitleap ds 0h                                                      
         mvi outrec+5,c'N'      .Set default value                                   
         n r5,=f'3'             .Are last 2 bits 0 (Divisible by 4)?
         bnz notleap            .No - not leap                      
         xr r4,r4               .Clear R4                           
         l r5,years             .Reload r5 with year                
         d r4,=f'100'           .divide r4/r5 pair by 100           
         ch r4,=h'0'            .Remainder 0?                       
         bne isleap             .No - leap year                     
         n r5,=f'3'             .Quotient divisible by 4?           
         bnz notleap            .No - not leap                      

isleap   ds    0h                                                   
         mvi outrec+5,c'Y'      .Move in leap year indicator                                    

notleap  ds    0h                                                   
         put O,outrec           .Print output record                                    
         br r10                 .Return to caller                   

* Program termination                                               
return   ds 0h                                                      
         l r13,w_savea+4         .Restore callers savearea          
         return (14,12),,rc=0    .Restore registers and return    
* storage areas                                                     
staticarea  dc 0d'0'                                                
outrec      ds cl10                                                 
years       ds f                                                    
w_savea     ds 18f                save area                         
edarea      ds cl8                    .edit area                    
double      ds d                                                    
* Macros and literals                                               
         print nogen                                                
O        dcb   recfm=F,lrecl=6,dsorg=PS,ddname=O,macrf=PM           
         print gen                                                  
*                                                                   
         ltorg                         literal storage              
         end

आउटपुट:

एक लीप वर्ष के लिए S0C1 को भेजें, S222 (जब CPU समय समाप्त हो गया है) यदि नहीं।

~~1936 वाई 1805 एन 1900 एन 2272 वाई 2400 वाई~~

~~(जब कई बार चलाते हैं)~~

— स्टीव इवेस
स्रोत

भंडारण क्षेत्रों को न्यूनतम आकार (13 बाइट्स) बनाकर 376 बाइट्स तक, कार्यक्रम में स्टेजिंग एरिया 'लीपफ्लैग' को हटाकर केवल एक वर्ष (5 के बजाय) सहित।

— स्टीव मेव्स

थोड़ा स्वरूपित आउटपुट प्रदान करके 384 बाइट्स:

— स्टीव इव्स

1

भाषा की दिलचस्प और शैक्षिक पसंद के लिए +1। :-)

— टोबी स्पाइट

मैं अधिवेशन को छोड़कर कुछ बाइट्स बचा सकता था और शुरू में फोन करने वालों के रजिस्टर को बचाने की जहमत नहीं उठाता था, क्योंकि प्रोग्राम कभी भी कॉलर के पास नहीं लौटता। यह बहुत बुरा रूप है।

— स्टीव इव्स

7

CJam, 18 16 बाइट्स

q~[YAK]f{2#%!}:^

1लीप वर्ष के लिए देता है (सत्य) और 0(मिथ्या) अन्यथा।

सभी परीक्षण मामलों को यहां चलाएँ।

व्याख्या

q~                 e# Read and eval input.
  [YAK]            e# Push an array containing 2, 10, 20 (the square roots of the
                   e# relevant divisors).
       f{    }     e# Map this block onto that array, also passing in the input year.
         2#        e# Square the divisor.
           %!      e# Modulo followed by logical negation. Gives 1 if the year is divisible
                   e# by the given divisor and 0 otherwise.
                   e# At this point we have one of the following arrays:
                   e#   [0 0 0] - not a leap year
                   e#   [1 0 0] - a leap year
                   e#   [1 1 0] - not a leap year
                   e#   [1 1 1] - a leap year
              :^   e# Reduce XOR onto this array, which gives 1 if there is an odd number
                   e# of 1s and 0 if there's an even number.

— मार्टिन एंडर
स्रोत

6

गणितज्ञ, 40 27 बाइट्स, 17 वर्ण

#∣4∧(#∣100<U+F523>#∣400)

17 वर्णों का उपयोग करता है, लेकिन 27 बाइट्स। टिप के लिए @alephalpha को धन्यवाद। ध्यान दें कि ऊर्ध्वाधर पट्टियां वास्तव में विभाजित करने के लिए U + 2223 हैं। <U+F523>इसी चरित्र के साथ प्रतिस्थापित किया जाना चाहिए।

— LegionMammal978
स्रोत

2

यह उन पहेलियों में से एक है, जहाँ गणितज्ञ एक तरह का समाधान प्रस्तुत करते हैं, जो कि एक प्रकार का धोखा देता है: LeapYearQ [#] &

— zeldredge

1

आप ∣प्रतिनिधित्व करने के लिए उपयोग कर सकते हैं Divisible: #∣4&&(!#∣100||#∣400)&21 वर्ण, 27 UTF-8 बाइट्स।

— एलेफाल्फा

@zeldredge फिर भी, यह एपीएल समाधान से कम नहीं है।

— FUZxxl

@alephalpha वैकल्पिक रूप से, आप 19 वर्णों (लेकिन अभी भी 27 बाइट्स) के लिए इसे बनाने के लिए U+F523( \[Implies]) उपयोग कर सकते हैं #∣4&&(#∣100<U+F523>#∣400)&।

— लीजनमोनमल 978

यह एक मानक खामियाजा है; आप एक फ़ंक्शन का उपयोग कर रहे हैं जो बिल्कुल आवश्यक कार्यक्षमता करता है। यह शब्दशः है।

— फुजेनक्ल

6

आर, २ ९

!(Y=scan())%%4&Y%%100|!Y%%400

परीक्षण चालन

> !(Y=scan())%%4&Y%%100|!Y%%400
1: 1936
2: 1805
3: 1900
4: 2272
5: 2400
6: 2200
7: 
Read 6 items
[1]  TRUE FALSE FALSE  TRUE  TRUE FALSE

— MickyT
स्रोत

5

सी, 81

मैं कम कर सकता हूं, लेकिन यह एक बड़े करीने से 'चार' प्रकारों से चिपक जाता है, बिना तर्क दिए (उदाहरण के साथ atoi):

main(c,v)char**v;{char*p=*v+9;p-=2*(96==*p+p[1]);putchar("ynnn"[(2**p^p[1])&3]);}

इसे 4 वर्णों के नाम के साथ लागू किया जाना चाहिए, क्योंकि यह मानक धारणा बनाता है कि तर्क तुरंत प्रोग्राम नाम का अनुसरण करते हैं, जो कि MULs द्वारा अलग किया जाता है। इसके अलावा, यह मानता है कि एकल तर्क ASCII में एन्कोडेड है और इसमें कोई अग्रणी स्थान नहीं है।

स्पष्टीकरण:

main(c,v)
char**v;
{
    char *p = *v+9;
    if (p[0] + p[1] == '0'+'0')
        p -= 2;
    putchar("ynnn"[((*p << 1) ^ p[1])&3]);
}

*v+9'दहाई' अंक की स्थिति है v[1]+2।

यदि 'दसियों' और 'इकाइयाँ' वर्ण 96 में जुड़ते हैं, तो हम अंत में 00दो वर्णों का समर्थन करते हैं, ताकि 'दहाई' और 'इकाइयाँ' सदी संख्या की ओर इंगित करें।

अब '' दसियों '' के साथ xor 'इकाइयाँ', mod 4. यह काम करता है 10==±2 mod 4, क्योंकि 'दहाई' का निचला हिस्सा 'इकाइयों' के बिट 1 को टॉगल कर सकता है। हम परिणाम को अपनी अनुरेखण तालिका में एक सूचकांक के रूप में उपयोग करते हैं, yकेवल मुद्रण यदि मॉड्यूलर परिणाम शून्य है।

— टोबी स्पाईट
स्रोत

4

Befunge -98, (41 बाइट्स)

&:4%#v_:aa*%#v_28*%|
"y",;<;@,"n";>;  ;#[

सादगी कमाल की है।

— MegaTom
स्रोत

4

सेड, ५५

s/00$//
y/0123456789/yNnNyNnNyN/
/N.$/y/ny/yn/
s/.\B//g

पहली पंक्ति 100 से सटीक सदियों को विभाजित करती है।
दूसरी पंक्ति 'N' को विषम अंक, 'y' को 4s और 'n' को गैर- 4s में देती है।
तीसरी पंक्ति स्वैप करता है 'y' और 'n' अगर एक विषम संख्या अंक (क्योंकि 10 2 मॉड 4 है)
अंतिम पंक्ति सभी लेकिन अंतिम वर्ण को हटा देती है

ध्यान दें कि गैर-लीप वर्ष मुद्रित किया जा सकता है nया Nइस पर निर्भर करता है कि वे सम या विषम हैं। मैं इस नियम की एक रचनात्मक व्याख्या पर विचार करता हूं जो विकल्प को 'हां' और 'नहीं' के विकल्प को निर्दिष्ट किए बिना अनुमति देता है कि उन्हें सुसंगत होना चाहिए।

— टोबी स्पाईट
स्रोत

4

पायथन 2 - 37

g=lambda x:(x%4or x%400and x%100<1)<1

ध्यान दें कि यदि aएक nonnegative पूर्णांक है, तो a<1लेखन का एक छोटा तरीका है not bool(a)। अंतिम <1इस प्रकार प्रभावी रूप से कोष्ठक में अभिव्यक्ति को एक बूलियन में परिवर्तित करता है और परिणाम को नकारता है।

फ़ंक्शन gको n1801 और 2400 के बीच पूर्णांक पर लागू करना Trueयदि nएक लीप वर्ष है, और Falseअन्यथा।

— mathmandan
स्रोत

3

केडीबी (क्यू), 27 बाइट्स

{0=x mod(4 400)0=x mod 100}

व्याख्या

               0=x mod 100      / boolean of 100 divisibility
        (4 400)                 / 0b -> 4, 1b -> 400
 0=x mod                        / boolean of 4/400 divisibility
{                         }     / lambda

परीक्षा

q){0=x mod(4 400)0=x mod 100}1936 1805 1900 2272 2400
10011b

— वूइकेंट ली
स्रोत

3

जूलिया, 30 28 बाइट्स

y->(y%4<1&&y%100>0)||y%400<1

यह एक अनाम फ़ंक्शन बनाता है जो पूर्णांक तर्क को स्वीकार करता है और एक बूलियन मान देता है। इसे कॉल करने के लिए, इसे एक नाम दें, उदा f=y->...।

Ungolfed:

function f(y)
    (y % 4 == 0 && y % 100 != 0) || y % 400 == 0
end

उदाहरण:

julia> for y in [1936, 1805, 1900, 2272, 2400] println(f(y)) end
true
false
false
true
true
true

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

3

PHP - 45 बाइट्स

$b=$argv[1]%400;echo !$b|!($b%4)&!!($b%100);

कुछ भी नहीं जो वास्तव में विशेष है, केवल प्रकार-बाजीगरी को गाली देना।

— उत्तर पुल
स्रोत

3

सी #, 23 बाइट्स

y=>y%25<1?y%16<1:y%4<1;

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

पूर्ण स्रोत, परीक्षण मामलों सहित:

using System;

namespace CountingLeapYears
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<int,bool>s=y=>y%25<1?y%16<1:y%4<1;
            Console.WriteLine(s(1936)); //y
            Console.WriteLine(s(1805)); //n
            Console.WriteLine(s(1900)); //n
            Console.WriteLine(s(2272)); //y
            Console.WriteLine(s(2400)); //y
        }
    }
}

— adrianmp
स्रोत

3

सी, 37 34 30 बाइट्स

l(y){y=y%(y%25?4:16)?110:121;}

Wandbox

— o79y
स्रोत

3

टी-एसक्यूएल 37 22 बाइट्स

ब्रैड की टिप्पणी के लिए धन्यवाद, 15 बाइट्स सहेजे गए।

कमी के लिए सामान्य हार्डकोड चर stdin।

जैसे

DECLARE @ NVARCHAR(4) = '2016'

तो समाधान है:

PRINT ISDATE(@+'0229')

— S.Karras
स्रोत

1

अगर मैं चुनौती को सही तरीके से पढ़ रहा हूं, तो मुझे लगता है कि आप सीधे 1या 0सीधे लौटकर बाइट्स का एक गुच्छा बचा सकते हैं:PRINT ISDATE(@+'0229')

— ब्रैडेक

3

जावा 8, 49 45 22 20 बाइट्स

n->n%(n%25<1?16:4)<1

-2 बाइट्स @ ओलिवियरग्रेगायर के लिए धन्यवाद ।

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

कुछ 22 बाइट्स समाधान:

n->n%25<1?n%16<1:n%4<1

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

n->(n%25<1?n%16:n%4)<1

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

java.time.Year::isLeap

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

स्पष्टीकरण:

n->                // Method with integer parameter and boolean return-type
   n%          <1  //  Return whether the integer is divisible by:
     (n%25<1?      //   If the input is divisible by 25:
             16    //    Check if its divisible by 16
            :      //   Else:
             4)    //    Check if its divisible by 4 instead

— केविन क्रूज़सेन
स्रोत

एक और 22 बाइट्स विकल्प java.time.Year::isLeap:।

— ओलिवियर ग्रेजायर

2

और एक 20 बाइट्स समाधान:n->n%(n%25<1?16:4)<1

— ओलिवियर ग्रेजायर

@ OlivierGrégoire नाइस 20-बटर! और एहसास नहीं हुआ कि बिलिन भी 22 बाइट्स था। :)

— केविन क्रूज़सेन

3

हास्केल, 19 बाइट्स

f i=gcd 80i>gcd 50i

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

— Primo
स्रोत

2

जावास्क्रिप्ट ईएस 6, 32, 29, 26

निम्नलिखित में से कोई भी काम करता है:

f=y=>new Date(y,2,0).getDate()&1
g=y=>!(y&3)^!(y%100)>!(y%400)
h=y=>!(y&3|y%100<1&&y%400)

— Qwertiy
स्रोत

2

सी, 57 बाइट्स

स्टड से इनपुट लेता है, रिक्त स्थान / न्यूलाइन के साथ या उसके बिना। केवल छोटी एंडियन मशीनों पर काम करता है (हाँ, जैसे हर कोई इन दिनों बीई पर है)। आउटपुट वाई या एन।

main(y){scanf("%d",&y);y=y%(y%100?4:400)?78:89;puts(&y);}

व्याख्या

Ungolfed:

int main(int y) {
   scanf("%d", &y);
   y = y % (y % 100 ? 4 : 400) ? 'N' : 'Y';
   puts(&y);
}

सबसे पहले, scanfवर्ष को y में पूर्णांक के रूप में पढ़ता है। फिर, y को 4 या 400 के साथ modulo'ed किया जाता है, इस आधार पर कि वर्ष 100 से विभाज्य है। यदि शेष शून्य है, तो Y के लिए ASCII कोड y को सौंपा गया है, अन्यथा इसे N के लिए ASCII कोड मिलता है। y का मान अब है 0x000000??, जहां 0x??निर्दिष्ट चरित्र है। एक छोटे से एंडियन मशीन पर होने के नाते, स्मृति में इसे संग्रहीत किया जाता है ?? 00 00 00। यह एक नेल-टर्मिनेटेड C स्ट्रिंग है, जिसमें केवल असाइन किए गए वर्ण हैं। Y के पते को पुट के लिए पास किया जाता है और चार्ट को प्रिंट किया जाता है (अनुगामी न्यूलाइन के साथ)।

— एंड्रिया बियोन्डो
स्रोत

1

"आप किसी भी तरह से आउटपुट करेंगे जो आपको पसंद है वह स्पष्ट रूप से उपयोगकर्ता को बताता है कि यह लीप ईयर है या नहीं।" क्या आप 'Y ’या? N’ की बजाय 1 या 0 देकर वापस आ सकते हैं? (मैं वास्तव में सी को बिल्कुल नहीं जानता, बस अनुमान लगा रहा हूं।)

— एलेक्स ए

@AlexA। संपादन के लिए धन्यवाद - अब मुझे पता है कि सिंटैक्स को कैसे उजागर किया जाए :) मैंने इसे माना। ASCII कोड दोनों दो अंक हैं, इसलिए इससे कोई लाभ नहीं है (वैसे, मैं 2 बाइट्स को बचाने के लिए अपरकेस Y और N का उपयोग कर रहा हूं, क्योंकि लोअरकेस के 3 अंक हैं)। वे अनुक्रमिक हैं, ताकि उपयोगी हो सके। दुर्भाग्य से, ऑपरेटर पूर्वता के कारण, मुझे एक ही बाइट गिनती मिलती है main(y){scanf("%d",&y);y=!(y%(y%100?4:400))+48;puts(&y);}:। मैं 48 बाइट्स तक नीचे जा सकता हूं अगर मैं लीप वर्षों के लिए एक खाली लाइन और किसी भी चरित्र (एएससीआईआई 1-99) को आउटपुट कर सकता हूं, लेकिन मुझे ऐसा लगता है कि यह नियमों को थोड़ा सा झुक रहा है। तुम क्या सोचते हो?

— एंड्रिया बियोनडो

मैंने चरस गिनते समय कुछ गलत किया होगा। यह 57 है, 59 नहीं :)

— एंड्रिया बियोनडो

1

हाँ, मैं कहूंगा कि यह नियम झुक रहा है, लेकिन आप इस सवाल पर टिप्पणी कर सकते हैं और ओपी से पुष्टि कर सकते हैं। बाइट्स की गिनती के लिए एक अच्छा उपकरण यह है - मुझे लगता है कि यहां बहुत से लोग इसका उपयोग करते हैं।

— एलेक्स ए

नहीं, मैं इसे छोड़ दूंगा जैसा कि यह :)

— एंड्रिया बियोनडो

2

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

मैं यह कहने के लिए उत्साहित हूं कि मैंने बिलिन की तुलना में इसे छोटा किया है!

param($a)!($a%(4,16)[!($a%25)])

उत्पादन लीप वर्ष के लिए सच है और अन्यथा गलत है।

अंतर्निहित:

[datetime]::IsLeapYear($args[0])

हालाँकि, अगर मैं स्टेटमेंट को स्ट्रेच करना चाहता था 'स्पष्ट रूप से उपयोगकर्ता को बताता है कि यह लीप ईयर है या नहीं और कुछ गैर-मानक है, तो मैं 3 बाइट्स बचा सकता था और उपयोग कर सकता था:

param($a)$a%(4,16)[!($a%25)]

यह 0लीप वर्ष के लिए आउटपुट और गैर-लीप वर्ष के लिए 1 या अधिक है, जो मुझे पसंद नहीं है क्योंकि मैं लीप वर्षों के लिए एक अधिक मानक सत्य मूल्य वापस करना पसंद करूंगा।

— ThePoShWolf
स्रोत

2

LOLCODE, 228 202 159 बाइट्स

HOW IZ I f YR a
MOD OF a AN 100
O RLY?
YA RLY
MOD OF a AN 4
O RLY?
YA RLY
b R 1
OIC
NO WAI
MOD OF a AN 400
O RLY?
YA RLY
b R 0
NO WAI
b R 1
OIC
OIC
IF U SAY SO

Ungolfed:

HAI 1.3 BTW "HAI" does nothing functionally in current versions and does not throw an error if you omit it.
HOW IZ I leap YR input
    I HAS A output
    DIFFRINT MOD OF input AN 100 AN 0 BTW Thanks @LeakyNun, In LOLCODE any non-empty values, i.e. 0, "", etc. default to WIN.
    O RLY?
        YA RLY
            BOTH SAEM MOD OF a AN 4 AN 0
            O RLY?
                YA RLY
                    output R WIN BTW "WIN" is true, but in the actual program I used 1 as a truthy value because it's shorter.
            OIC
        NO WAI
            DIFFRINT MOD OF a AN 400 AN 0
            O RLY?
                YA RLY
                    output R FAIL BTW "Fail" is false, but in the actual program I used 0 as a falsy value.
                NO WAI
                    output R WIN
            OIC
    OIC
    FOUND YR output BTW This statement is implied in the golfed version.
IF U SAY SO BTW "KTHXBYE", just like "HAI" has no functional purpose and throws no error on omission.
KTHXBYE

Python में अपुष्ट, क्योंकि LOLCODE भ्रामक है:

def leap:
    if(year % 100 != 0):
        if(year % 4 == 0):
            output = true
    else:
        if(year % 400 != 0):
            output = false
        else:
            output = true
    return(output)

— OldBunny2800
स्रोत

क्या किसी फ़ंक्शन को परिभाषित करना कम होगा?

— लीक

शायद, लेकिन मैं इसे बाद में संपादित करूंगा।

— OldBunny2800

आपने मुख्य कोड को एक फ़ंक्शन होने के लिए अपडेट किया है, लेकिन असंगठित कोड नहीं है?

— विध्वंसक नींबू

मुझे लगा कि LOLCODE में स्वचालित प्रकार का बल है, जिसका अर्थ है कि कोई भी शून्य-शून्य मूल्य के बराबर है WIN..

— Leaky Nun

यह है, लेकिन मैं इसका उपयोग कैसे कर सकता हूं? मुझे नहीं लगता कि मैं कोई कास्टिंग कर रहा हूं।

— OldBunny2800

क्या यह एक लीप वर्ष है?

एपीएल, १६ १४ १२ अक्षर

व्याख्या

अजगर, 11 बाइट्स

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

CJam, 12 बाइट्स

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

जावास्क्रिप्ट (ईएस 6), 21 अक्षर

पर्ल, २ characters २६ अक्षर

पिप , 13 बाइट्स

पायथ, 19 15 14 बाइट्स

व्याख्या

रेगेक्स, 83 62 38

जावास्क्रिप्ट ( ईएस 6 ) 27

TI-BASIC, 20 17 16 13

स्टैकलॉजिक, 226 बाइट्स (गैर-प्रतिस्पर्धात्मक)

अल्प व्याख्या

आईबीएम सिस्टम जेड असेंबलर - 56 बाइट्स।

(स्रोत के 96 बाइट्स। पहले 712 384 202 स्रोत के बाइट्स, 168 बाइट निष्पादन योग्य)।

CJam, 18 16 बाइट्स

व्याख्या

गणितज्ञ, 40 27 बाइट्स, 17 वर्ण

आर, २ ९

सी, 81

स्पष्टीकरण:

Befunge -98, (41 बाइट्स)

सेड, ५५

पायथन 2 - 37

केडीबी (क्यू), 27 बाइट्स

व्याख्या

परीक्षा

जूलिया, 30 28 बाइट्स

PHP - 45 बाइट्स

सी #, 23 बाइट्स

सी, 37 34 30 बाइट्स

टी-एसक्यूएल 37 22 बाइट्स

जावा 8, 49 45 22 20 बाइट्स

हास्केल, 19 बाइट्स

जावास्क्रिप्ट ईएस 6, 32, 29, 26

सी, 57 बाइट्स

व्याख्या

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

LOLCODE, 228 202 159 बाइट्स