लीप सेकंड के लिए लीप!

28

चूंकि आज होने वाली 26 वीं लीप सेकंड के अवसर को चिह्नित करता है, इसलिए आपकी चुनौती जीएमटी या यूटीसी में हर लीप सेकेंड की तारीख और समय का उत्पादन करना होगा जो अब तक हुई है, साथ ही आज होने वाली एक भी है।

इनपुट

कोई इनपुट नहीं है।

उत्पादन

1972-06-30 23:59:60
1972-12-31 23:59:60
1973-12-31 23:59:60
1974-12-31 23:59:60
1975-12-31 23:59:60
1976-12-31 23:59:60
1977-12-31 23:59:60
1978-12-31 23:59:60
1979-12-31 23:59:60
1981-06-30 23:59:60
1982-06-30 23:59:60
1983-06-30 23:59:60
1985-06-30 23:59:60
1987-12-31 23:59:60
1989-12-31 23:59:60
1990-12-31 23:59:60
1992-06-30 23:59:60
1993-06-30 23:59:60
1994-06-30 23:59:60
1995-12-31 23:59:60
1997-06-30 23:59:60
1998-12-31 23:59:60
2005-12-31 23:59:60
2008-12-31 23:59:60
2012-06-30 23:59:60
2015-06-30 23:59:60

नियम

चूंकि मुझे संदेह है कि कई बिल्ट-इन हैं जो लीप-सेकंड की अनुमति देते हैं, मैं उन्हें अनुमति दूंगा।

मानक खामियों को अस्वीकार कर दिया जाता है।

सबसे छोटा कोड जीतता है।

दिनांक प्रारूप में शून्य-गद्देदार महीना और 4-अंक वाला वर्ष, साथ ही साथ सैन्य समय और तारीख से समय को अलग करने वाला स्थान होना चाहिए। UTCअंत में लाना वैकल्पिक है। आपकी पसंद डैश या स्लैश।

संपादित करें: जैसा कि भविष्यवाणी की गई थी, यह एक एन्कोडिंग चुनौती बन गई। यदि केवल एन्कोडिंग लीप दूसरी समस्या को ठीक कर सकता है, ... तो हमारे सभी कोड बहुत अधिक व्यावहारिक होंगे। शायद हमें व्यावहारिक उपयोगों के साथ अधिक मजेदार चुनौतियों के लिए कुछ विचारों की आवश्यकता है?

code-golf  kolmogorov-complexity  date 
— mbomb007
स्रोत
क्या आउटपुट के लिए उस सटीक वितरण की आवश्यकता है, या जब तक 26 तारीखें हैं, तब तक उसका कोई वितरण हो सकता है?
— इस्माइल मिगुएल
2
@IsmaelMiguel उन्हें इस क्रम में होना चाहिए।
— mbomb007
विषय से हटकर, लेकिन सूची को देखते हुए, मैं सोच रहा हूं कि पिछली शताब्दी की तुलना में हमें इन दिनों कम छलांग सेकंड की आवश्यकता क्यों है।
— मिस्टर लिस्टर
@Mrister लिंक किया गया विकिपीडिया लेख देखें। मुझे लगता है कि इसका पृथ्वी की बदलती घूर्णी गति के साथ क्या करना है।
— mbomb007

जवाबों:

25

CJam, 72 70 69 64 बाइट्स

26,"~g¼K&Béx¸¦­Ø"240bFbf{<1b2md\1972+'-@6X$4*-'-Z3$" 23:59:60"N}

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

विचार

हम के रूप में प्रत्येक छलांग दूसरा एन्कोडिंग से शुरू + डी - 2 * (1972 वाई) है, जहां विकास है 1 अगर यह दिसंबर में और होता है 0 अन्यथा।

सभी एन्कोडेड लीप सेकंड की सरणी है:

[0 1 3 5 7 9 11 13 15 18 20 22 26 31 35 37 40 42 44 47 50 53 67 73 80 86]

चलो इस सरणी को एल कहते हैं ।

चूंकि सरणी आरोही क्रम में है, इसलिए हम वास्तविक संख्याओं के बजाय लगातार अंतरों को संग्रहीत कर सकते हैं:

[1 2 2 2 2 2 2 2 3 2 2 4 5 4 2 3 2 2 3 3 3 14 6 7 6]

इस सरणी को आधार संख्या 15 के अंकों के रूप में मानते हुए, हम पूर्णांक प्राप्त करते हैं

19238985373462115979359619336

बेस 240 (वर्णों के लिए) में कौन से अंक हैं

~g¼K&Béx¸¦­Ø

कोड

26,             e# Push I := [0 ... 25].
"~g¼K&Béx¸¦­Ø"   e# Push the string from above.
240bFb          e# Convert from base 250 to base 15 to push L.
f{              e# For each J in I:
                e#   Push L.
  <             e#   Replace L with L[:J].
  1b            e#   Push the sum S of the integers in L[:J].
  2md           e#   Push (S / 2) and (S % 2).
  \1972+        e#   Add 1972 to (S / 2).
  '-@           e#   Push '-' and rotate (S % 2) on top.
  6X$4*-        e#   Compute (6 - 4 * (S % 2)).
  '-Z           e#   Push '-' and 3.
  3$            e#   Push a copy of (S % 2).
  " 23:59:60"   e#   Push that string.
  N             e#   Push a linefeed.
}
— डेनिस
स्रोत
28
यह महसूस करते हुए कि आपके पास एक बिल्ट है, लगभग पूरी तरह से समस्या को हल करता है और फिर भी सीजेएम में मैनुअल समाधान कम है।
— एलेक्स ए।
9
@AlexA। Mathematica में कुछ बिल्ट-इन हैं जिन्हें मैं Mathematica में कम बाइट्स में फिर से लागू कर सकता हूं ।
— मार्टिन एंडर
@ मार्टिनबटनर: क्रूर।
— एलेक्स ए।
35

