क्या मेरा दूध निकल गया है?

Question

Aww, यार, यह एक्सपायरी डेट अक्षरों के साथ महीने नहीं लिखता है! मैं यह नहीं बता सकता कि यह 10 मार्च या 3 अक्टूबर को समाप्त हो रहा है ... रुको, नहीं, कोई बात नहीं, वर्ष 2012 कहता है। (गली-कूचों में पनीर की आधी-आधी ईंट का इस्तेमाल प्रो जैसे कर सकते हैं)

तो चलिए एक पल के लिए मान लेते हैं कि आप बहुत व्यस्त रहने की कोशिश कर रहे हैं जब मारिनारा का यह जार समाप्त होने वाला है। आप बस क्लिफ नोट्स संस्करण चाहते हैं: यह संभावना है कि यह पिछले कारण है? कुछ कोड लिखते हैं!

आप जानते हैं कि निर्माता पूर्णांकों के एक तीन गुना के क्रम में तारीख को प्रिंट करते हैं:

YEAR  MONTH DAY
MONTH DAY   YEAR
DAY   MONTH YEAR

और आप जानते हैं कि कुछ तिथियों की व्याख्या केवल एक या दो तरीकों से की जा सकती है, तीनों में नहीं: 55 में 55-11-5एक वर्ष होना है, जिसका अर्थ है कि ट्विंकीज़ का यह विशेष बॉक्स 5 नवंबर, 1955 को समाप्त हो गया है। वर्ष कभी-कभी चार अंकों में दिया जाता है और दो नहीं, जो कुछ विकल्पों को खारिज कर सकते हैं। जब यह दो अंक है, हालांकि, 50..99 का मतलब 1950..1999 और 0..49 का मतलब 2000..2049 है।

आपका काम एक प्रोग्राम या फ़ंक्शन लिखना है जो पूर्णांकों की एक सरणी लेता है जो ऊपर दिए गए व्याख्याओं में से कम से कम एक मान्य तिथि है, और एक प्रतिशत संभावना को आउटपुट करता है यह अभी भी अच्छा है। प्रतिशत मौका बस उस तारीख की वैध व्याख्याओं का प्रतिशत है जो आज की तारीख से या बाद में है।

पूर्णांक की सरणी आपकी भाषा की [Int]लंबाई तीन होगी यदि यह एक फ़ंक्शन का तर्क है, और इसे डैश के रूप में दिया गया है-, स्लैश- या स्थान-अलग (आपको लेने के लिए) पूर्णांक यदि किसी इनपुट पर STDIN के रूप में उपयोग किया जाता है पूरा कार्यक्रम। *

"आज की तारीख" आज की वास्तविक तारीख हो सकती है, जैसा कि एक तिथि समारोह, या एसटीडीआईएन में कार्य करने के लिए एक अतिरिक्त तर्क या अतिरिक्त पैरामाटर में दी गई तारीख। यह यूनिक्स युगों के सेकंड में हो सकता है, एक और साल-महीने का दिन ऊपर तीन तरीकों में से एक में प्रवेश किया, या एक और अधिक सुविधाजनक फैशन।

चलो कुछ उदाहरण हैं! समाप्ति तिथि इनपुट डैश-अलग शैली में होगी, और नीचे दिए गए उदाहरणों के लिए मान लें कि आज की तारीख 5 जुलाई, 2006 है।

• 14-12-14- इस (DMY और YMD) के लिए दोनों मान्य व्याख्याएं 14 दिसंबर 2014 के बराबर हैं। आउटपुट 100 है क्योंकि यह उत्पाद निश्चित रूप से अच्छा है।
• 8-2-2006- अंतिम संख्या एक वर्ष है, निश्चित रूप से, क्योंकि इसके चार अंक हैं। यह या तो 8 फरवरी (समाप्त हो गया) या 2 अगस्त (अभी भी अच्छा) हो सकता है। आउटपुट 50 है ।
• 6-7-5- यह कुछ भी हो सकता है! "5 जुलाई, 2006" की व्याख्या अभी भी अच्छी है (केवल एक दिन के लिए), लेकिन शेष दो 2005 में दोनों हैं और जितनी जल्दी हो सके फेंक दिया जाना चाहिए। आउटपुट 33 है ।
• 6-5-7- यहाँ, तीन व्याख्याओं में से दो सुरक्षित हैं। आप अपने दशमलव को ऊपर या नीचे गोल कर सकते हैं, इसलिए 66 या 67 दोनों ठीक हैं।
• 12-31-99- ठीक है, यह एक शताब्दी के मोड़ से असंदिग्ध रूप से है (50 से 99 तक वर्ष 19XX हैं, और 31 संभवतः एक महीना नहीं हो सकता है)। एक बड़ा वसा 0 , और आपको वास्तव में अपने फ्रिज को अधिक बार साफ करना चाहिए।

आप सुरक्षित रूप से मान सकते हैं कि कोई भी इनपुट जो उपरोक्त मानकों को पूरा नहीं करता है, ऊपर दिए गए आउटपुट नियमों के लिए निजी नहीं है।

कोई वेब अनुरोध या मानक कमियां नहीं। दिनांक हैंडलिंग पुस्तकालयों की अनुमति है। यह कोड गोल्फ है: सबसे कम कार्यक्रम की जीत हो सकती है।

