लाइब्रेरी के बिना डूम्सडे तारीख गणित
1960 की एक डूम्सडे सुर्खी के पीछे एक काम की सीख छिपी है: तारीख के गणित का डेमो आसान है, पर बिना लाइब्रेरी के उसे सही करना मुश्किल है।

कुछ पुरानी अजीब सी सुर्खी फिर से घूम रही है: 1960 की एक Science रिपोर्ट ने शुक्रवार, 13 नवंबर 2026 की ओर इशारा करते हुए उसे प्रलय का दिन बताया था। वर्किंग प्रोग्रामर के लिए भविष्यवाणी इतनी दिलचस्प नहीं है। दिलचस्प बात यह है कि वह तारीख सच में शुक्रवार है, और इस जवाब तक पहुँचने के लिए आपको date arithmetic से जूझना पड़ता है: लीप नियम, महीनों की लंबाई, सदी वाले अपवाद, ऋणात्मक वर्ष, और वह चुपचाप दिखने वाला फर्क कि लोगों को प्रभावित करने वाला फॉर्मूला और प्रोडक्शन में टिकने वाला कोड अलग-अलग चीज़ें हैं।
इस सुर्खी के पीछे का पेपर Heinz von Foerster और उनके सहयोगियों का था, और उसमें एक उकसाने वाला अंदाज़ है। उन्होंने मानव जनसंख्या वृद्धि को देखा, तर्क दिया कि वह घातांकीय से भी तेज़ है, एक हाइपरबोलिक वक्र फिट किया, और हर को शून्य की ओर बढ़ने दिया। नतीजा एक सिंगुलैरिटी थी, जिसे अख़बार वाली चटपटी तारीख मिल गई। इतिहासकार और जनसांख्यिकी विशेषज्ञ इस पर बहस कर सकते हैं कि यह कितना गंभीर था; यह आधा चेतावनी लगता है और आधा ऐसे व्यक्ति का मज़ाक, जिसे पता था कि शुक्रवार वाला तेरहवाँ दिन कितना नाटकीय सुनाई देगा।
मैं बार-बार उसी कारीगरी पर लौटता हूँ जो नीचे छिपी है। भविष्यवाणी का मज़ाक उड़ाने से पहले वार की पुष्टि करनी होगी। वार की पुष्टि से पहले तय करना होगा कि आप किस कैलेंडर की बात कर रहे हैं। Proleptic Gregorian? किसी देश की वास्तविक नागरिक तिथियाँ? Astronomical वर्ष गणना या वह no-year-zero परंपरा जिसे इतिहासकार इस्तेमाल करते हैं? हम में से ज़्यादातर लोग datetime, java.time या chrono उठाते हैं और आगे बढ़ जाते हैं। यह आम तौर पर सही भी है। लेकिन बिना लाइब्रेरी के यह काम करना आज भी प्रोग्रामिंग की सबसे अच्छी छोटी correctness कसरतों में से एक है, क्योंकि नियम सीमित हैं, पुराने हैं और जालों से भरे हुए हैं।
डूम्सडे सुर्खी दरअसल एक कैलेंडर समस्या है
शुरुआत दावे से करें: 13 नवंबर 2026 शुक्रवार है। इसे REPL में कुछ सेकंड में जाँचा जा सकता है। हाथ से करने का मकसद रफ्तार नहीं है। मकसद मॉडल को उजागर करना है। कैलेंडर एक state machine है जिसमें अनियमित transitions हैं: ज़्यादातर महीने तीस या इकतीस दिन आगे बढ़ते हैं, लीप वर्ष में फरवरी का आकार बदल जाता है, सदी वाले वर्ष चार सौ से विभाज्य न हों तो लीप नहीं होते, और ग्रेगोरियन प्रणाली में पूरा पैटर्न चार सौ साल के चक्र में दोहराता है। एक बार यह चक्र दिख जाए, तो वार निकालना अंकविद्या नहीं रहता, बल्कि सावधानी से बनाए गए चक्र पर modular arithmetic बन जाता है।
Conway का Doomsday method एक यादगार मानव एल्गोरिदम देता है। हर सदी में एक anchor वार होता है; 2000 के दशक के लिए यह मंगलवार है। 2026 जैसे वर्ष के लिए आखिरी दो अंक लीजिए, यानी छब्बीस। उसे बारह से भाग दें तो दो दर्जन वर्ष मिलते हैं, शेषफल दो है, और शेषफल के भीतर के लीप वर्ष शून्य हैं। दो जोड़ दो जोड़ शून्य चार होता है; मंगलवार में चार जोड़ें तो शनिवार आता है। यही उस वर्ष का “doomsday” है, यानी वह वार जो 4/4, 6/6, 8/8, 10/10, 12/12, फरवरी के आखिरी दिन और 7 नवंबर जैसी आसान पहचान वाली तारीखों पर पड़ता है। अगर 7 नवंबर 2026 शनिवार है, तो 13 नवंबर छह दिन बाद होगा: शुक्रवार। सुर्खी के लिए काफी नाटकीय, और कागज़ के टुकड़े पर करने लायक काफी यांत्रिक।
मानसिक तरीका इसलिए खूबसूरत है क्योंकि वह कैलेंडर को कुछ landmarks में समेट देता है। पर संक्षेप ही बग्स का घर भी है। Doomsday एल्गोरिदम मान लेता है कि ग्रेगोरियन लीप नियम लागू है, आम सदी anchors सही हैं, आप कोई कैलेंडर सुधार (calendar reform) पार नहीं कर रहे, और जनवरी व फरवरी को चुपचाप सामान्य महीनों की तरह नहीं माना गया। यह एक सुंदर स्थानीय औज़ार है। यह कोई date library नहीं है।
असली कोड में weekday गणित क्यों टूटता है
कैलेंडर के बग्स शायद ही कभी शोर मचाकर आते हैं। वे ऐसे दिखते हैं: लीप डे के बाद एक renewal ईमेल एक दिन पहले चला जाना, हर फरवरी में invoice period का आखिरी बिंदु छूट जाना, किसी ऐसी सदी की सीमा पर weekly job का खिसकना जिसे कोई देखने की उम्मीद नहीं करता, या किसी इतिहासकार के dataset में year zero का एक मतलब ISO 8601 में और दूसरा किसी संग्रहालय के catalog में होना। specification और implementation के बीच का फासला ठीक वही जगह है जहाँ ये दोष रहते हैं, क्योंकि हर किसी को लगता है कि नियम स्पष्ट है, जब तक दो स्पष्ट नियम आपस में टकरा न जाएँ।
सीमा का क्लासिक मामला वर्ष 2000 है: सौ से विभाज्य, फिर भी लीप वर्ष, क्योंकि वह चार सौ से विभाज्य है। वर्ष 1900 लीप नहीं था। 2100 भी नहीं होगा। कई hand-rolled लीप चेक बस year % 4 == 0 याद रखते हैं और वहीं रुक जाते हैं। स्टार्टअप को जिन वर्षों की परवाह है, उनके लिए यह लगभग हर बार सही है, लेकिन लंबी समय-सीमा पर गलत। वित्तीय सिस्टम, archives और infrastructure अब इतने लंबे समय तक जीते हैं कि लंबी समय-सीमा अब सिद्धांत भर नहीं रही।
- लीप-नियम का शॉर्टकट: पूरे ग्रेगोरियन नियम की जगह
y % 4। - महीने की गिनती के जाल: मानव कैलेंडर में जनवरी एक है, कई APIs में शून्य से शुरू होता है, और Zeller मार्च को पहला महीना मानता है।
- ऋणात्मक वर्ष का अर्थ: astronomical वर्ष शून्य बनाम ऐतिहासिक 1 BCE के बाद 1 CE।
- सप्ताह की शुरुआत: अलग-अलग फॉर्मूलों में रविवार, सोमवार या शनिवार से शुरुआत।
- कैलेंडर सुधार: किसी क्षेत्र द्वारा ऐतिहासिक रूप से ग्रेगोरियन नियम अपनाने से पहले ही उन्हें लागू कर देना।
- Integer division: C शून्य की ओर truncate करता है, जबकि कैलेंडर गणित अक्सर floor division चाहता है।
इनमें से कितनी गलतियाँ अंकगणित की नहीं, बल्कि representation की हैं, यह देखने लायक है। यही भाषा और library design के लिए गहरा सबक है। तारीख कोई बेहतर नाम वाला integer नहीं है। वह एक calendrical system का मान है, जिसके साथ वैधता के नियम, एक epoch, epoch से पहले के वर्षों की परंपरा, और वारों तक का नक्शा जुड़ा होता है जो इन सबपर निर्भर है। अच्छे APIs गलत अवस्थाओं को मुश्किल बना देते हैं। बुरे APIs आपको तीन integers देते हैं और शुभकामनाएँ।
Zeller, Doomsday और एक फॉर्मूले का आकार
Zeller का congruence Conway वाली चाल का पुराना, ज़िद्दी रिश्तेदार है। ग्रेगोरियन कैलेंडर के लिए इसे अक्सर इस तरह लिखा जाता है कि मार्च को महीना 14 माना जाए, अप्रैल को 15, और जनवरी व फरवरी को पिछले वर्ष के 13वें और 14वें महीने। दिन q, महीना m, सदी के भीतर का वर्ष K और शून्य-आधारित सदी J हो, तो एक आम रूप है h = (q + floor(13(m+1)/5) + K + floor(K/4) + floor(J/4) + 5J) mod 7, जहाँ h = 0 का मतलब शनिवार है। यह काम करता है। पर यह परंपराओं की बारूदी सुरंगों से भी भरा है।
इसके कई प्रकाशित रूप हैं: कुछ में वार का शून्य बिंदु अलग है, कुछ जूलियन कैलेंडर के लिए हैं, कुछ में पद घटाने की जगह जोड़े जाते हैं। फोरम से कोई फॉर्मूला उठाइए, और वह 1901 से 2099 के बीच सही हो सकता है और किनारों पर गलत, या सिर्फ तभी सही जब आपकी भाषा integer division को उसी तरह floor करे जैसा लेखक ने माना था। इसी वजह से मुझे Zeller को production कोड की तरह पेश करना पसंद नहीं। संरचना समझने के लिए यह शानदार है: एक रैखिक दिन पद, अनियमित लंबाइयों का अनुमान लगाने वाला महीना सुधार, वर्ष पद, लीप सुधार और सदी सुधार। पर जब कोई maintainer यह उलटकर खोजना चाहे कि आपने कौन सी परंपरा इस्तेमाल की, तब यह उतना अच्छा नहीं रहता।
Conway का तरीका मानव स्मृति के लिए optimize करता है। Zeller बीजगणितीय सफाई के लिए। Production कोड को auditability के लिए optimize करना चाहिए। ये अलग लक्ष्य हैं। भाषा-डिज़ाइन की दृष्टि से यह एक चालाक macro और एक उबाऊ function के बीच का फर्क है, जिसके नामों में ही invariants लिखे हों। हमें ऐसे और उबाऊ functions चाहिए, जिनके नामों में invariants लिखे हों।