आर, 78 75 बाइट्स

बिल्ट-इन, आप कहते हैं? कुंआ...

message(paste(as.Date(.leap.seconds)-1,"23:59:60\n"),"2015-06-30 23:59:60")

आर में एक स्वचालित चर .leap.secondsहोता है जिसमें सिस्टम के स्थानीय समय में दिए गए प्रत्येक लीप सेकंड प्रविष्टि की तारीख और समय होता है। आर संस्करण 3.2.0 के रूप में, इसमें आज शामिल नहीं है, इसलिए मैंने इसे मैन्युअल रूप से जोड़ा है।

असंगठित + स्पष्टीकरण:

# Convert the datetime values to UTC dates. These will be a day past the
# expected output, so we can subtract 1 to get what we want.
dates <- as.Date(.leap.second) - 1

# Paste the UTC time and a newline onto the end of each date
datetimes <- paste(dates, "23:59:60\n")

# Print each time, including today, on its own line
message(datetimes, "2015-06-30 23:59:60")

आप इसे ऑनलाइन आज़मा सकते हैं !

— एलेक्स ए।
स्रोत
यदि आप "23:59:60" को एक चर में असाइन कर सकते हैं, तो आप कुछ चार्ट बचा सकते हैं
— ऐसा नहीं है कि चार्ल्स
1
@ नॉचचार्ल्स: मैंने इसके बारे में सोचा था, लेकिन आर के तार संयोजन की विधि आज की तारीख और समय को कम करने के लिए पर्याप्त नहीं है। वैसे, इनपुट के लिए धन्यवाद!
— एलेक्स ए।
24

HTML, 594 बाइट्स

1972-06-30 23:59:60<br>1972-12-31 23:59:60<br>1973-12-31 23:59:60<br>1974-12-31 23:59:60<br>1975-12-31 23:59:60<br>1976-12-31 23:59:60<br>1977-12-31 23:59:60<br>1978-12-31 23:59:60<br>1979-12-31 23:59:60<br>1981-06-30 23:59:60<br>1982-06-30 23:59:60<br>1983-06-30 23:59:60<br>1985-06-30 23:59:60<br>1987-12-31 23:59:60<br>1989-12-31 23:59:60<br>1990-12-31 23:59:60<br>1992-06-30 23:59:60<br>1993-06-30 23:59:60<br>1994-06-30 23:59:60<br>1995-12-31 23:59:60<br>1997-06-30 23:59:60<br>1998-12-31 23:59:60<br>2005-12-31 23:59:60<br>2008-12-31 23:59:60<br>2012-06-30 23:59:60<br>2015-06-30 23:59:60

¯ \ _ (ツ) _ / ¯

— vijrox
स्रोत
6
@ Vioz- इस सवाल को kolmogorov-complexity टैग किया गया है और इसलिए यह पूरी तरह से कानूनी जवाब है। हालांकि जीतने की संभावना नहीं है ...
— डिजिटल ट्रॉमा
10
@mlepage यह "मानक खामियों" में से एक है।
— जैकब रायले
4
@Voitcus फ़ाइल में सहेजें, ब्राउज़र में खोलें। यह एक workinghtml कोड है
— edc65
9
@ AntonyD'Andrea हाँ, तो क्या? code golfचुनौतियों में बर्बरता का अनुरोध नहीं किया जाता है ।
— edc65
5
@anatolyg आप [kolmogorov-complexity] के लिए मज़ेदार नहीं हैं
— vijrox
11

सी, 160 146 141 140 बाइट्स

पहली बार पोस्टिंग, सुनिश्चित नहीं है कि "मानक कमियां" क्या हैं। मेरे पास निश्चित रूप से प्रिंटफ की चेतावनी है।

160 बाइट्स:

मूल विचार प्रति वर्ष दो बिट्स का उपयोग करके लीप सेकंड को एन्कोड करना है: एक जून के लिए और एक दिसंबर के लिए। एन्कोडिंग का उपयोग एक समय में एक बार आंतरिक जबकि लूप द्वारा किया जाता है। 128-बिट पूर्णांक के बिना, बाहरी जबकि लूप आवश्यक है। बाकी सब बहीखाता और गणित है। :-)

int main(){long long X=0x2495288454AAAB,Y=1972,Z=1;while(Y<2000){while(X){if(X&1)printf("%d-%02d-%d 23:59:60\n",Y,6*(2-Z),31-Z);Y+=Z^=1;X>>=1;}X=0x104082000;}}

141 बाइट्स:

सुझाए गए सुझावों को लागू करने से यह 146 बाइट्स के नीचे हो जाता है। तब मुझे बाहरी हालत को सरल बनाने का एक तरीका मिला (Y <2000 से सिर्फ Z तक), इसे 141 बाइट्स तक लाया। तो एक ट्वीट के करीब!

main(Z){long long X=0x2495288454AAAB,Y=1972;while(Z){while(X)X&1?printf("%d-%02d-%d 23:59:60\n",Y,12-6*Z,31-Z):1,Y+=Z^=1,X/=2;X=4362608640;}}

140 बाइट्स:

मैंने देखा कि दिन को नकारात्मक बनाकर तिथि में आने वाले डैश को समाप्त किया जा सकता है। जून में अग्रणी शून्य के कारण महीने के साथ ऐसा नहीं कर सकते। लेकिन कम से कम यह अब एक ट्वीट में फिट बैठता है!

main(Z){long long X=0x2495288454AAAB,Y=1972;while(Z){while(X)X&1?printf("%d-%02d%d 23:59:60\n",Y,12-6*Z,Z-31):1,Y+=Z^=1,X/=2;X=4362608640;}}

सुंदर संस्करण:

main(Z) {
    long long X = 0x2495288454AAAB, Y = 1972;
    while (Z) {
        while (X)
            X&1 ? printf("%d-%02d%d 23:59:60\n", Y, 12-6*Z, Z-31) : 1,
            Y += Z ^= 1,
            X /= 2;
        X = 4362608640;
    }
}

बोनस संस्करण:

मैंने बाहरी लूप को 64-बिट पूर्णांक को एक-दूसरे में बदलकर बाहरी लूप को समाप्त कर दिया, लेकिन यह 150 बाइट्स है, बल्कि लंबे "अहस्ताक्षरित लंबे" के कारण; अगर मैं "uint64" जैसे कुछ का उपयोग कर सकता हूं तो यह 138 बाइट्स होगा।

main(Z) {
    unsigned long long Y = 1972, X = 0x2495288454AAAB, W = 8520720;
    while (X)
        X&1 ? printf("%d-%02d-%d 23:59:60\n", Y, 12-6*Z, 31-Z) : 1,
        Y += Z^= 1,
        X = X/2 | (W>>=1)<<63;
}
— mlepage
स्रोत
4
PPCG में आपका स्वागत है। "स्टैंडर्ड लूपहोल्स" इस पोस्ट को संदर्भित करता है , लेकिन आम तौर पर इसका मतलब सिर्फ यह है कि "सामान्य ज्ञान का उपयोग करें और धोखा न दें"। :)
— मार्टिन एंडर
1
मुझे लगता है कि forलूप का उपयोग करने से कुछ बाइट्स बचेंगे। BTW, int main()-> main()। आपको यह बहुत मददगार लग सकता है ।
— स्पिकैट्रिक्स
इसके अलावा: X>>=1एक ही रूप में है X/=2, 6*(2-Z)के रूप में ही है 12-6*Z, और 4362608640की तुलना में एक बाइट में कम है 0x104082000। के intसामने main()अनावश्यक है, और यदि आप के लिए बदल main()जाते हैं main(Z)तो आप घोषणा को हटा सकते हैं Z=1।
— स्क्वीज़िश ossifrage
वास्तव में अच्छा समाधान- एक और बात जिसके बारे में आप सोच सकते हैं- जिसके if(X&1)printf(...);साथ आप बदल सकते हैं X&1?printf(...):1;1 बाइट
— euanjt
और बजाय while(X){...}अल्पविराम का उपयोग करें ताकि आप ब्रेसिज़ को हटा सकेंwhile(X)X&1?printf("%d-%02d-%d 23:59:60\n",Y,6*(2-Z),31-Z):1,Y+=Z^=1,X>>=1;
— euanjt
9

पायथन 3, 91

Sp3000 द्वारा एन्कोडिंग और स्ट्रिंग प्रारूपण का उपयोग करता है , लेकिन एक पायदान 3 बाइट ऑब्जेक्ट में मानों को एक जादुई संख्या के बजाय संग्रहीत करता है ।

for n in b'()+-/1357:<>BGKMPRTWZ]kqx~':print('%d-%02d-3%d 23:59:60'%(1952+n/2,n%2*6+6,n%2))

एन्कोडिंग को बाइट्स के 256 संभावित मूल्यों में से केवल 86 की आवश्यकता होती है, इसलिए इसे देखने योग्य बनाने के लिए मुद्रण योग्य वर्णों की एक श्रृंखला का उपयोग किया जाता है।

— XNOR
स्रोत
7

ब्रेनफक, 806