* ^{यदि आप ब्रेनफक या कुछ इसी तरह के डेटाटाइप-हैंडीकैप्ड भाषा का उपयोग कर रहे हैं, तो आप मान सकते हैं कि इनपुट में पहले तीन अक्षरों के एएससीआईआई मान तारीख के लिए पूर्णांक हैं। यह चार अंकों के वर्ष के तर्क को बाहर करता है, निश्चित रूप से, लेकिन मुझे लगता है कि हम आपको इसके लिए थोड़ा सा ब्रेनफक में इसका हल देखकर बहुत चकित होंगे।}

Comments

उम्म ... चालू वर्ष 2014 है, 2006 नहीं। आपका दूध आठ साल का है, इसकी समाप्ति सबसे अच्छी है।

— जॉन ड्वोरक

@JanDvorak मैं सिर्फ सार्थक उदाहरणों का निर्माण करने की बहुत कोशिश नहीं करना चाहता था, इसलिए मैंने इसे आसान बनाने के लिए आज की तारीख को बदल दिया।

— एलगोरिदमशार्क

@ Dgrin91 परवाह नहीं है, मैं अभी भी उन्हें खाऊंगा: D

— aditsu

ऑस्ट्रेलिया में, दूध का उपयोग तिथि से एक सप्ताह पहले समाप्त होता है

— gnibbler

आपको इसमें 00 के साथ एक परीक्षण जोड़ना चाहिए, क्योंकि यह एक कानूनी दिन या महीना नहीं हो सकता है।

— माउंटन व्यूमार्क

Answer 1

k4 (90) (88) (87) (82)

{100*(+/~d<x)%3-+/^d:{"D"$"."/:$|z,y,x+(x<100)*100*19+x<50}.'y@/:3 3#.:'$21020101}

साथ आह्वान xका .z.Dआज की तुलना, या एक तारीख अपनी पसंद का शाब्दिक अन्यथा के लिए (अंतर्निहित):

  f:{100*(+/~d<x)%3-+/^d:{"D"$"."/:$|z,y,x+(x<100)*100*19+x<50}.'y@/:3 3#.:'$21020101}
  .z.D f'(14 12 14;8 2 2006;6 7 5;6 5 7;12 31 99)
100 0 0 0 0f
  2006.07.05 f'(14 12 14;8 2 2006;6 7 5;6 5 7;12 31 99)
100 50 33.33333 66.66667 0

यह मूल रूप से @ एलेक्स-एल के पायथन समाधान का एक बंदरगाह है, जिसमें कुछ विविध गोल्फ ट्रिक्स जोड़े गए हैं:

• पुनर्व्यवस्था निर्देश एक युगल वर्णों को बचाने के लिए एक स्ट्रिंग में एन्कोड किए गए हैं।
• सशर्त तर्क (ab) सत्य के रूप में पूर्णांक (लेकिन पायथन समाधान से एक अलग तरीके से) का उपयोग करता है।
• वैधता परीक्षण थोड़ा अलग है - k4 / q खुशी से किसी भी डेटाटाइप में किसी भी स्ट्रिंग को पार्स करेगा; अगर यह समझ में नहीं आता है तो यह बस एक अशक्त देता है। इस प्रकार, मैं आंतरिक फ़ंक्शन से तिथियों की एक सूची लौटाता हूं, जो शून्य हो सकती है या नहीं।
• अंतिम परिणाम यह जांचने से आता है कि संभावित तारीख व्याख्याओं में से कितने शून्य हैं; तुलना तिथि से कितने कम हैं; यहां यह महत्वपूर्ण है कि अशक्त तिथि किसी भी अन्य तिथि से कम मानी जाती है।

Comments

आप पिछले 4 को हटाकर एक चर को बचा सकते हैं "012201210", क्योंकि #इसके आइटम को चक्रीय रूप से लिया जाता है। वास्तव में, आप पिछले दो मामलों की अदला-बदली करके इस तरह से एक दूसरा चार्ट बचा सकते हैं 3 3#.:'"0122102":।

— एल्गोरिथमशार्क

भीतरी फफूंद के आर्गन को उलट कर एक और चार को शेव किया, जिससे परों को बचाया (लेकिन उल्टा जोड़ दिया गया)। क्या कोई मुझे एक और दो वर्ण बचाने में मदद कर सकता है? एपीएल मुझे पीट रहा है!

— हारून डेविस

अंत में गणित को फिर से लिखकर एक और पाँच को शेव किया। लीड में वापस!

— आरोन डेविस

और अगर मैं गंभीरता से गैर-कार्यात्मक कोड लिखने के लिए रुकता हूं, तो मैं वैश्विक नाम स्थान को प्रदूषित करके एक और बाइट दाढ़ी कर सकता हूं {c*(+/~d<x)%3-+/^d:{"D"$"."/:$|z,y,x+(c*19+x<50)*x<c::100}.'y@/:3 3#.:'$21020101}:।

— एरोन डेविस

Answer 2

रूबी, 115 वर्ण

f=->a,t{[a,a.rotate(~s=r=0),a.reverse].map{|x,*y|(t>Time.gm(x<100?x+2e3-100*x/=50:x,*y)||r+=100
s+=1)rescue p}
r/s}

यह एक फ़ंक्शन को परिभाषित करता है fजो दो तर्क लेता है: एक सरणी जिसमें इनपुट होता है, और "आज की" तारीख।

उदाहरण:

f[[14,12,14], Time.new]
100
f[[8,2,2006], Time.new]
0
f[[8,2,2006], Time.new(2006, 7, 5)]
50
f[[6,7,5], Time.new(2006, 7, 5)]
33

Answer 3

पायथन 2.7 - 172

