algorithm year लीप साल की गणना




when was the last leap year (16)

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


पायथन 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 पर एक एल्गोरिदम है:

function isLeapYear (year):
    if ((year modulo 4 is 0) and (year modulo 100 is not 0))
    or (year modulo 400 is 0)
        then true
    else false

इस विषय के बारे में wikipedia पर wikipedia , विभिन्न कैलेंडर के बारे में समावेशी जानकारी के बारे में बहुत सारी जानकारी है।


पीएचपी:

// is number of days in the year 366?  (php days of year is 0 based)
return ((int)date('z', strtotime('Dec 31')) === 365);

यदि हम एक कदम आगे बढ़ते हैं तो यह बेहतर नहीं होगा। प्रत्येक 3200 वर्ष को कोई लीप वर्ष के रूप में मानते हुए, वर्ष की लंबाई आ जाएगी

364.999696 + 1/3200 = 364.999696 + .0003125 = 365.0000085

और इसके बाद लगभग 120000 वर्षों के बाद समायोजन की आवश्यकता होगी।


इनपुट वर्ष एक लीप वर्ष है तो सच वापसी करें

मूल आधुनिक दिन कोड:

  If year mod 4 = 0, then leap year
  if year mod 100 then normal year
  if year mod 400 then leap year
  else normal year

आज के शासन ने 1582 ईस्वी जूलियन कैलेंडर नियम शुरू किया, प्रत्येक चौथे वर्ष के साथ 46 बीसी शुरू हुआ लेकिन सीज़र द्वारा घोषित 10 ईस्वी से पहले सुसंगत नहीं है। हालांकि उन्होंने हर तीसरे वर्ष में कुछ साल पहले और फिर कुछ वर्षों में कुछ लीप साल जोड़े थे: इसलिए लीप साल 45 ईसा पूर्व, 42 ईसा पूर्व, 3 9 ईसा पूर्व, 36 ईसा पूर्व, 33 ईसा पूर्व, 30 ईसा पूर्व, 27 ईसा पूर्व, 24 ईसा पूर्व, 21 ईसा पूर्व, 18 ईसा पूर्व थे। बीसी, 15 ईसा पूर्व, 12 ईसा पूर्व, 9 ईसा पूर्व, 8 ईस्वी, 12 ईस्वी से पहले 45 बीबीसी लीप वर्ष जोड़ा नहीं गया था। http://www.wwu.edu/depts/skywise/leapyear.html

वर्ष 0 अस्तित्व में नहीं है ... 2BC 1BC 1AD 2AD ... कुछ गणना के लिए यह एक मुद्दा हो सकता है।

function isLeapYear(year: Integer): Boolean;
begin
  result := false;
  if year > 1582 then // Todays calendar rule was started in year 1582 
    result := ((year mod 4 = 0) and (not(year mod 100 = 0))) or (year mod 400 = 0)
  else if year > 10 then // Between year 10 and year 1582 every 4th year was a leap year 
    result := year mod 4 = 0
  else //Between year -45 and year 10 only certain years was leap year, every 3rd year but the entire time
    case year of
      -45, -42, -39, -36, -33, -30, -27, -24, -21, -18, -15, -12, -9:
        result := true;
    end;
end;

इस समय एक वर्ष में औसतन 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 में से एक लीप वर्ष है।
  • कुछ भी एक छलांग वर्ष नहीं है।

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

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

लीप साल मनमाने ढंग से हैं, और उनका वर्णन करने के लिए उपयोग की जाने वाली प्रणाली एक मानव निर्मित निर्माण है। ऐसा क्यों नहीं है।

मेरा मतलब यह है कि हर 28 साल में एक छलांग वर्ष हो सकता था और हमारे पास उन छलांग वर्षों में एक अतिरिक्त सप्ताह होगा ... लेकिन शक्तियां जिन्हें हर 4 साल तक पकड़ने का फैसला किया जाता है।

इसे पृथ्वी के साथ सूरज के चारों ओर जाने के लिए 365.25 दिनों का समय लेना पड़ता है। बेशक यह वास्तव में 365.25 नहीं है, यह थोड़ा कम है ( 365.242222 ... ), इसलिए इस विसंगति के लिए सही करने के लिए उन्होंने छलांग छोड़ने का फैसला किया साल जो 100 से विभाजित हैं।


एक वर्ष की लंबाई (अधिक या कम) 365.2421 9 6 दिन है। इसलिए हमें इसे कम करने के लिए दिन की एक चौथाई, कम या ज्यादा घटाना होगा:

365.242196 - 0.25 = 364.9921 9 6 (4 साल में 1 दिन जोड़कर): लेकिन ओह, अब यह बहुत छोटा है !! चलो एक दिन का एक हंडर जोड़ें (उस दिन एक सौ साल में एक बार नहीं जोड़कर :-))

364.992196 + 0,01 = 365.002196 (ओह, थोड़ा बड़ा, चलिए उस दिन को लगभग 400 वर्षों में एक बार जोड़ दें)

365.002196 - 1/400 = 364.999696

लगभग अभी, बस और फिर leapseconds के साथ खेलते हैं, और आप सेट कर रहे हैं।

(ध्यान दें: इस चरण के बाद कोई और सुधार लागू नहीं हुआ है क्योंकि एक वर्ष भी लिंग में परिवर्तन करता है !! यही कारण है कि लीसेकंड सबसे लचीला समाधान है, here परीक्षा के लिए देखें)

यही कारण है कि मुझे लगता है


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

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

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


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

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

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

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

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 , जबकि वास्तव में उस वर्ष एक लीप वर्ष था, तब उपयोग किए जाने वाले जूलियन कैलेंडर के अनुसार। मैं इसे अभी भी डेटटाइम लाइब्रेरी में छोड़ दूंगा क्योंकि मैं लिख रहा हूं क्योंकि तिथियों से निपटने के लिए सही कोड लिखना जल्द ही आश्चर्यजनक रूप से शामिल हो जाता है, इसलिए मैं केवल ग्रेगोरियन कैलेंडर का समर्थन करूंगा (या किसी अन्य के लिए भुगतान प्राप्त करूंगा)।


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

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


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


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

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




leap-year