++++++++[>++++++>+++++++>+++++++>++++++>++++++>++++++>+++++++>++++++>++++++>++++++>++++>++++++>++++++>+++++++>+++++++>+++++++>+++++++>+++++++>++++++>+<<<<<<<<<<<<<<<<<<<<-]>+>+>->++>--->>-->--->+++>>>++>+++>++>--->+>++>-->>++[<]>[.>]<[<]>>>>>>+>---->>>+[<]>[.>]<[<]>>>>+[<]>[.>]<[<]>>>>+[<]>[.>]<[<]>>>>+[<]>[.>]<[<]>>>>+[<]>[.>]<[<]>>>>+[<]>[.>]<[<]>>>>+[<]>[.>]<[<]>>>>+[<]>[.>]<[<]>>>+>-------->>->++++>>>-[<]>[.>]<[<]>>>>+[<]>[.>]<[<]>>>>+[<]>[.>]<[<]>>>>++[<]>[.>]<[<]>>>>++>>+>---->>>+[<]>[.>]<[<]>>>>++[<]>[.>]<[<]>>>+>---------[<]>[.>]<[<]>>>>++>>->++++>>>-[<]>[.>]<[<]>>>>+[<]>[.>]<[<]>>>>+[<]>[.>]<[<]>>>>+>>+>---->>>+[<]>[.>]<[<]>>>>++>>->++++>>>-[<]>[.>]<[<]>>>>+>>+>---->>>+[<]>[.>]<[<]>+>--------->--------->---[<]>[.>]<[<]>>>>+++[<]>[.>]<[<]>>>+>------>>->++++>>>-[<]>[.>]<[<]>>>>+++[<]>[.>]

आप इसे इस ऑनलाइन दुभाषिया पर चला सकते हैं।

— पीटर ओल्सन
स्रोत
6

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

n=0x6697f252225354422533333330;y=1972
while n:print'%d-%02d-3%d 23:59:60'%(y,n%2*6+6,n%2);y+=n/2%8;n/=16

बेस एन्कोडिंग और अधिक बेस एनकोडिंग।

— Sp3000
स्रोत
5

GNU sed + दिनांक: 112

आम लिनक्स वितरण में निर्मित लीप सेकंड भी होते हैं। GNU सेड और दिनांक का उपयोग करना:

sed -n 's/^\([0-9]\+\).*/1899-12-31 \1sec/p' /usr/share/zoneinfo/leap-seconds.list|date -f- +"%Y-%m-%d 23:59:60"

GNU sed + दिनांक: 90

रास्ता काटकर कुछ पात्रों को सुरक्षित करना:

sed -n 's/^\([0-9]\+\).*/1899-12-31 \1sec/p' /u*/s*/z*/leap*|date -f- +'%Y-%m-%d 23:59:60'

टोबी स्पाइट द्वारा जीएनयू सेड + डेट ट्यून: 84

टिप्पणियों में गहराई से प्रस्तावित संस्करण:

sed -nr 's/^([0-9]+).*/date -d "1899-12-31 \1sec" "+%F 23:59:60"/ep' /u*/s*/z*/leap*
— जेन्स इरट
स्रोत
मुझे यह सिखाने के लिए धन्यवाद कि लीप-सेकंड डेटा कहां मिलेगा। दुर्भाग्य से, मेरी date(GNU 8.23) उन लोगों को अगले मिनट के पहले दूसरे के रूप में प्रदर्शित करती है। आप ऐसा क्या उपयोग कर रहे हैं जो 60 सेकंड के मिनट को समझता है?
— टोबे स्पाइट
जीएनयू कोरुटिल्स के साथ, मैंने इसे 76 तक नीचे कर दिया, -rझंडे के साथ बाइट्स शेपिंग, संशोधक के dateसाथ प्रतिस्थापन s///e, और इसके %Y-%m-%dसाथ प्रतिस्थापित किया %Fगया date: TZ = UTCsed -nr 's/^([0-9]+).*/date -d "1900-1-1 \1sec" "+%F %T"/ep' /u*/s*/z*/leap*
— टोबी स्पाइट नाइट
मुझे पता था कि मुझे कुछ याद है। लगता है कि इसे मैन्युअल रूप से निर्दिष्ट करने का कोई तरीका नहीं है, कम से कम अन्य समाधानों की तुलना में बदतर नहीं है। चलो देखते हैं कि क्या कोई उन तारीखों को ठीक से समर्थन करने के लिए कुछ तारीख पुस्तकालय के साथ आता है।
— जेन्स एराट जूल
मैं 1899-12-31 \1secतारीख के लिए उपयोग करके वहाँ गया था , और 23:59:60समय के रूप में हार्डकोडिंग :sed -nr 's/^([0-9]+).*/date -d "1899-12-31 \1sec" "+%F 23:59:60"/ep' /u*/s*/z*/leap*
— टोबे स्पाइट
3

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

`` के अंदर की नई रूपरेखा महत्वपूर्ण और गिनी जाती है।

परीक्षण करने के लिए, नीचे स्निपेट को चलाएं (केवल EcmaScript 6, Firefox के साथ)

alert([..."09:;=DEFIX[01234567?ABGJQS"].map((c,i)=>c.charCodeAt()+1924+(i>10?'-12-31':'-06-30')+' 23:59:60').sort().join`
`)
स्निपेट का विस्तार करें

— edc65
स्रोत
2

PHP, 198 बाइट्स

foreach([.5,1,2,3,4,5,6,7,8,9.5,10.5,11.5,13.5,16,18,19,20.5,21.5,22.5,24,25.5,27,34,37,40.5,43.5] as$d){$h=(int)$d-ceil($d);echo date("Y-m-d 23:59:60",mktime(0,0,0,-6*$h,31+$h,(int)$d+1972))."\n";}

दुर्भाग्य से, मुझे नहीं पता कि मैं \nतिथि फ़ंक्शन में सम्मिलित कर सकता हूं या नहीं । यदि हां, तो इसकी वजह से 3 बाइट्स कम हैं .""।