मैं डेटटाइम और तारीखों की तुलना के लिए डेटाटाइम मॉड्यूल का उपयोग करता हूं। यदि dateइनपुट से वैध डेटाइम नहीं बनाया जा सकता है, तो यह बढ़ जाता है ValueError। यह तरीका sगैर-समाप्‍त तारीखों का योग है और tवैध तिथियों की कुल संख्‍या है। मैं इस तथ्य का लाभ उठा रहा हूं कि True == 1पायथन में जोड़ और अनुक्रमण के प्रयोजनों के लिए। मैं (1900,2000) के बजाय 25 * (76,80) का उपयोग करके एक चरित्र को भी बचाता हूं।

नोट करें कि दूसरे स्तर के इंडेंटेशन में लाइनें 2 अक्षरों का नहीं बल्कि टैब कैरेक्टर का उपयोग करती हैं।

def f(e,c,s=0,t=3):
 for Y,M,D in(0,1,2),(2,0,1),(2,1,0):
  y=e[Y]
  try:s+=date(y+25*[[76,80][y<50],0][y>99],e[M],e[D])>=c
  except:t-=1
 return 100*s/t

परीक्षण के लिए इसे अंत में जोड़ें:

examples = [[14,12,14],[8,2,2006],[6,7,5],[6,5,7],[12,31,99]]
for e in examples:
 print f(e, date(2006,7,5))

Answer 4

पॉवरशेल, 183 173 168

[int](100*(($d=@(($a,$b,$c=$args[0]),($c,$a,$b),($c,$b,$a)|%{$_[0]+=1900*($_[0]-le99)+100*($_[0]-le49)
.{date($_-join'-')}2>$x}|sort -u))-ge(date)+'-1').Count/$d.Count)

• इनपुट int[]पैरामीटर के माध्यम से, उदाहरण के लिए

  PS> ./milk.ps1 5,6,7
  

• त्रुटि संदेशों को try/ के माध्यम से चुप कराया जाता है catch, जब तक कि मुझे नहीं पता है कि stderr पर आउटपुट की अनुमति है या नहीं।
• +"-1"दिनांक का उपयोग करना , जिसकी व्याख्या .AddDays(-1)वर्तमान तिथि को एक दिन में स्थानांतरित करने के लिए की जाती है, ताकि हम कल (आज के बजाय) की तुलना कर सकें। यह उस समस्या को हल करता है जो हमें समय के साथ 0:00 के साथ मिलती है लेकिन आज से समय के साथ तुलना करने की आवश्यकता है।
• अब तक भारी है
• त्रुटियों को शांत करने के लिए एक नई ट्रिक का उपयोग करना जो थोड़ा कम है

Answer 5

आर, 269

मैं आर में आसान होने की उम्मीद कर रहा था, लेकिन एकल-अंक के वर्षों में एक बहुत बड़ा करबॉल था। मुझे ऐसा लगता है कि यह इससे बेहतर हो सकता है।

lubridateCRAN से एक पैकेज है, आपको इसे स्थापित करना पड़ सकता है install.packages("lubridate")।

require(lubridate)
f = function(d){
d=sapply(d,function(l)if(nchar(l)==1)sprintf("%02d",l)else l)
d=paste0(d,collapse="-")
t=ymd(Sys.Date())
s=na.omit(c(ymd(d),mdy(d),dmy(d)))
s=lapply(s,function(d){
if(year(d)>2049){year(d)=year(d)-100;d}
else d})
sum(s>t)/length(s)}

उपयोग: f(c(d1,d2,d3))जहां c(d1,d2,d3)पूर्णांक का एक वेक्टर है।

जैसे f(c(6,10,14))रिटर्न 0.3333333।

lubridateपैकेज विभिन्न क्रम में दिनांक पार्स करने के लिए आवरण कार्यों की एक श्रृंखला है। मैं इनका उपयोग यह देखने के लिए करता हूं कि कौन से प्रारूप मान्य तिथियों का उत्पादन करते हैं, अमान्य लोगों को बाहर निकालते हैं, और फिर देखते हैं कि कौन से अभी तक नहीं हुए हैं।

Answer 6

गणितज्ञ, 163 153 164 बाइट्स

( संपादित करें: 1950 - 2049 रेंज के बाहर की निश्चित तारीखें)

