उलट तारीख को वैध करें

18

इनपुट:

एक तिथि (युक्त dd, MMऔर yyyy)। एक दिनांक-ऑब्जेक्ट या तीन अलग-अलग पूर्णांक भी इनपुट के रूप में मान्य हैं।

आउटपुट:

प्रत्येक भाग ( dd, MMऔर yyyy) व्यक्तिगत रूप से लौट आया और उस से निकटतम मान्य दिनांक में गोल।

उदाहरण के लिए (प्रारूप में dd-MM-yyyy):
21-10-2016बन जाता है12-01-6102

चुनौती नियम:

  • केवल dd, MM, yyyyमान्य है, लेकिन आदेश और जो अलग-प्रतीकों आप का उपयोग अपने स्वयं के विकल्प है।
    तो ये कुछ मान्य प्रारूप उदाहरण हैं dd-MM-yyyy:; MM/dd/yyyy; yyyy MM dd; ddMMyyyy, आदि
    और ये कुछ अमान्य प्रारूप उदाहरण हैं dd MMM yyyy:; dd-MM-'yy; आदि।
  • आप किसी दिनांक-ऑब्जेक्ट को इनपुट करने का विकल्प भी चुन सकते हैं यदि आपकी भाषा इसे या तीन अलग-अलग पूर्णांक मापदंडों का समर्थन करती है, तो तारीख का प्रतिनिधित्व करने वाले स्ट्रिंग के बजाय।
  • कृपया बताएं कि आपने किस दिनांक-प्रारूप का उपयोग किया है! (और इनपुट और आउटपुट एक ही प्रारूप में होना चाहिए।) यह एक दिनांक-ऑब्जेक्ट को आउटपुट करने की भी अनुमति है, जब तक कि यह सभी परीक्षण मामलों और नीचे चुनौती नियम को संभाल सकता है।
  • इस चुनौती के लिए जूलियन से ग्रेगोरियन कैलेंडर संक्रमण की अनदेखी की जाती है। तो 1582बस एक वैध उलटा वर्ष है 2851।
    सभी वैध वर्षों, महीनों और दिनों के लिए चैलेंज की जानकारी / सुझाव देखें।
  • चूंकि आपके पास फरवरी किसी अन्य महीने के उलट नहीं हो सकता है, इसलिए आपको लीप वर्ष के बारे में चिंता करने की आवश्यकता नहीं है।

सभी वर्ष, महीने और दिन उलट दिए गए:

  • वर्ष हमेशा एक समस्या के बिना उलटा हो सकता है, 0001 (उलट 1000) से 9999 (अवशेष 9999) तक पहुंच सकता है । (इसलिए 0000एक वैध इनपुट नहीं है, और इसके लिए कोई परीक्षण मामले भी नहीं हैं।)
  • आपके द्वारा उलटा किए गए केवल महीने हैं: जनवरी (अक्टूबर / से उलट 10); अक्टूबर (जनवरी / से उलट 01); नवंबर (नवंबर / नवंबर रहता है 11); और दिसम्बर (हर दूसरे महीने से उलट / 02- 09, 12)।
  • आपके द्वारा उलटे किए गए केवल दिन हैं: 01 (उल्टा 10), 02 (इससे उलट 20), 03 ( 10 से उल्टा 30), 10 ( 11 से उल्टा 01), 11 (अवशेष 11), 12 (उल्टा 21), 13 (उलट 31) , २० (से उलटा 02), २१ (से उलटा 12), २२ (शेष 22), ३० ( ३१ से उल्टा 03या ३१ नवंबर तक!), ३१ (से उलट 04- ३ 09/ 13-)19/ 23- 29)।

सामान्य नियम:

  • यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
    कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव कम उत्तर के साथ आने की कोशिश करें।
  • मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न स्टेटमेंट / आउटपुट, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा फोन।
  • डिफ़ॉल्ट लूपोल्स निषिद्ध हैं।
  • यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
  • इसके अलावा, यदि आवश्यक हो तो एक स्पष्टीकरण जोड़ें।

परीक्षण के मामले ( dd-MM-yyyyप्रारूप के रूप में):