— Voitcus
स्रोत
आप दोनों (int)को हटा सकते हैं और कुछ व्हाट्सएप को हटा सकते हैं। दिनांक एक त्रुटि फेंकता है, यदि डिफ़ॉल्ट टाइमज़ोन सेट नहीं है, तो इसे एक के साथ मौन करें @। 187 बाइट्स:foreach([.5,1,2,3,4,5,6,7,8,9.5,10.5,11.5,13.5,16,18,19,20.5,21.5,22.5,24,25.5,27,34,37,40.5,43.5]as$d){$h=$d-ceil($d);echo@date("Y-m-d 23:59:60",mktime(0,0,0,-6*$h,31+$h,$d+1972))."\n";}
— ऑक्टफैक्स
2

8086 मशीन कोड + डॉस, 92 बाइट्स

कोड के Hexdump:

BE 3A 01 B1 57 D1 E0 75 03 AD EB F9 72 09 50 BA
47 01 B4 09 CD 21 58 BB 50 01 81 77 FC 01 04 80
37 01 80 3F 31 74 10 83 EB 05 4B FE 07 80 3F 3A
75 05 C6 07 30 EB F3 E2 CC C3 AA 2A 77 B5 6A DD
DF B6 BE FF 7D BF 31 39 37 32 2D 30 36 2D 33 30
20 32 33 3A 35 39 3A 36 30 0D 0A 24

चलाने के लिए, 92 बाइट्स को com-file में लिखें और 32-बिट विंडोज या डॉसबॉक्स के तहत चलाएं।

कोड 87 बिट्स के साथ बिटमैप का उपयोग करता है, प्रति वर्ष एक आधा। बिट्स को MSB से शुरू करके 16 के समूहों में व्यवस्थित किया जाता है।

बिटमैप को डिकोड करना:

                 ; when the program starts, ax=0 (tested on DOSBox)
myloop:
    shl ax, 1    ; shift the MSB left into the carry flag
    jnz mywork   ; if some bits are left in the register, work normally
    lodsw        ; if all bits were shifted out, load the next 16 bits
    jmp myloop   ; and check the MSB again

कोड की संरचना के कारण, कुछ बिट्स डिकोडिंग के दौरान खो जाते हैं, इसलिए मुझे उन्हें दोहराना पड़ा। यह दोहराव बिटमैप को फूला नहीं समाता क्योंकि मुझे 87 बिट्स को 96 बिट्स पर वैसे भी पैड करना था।

लीप सेकंड को प्रिंट करने (या प्रिंट नहीं) करने के बाद, आउटपुट संदेश के एएससीआईआई कोड पर जोड़तोड़ का उपयोग करते हुए, कोड को आधे साल तक बढ़ाता है।

स्रोत कोड (के साथ इकट्ठा किया जा सकता है tasm):

    mov si, offset mydata
    mov cl, 57h ; number of iterations

myloop:
    shl ax, 1   ; shift the MSB left into the carry flag
    jnz mywork  ; if some bits are left in the register, work normally
    lodsw       ; if all bits were shifted out, load the next 16 bits
    jmp myloop  ; and check the MSB again
mywork:
    jc myinc_date ; shifted bit 1? - skip printing the message

    push ax
    mov dx, offset mymsg
    mov ah, 9
    int 21h     ; print the message
    pop ax

myinc_date:
    mov bx, offset mymsg + 9 ; pointer to the middle of the message
    xor word ptr [bx - 4], 401h ; change month 06<->12
    xor byte ptr [bx], 1 ; change day 30<->31
    cmp byte ptr [bx], '1'
    je myloop_end ; if 31 December, no need to increase the year
    sub bx, 5 ; pointer beyond the last digit of the year

myinc_year:
    dec bx
    inc byte ptr [bx] ; increase the digit
    cmp byte ptr [bx], '0' + 10
    jne myloop_end ; if the digit was less than 9, done
    mov byte ptr [bx], '0' ; set the digit to 0
    jmp myinc_year ; continue increasing other digits

myloop_end:
    loop myloop
    ret ; terminate the program

; In the following bitmap, the spaces before some LSBs
; show that the least significant 1-bit and all
; following 0-bits are lost during decoding.
mydata:
    dw 02aaah ; 00101010101010     10
    dw 0b577h ; 101101010111011    1
    dw 0dd6ah ; 11011101011010     10
    dw 0b6dfh ; 101101101101111    1
    dw 0ffbeh ; 11111111101111     10
    dw 0bf7dh ; 101111110111110    1

mymsg:
    db '1972-06-30 23:59:60',13,10,'$'
— anatolyg
स्रोत
मैं इसका परीक्षण करना चाहूंगा, लेकिन मुझे कहीं भी एक भी संपादक नहीं मिल सकता है जो आपको हेक्स पेस्ट करने और बाइनरी फ़ाइल में सहेजने की अनुमति देता है।
— श्री लिस्टर
@ किसी भी सामान्य हेक्स संपादक को लाइक करें जो आपके लिए है।
— TheDoctor
1

पायथ - 88 84 बाइट्स

डेटा को संपीड़ित करने के लिए char को धर्मान्तरित करता है और 06-30बनाम 12-31डेटा को बाइनरी नंबर के रूप में बचाता है ।

