algorithm - when was the last leap year




लीप साल की गणना (14)

लीप वर्षों को खोजने के लिए, साल 100 से अविभाज्य क्यों होना चाहिए और 400 से विभाजित होना चाहिए? मैं समझता हूं कि इसे 4 तक विभाजित क्यों किया जाना चाहिए। कृपया एल्गोरिदम की व्याख्या करें।


आप सिर्फ यह जांच सकते हैं कि वर्ष संख्या 4 और 400 दोनों के द्वारा विभाजित है या नहीं। आपको वास्तव में यह जांचने की ज़रूरत नहीं है कि यह 100 से अविभाज्य है या नहीं। कारण 400 सवाल में आता है क्योंकि ग्रेगोरियन कैलेंडर के अनुसार, हमारी "दिन की लंबाई" थोड़ा है बंद, और इस प्रकार इसे क्षतिपूर्ति करने के लिए, हमारे पास 303 नियमित वर्ष (365 दिन प्रत्येक) और 9 7 लीप वर्ष (366 दिन प्रत्येक) हैं। उन 3 अतिरिक्त वर्षों का अंतर जो छलांग वर्ष नहीं हैं, ग्रेगोरियन कैलेंडर के साथ चक्र में रहना है, जो हर 400 वर्षों में दोहराता है। क्रिश्चियन ज़ेलर के एकरूप समीकरण को देखो। यह वास्तविक कारण को समझने में मदद करेगा। उम्मीद है की यह मदद करेगा :)


आपको वास्तव में पहले Google पर आज़माएं।

विकिपीडिया में wikipedia । आपके वर्णन algorithm प्रणोदनिक ग्रेगोरियन कैलेंडर के लिए है

इसके आसपास गणित के बारे में अधिक लेख कैलेंडर एल्गोरिदम लेख में पाया जा सकता है।


इस समय एक वर्ष में औसतन 365.2425 दिन होते हैं (पृथ्वी धीमा हो रही है लेकिन चलो अब इसे अनदेखा करें)।

हमारे पास हर 4 साल में लीप साल होने का कारण यह है क्योंकि यह हमें औसतन 365.25 [(365+365+365+366) / 4 = 365.25, 1461 days in 4 years]