21-07-2016   ->   12-12-6102
12-11-1991   ->   21-11-1991
01-01-2000   ->   10-10-0002
27-08-1875   ->   31-12-5781
18-12-2010   ->   31-12-0102
13-01-1981   ->   31-10-1891
04-11-1671   ->   30-11-1761  // Semi-tricky case, since November has 30 days
28-11-2036   ->   30-11-6302  // Semi-tricky case, since November has 30 days
14-06-1855   ->   31-12-5581
30-10-9999   ->   03-01-9999
01-01-2851   ->   10-10-1582
code-golf  date 
— केविन क्रूज़सेन
स्रोत
@ LegionMammal978 नहीं, उल्टा 21-07-2016है 12-70-6102जो गोल है 12-12-6102। निश्चित नहीं कि आपको परिणाम कैसे मिलेगा ##-10-6107..
— केविन क्रूज़सेन
@KevinCruijssen ठीक है, मैंने सोचा था कि यह महीना 70चारों ओर लिपटा हुआ था, वर्ष वृद्धि के साथ।
— लीजनमोनमाल 978
है 10-10-2तीसरे मामले में वैध उत्पादन?
— लुइस मेंडू
@LuisMendo हाँ ज़रूर। मैंने अन्य लोगों को भी ऐसा करते देखा है। इन-या आउटपुट फॉर्मेट की तुलना में चुनौती सही रूप से तारीखों को उलटने और गोल करने के बारे में अधिक है।
— केविन क्रूज़सेन
क्या यह तीन तार लेने के लिए स्वीकार्य होगा, और अग्रणी शून्य की उम्मीद करेगा?
— जस्टिनएम -

जवाबों:

3

उत्तल , 23 बाइट्स

बाइट गिनती CP-1252 एन्कोडिंग मानती है।

qS/Wf%_1=:=31^sCs¶.e<S*

आई / ओ प्रारूप है dd mm yyyy।

इसे ऑनलाइन आज़माएं!

यह मेरे CJam उत्तर का सीधा पोर्ट है । उत्तल सीजेएम पर आधारित है, और इसलिए एकमात्र अंतर उत्तल ऑपरेटर के उपयोग का है जो एक सूची में शीर्ष दो स्टैक तत्वों को लपेटता है, एक बाइट को बचाता है [...]।

— मार्टिन एंडर
स्रोत
8

सीजेएम, 24 बाइट्स

qS/Wf%[_1=:=31^sCs].e<S*

आई / ओ प्रारूप है dd mm yyyy।

इसे ऑनलाइन आज़माएं!

एक ही बाइट काउंट, I / O प्रारूप mm dd yyyy:

qS/Wf%_0=:=1231^s2/.e<S*

इसे ऑनलाइन आज़माएं!

व्याख्या

qS/     e# Read input, split around spaces.
Wf%     e# Reverse each component.
[       e# Set marker for new list.
  _1=   e#   Duplicate reversed strings, extract reversed month.
  :=    e#   Check for equality of the characters. This gives 1 for
        e#   November (11) and 0 for everything else.
  31^   e#   XOR the result with 31, giving 30 for November and 31
        e#   for everything else.
  s     e#   Convert the result to a string, "30"/"31".
  Cs    e#   Push 12, convert to string, "12".
]       e# Wrap "30"/"31" and "12" in a list.
.e<     e# Element-wise minimum. This clamps the day and month to their
        e# respective maxima.
S*      e# Join the result with spaces.

दूसरे संस्करण इसी तरह काम करता है, को छोड़कर हम पूर्णांक से शुरू कि 1230या 1231इसे करने के लिए परिवर्तित करने से पहले ["12" "30"] या ["12" "31"]।

— मार्टिन एंडर
स्रोत
2
अंतर्निहित दिनांक वाली भाषाएं ...
— लीक नून
1
@LeakyNun यह अंतर्निहित तिथि का उपयोग नहीं करता है और मैं नहीं देखता कि यह कैसे मदद करेगा।
— मार्टिन एंडर
फिर आपको कैसे पता चलेगा कि नवंबर में 30 दिन होते हैं?
— लीक नन
2
@LeakyNun मैं बाद में एक स्पष्टीकरण जोड़ूंगा, लेकिन 1=उलटा महीना हो जाता है, यह :=जांचता है कि क्या इसके अंक समान हैं और ^परिणाम में 31, x 30 महीने के लिए 11और 31 बाकी सब के लिए देता है।
— मार्टिन एंडर
ओह, मैंने ऐनक नहीं पढ़ी ...
— लीक नून
5

पायथ, 55 53 46 43 41 बाइट्स