jbm++-2047ed?"-06-30"hd"-12-31"" 23:59:60"C,j33678243 2CM"KKJIHGFEDBA@><:9765421*'#

(वहाँ एक जगह है अंत में)

इसे यहाँ ऑनलाइन प्रयास करें ।

— Maltysen
स्रोत
1

पायथन 2, 123 121 116 114 111

मैं इसे बहुत छोटा पाने में कामयाब रहा, लेकिन मुझे यकीन नहीं है कि यह कितना छोटा हो सकता है। मैंने उपयोग करने की कोशिश की exec, लेकिन स्वरूपण बहुत महंगा हो जाता है।

मैंने लिंक किए गए विकिपीडिया पृष्ठ से तालिका के आधार 16 एन्कोडिंग का उपयोग किया।

संपादित करें: हेक्स एन्कोडिंग का उपयोग बेस 36 से कम है (कम गोल्फ संस्करण देखें)।

इसे यहाँ आज़माएँ

n=0x410208002495288454aaab
for i in range(88):
    if n%2:print"%d-%02d-3%d 23:59:60"%(1972+i/2,i%2*6+6,i%2)
    n/=2

कम गोल्फ वाला:

s=bin(int('WELD24ZDGIMBWWLFM',36))[2:]
for i in range(44):
    t,s=int(s[0]),s[1:]
    if t:print"%d-06-30 23:59:60"%(i+1972)
    t,s=int(s[0]),s[1:]
    if t:print"%d-12-31 23:59:60"%(i+1972)
— mbomb007
स्रोत
1

सी, 155 149 147 बाइट्स

यहां सी में एक और दृष्टिकोण है, स्ट्रिंग्स का उपयोग करना और लंबाई एन्कोडिंग चलाना। मेरे अन्य सी समाधान के रूप में काफी नहीं है, लेकिन शायद इसमें सुधार किया जा सकता है?

155 बाइट्स:

महीने / दिन के लिए एक स्ट्रिंग का उपयोग करना।

main(Y){Y=1972;char*M="06-3012-31",*B="#@DGCDF7D3daTdS#!",b,c;while(b=*B++-33){c=b>>1&7;while(c--)printf("%d-%.5s 23:59:60\n",Y++,M+b%2*5);Y+=(b>>4&7)-1;}}

149 बाइट्स:

महीने / दिन की स्ट्रिंग को खत्म करना।

main(Y){Y=1972;char*B="#@DGCDF7D3daTdS#!",b,c;while(b=*B++-33){c=b>>1&7;while(c--)printf("%d-%02d-%d 23:59:60\n",Y++,6+b%2*6,30+b%2);Y+=(b>>4&7)-1;}}

147 बाइट्स:

साल की शुरुआत को खत्म करना।

main(Y){char*B="#@DGCDF7D3daTdS#!",b,c;while(b=*B++-33){c=b>>1&7;while(c--)printf("%d-%02d-%d 23:59:60\n",1971+Y++,6+b%2*6,30+b%2);Y+=(b>>4&7)-1;}}

144 बाइट्स:

अगर मैं रन से पहले (बाद में नहीं) छोड़ें गणना लागू करने के लिए बफर को फिर से लोड करता हूं, तो मैं बाहरी बयानों को लूप करते समय पुन: व्यवस्थित कर सकता हूं, कॉमा ऑपरेटर का उपयोग कर सकता हूं, और ब्रेस को खत्म कर सकता हूं, 2 बाइट्स बचा सकता हूं।

मैं दिन को नकारात्मक (मेरे अन्य समाधान में) बनाकर एक और बाइट बचा सकता हूं।

सुंदर हे:

main(Y) {
    char *B = "#@DGCDF7D3daTdS#!", // buffer of bytes encoding runs
         b, // current byte
         c; // current count
    while (b = *B++-33) { // get byte
        c = b>>1&7; // get count
        while (c--) printf("%d-%02d-%d 23:59:60\n", 1971+Y++, 6+b%2*6, 30+b%2); // run
        Y += (b>>4&7)-1; // skip years
    }
}

स्पष्टीकरण:

रन बाइट्स में एन्कोडेड होते हैं। प्रत्येक बाइट में यह कहने के लिए एक बिट होता है कि यह जून या दिसंबर है, लंबाई की गिनती के लिए 3 बिट्स, स्किप काउंट के लिए 3 बिट्स और 1 अप्रयुक्त उच्च बिट।

स्किप काउंट एक रन के बाद छोड़ने के लिए वर्षों की संख्या है; 1972 में दो लीप सेकंड के लिए अनुमति देने के लिए यह -1 से ऑफसेट है। लंबाई एक रन में कितने साल है; यह शायद +1 द्वारा ऑफसेट किया जा सकता है लेकिन यह वर्तमान में नहीं है।

तो एक बाइट का अर्थ है: "लीपहट वर्षों के जून (या DECEMBER) वर्षों के लीप सेकंड, फिर अगले बाइट पर जाने से पहले SKIP-1 वर्ष को छोड़ दें"।

बाइट्स को पठनीय बनाने और फैंसी एन्कोडिंग से बचने के लिए 33 से ऑफसेट किया जाता है।