एक छोटा ग्रेगोरियन कोर जिसका ऑडिट हो सके
अगर मुझे सीमित संसाधनों वाले कोड में weekday लॉजिक चाहिए, तो मेरा पसंदीदा आधार Howard Hinnant का days-from-civil निर्माण है। यह ग्रेगोरियन तारीख को 1970-01-01 के सापेक्ष एक serial day count में बदलता है, फिर ज्ञात गुरुवार से modular arithmetic करके वार निकलता है। इम्प्लीमेंटेशन छोटा है, पर हर constant की कोई वजह है। यह वर्ष को इस तरह खिसकाता है कि मार्च पहला महीना बन जाए; तब लीप डे खिसके हुए वर्ष के आखिर में आता है, जहाँ वह उससे पहले की किसी चीज़ को नहीं छेड़ता।
typedef long long i64;
/* Gregorian proleptic calendar; March is treated as the first month. */
static i64 days_from_civil(i64 y, int m, int d) {
y -= m <= 2;
i64 era = (y >= 0 ? y : y - 399) / 400; /* floor-ish 400-year era */
int yoe = (int)(y - era * 400); /* year of era, 0..399 */
int mp = m + (m > 2 ? -3 : 9); /* Mar=0 ... Feb=11 */
int doy = (153 * mp + 2) / 5 + d - 1; /* day of shifted year */
int doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
return era * 146097 + doe - 719468; /* 1970-01-01 == 0 */
}
/* Returns 0=Sunday, 1=Monday, ... 6=Saturday. */
static int weekday_gregorian(i64 y, int m, int d) {
i64 z = days_from_civil(y, m, d);
int r = (int)((z + 4) % 7); /* 1970-01-01 was Thursday */
if (r < 0) r += 7;
return r;
}
संख्या 153 सम्मान का हकदार है। खिसकाए गए महीनों मार्च से फरवरी तक लंबाइयाँ लगभग तीस और इकतीस दिनों के पैटर्न में बदलती हैं, और (153 * mp + 2) / 5 बिना lookup table के हर महीने से पहले के संचयी दिन एन्कोड करता है। 146097 चार सौ साल वाले ग्रेगोरियन चक्र के दिन हैं: चार सदियों के 146,000 दिन, प्लस सत्तानवे लीप दिन। 719468 घटाने से गिनती Unix epoch पर फिर से केंद्रित होती है। इसमें कुछ रहस्यमय नहीं है; यह कैलेंडर स्पेक का अंकगणित में निचोड़ है।
यहाँ type चुनाव मायने रखते हैं। serial days के लिए signed wide integers इस्तेमाल करें। अगर आप proleptic Gregorian लागू कर रहे हैं तो उसे साफ लिखें। तय करें कि 31 अप्रैल जैसे सीमा से बाहर के दिन अस्वीकार होंगे या normalize होंगे; मैं civil dates के लिए rejection पसंद करता हूँ, क्योंकि चुपचाप rollover ऊपर के बग्स को छुपा देता है। अगर आप BCE इनपुट स्वीकार करते हैं, तो पहली subtraction से पहले बताइए कि कौन सी numbering इस्तेमाल हो रही है। ये library की चिंताएँ लगती हैं, पर वही अनुशासन firmware blob या stored procedure के अंदर भी लागू होता है, जहाँ कोई यह मानना नहीं चाहता कि तारीखें जटिल होती हैं।
समय क्षेत्र (time zones) कैलेंडर गणित नहीं हैं
Weekday तभी स्थिर होता है जब आप time scale और location तय कर लें। टोक्यो में 00:30 की मीटिंग सैन फ्रांसिस्को में अब भी पिछले civil day की होती है। अगर आपका सिस्टम instants स्टोर करता है, तो weekday पूछने से पहले time-zone database के ज़रिए बदलिए। अगर आपका सिस्टम civil dates स्टोर करता है, तो बिना zone जोड़े उन्हें instants में लापरवाही से न बदलें। विफलता का तरीका सूक्ष्म है: दो सेवाएँ timestamp पर सहमत हो सकती हैं और दिन पर असहमत।
इसी वजह से मैं code reviews में तीन विचारों को अलग रखता हूँ। instant भौतिक timeline पर एक बिंदु है। civil date 2026-11-13 जैसा कानूनी या सामाजिक लेबल है। local time civil लेबल का zone और उसके offset इतिहास के साथ जोड़ा हुआ रूप है। Weekday के सवाल ज़्यादातर civil dates से जुड़े हैं। Scheduling के सवाल instants और zones से। जब कोड इन्हें मिलाता है, तो हर साफ फॉर्मूला भूत की तरह भटकने लगता है। यहाँ defensive engineering का मतलब है timestamp को यह दिखावा न करने देना कि वह उपयोगकर्ता का कैलेंडर जानता है।
Leap seconds एक और परत हैं जिन्हें लोग weekday बहस में घसीटना पसंद करते हैं। Civil weekday गणित के लिए उन्हें नज़रअंदाज़ करें। Weekdays calendar days का पालन करते हैं, smoothed atomic time का नहीं। अगर आप leap seconds को smear करते हैं या duration के लिए monotonic clock इस्तेमाल करते हैं, तो ठीक है, पर इसे सवाल “क्या यह शुक्रवार है?” में रिसने न दें। शुक्रवार एक सामाजिक तथ्य है।
CI में जगह पाने लायक टेस्ट
तारीख वाला कोड भरोसा adversarial fixtures से कमाता है, vibes से नहीं। मुश्किल मामलों को function के पास रखें। 1900-02-28 और 1900-03-01 को लगातार दिनों के रूप में टेस्ट करें, जिनके बीच कोई लीप डे नहीं है। 2000-02-29 को टेस्ट करें क्योंकि वह मौजूद है। 2099-12-31 का 2100 में बदलना टेस्ट करें, जहाँ केवल-चार वाला नियम गलत हो जाता है। अगर आप उस epoch का इस्तेमाल करते हैं, तो 1970-01-01 को गुरुवार के रूप में टेस्ट करें। अगर आप ऋणात्मक वर्षों का समर्थन करने का दावा करते हैं, तो उन्हें टेस्ट करें, और यह भी कि arithmetic से पहले खराब इनपुट अस्वीकार होता है।
Property tests तभी उपयोगी हैं जब उनकी properties ईमानदार हों। किसी भी valid तारीख में एक दिन जोड़ने पर weekday सात के modulo में एक आगे बढ़ना चाहिए। चार सौ ग्रेगोरियन वर्षों में 146,097 दिन होने चाहिए और वही वार लौटना चाहिए। एक गैर-लीप सदी में doomsday-शैली की landmarks तभी एक वार साझा करें जब आपका implementation सुसंगत हो। ऐसी library के खिलाफ टेस्ट न करें जो उसी गलतफहमी से बनी हो जिससे आप बचना चाहते हैं; अपेक्षित जवाब standard से या स्वतंत्र रूप से निकाली गई tables से तय करें।
किसी date routine का सही होना तब माना जाए जब उसकी परंपराएँ उबाऊ, स्पष्ट हों और उन सीमाओं पर टेस्ट की गई हों जहाँ कैलेंडर अपना मन बदलता है।
डूम्सडे तारीख के लिए अपेक्षित जवाब इतना सरल है कि उसे एक comment में hard-code किया जा सकता है: proleptic Gregorian नियमों के तहत 2026-11-13 का नतीजा शुक्रवार है। फिर उसके आसपास का रास्ता भी जाँचें: 2026-11-07 एक doomsday landmark शनिवार है, 2026-02-28 शनिवार है, 2027-02-28 एक साधारण वर्ष के बाद रविवार है, और 2028-02-29 मौजूद है क्योंकि 2028 चार से विभाज्य है और सौ से नहीं। ये छोटे-छोटे तारामंडल किसी भी मनमाने दस लाख मामलों से बेहतर off-by-one गलतियाँ पकड़ते हैं।