100-गुणों पर हमारे पास छलांग वर्ष नहीं होने का कारण है हमें 1005 वर्षों में 365.24 `((1461 x 25 - 1) / 100 = 365.24, 36,524 दिन प्राप्त करना है।

फिर 400-गुणों पर एक बार फिर से लीप वर्ष होने का कारण हमें 365.2425 [(36,524 x 4 + 1) / 400 = 365.2425, 146,097 days in 400 years] 36,524 [(36,524 x 4 + 1) / 400 = 365.2425, 146,097 days in 400 years]

मेरा मानना ​​है कि 3600-गुणकों पर एक और नियम हो सकता है लेकिन मैंने कभी इसके लिए कोड नहीं किया है (वाई 2 के एक चीज थी लेकिन भविष्य में साढ़े हजार साल की योजना बनाना मेरी राय में जरूरी नहीं है - ध्यान रखें कि मैं रहा हूं पहले गलत)।

इसलिए, नियम कम प्राथमिकता में हैं:

  • 400 में से एक लीप वर्ष है।
  • 100 में से कई एक लीप वर्ष नहीं है।
  • 4 में से एक लीप वर्ष है।
  • कुछ भी एक छलांग वर्ष नहीं है।

ए) वर्ष 365.2421 99 दिन है।

बी) यदि हर साल 365 दिन थे, तो 100 वर्षों में हम 24.219 9 दिन खो देंगे। यही कारण है कि हम प्रति शताब्दी में 24 दिन जोड़ते हैं (100 से विभाजित होने पर हर 4 साल)

सी) लेकिन फिर भी हम 0.212 99 दिन / शताब्दी खो देते हैं। तो 4 शताब्दियों में हम 0.8796 दिन खो देते हैं। यही कारण है कि हम प्रति 4 शताब्दियों में 1 दिन जोड़ते हैं (हर चौथी शताब्दी में हम एक लीप वर्ष गिनते हैं)।

डी) लेकिन इसका मतलब है कि हम प्रति क्वाड्रिसेंटेनियल (4 शताब्दियों) -0.1204 दिन (हम आगे बढ़ते हैं) खो देते हैं। तो 8 क्वाड्रिकेंटेनेियल (3200 साल) में हम एक लीप वर्ष की गणना नहीं करते हैं।

ई) लेकिन इसका मतलब है कि हम प्रति 3200 वर्षों में 0.0368 दिन खो देते हैं। तो 24x3200 वर्षों (= 76800years) में हम 0.8832 दिन खो देते हैं। यही कारण है कि हम एक छलांग वर्ष गिनती है।

और इसी तरह ... (तब तक हम ग्रह को नष्ट कर देंगे, इसलिए इससे कोई फर्क नहीं पड़ता)

हालांकि मैं समझ नहीं पा रहा हूं, यही कारण है कि हम 400 के बजाय हर 500 साल में एक लीप वर्ष की गणना नहीं करते हैं। इस तरह हम सही समय पर अधिक तेजी से अभिसरण करेंगे (हम 2.3 घंटे / 500 साल खो देंगे)।


कॉफी-स्क्रिप्ट में बस लिखा है:

is_leap_year = ( year ) ->
  assert isa_integer year
  return true   if year % 400 == 0
  return false  if year % 100 == 0
  return true   if year %   4 == 0
  return false

# parseInt? that's not even a word. 
# Let's rewrite that using real language:
integer = parseInt 

isa_number = ( x ) ->
  return Object.prototype.toString.call( x ) == '[object Number]' and not isNaN( x )

isa_integer = ( x ) ->
  return ( isa_number x ) and ( x == integer( x ) )

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

ध्यान दें कि इस फ़ंक्शन के रिटर्न वैल्यू तथाकथित प्रलेप्टिक ग्रेगोरियन कैलेंडर में लीप साल इंगित करते हैं, इसलिए वर्ष 1400 के लिए यह false इंगित करता false , जबकि वास्तव में उस वर्ष एक लीप वर्ष था, तब उपयोग किए जाने वाले जूलियन कैलेंडर के अनुसार। मैं इसे अभी भी डेटटाइम लाइब्रेरी में छोड़ दूंगा क्योंकि मैं लिख रहा हूं क्योंकि तिथियों से निपटने के लिए सही कोड लिखना जल्द ही आश्चर्यजनक रूप से शामिल हो जाता है, इसलिए मैं केवल ग्रेगोरियन कैलेंडर का समर्थन करूंगा (या किसी अन्य के लिए भुगतान प्राप्त करूंगा)।


ग्रेगोरियन कैलेंडर में 3 मानदंडों को लीप वर्षों की पहचान करने के लिए ध्यान में रखा जाना चाहिए:

  1. वर्ष 4 तक समान रूप से विभाजित है;
  2. यदि वर्ष को समान रूप से 100 से विभाजित किया जा सकता है, तो यह एक छलांग वर्ष नहीं है, जब तक;
  3. वर्ष 400 तक भी समान रूप से विभाजित है। फिर यह एक छलांग वर्ष है। 100 साल से विभाजित वर्ष लीप वर्ष क्यों नहीं है

जावास्क्रिप्ट टर्नरी ऑपरेटर का उपयोग करके, विकिपीडिया एल्गोरिदम का एक सरल कार्यान्वयन यहां दिया गया है:

isLeapYear = (year % 100 === 0) ? (year % 400 === 0) : (year % 4 === 0);

पायथन 3.5

def is_leap_baby(year):
    if ((year % 4 is 0) and (year % 100 is not 0)) or (year % 400 is 0):
        return "{0}, {1} is a leap year".format(True, year)
    return "{0} is not a leap year".format(year)

print(is_leap_baby(2014))
print(is_leap_baby(2012))

मुझे यकीन है कि Wikipedia इसे बेहतर तरीके से समझा सकता है, लेकिन मूल रूप से यह तथ्य यह है कि यदि आपने हर चार साल में एक अतिरिक्त दिन जोड़ा तो हम सूरज से आगे निकल जाएंगे क्योंकि सूर्य की कक्षा में समय कम है 365.25 दिन इसलिए हम वर्षों के लिए लीप दिनों को जोड़कर इसकी क्षतिपूर्ति नहीं करते हैं जो 400 से 1 9 00 तक विभाजित नहीं हैं।

उम्मीद है की वो मदद करदे


यदि आप इन नियमों के कारणों में रूचि रखते हैं, तो ऐसा इसलिए होता है क्योंकि सूर्य के चारों ओर एक कक्षा बनाने के लिए धरती को ले जाने का समय एक लंबा अपरिचित दशमलव मूल्य है। यह बिल्कुल 365.25 नहीं है। यह 365.25 से थोड़ा कम है, इसलिए हर 100 साल, एक छलांग का दिन समाप्त होना चाहिए (365.25 - 0.01 = 365.24)। लेकिन यह बिल्कुल सही नहीं है। मूल्य 365.24 से थोड़ा बड़ा है। तो 100 बार नियम लागू होने पर 4 बार में से केवल 3 (या दूसरे शब्दों में, प्रत्येक 400 वर्षों में 1 दिन में वापस जोड़ें; 365.25 - 0.01 + 0.0025 = 365.2425)।


यह जांचने के लिए पर्याप्त है कि एक साल एक लीप वर्ष है या नहीं।

if( (year%400==0 || year%100!=0) &&(year%4==0))
    cout<<"It is a leap year";
else
    cout<<"It is not a leap year";

यहां एक बदसूरत विचार आता है। जब हर साल 100 के साथ विभाजित 365 दिन हो जाता है, तो इस समय क्या किया जाएगा? दूरदराज के भविष्य में, जब 400 के साथ लाभदायक वर्ष भी केवल 365 दिन प्राप्त कर सकते हैं।

फिर 80 के साथ विभाजित वर्षों में सुधार करने की संभावना या कारण है। सामान्य वर्षों में 365 दिन होंगे और 400 के साथ विभाजित होने वाले 366 दिन प्राप्त हो सकते हैं। या यह एक ढीली ढीली स्थिति है।


सामान्य रूप से एक लीप वर्ष की गणना के लिए एल्गोरिदम निम्नानुसार है ...

एक वर्ष एक लीप वर्ष होगा यदि यह 4 से विभाजित है लेकिन 100 से नहीं। यदि एक वर्ष 4 से 100 तक विभाजित होता है, तो यह एक लीप वर्ष नहीं है जब तक कि यह 400 तक विभाजित न हो।

इस प्रकार 1 99 6, 1 99 2, 1 9 88 और इस तरह के वर्षों में लीप साल हैं क्योंकि वे 4 से विभाजित हैं लेकिन 100 से नहीं। सदी के वर्षों के लिए, 400 नियम महत्वपूर्ण है। इस प्रकार, शताब्दी वर्ष 1 9 00, 1800 और 1700 जबकि सभी अभी भी 4 से विभाजित हैं, वे 100 से भी विभाजित हैं। क्योंकि वे 400 से आगे विभाजित नहीं हैं, वे छलांग वर्ष नहीं हैं


Java कोड नीचे दिए गए वर्ष के बीच लीप वर्ष की गणना की गणना करता है। लूप के प्रारंभ और समापन बिंदु का निर्धारण करें।

फिर यदि पैरामीटर मॉड्यूलो 4 बराबर 0 है और पैरामीटर मॉड्यूल 100 बराबर 0 या पैरामीटर मॉड्यूल 400 बराबर शून्य नहीं है तो यह लीप वर्ष है और काउंटर बढ़ाता है।

static int calculateLeapYearCount(int year, int startingYear) {
        int min = Math.min(year, startingYear);
        int max = Math.max(year, startingYear);
        int counter = 0;
        for (int i = min; i < max; i++) {
            if ((i % 4 == 0 && i % 100 != 0) || i % 400 == 0) {
                counter = counter + 1;
            }
        }
        return counter;
    }




leap-year