इसका अर्थ यह है कि हालांकि हमारे पास 1998-2005 को कवर करने के लिए पर्याप्त स्किप बिट्स हैं, हम ASCII सीमा से बाहर हैं, इसलिए हमारे पास एक अतिरिक्त शून्य लंबाई है। इसके अलावा, 1979 अपने आप प्रकट होता है क्योंकि 1972-1979 की लंबाई बहुत लंबी है।

बाइट्स में पर्याप्त बिट्स हैं, इसलिए उन मुद्दों को अंततः ठीक किया जा सकता है।

— mlepage
स्रोत
1

q / kdb +, 95 94 93 बाइट्स

asc 1_" "0:([]raze("DEFGHIJKSUV[^eh";"DMNOQXYZ]lo"){("d"$"m"$-12*95-6h$x)-y}'1 185;`23:59:60)

व्याख्या

प्रत्येक वर्ष + 1 के लिए , ASCII वर्ण के रूप में 1905 से वर्षों के लिए सांकेतिक शब्दों में बदलना, उदाहरण के लिए:

1972 -> 1973 -> 68 -> D

6h$xपर "D"वापस जाता है 68। चूंकि qतिथि की अवधि है 2000.01.01, हम 95पूर्णांक-टू-डेट रूपांतरण को घटाते और निष्पादित करते हैं "d"$"m"$-12*95-6h$x।

हम + 1 ऊपर का कारण वास्तविक वर्ष के 31 दिसंबर या 30 जून को प्राप्त करने के लिए अगले वर्ष की शुरुआत से दिनों की संख्या को घटाना है , अर्थात् 1 या 185 दिन। इसलिए, दिसंबर में एक छलांग के साथ वर्षों का प्रतिनिधित्व करता है, और जून में उन लोगों के लिए। जोड़ी-घटाव के माध्यम से किया जाता है , जहां और साल कि द्वारा घटा दिए जाएंगे रहे हैं और क्रमश: दिनों की संख्या।"DEFGHIJKSUV[^eh""DMNOQXYZ]lo"(a;b){x-y}'(c;d)abcd

" "0:([]...)एक छोटी सी चेतावनी के साथ एक कॉलम हेडर उत्पन्न किया जाएगा, हमें सही स्वरूपण देने के लिए परिणाम तैयार करता है। 1_उस हेडर को ड्रॉप करता है और अंत ascमें ऑर्डरिंग को सही करने के लिए आवेदन करता है।

संपादित करें : 100 के बजाय 95 वर्षों को घटाने के लिए 'पुनः आधार' (1 वर्ण को बचाने)।

2 संपादित करें : पूर्णांक-टू-डेट रूपांतरण फ़ंक्शन के अंदर ऑपरेंड की स्थिति को फिर से आदेश देना।

— hjk
स्रोत
1

पायथन, 204 201

e,g,h=0,1972,0
for i in range(1,27):e,g,h={2:1,9:2,10:1,12:2,15:1,16:2,17:1,20:2,21:1,22:7,23:3,24:4,25:3}.get(i,e),g+e,(h,1-h)[i in[2,10,14,17,20,21,22,25]];print`g`+("-06-30","-12-31")[h]+" 23:59:60"

आप इसके साथ repl.it पर खेल सकते हैं ।

संपादित करें: पूरी तरह से पीटा! संपीड़न जवाब आश्चर्यजनक कम हैं।

— सुडो rm -rf स्लैश
स्रोत
हैरानी की बात है, समान एल्गोरिथ्म का उपयोग करते हुए , मेरा PHP एवियर छोटा है। मैंने हमेशा उम्मीद की है कि पायथन अधिक कॉम्पैक्ट होगा। शायद आप इसे थोड़ा और गोल्फ कर सकते हैं?
— Voitcus
मैं एक नजर मार लूगां। मुझे लगता है कि सबसे अच्छा मार्ग हालांकि संपीड़न है, और अन्य लोग पहले ही कर चुके हैं कि
— sudo rm -rf स्लैश
0

PHP, 164 बाइट्स

foreach([.5,1,2,3,4,5,6,7,8,9.5,10.5,11.5,13.5,16,18,19,20.5,21.5,22.5,24,25.5,27,34,37,40.5,43.5]as$d){echo(ceil($d)+1971).($d%2?'-12-31':'-06-30')." 23:59:60\n";}

यह @ Voitcus के विचार पर केवल कुछ संशोधन है

— pranzer
स्रोत
0

पायथन, 221 217

def d(x):
 q=x%10
 if x%2==0:
  p,r=q/2,"06-30"
 else:
  p,r=(q-1)/2,"12-31"
 return"%d%d-%s 23:59:60"%(p+197,x/10,r)
for x in [20,21,31,41,51,61,71,81,91,12,22,32,52,73,93,5,24,34,44,55,74,85,57,87,28,58]:print(d(x))

कुछ अंतर्दृष्टि

असल में, d(x)एक 2-अंकीय पूर्णांक से 3 पूर्णांक के एक वेक्टर को विघटित करता है। d(x)इसका उलटा फ़ंक्शन (26 लीप सेकंड डेटेटाइम पर) के रूप में बनाया गया है c(v), जो बदले में एक संपीड़न फ़ंक्शन है जो 3-अपल जैसे (1998,12,31) को 85 जैसी संख्या में बदल देता है। सूची प्राप्त करने के लिए [20] , 21 ... 28,58] मैंने यह पुष्टि करने के लिए एक अन्य एल्गोरिदम तैयार किया कि संपीड़न फ़ंक्शन डोमेन पर विशेषण है। यही है, मैंने यह सुनिश्चित किया कि निम्न कार्यक्रम डुप्लिकेट का उत्पादन नहीं करता है, और मैंने इसके आउटपुट का उपयोग कार्यक्रम की सूची के रूप में किया है।