नए मॉडलों के लिए पुराना सबक
1960 का डूम्सडे वक्र जनसांख्यिकी के रूप में इसलिए विफल हुआ क्योंकि मानव प्रणालियाँ फिट किए गए रेखा पर निष्क्रिय बिंदु नहीं हैं। जन्म दर बदली, नीतियाँ बदलीं, खेती बदली, शहरीकरण बदला, और सिंगुलैरिटी भविष्य में ही टिकी रही, जहाँ सुर्खियाँ उसे हमेशा रखती हैं। यह असफलता प्रोग्रामरों के लिए भी काम की है। कोई मॉडल भीतर से सुसंगत, ऐतिहासिक रूप से आधारित और फिर भी गलत हो सकता है, क्योंकि जिस प्रणाली का अध्ययन हो रहा है, वह आपके मापते समय ही नियम बदल देती है।
कैलेंडर अंकगणित इसके उलट सुविधा देता है। नियम धीमे, सार्वजनिक और ज़्यादातर स्थिर हैं, यानी स्पेक का सम्मान करें तो सही होना संभव है। इसी कारण तारीखें एक व्यापक आदत के लिए आदर्श प्रशिक्षण मैदान हैं: मॉडल का नाम तय करें, core को time zones और IO से अलग करें, परंपराएँ स्पष्ट करें, और उन जगहों पर टेस्ट करें जहाँ निरंतरता टूटती है। चाहे आप embedded RTC के लिए C लिख रहे हों, query planner के लिए, या किसी language runtime में validation layer के लिए, जीत एक ही है। उबाऊ स्पष्टता चालाक निश्चितता को हरा देती है।
तो हाँ, तेरहवाँ शुक्रवार अपने समय पर आ रहा है। किसी सर्वनाश की ज़रूरत नहीं। असली डर यह है कि एक टीम कितनी आसानी से weekday लॉजिक शिप कर सकती है जो लगभग काम करता है, आधे-याद रखे congruences और उन मान्यताओं से बना है जिन्हें किसी ने लिखा ही नहीं। सरल काम को कठोरता से करें: चार सौ साल वाला चक्र लागू करें, असंभव तारीखें अस्वीकार करें, instants को civil लेबल से अलग रखें, और भविष्य के maintainers के लिए constants का ऐसा रास्ता छोड़ें जिसे वे जाँच सकें। Doomsday एक भविष्यवाणी से बेहतर unit test बनाता है।