f=100.Count[#,x_/;x<1]/Length@#&[DateDifference[#,Date[]]&/@Cases[{If[#<100,Mod[#+50,100]+1950,#],##2}&@@@{{##},{#3,#2,#},{#3,#,#2}}&@@#,d_/;DateList@d~Take~3==d]]&

यह एक फ़ंक्शन को परिभाषित करता है जिसे आप पसंद कर सकते हैं

f[{6,7,5}]

वर्तमान में, प्रतिशत गोल नहीं है (ओपी के स्पष्ट होने की प्रतीक्षा)।

यहाँ एक से थोड़ा लंबा स्पष्टीकरण यह है कि किसी भी मेथेमेटिका ज्ञान के बिना समझने योग्य होने चाहिए (ध्यान दें कि है &सब कुछ इसके बारे में छोड़ दिया एक गुमनाम समारोह जिसका मापदंडों रूप में भेजा जाता बनाता है #, #2, #3...):

{{##},{#3,#2,#},{#3,#,#2}}&

यह एक फ़ंक्शन को परिभाषित करता है, जो 3 मापदंडों a,b,cको 3 सूचियों में बदल देता है {{a,b,c},{c,b,a},{c,a,b}। ध्यान दें कि ##सभी मापदंडों का सिर्फ एक क्रम है।

{{##},{#3,#2,#},{#3,#,#2}}&@@#

समाप्ति की तारीख के लिए लागू, यह {y,m,d}तीन संभावित क्रमपरिवर्तन में से प्रत्येक के लिए एक सूची देता है ।

{If[#<100,Mod[#+50,100]+1950,#],##2}&

यह एक अनाम फ़ंक्शन है जो तीन मापदंडों को लेता है a,b,cऔर तीनों की सूची लौटाता है, जहां पहले दिए गए नियमों के अनुसार एक वर्ष में परिवर्तित किया गया है: 50और 99(modulo 100) के बीच की संख्याओं को 20 वीं शताब्दी के वर्ष में बदल दिया जाता है, 0और 49(के बीच की संख्या ) modulo 100) को 21 वीं सदी के वर्ष में बदल दिया जाता है, अन्य सभी को छोड़ दिया जाता है। यहाँ, ##2दूसरे के साथ शुरू होने वाले मापदंडों का एक क्रम है, अर्थात b,c।

{If[#<100,Mod[#+50,100]+1950,#],##2}&@@@{{##},{#3,#2,#},{#3,#,#2}}&@@#

पिछले तीन परिणामों में से प्रत्येक पर लागू होता है, यह सिर्फ वर्ष स्वरूपों को कैनोनिकलिज़ करता है। चलिए canonicalDatesइसे निम्नलिखित अभिव्यक्ति को छोटा करने के लिए कहते हैं :

Cases[canonicalDates,d_/;DateList@d~Take~3==d]

यह अमान्य व्याख्याओं को फ़िल्टर करता है। विभिन्न तिथियों के प्रारूप में DateList@dपूर्ण {y,m,d,h,m,s}प्रतिनिधित्व करता है। यह उसी क्रम में सूचियों की व्याख्या करेगा, लेकिन पकड़ यह है कि आप इसे चीजों को पारित कर सकते हैं जैसे कि यह {8,2,2006}किस मामले में गणना करेगा 8 years + 2 months + 2006 days। इसलिए हम जांचते हैं कि लौटी हुई सूची के पहले तीन तत्व इनपुट के समान हैं (जो कि केवल उचित रेंज में महीना और दिन होने पर ही हो सकता है)।

निम्नलिखित पंक्तियों को छोटा करने के लिए, मैं उस अभिव्यक्ति के परिणाम को validDatesअभी से देखूंगा:

DateDifference[#,Date[]]&

एक और अनाम फ़ंक्शन जो एक तारीख लेता है और आज (दिनों से प्राप्त Date[]) के दिनों में अंतर लौटाता है ।

DateDifference[#,Date[]]&/@validDates

मान्य दिनांक व्याख्याओं पर मानचित्र।

100.Count[#,x_/;x<1]/Length@#&

फिर भी एक अन्य अनाम फ़ंक्शन, जो एक सूची ( #) दिया गया है , उस सूची में गैर-सकारात्मक संख्याओं का प्रतिशत लौटाता है। .एक गुणा लेकिन सिर्फ दशमलव अंकों, परिणाम के रूप में तर्कसंगत संख्याओं से बचने के लिए नहीं है (आप की तरह बातें करता हूँ 100/3के बजाय 33.333- मैं वास्तव में नहीं पता है कि अगर कोई समस्या है)।

100.Count[#,x_/;x<1]/Length@#&[DateDifference[#,Date[]]&/@validDates]

तारीख के अंतर की सूची के लिए लागू, यह हमें व्याख्याओं का अंश देता है जो अभी तक समाप्त नहीं हुए हैं।

Comments

मुझे लगता है कि आप गलत तरीके से 2999 या 2099 से 1999 तक के वर्षों को बदल सकते हैं।

— वेंचरो

@Ventero यह सच है। मुझे लगता है कि हम केवल वर्ष 1950 - 2049 (और उनके 1 या 2 अंकों वाले संस्करणों) के साथ काम कर रहे थे , लेकिन इस चुनौती का फिर से पढ़ना कोई उल्लेख नहीं है।

— मार्टिन एंडर

@Ventero तय (लेकिन आप पहले ही मुझे वैसे भी काफी पीट चुके थे;))

— मार्टिन एंडर

मुझे यह देखकर आश्चर्य हुआ कि आपके पास गणितज्ञ का एक खाता है लेकिन उसने कोई प्रश्न या उत्तर पोस्ट नहीं किया है। क्या कुछ आपको वापस पकड़ रहा है?

— श्री। छिपकली

@ Mr.Wizard क्षमा करें, आपको जवाब देना पूरी तरह से भूल गया। प्रश्न: अब तक मेरी हर समस्या का समाधान गुग्लिंग / अन्य एसई प्रश्नों के साथ किया जा सकता था। उत्तर: मुझे नहीं पता ... मुझे लगता है कि मैं अपने आप को उस प्रवीण के रूप में नहीं देखता जब यह गणितीय रूप से मैथमेटिका का उपयोग करने की बात आती है ... मैं इसका उपयोग केवल त्वरित स्निपेट के लिए यहां और वहां (और कोड गोल्फ) करता हूं। इसके अलावा, मुझे लगता है कि मैं उन सवालों के जवाब देने के लिए हूं, जो मुझे जवाब देने के लिए सक्रिय रूप से देखने होंगे, और वर्तमान में मेरे सभी एसई समय पीपीजीजी के लिए आवंटित किए गए हैं। ;) यदि आप चाहते हैं कि मुझे मना लें अन्यथा, चैट में ऐसा करने के लिए स्वतंत्र महसूस करें! :)

— मार्टिन एंडर

Answer 7

जावास्क्रिप्ट (E6) 159 164 172

संकेत के लिए और मुझे फिर से सोचने के लिए प्रेरित करने के लिए धन्यवाद के लिए धन्यवाद संपादित करें। पुनर्गठित डी मापदंडों से बचने और कुछ चार्ट काटने में।

2 संपादित करें nderscore द्वारा एक और ट्रिक, 2 फ़ंक्शंस 1 में मर्ज किए गए। फिर दो कोष्ठक ने विलय कॉमा को अलग-अलग अभिव्यक्तियों को एक में हटा दिया। 0. के पास पठनीयता: सिडेनोट: राउंडिंग अन्य 2 वर्णों को नहीं बचा सकता था (! 0)।

F=(a,t)=>t?100*(3-((i=F([y,m,d]=a))<t)-((j=F([m,d,y]=a))<t)-((k=F([d,m]=a))<t))/(3-!i-!j-!k)|0:(q=new Date(y<50?y+2e3:y,--m,d)).getMonth()==m&q.getDate()==d&&q

फ़ायरफ़ॉक्स कंसोल में टेस्ट

;[[14,12,14],[8,2,2006],[6,7,5],[6,5,7],[12,31,99]]
.map(x=>x + ' ' + F(x, new Date(2006,6,5)))

आउटपुट:

["14,12,14 100", "8,2,2006 50", "6,7,5 33", "6,5,7 66", "12,31,99 0"]

Ungolfed

NB D फ़ंक्शन दिए गए वर्ष, महीने, दिन के साथ एक दिनांक बनाने की कोशिश करता है, लेकिन यदि बनाई गई तारीख का इरादा नहीं है तो गलत रिटर्न देता है (! = दिन या महीने)

F=(d,t)=>
(
  D=(y,m,d)=>(
    q=new Date(y<50?y+2000:y, --m, d), // decr m as javascript (like java) counts months starting at 0
    q.getMonth() == m & q.getDate() == d && q
  ),
  [a,b,c] = d, 
  x=D(...d), // three ways of express the date ...
  y=D(c,a,b),
  z=D(c,b,a),
  100 * (3-(x<t)-(y<t)-(z<t)) / (3-!x-!y-!z) | 0  
)   

Comments

D में बदलाव के लिए @nderscore ओके, दूसरे के लिए सिंटेक्स एरर। लेकिन वैसे भी और अधिक बचाया

— edc65

अजीब। जब मैंने इसे टिप्पणी में चिपकाया तो कुछ हुआ होगा। आपकी नवीनतम

— आशाएँ

इसे एक पेस्ट में डालें

— ndcore

Answer 8

लिनक्यूपैड में सी # - 446 408 272 बाइट्स

तीसरा संपादित करें: DateTime.To को इंगित करने के लिए Le Canard fou के लिए धन्यवाद, सही है, DateTime.Now नहीं। दूसरा संपादित करें: इस चतुर समाधान के लिए धन्यवाद VisualMelon!

void g(int[]d){var p=".";int a=d[2],b=d[1],e=d[0],y=a+(a<100?a>49?1900:2000:0),q=0,s=0;DateTime c;Action<string>z=x=>{if(DateTime.TryParse(x,out c)){s++;if(c>=DateTime.Today)q+=100;}};z(e+p+b+p+y);z(b+p+e+p+y);z(a+p+b+p+(e<100?‌​e>49?1900+e:2000+e:e));(q/(s>0?s:1)).Dump();}

संपादित करें: कोड को छोटा करने में मेरी मदद करने के लिए podiluska और edc65 का धन्यवाद! मैंने यह भी देखा कि अगर साल का इनपुट 4 बाइट्स लंबा होता, तो मेरा समाधान सही नहीं होता, इसलिए मैंने उस समस्या के समाधान को शामिल किया। इस समाधान का स्कोर 408 बाइट्स है।

भले ही मैं पिछले उत्तरों में से कोई भी नहीं मार रहा हूं, फिर भी मैं अपना सी # समाधान साझा करना चाहता था। किसी भी मदद / सुझाव की सराहना की है! ;)

void g(int[]d){var q=new List<DateTime>();var p=".";int s=0,a=d[2],b=d[1],e=d[0],y=0;var c=new DateTime();y=(a<100)?(a>49)?1900+a:2000+a:a;if(DateTime.TryParse(e+p+b+p+y,out c)){q.Add(c);s++;}if(DateTime.TryParse(b+p+e+p+y,out c)){q.Add(c);s++;}y=(e<100)?(e>49)?1900+e:2000+e:e;if(DateTime.TryParse(a+p+b+p+y,out c)){q.Add(c);s++;}q=q.Where(i=>i>=DateTime.Now).ToList();if(s==0){s=1;}(q.Count*100/s).Dump();}

निरूपित और असम्बद्ध संस्करण:

void g(int[] d)
    {
        var q = new List<DateTime>();
        var p = ".";
        int s = 0, a = d[2],b = d[1],e = d[0], y=0;
        var c = new DateTime();
        y = (a < 100) ?((a > 49) ? 1900 + a : 2000 + a) : a;

        if (DateTime.TryParse(e + p + b + p + y, out c))
        {
            q.Add(c);
            s++;
        }
        if (DateTime.TryParse(b + p + e + p + y, out c))
        {
            q.Add(c);
            s++;
        }
        y = (e < 100) ? ((e > 49) ? 1900 + e : 2000 + e) : e;

        if (DateTime.TryParse(a + p + b + p + y, out c))
        {
            q.Add(c);
            s++;
        }
        q = q.Where(i => i >= DateTime.Now).ToList();
        if (s == 0)
        {
            s = 1;
        }
        (q.Count*100/s).Dump();
    }

मैंने एक समाधान बनाने की कोशिश की जहां "DateTime.TryParse" -art इस समाधान के रूप में दोहराया नहीं गया है, लेकिन यह 21 गुना लंबा था।

"DateTime.TryParse" को दोहराए बिना समाधान: 467 बाइट्स

void g(int[]d){var q=new List<DateTime>();int s=0;int a=d[2];int b=d[1];int e=d[0];int y=0;if(a<100){if(a>49){y=1900+a;}else{y=2000+a;}}if(z(e,b,y,q)){s++;}if(z(b,e,y,q)){s++;}if(e<100){if(e>49){y=1900+e;}else{y=2000+e;}}if(z(a,b,y,q)){s++;}q=q.Where(i=>i>=DateTime.Now).ToList();if(s==0){s=1;}(q.Count*100/s).Dump();}bool z(int a,int b,int d,List<DateTime> q){var c=new DateTime();var p=".";if(DateTime.TryParse(a+p+b+p+d,out c)){q.Add(c);return true;}return false;}

Ungolfed संस्करण:

private void g(int[] d)
    {
        var q = new List<DateTime>();
        int s = 0;
        int a = d[2];
        int b = d[1];
        int e = d[0];
        int y = 0;
        if (a < 100)
        {
            if (a > 49)
            {
                y = 1900 + a;
            }
            else
            {
                y = 2000 + a;
            }
        }
        if (z(e, b, y, q))
        {
            s++;
        }
        if (z(b, e, y, q))
        {
            s++;
        }
        if (e < 100)
        {
            if (e > 49)
            {
                y = 1900 + e;
            }
            else
            {
                y = 2000 + e;
            }
        }
        if (z(a, b, y, q))
        {
            s++;
        }
        q = q.Where(i => i >= DateTime.Now).ToList();
        if (s == 0)
        {
            s = 1;
        }
        (q.Count*100/s).Dump();
    }

    private bool z(int a, int b, int d, List<DateTime> q)
    {
        var c = new DateTime();
        string p = ".";
        if (DateTime.TryParse(a + p + b + p + d, out c))
        {
            q.Add(c);
            return true;
        }
        return false;
    }

Comments

int s=0;int a=d[2];int b=d[1];int e=d[0];->int s=0,a=d[2],b=d[1],e=d[0];

— पोडिलुस्का

सुझाव: का उपयोग करें ternary (! :) जब संभव के बजाय अगर / और

— edc65

@ThomasW। मुझे नहीं लगता कि चूंकि y में 2 अलग-अलग मूल्य हैं, एक बार यह एक पर निर्भर करता है, दूसरी बार यह ई पर निर्भर करता है। फिर भी धन्यवाद!

— tasavinho

DateTime.TryParseकॉलों को हटाना मेरी पहली वृत्ति थी, इसे लैम्ब्डा के साथ बदल दिया जिसने मूल्य को भी क्यू में वापस रखा। इसके अलावा कुछ अन्य कदम प्रदर्शन ( pastebin ) 328chars पाने के लिए:void g(int[]d){var q=new List<DateTime>();var p=".";int a=d[2],b=d[1],e=d[0],y;DateTime c;y=(a<100)?(a>49)?1900+a:2000+a:a;Action<string>z=(x)=>{if(DateTime.TryParse(x,out c))q.Add(c);};z(e+p+b+p+y);z(b+p+e+p+y);y=(e<100)?(e>49)?1900+e:2000+e:e;z(a+p+b+p+y);(q.Where(i=>i>=DateTime.Now).Count()*100/(q.Any()?q.Count:1)).Dump();}

— VisualMelon

@VisualMelon वाह, आप कोड-गोल्फिंग में बहुत अच्छे हैं! मैंने Action<string>पहले कभी नहीं देखा था, इसलिए मैं आपसे कुछ सीख सकता था;) मैं आपके उत्तर को 318 वर्णों के q.Where(i=>i>=DateTime.Now).Countसाथ बदलने में सक्षम था q.Count(i=>i>=DateTime.Now। मैंने आसपास के कोष्ठक भी हटा दिए xताकि मैं 2 और पात्रों को बचा सकूँ!

— tsavinho

Answer 9

हास्केल, 171 165 वर्ण

l=length
r y|y<100=(y+50)`mod`100+1950|y>0=y
q d m y z|d<32&&m<13&&d*m>0=(r y,m,d):z|1<3=z
v(a,b,c)=q c b a$q b a c$q a b c[]
t%d=(l$filter(>t)(v d))*100`div`l(v d)

समारोह का नाम है %। वास्तविक वर्ष के साथ विहित (y, m, d) क्रम में एक टपल के रूप में परीक्षण की तारीख के साथ चलाएं, और तीन नंबर के टपल के रूप में कार्टन स्टैम्प:

λ: (2006,6,5)%(14,12,14)
100

λ: (2006,6,5)%(8,2,2006)
50

λ: (2006,6,5)%(6,7,5)
33

λ: (2006,6,5)%(6,5,7)
66

λ: (2006,6,5)%(12,31,99)
0

λ: (2006,6,5)%(0,1,7)
0

Answer 10

एर्लैंग, 146

f([A,B,C]=U,N)->F=[T||T<-[{(Y+50)rem 100+1950,M,D}||[Y,M,D]<-[U,[C,A,B],[C,B,A]]],calendar:valid_date(T)],100*length([1||T<-F,T>=N])div length(F).

परीक्षण समारोह होगा:

t() ->
    0 = f([12,31,99],{2006,6,5}),
    66 = f([6,5,7],{2006,6,5}),
    33 = f([6,7,5],{2006,6,5}),
    100 = f([14,12,14],{2006,6,5}),
    50 = f([8,2,2006],{2006,6,5}),
    100 = f([29,2,2],{2006,6,5}).

Ungolfed

f([A,B,C]=U,Today)->
    Perms = [U,[C,A,B],[C,B,A]],
    WithYears = [{(Y+50) rem 100+1950,M,D} || [Y,M,D] <- Perms],
    ValidDates = [T || T <- WithYears, calendar:valid_date(T)],
    100*length([1 || T <- ValidDates, T >= Today]) div length(ValidDates).

यह समाधान सूची की समझ पर निर्भर करता है। यह हास्केल समाधान से वर्ष के लिए मोडुलो चाल उधार लेता है। यह calendar:valid_date/1किसी निश्चित महीने में दिनों की संख्या के कारण असंभव तिथियों को संभालने के लिए भी उपयोग करता है (उदाहरण के लिए "29-2-2" केवल YMD प्रारूप में हो सकता है)। इसके अलावा, आज date()एर्लांग के प्रारूप (एक YMD टपल) में है।

Answer 11

एपीएल (85)

यह कुछ Dyalog APL 14 के नए कार्यों का उपयोग करता है, लेकिन कोई बाहरी पुस्तकालय नहीं है। एक बदलाव के लिए, यह TryAPL पर काम करता है ।

{100×(+/÷⍴)⍺≤{(3/100)⊥⍵+(99≥⊃⍵)×3↑1900+100×50>⊃⍵}¨Z/⍨{∧/12 31≥1↓⍵}¨Z←(⊂⌽⍵),(⊂2⌽⍵),⊂⍵}

यह एक ऐसा फंक्शन है जो 3-एलीमेंट एरे को अपने राइट साइड ( ⍵) तर्क के रूप में लेता है, और फॉर्मेट के ⍺पूर्णांक के रूप में इसके लेफ्ट साइड ( ) लॉजिक के रूप में चेक करने की डेट YYYYMMDD। यानी, तारीख 2014-07-09को संख्या के रूप में दर्शाया जाता है 20140709।

परीक्षा:

      20060705 {100×(+/÷⍴)⍺≤{(3/100)⊥⍵+(99≥⊃⍵)×3↑1900+100×50>⊃⍵}¨Z/⍨{∧/12 31≥1↓⍵}¨Z←(⊂⌽⍵),(⊂2⌽⍵),⊂⍵} 14 12 14
100
      20060705 {100×(+/÷⍴)⍺≤{(3/100)⊥⍵+(99≥⊃⍵)×3↑1900+100×50>⊃⍵}¨Z/⍨{∧/12 31≥1↓⍵}¨Z←(⊂⌽⍵),(⊂2⌽⍵),⊂⍵} 8 2 2006
50
      20060705 {100×(+/÷⍴)⍺≤{(3/100)⊥⍵+(99≥⊃⍵)×3↑1900+100×50>⊃⍵}¨Z/⍨{∧/12 31≥1↓⍵}¨Z←(⊂⌽⍵),(⊂2⌽⍵),⊂⍵} 6 7 5
33.3333
      20060705 {100×(+/÷⍴)⍺≤{(3/100)⊥⍵+(99≥⊃⍵)×3↑1900+100×50>⊃⍵}¨Z/⍨{∧/12 31≥1↓⍵}¨Z←(⊂⌽⍵),(⊂2⌽⍵),⊂⍵} 12 31 99
0

स्पष्टीकरण:

• Z←(⊂⌽⍵),(⊂2⌽⍵),⊂⍵: दिए गए दिनांक को YMD प्रारूप में फ़्लिप करके (⊂⌽⍵), इसे बाईं ओर 2 से घुमाएं (⊂2⌽⍵), या केवल कुछ भी न करें ⊂⍵। कम से कम इनमें से एक अब YMD प्रारूप में एक उचित तारीख है, शायद एक से अधिक अगर तारीख अस्पष्ट है।
• {∧/12 31≥1↓⍵}¨Z: परीक्षण करें कि क्या प्रत्येक तिथि मान्य है: वर्ष (पहला तत्व) गिरा दिया गया है, और फिर माह 12 से अधिक नहीं होना चाहिए और दिन 31 से अधिक नहीं होना चाहिए।
• Z/⍨: से मान्य दिनांक फ़िल्टर करें Z।
• {... }¨: प्रत्येक मान्य तिथि के लिए:
  • ⍵+(99≥⊃⍵)×3↑1900+100×50>⊃⍵: यदि वर्ष ९९ से अधिक नहीं है, तो १ ९ ०० को जोड़ें, तो १०० यदि वर्ष ५० से कम है।
  • (3/100)⊥: इसे डिकोड करें जैसे कि यह बेस -100 नंबर का एक सेट था। (वर्ष 100 से अधिक है, लेकिन यह पहला तत्व है क्योंकि यह कोई फर्क नहीं पड़ता।) यह बाएं स्वरूप के समान प्रारूप में प्रत्येक मान्य तिथि के लिए एक नंबर देता है।
• ⍺≤: प्रत्येक तिथि के लिए, देखें कि क्या यह उससे छोटा नहीं है ⍺। यह एक द्विआधारी वेक्टर देगा जहां 1 का मतलब OKऔर 0 का मतलब है spoiled।
• 100×(+/÷⍴): बाइनरी वेक्टर की राशि को इसकी लंबाई से विभाजित करें और 100 से गुणा करें।

Comments

7 बाइट्स बचाएं (और कश्मीर को एक अच्छे अंतर से हरा दें) फंसे और एक आंतरिक कार्य को {100×(+/÷⍴)⍺≤((3/100)⊥⊢+(99≥⊃)×3↑1900+100×50>⊃)¨Z/⍨{∧/12 31≥1↓⍵}¨Z←(⌽⍵)(2⌽⍵)⍵}

— शांत बनाये

Answer 12

जावा: 349 वर्ण (3 w / o स्थान)

int e(int[]n,Date t){int a=n[0],b=n[1],c=n[2];Date[]d=new Date[3];if(b<13&&c<32)d[0]=new Date((a<50?100:(a>100?-1900:0))+a,b-1,c);if(b<13&&a<32)d[1]=new Date((c<50?100:(c>100?-1900:0))+c,b-1,a);if(a<13&&b<32)d[2]=new Date((c<50?100:(c>100?-1900:0))+c,a-1,b);int v=0,g=0;for(int i=0;i<3;i++)if(d[i]!=null){if(!d[i].before(t))g++;v++;}return 100*g/v;}

यहाँ एक युक्त वर्ग है जो इसका परीक्षण करने के लिए इस्तेमाल किया जा सकता है, जिसमें विधि का एक (थोड़ा) विकृत संस्करण भी शामिल है:

import java.util.*;
class i{

   int e(int[]n,Date t){
      int a=n[0],b=n[1],c=n[2];
      Date[]d=new Date[3];
      if(b<13&&c<32)d[0]=new Date((a<50?100:(a>100?-1900:0))+a,b-1,c);
      if(b<13&&a<32)d[1]=new Date((c<50?100:(c>100?-1900:0))+c,b-1,a);
      if(a<13&&b<32)d[2]=new Date((c<50?100:(c>100?-1900:0))+c,a-1,b);
      int v=0,g=0;
      for(int i=0;i<3;i++)
         if(d[i]!=null){
            if(!d[i].before(t))
               g++;
            v++;
         }
      return 100*g/v;}

   public static void main(String[] args){
      int[]i=new int[3];
      for(int k=0;k<3;k++)
         i[k] = Integer.parseInt(args[k]);
      int j = new i().e(i,new Date());
      System.out.println(j+"%");
   }   
}

यह कोड गोल्फ का मेरा पहला दौर है, और मुझे लगता है कि मुझे लगा कि मैं आमतौर पर बहुत सारे जावा गोल्फरों को क्यों नहीं देखता।

Comments

आपको int[]तीन intएस नहीं, एक तर्क के रूप में स्वीकार करने की आवश्यकता है ।

— जॉय

ठीक है, मैंने इसे ठीक किया।

— ढालगेंटर shield

Answer 13

सी # 287 बाइट्स

namespace System{class E{static float a,o,l;void M(int[]i){int d=i[0],m=i[1],y=i[2],t;if(l<3)try{if(l==1){t=y;y=d;d=t;}if(l++==0){t=d;d=m;m=t;}if(y<100&&(y+=1900)<1950)y+=100;o+=new DateTime(y,m,d)>=DateTime.Today?1:0;a++;if(l<3)i[9]=9;}catch{M(i);throw;}Console.Write(o/a);}}}

पहली बार गोल्फ, सलाह की तलाश में। विशेष रूप से, नामस्थान के कारण बाइट्स निकालना।

इस तथ्य का दुरुपयोग करना कि केवल एक फ़ंक्शन की आवश्यकता है, एक वास्तविक कार्यक्रम नहीं। साथ ही, फ़ंक्शन हमेशा एक अनकहा अपवाद के रूप में होता है।

Ungolfed

namespace System {
    class E {
        static float a, o, l;
        void M(int[] i) {
            int d = i[0], m = i[1], y = i[2], t;
            if (l < 3)
                try {
                    if (l == 1) { 
                        t = y; y = d; d = t; 
                    } 
                    if (l++ == 0) { 
                        t = d; d = m; m = t; 
                    } 
                    if (y < 100 && (y += 1900) < 1950)
                        y += 100; 
                    o += new DateTime(y, m, d) >= DateTime.Today ? 1 : 0; // # not expired
                    a++; // # valid dates
                    if (l < 3)
                        i[9] = 9; // throw new Exception()
                } 
                catch { 
                    M(i);
                    throw; // fail after the first Console.Write()
                } 
            Console.Write(o / a); 
        } 
    } 
}

Answer 14

गणितज्ञ , ११hem

शुरुआती बिंदु के रूप में m.buettner के कोड का उपयोग करने से मेरे पास कुछ सुधार हैं:

⌊100Mean@UnitStep@Cases[DateDifference@{If[#<100,Mod[#+50,100]+1950,#],##2}&@@@{#,RotateRight@#,Reverse@#},_Integer]⌋&

Comments

गोल्फ तर्क के रूप में तीन-इंट की सूची लेने वाला एक फ़ंक्शन हो सकता है।

— एल्गोरिथमशार्क

@algorithmshark धन्यवाद मुझे नहीं पता कि मैं कैसे चूक गया। अपडेट कर रहा

— हूं