dates = [(1972,06,30),
    (1972,12,31),
    (1973,12,31),
    (1974,12,31),
    (1975,12,31),
    (1976,12,31),
    (1977,12,31),
    (1978,12,31),
    (1979,12,31),
    (1981,06,30),
    (1982,06,30),
    (1983,06,30),
    (1985,06,30),
    (1987,12,31),
    (1989,12,31),
    (1990,12,31),
    (1992,06,30),
    (1993,06,30),
    (1994,06,30),
    (1995,12,31),
    (1997,06,30),
    (1998,12,31),
    (2005,12,31),
    (2008,12,31),
    (2012,06,30),
    (2015,06,30)]

def c(v):
    x = (v[0] % 10) * 10
    x += v[2] % 30
    x += 2 * (int(v[0] / 10) - 197)
    return x

for v in dates:
    print(c(v))

c(v)एक बहुत ही सरल योजना का उपयोग करके संपीड़न फ़ंक्शन को विशेषण के रूप में डिजाइन किया गया था। एक उदाहरण के रूप में लेते हैं (1998,12,31)।

  • अभिव्यक्ति (V [0]% 10) * 10 चयन साल की इकाइयों (जैसे 1 9 9 8 -> 8) और यह निर्गम (अब एक्स = 80) की दसवां अंकों बनाता है।
  • केवल दो महीने का दिन संयोजन होता है जिसमें छलांग दूसरी बात होती है, इसलिए मैंने 06,30 मामले और 12,31 मामले के बीच अंतर करने के लिए दिन के घटक का उपयोग करने का निर्णय लिया। अभिव्यक्ति v [२]% ३० ० है यदि दिन ३० है, और १ अगर दिन ३१ है तो। हमारे उदाहरण में, हम १ से x जोड़ते हैं (इसलिए, अब x = .१)।
  • अंत में, मैंने देखा कि इस पहेली में केवल 5 दशक शामिल हैं; इसलिए अगर मैं पहले दशक (सत्तर के दशक) को 0 और आखिरी दशक (2010 के दशक) से 4 तक मैं ठंडा सामान कर सकता हूं। अधिक विशेष रूप से, अगर 0,1,2,3,4 के मानचित्रण के बजाय मैं 0,2,4,6,8 पर मैप करता हूं, तो मैं इस मान को x की इकाइयों में जोड़ सकता हूं, जो कि पिछले नियम के कारण या तो 0 है या 1. तो अंत में हमारे पास यह भी है कि यह अंतिम कदम जीवनी को खराब नहीं करता है, और हमें लगता है कि 06,30 मामले की इकाइयाँ 0,2,4,6,8 में से एक हैं और एक की इकाइयाँ 12,31 मामले 1,3,5,7,9 में से एक हैं। इसलिए आक्षेप स्पष्ट है। हमारे उदाहरण में, 1998 तीसरे दशक (70s-> 0, 80s-> 1, 90s-> 2) में है, इसलिए हम 2 * 2 = 4 जोड़ते हैं। तो हमें x = 85 मिलता है।

मैंने यह सत्यापित करने के लिए कार्यक्रम लिखा कि यह सच है, और फिर मैंने d(x)इसका उलटा परिभाषित किया c(v)। हमारे उदाहरण में, c ((1998,12,31)) 85 और d (85) सही ढंग से प्रिंट है 1998-12-31 23:59:60।

— damix911
स्रोत
1
निकालें q=x%10और हर जगह qसे बदलें x%10। यह छोटा है। मैं यहां आपके कार्यक्रम पर कुछ अतिरिक्त गोल्फिंग का एक उपयोगी विवरण भी देता हूं । मैं पायथन पेज में गोल्फिंग के लिए टिप्स देखने की सलाह देता हूं ।
— mbomb007
यह कोड-गोल्फ है , इसलिए आपको किसी भी तरह से अपने कोड की लंबाई कम करने की कोशिश करनी चाहिए।
— mbomb007
-1

gzip, 114 बाइट्स

Hexdump:

1f8b080853f9975502006c006dd04b0a80300c84e1bde01dbc40218fa6697aff8309e2a6fa6f3f86cc10adb426a3b95ce62b6a0d398f07d59aeb8e4ed80983701026e1242cc0a9307e1aa11306615211b59710527b3961270cba9994fc7fc944829092faeedc313e7803993cfafb20020000

ऊपर वर्णित बाइट्स के साथ एक फ़ाइल बनाएँ।

"एल" नामक एक नई फ़ाइल प्राप्त करने के लिए गनज़िप या एक अन्य विघटन कार्यक्रम का उपयोग करके निकालें। इस फ़ाइल में वांछित आउटपुट है।

— स्टेफ हेयानाथ
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.