APJ_Mczd = HhS, 12sH = GhS, sGC @। "»Ó» d "H%"% 02d% 02d% s "[GHeJ 
APJ_Mczd = hS, 12sH = hS, sGC @" ó "" H% "। "% 02d% 02d% s" [GHeJ 
APJ_Mcz \ -% "% 02d% 02d% s" [hS, sGx31q11sHhS, 12sHeJ 
APJ_MKdjd>> 2+ \ 0hS, sGx31q11sH> 2+ \ _ 0SS 12/S
APJ_Mczdjd। [एल \ 02 [ `एच एस, sGx31q11sH`hS, 12sHeJ

जहां ❤❤दो unprintables थे, क्रमशः U + 001C और U + 001F।

परीक्षण सूट।

— लीक नन
स्रोत
3

पायथन 3, 82 बाइट्स

lambda x:[min(x[0][::-1],['31','30'][x[1]=='11']),min(x[1][::-1],'12'),x[2][::-1]]

एक अनाम फ़ंक्शन जो इनपुट को तर्क के माध्यम से लेता है, फॉर्म के तार की सूची के रूप में तारीख ['dd', 'mm', 'yyyy']और उसी प्रारूप में मान्य उलट तारीख को वापस करता है।

यह काम किस प्रकार करता है

पायथन अपने यूनिकोड कोड-पॉइंट द्वारा पात्रों और तार की तुलना करता है। इसका मतलब यह है कि दो या दो से अधिक पूर्णांकों पर कोई भी तुलना तार के रूप में उन पूर्णांकों की तुलना में समान है। इसलिए, minदो पूर्णांकों को स्ट्रिंग के रूप में कॉल करने से एक स्ट्रिंग के रूप में सबसे छोटा पूर्णांक वापस आ जाता है; उल्टे तारीख वाले हिस्से को एक तर्क के रूप में और दूसरे के रूप में अधिकतम मान लेकर, दिन और महीने को वांछित सीमा तक जकड़ दिया जाता है। तारीखों के हिस्सों को -1( [::-1]) के चरणों के साथ अनुक्रमित करके उलट दिया जाता है , और महीने के लिए अधिकतम मान को बदल दिया जाता '31'है, '30'यदि माह नवंबर है एक सशर्त के बूलियन परिणाम के साथ एक सूची में शामिल करके।

Ideone पर इसे आज़माएं

— TheBikingViking
स्रोत
2

डायलॉग एपीएल , 32 33 बाइट्स

⍕¨{⍵-3↑31 11≡2↑⍵}31 12 1E4⌊⍎∊⍕⌽¨⎕

I / O तीन तारों की सूची है ( 'dd' 'mm' 'yyyy')।

TryAPL , लेकिन ध्यान दें कि ⎕(इनपुट के लिए संकेत) के साथ बदल दिया गया है ⍵और पूरी लाइन में संलग्न है {... }ऑनलाइन परीक्षण सक्षम करने के लिए, और ⍎(निष्पादित अभिव्यक्ति) के साथ प्रतिस्थापित किया गया है 2⊃⎕VFI(सत्यापित और फिक्स इनपुट) क्योंकि मनमाना कोड का निष्पादन अवरुद्ध है ।

— एडम
स्रोत
2

सी # 314 305 299 249 232 223 बाइट्स

using System.Linq;string f(int d,int m,int y){Func<int,string>r=i=>string.Concat((""+i).PadLeft(2,'0').Reverse());Func<string,int,string>x=(j,k)=>int.Parse(j)>k?""+k:j;return x(r(d),m==11?30:31)+"-"+x(r(m),12)+"-"+r(y);}

@KevinCruijssen को यह बताने के लिए धन्यवाद कि मैं अपनी परिवर्तनशील घोषणा को छोटा कर सकता हूं, जिसने कुछ बाइट्स को बचाने के लिए अलियासिंग स्ट्रिंग को भी सक्षम बनाया।

सहेजे गए 50 बाइट्स का पुन: उपयोग करने के लिए रिवर्सलिंग फ़ंक्शन को संग्रहीत करना और अन्य 13 को राउंडिंग के लिए एक ही कर और चर घोषणाओं को हटा देना।

अंतिम अद्यतन अलियासिंग स्ट्रिंग को बाइट सेवर नहीं बनाता है।

Ungolfed संस्करण:

using System.Linq;
    string dateReverse(int day, int month, int year)
{
    //setup a resuable function to reverse
    Func<int, string> reverse = intToReverse => string.Concat((""+intToReverse).PadLeft(2, '0').Reverse());

    //another function for rounding
    Func<string, int, string> round = (strToRound, maxVal) => int.Parse(strToRound) > maxVal ? "" + maxVal : strToRound;

    //Join the strings into the "dd-mm-yyyy" date format
    return 
        //Round down the day value, if november cap to 30 otherwise cap to 31
        round(reverse(day), month == 11 ? 30 : 31) + "-" +

        //Round the month down
        round(reverse(month), 12) + "-" +

        //we can use the reverse function here too and pad left just won't do anything
        reverse(year);
}

इसका परीक्षण यहां करें

— जस्टिनएम - मोनिका को बहाल करें
स्रोत
आप using System.Linq;और फ़ंक्शन के बीच के स्थान को अनदेखा कर सकते हैं , इसलिए यह -1 बाइट है। इसके अलावा, इसके var n=...;var e=...;बजाय 1 बाइट द्वारा गोल्फ किया जा सकता है: string n=...,e=...;यह बहुत ज्यादा नहीं है, लेकिन फिर भी -2 बाइट्स। ;)
— केविन क्रूज़सेन
उस स्थान पर अच्छी पकड़ है, हालांकि ऐसा लग रहा है कि मेरी बाइट गिनती वास्तव में इसे गिन नहीं पाई थी, इसलिए एक नकल पेस्ट मुद्दे तक बीमार है। इसके अलावा, मुझे लगता है कि चर घोषणा शैली का उपयोग करके एलियासिंग स्ट्रिंग द्वारा कुछ और बाइट्स जीतने में सक्षम हैं।
— जस्टिनएम -
2

जावास्क्रिप्ट, 106 105 94 बाइट्स

d=>d.split`,`.map((a,b,r)=>(e=[...a].reverse().join``,f=!b?r[1]==11^31:b<2&&12,f&&f<e?f:e))+''

टेस्ट सूट (रेव। 3)


व्याख्या

d=>d.split`,`                 // split into sections by `,`

.map((a,b,r)=>(               // map each section

e=[...a].reverse().join``,    // spread a date section into array and reverse and 
                              // join with `` to get string result

f=!b?r[1]==11^31              // if section being mapped is day (section 0), 
                              // then max (f) is 30 for November(month 11) or else 31

:b<2&&12,                     // if part being mapped is month (section 1), then max (f) is 12

f&&f<e?f:e))                  // if there is a max (f)
                              // and the max (f) is less than the reversed string (e),
                              // then return the max (f), 
                              // else return the reversed string (e)

+''                           // join all the sections back together with `,` 
                              // (concatenating [] with a string will do this)

धन्यवाद @KevinCruijssen के लिए 1 बाइट बचाने के b==1लिए b<2। ES6 टेम्पलेट शाब्दिक और ,विभाजक का सुझाव देकर 11 बाइट बचाने के लिए @Neil धन्यवाद ।

— CShark
स्रोत
मैं जेएस पर बहुत बुरा हूं, इसलिए मुझे सही करें अगर मैं कुछ गलत कहता हूं, लेकिन बाइट को बचाने के लिए b==1नीचे नहीं जाया जा सकता है b<2? यह अब 0 नहीं हो सकता है, क्योंकि आपने पहले ही !b?कोड के हिस्से पर जाँच कर ली है । जब मैं इसे बदलता हूं तो यह आपके परीक्षण सूट में काम करता है।
— केविन क्रूज़सेन
@ केविनक्रूजसेन हां, आप सही कह रहे हैं, धन्यवाद! मैंने इसे अनदेखा कर दिया। मैंने बहुत आसानी से देखने के लिए जावास्क्रिप्ट में गोल्फिंग नहीं की है इसलिए मुझे कभी
— CShark
* मेरा मतलब 'बहुत लंबे समय तक' है, 'बहुत देखने के लिए' नहीं
— सीएसकेर जूल
2
- आप ES6 लक्षित कर रहे हैं के रूप में, आप अपने कोड को छोटा करने के टेम्पलेट तार का उपयोग कर सकते join``के बजाय join('')उदाहरण के लिए - लेकिन आप का उपयोग करके एक छोटे से अधिक बचा सकता है ,अपने विभाजक, जो आप का उपयोग करने के लिए अनुमति देता है के रूप में +''तीन मानों को एक साथ शामिल होने के लिए।
— नील
@ क्या आप ,इनपुट में विभाजक के रूप में मतलब है ?
— CShark
1

रूबी, 92 84 + 1 ( -pध्वज) = 93 85 बाइट्स

सेपरेटर के -रूप में उपयोग करता है ।

d,m,y=chomp.split(?-).map &:reverse
$_=[[d,m=="11"?"30":"31"].min,[m,"12"].min,y]*?-
— मूल्य स्याही
स्रोत
0

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

z=input().split("-");r=[x[::-1]for x in z];z[1]=r[1]if r[1]<'12'else '12';z[0]=r[0]if r[0]<'31'else '30'if z[1]=='11'else '31';z[2]=r[2];print "-".join(z)

इनपुट को एक स्ट्रिंग के रूप में लेता है, इसलिए उद्धरण को इनपुट में निर्दिष्ट करने की आवश्यकता है, उदाहरण के लिए "11-04-2016"।

— जेरेमी
स्रोत
मैं पायथन गोल्फर नहीं हूं, बस एक बुनियादी सुधार z=[x[::-1]for x in z];z[1]=min(z[1],'12');z[0]=min(z[0],['31','30'][z[1]=='11']);print"-".join(z):। मूल रूप से, आपको बिल्कुल भी उपयोग करने की आवश्यकता नहीं है r, और minबहुत सारे कामों को पूरा करना है जो आप करना चाहते हैं।
— वैल्यू इंक
0

05AB1E , 24 बाइट्स

#íÐÅsË31^12‚øεßт+¦}sθªðý

@MartinEnder के CJam उत्तर का पोर्ट , इसलिए प्रारूप में एक स्ट्रिंग के रूप में इनपुट और आउटपुट भी dd MM yyyy।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

#                         # Split the (implicit) input by spaces
                          #  i.e. "04 11 1671" → ["04","11","1671"]
                          #  i.e. "20 01 2000" → ["20","01","2000"]
 í                        # Reverse each string
                          #  i.e. ["04","11","1671"] → ["40","11","1761"]
                          #  i.e. ["20","01","2000"] → ["02","10","0002"]
  Ð                       # Triplicate this list
   Ås                     # Pop one of them, and push it's middle element (the months)
                          #  i.e. ["40","11","1761"] → "11"
                          #  i.e. ["02","10","0002"] → "10"
     Ë                    # Check if the digits are the same (1 for 11; 0 otherwise)
                          #  i.e. "11" → 1 (truthy)
                          #  i.e. "10" → 0 (falsey)
      31^                 # Bitwise-XOR with 31 (30 for November, 31 for other months)
                          #  i.e. 1 → 30
                          #  i.e. 0 → 31
         12‚              # Pair it with 12
                          #  i.e. 30 → [30,12]
                          #  i.e. 31 → [31,12]
            ø             # Zip/transpose; swapping rows and columns
                          # (implicitly removes year)
                          #  i.e. ["40","11","1761"] and [30,12] → [["40",30],["11",12]]
                          #  i.e. ["02","10","0002"] and [31,12] → [["02",31],["10",12]]
             ε    }       # Map each pair to:
              ß           # Get the minimum (implicitly converts to integer unfortunately)
                          #  i.e. [["40",30],["11",12]] → [30,11]
                          #  i.e. [["02",31],["10",12]] → [2,10]
               т+         # Add 100
                          #  i.e. [30,11] → [130,111]
                          #  i.e. [2,10] → [102,110]
                 ¦        # Remove the first character
                          #  i.e. [130,111] → ["30","11"]
                          #  i.e. [102,110] → ["02","10"]
                   s      # Swap so the triplicated list is at the top of the stack again
                    θ     # Pop and only leave it's last element (the year)
                          #  i.e. ["40","11","1761"] → "1761"
                          #  i.e. ["02","10","0002"] → "0002"
                     ª    # Append it to the list
                          #  i.e. ["30","11"] and "1761" → ["30","11","1761"]
                          #  i.e. ["02","10"] and "0002" → ["02","10","0002"]
                      ðý  # Join the list by spaces (and output implicitly)
                          #  i.e. ["30","11","1761"] → "30 11 1761"
                          #  i.e. ["02","10","0002"] → "02 10 0002"
— केविन क्रूज़सेन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.