अलार्म अनुकूलन

Question

मेरी अलार्म घड़ी

मैं अमेरिकी हूं, और इसलिए मेरी (डिजिटल) अलार्म घड़ी है। अलार्म सेट करने के लिए, यह उस समय शुरू होता है जब यह पहले था। घंटे के बटन को हिलाने से यह एक घंटा ऊपर चला जाता है, और मिनट के बटन को हिलाने से यह एक मिनट ऊपर चला जाता है। एक ही समय में दोनों बटन मारना इसे आधी रात (12:00 बजे) तक रीसेट करता है, और दो बटन प्रेस के रूप में गिना जाता है।

जब घंटे उनकी कैप (12) से अधिक हो जाते हैं, तो यह 1 पर सेट हो जाता है और एएम / पीएम लाइट को टॉगल करता है। जब मिनट उनकी टोपी (59) से अधिक हो जाते हैं, तो वे घंटों को प्रभावित किए बिना, 0 पर रीसेट हो जाते हैं।

काम

आपका कार्य है, एक शुरुआती समय और एक लक्ष्य समय दिया गया है, जिससे मेरे अलार्म को लक्ष्य समय पर सेट करने के लिए आवश्यक बटन की अधिकतम संख्या को आउटपुट किया जा सके।

जो भी प्रारूप आपको सबसे अच्छा लगे उसमें आप इनपुट ले सकते हैं। आपके इनपुट के लिए आपके प्रोग्राम को केवल डेटा की आवश्यकता घंटे और मिनट होनी चाहिए। इसका मतलब है कि आप, उदाहरण के लिए, युग के बाद से मिलीसेकंड के रूप में डेटा ले सकते हैं, और घंटों और मिनटों को निकाल सकते हैं, लेकिन आप वर्ष, महीने, दूसरे, आदि में कुछ भी सांकेतिक शब्दों में बदलना नहीं कर सकते हैं । नोट करें कि आप उदाहरण के लिए, इनपुट का उपयोग कर रहे हैं "सैन्य समय" (या दुनिया के अधिकांश समय के लिए नियमित समय), लेकिन यह नहीं बदलता है कि मेरी घड़ी कैसे काम करती है।

उदाहरण

1:15 pm -> 2:30 am

आप 12:00 पर रीसेट करने के लिए दोनों बटन को नीचे धकेल सकते हैं, फिर 2:30 बजे वेतन वृद्धि, जो 2+2+30 = 34बटन प्रेस होगा। आप 2:30 बजे भी बढ़ा सकते हैं, जो 13+15 = 28बटन प्रेस होगा। इसलिए, अपने उत्पादन होता है 28।

3:58 am -> 4:02 am

आप रीसेट और इंक्रीमेंट कर सकते हैं, जो 2+4+2 = 8बटन प्रेस होगा। आप वेतन वृद्धि भी कर सकते हैं, जो 1+4 = 5बटन दबाया जाएगा। इसलिए, अपने उत्पादन होता है 5।

10:55 pm -> 1:00 am

आप रीसेट और इंक्रीमेंट कर सकते हैं, जो 2+1 = 3बटन प्रेस होगा। आप वेतन वृद्धि भी कर सकते हैं, जो 3+5=8बटन दबाया जाएगा। इसलिए, अपने उत्पादन होता है 3।

1:00 am -> 1:59 pm

आप रीसेट कर सकते हैं और वेतन वृद्धि कर सकते हैं, लेकिन यह सिर्फ वेतन वृद्धि की तुलना में तीन और प्रेस होगा। इसलिए, अपने उत्पादन होता है 12+59 = 71।

परीक्षण के मामलों

Current  Target   = Output
1:15pm   2:30am   = 28
3:58am   4:02am   = 5
10:55pm  1:00am   = 3
1:00am   1:59pm   = 71
12:00am  12:00am  = 0
6:51pm   12:00am  = 2
2:01pm   11:00pm  = 25
2:01pm   11:01pm  = 9
12:59am  12:01am  = 2
11:50am  12:00pm  = 11

Comments

सैंडबॉक्स

— स्टीफन

बकवास! दो बटन दबाने से मेरी (यूरोपीय) अलार्म घड़ी 0:00 पर भी रीसेट हो जाती है ... इन सभी वर्षों में कई बार बटन दबाने पर खर्च होता है ... O_o

— Arnauld

"सैन्य समय (या दुनिया के अधिकांश के लिए नियमित समय)" ... आप जिस शब्द की तलाश कर रहे हैं वह "24-घंटे का समय" है।

— जकॉब

@ जाकोब नहीं, वह जिस शब्द की तलाश में है वह "नियमित समय" है। अमेरिकी अनियमित समय, अनियमित तिथियों, अनियमित इकाइयों आदि का उपयोग करते हैं

— नील

@ स्टेपहेन मैं यूके में हूं और जब तक कि जैकब ने इसे समझाया तब तक आपको "सैन्य समय" से कोई मतलब नहीं था। 210 का समय मेरे लिए एक सही अर्थ है

— डैरेन एच।

Answer 1

भूसी , 16 बाइट्स

§▼ṁ→(Σz%e24 60z-

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

आरंभ और समाप्ति समय के लिए 24 घंटों के प्रारूप में, दो सूचियों [घंटे, मिनट] के रूप में तर्क देता है।

मैं इस बात से काफी खुश हूं कि मैं इसको कैसे हासिल करने में सक्षम था, मुझे दिलचस्प लगता है कि कार्यों की इस संरचना में तर्क कैसे प्रबंधित किए जाते हैं।

फ़ंक्शन जो गणना करता है कि रीसेट की अनुमति नहीं है, तो हमें कितने प्रमुख प्रेस की आवश्यकता है:

Σz%e24 60z-
         z-    elementwise subtract the two times
 z%e24 60      take the hours difference modulo 24 and the minutes difference modulo 60
Σ              sum the two resulting numbers

दिलचस्प बात यह है कि चूंकि इस समाधान के बाकी हिस्से केवल तर्क के रूप में एक ही सूची के साथ काम कर सकते हैं, इसलिए यह आंशिक रूप से पूरे कार्यक्रम के पहले तर्क पर लागू होता है, इसे "खाने" और केवल दूसरे तर्क को छोड़कर दोनों के लिए ही दिखाई देता है और कार्यक्रम के बाकी।

इसके बाद, हम गणना करते हैं कि यदि हम 0:00 बजे का समय रीसेट करते हैं, तो हमें कितने प्रमुख प्रेस की आवश्यकता है

ṁ→    take the sum of each element of the list increased by 1

जैसा कि पहले कहा गया था, यह केवल दूसरे तर्क (अंतिम समय) पर काम करता है hours+minutes+2, और गणना करता है , बस एक गोल्फर तरीके से।

अंत में, §▼वह हिस्सा है जो दोनों कार्यों के लिए दूसरा तर्क देता है, और दो परिणामों के कम रिटर्न देता है।

Answer 2

जावास्क्रिप्ट (ईएस 6), 73 56 54 52 50 बाइट्स

24 घंटे के प्रारूप का उपयोग करता है। प्रत्येक समय के घंटे और मिनट का प्रतिनिधित्व करने वाले 4 पूर्णांकों के रूप में इनपुट लेता है।

(g,l,h,m)=>Math.min(2+h+m,(h-g+24)%24+(m-l+60)%60)

• 2 बाइट्स ने अरनौलड को धन्यवाद दिया ।

---

कोशिश करो

24-घंटे के प्रारूप में :विभाजक के साथ समय दर्ज करें ।

o.innerText=(f=

(g,l,h,m)=>Math.min(2+h+m,(h-g+24)%24+(m-l+60)%60)

)(+(x=(i.value="01:00").split`:`)[0],+x[1],+(y=(j.value="13:59").split`:`)[0],+y[1]);oninput=_=>o.innerText=f(+(x=i.value.split`:`)[0],+x[1],+(y=j.value.split`:`)[0],+y[1])

label,input{font-family:sans-serif;font-size:14px;height:20px;line-height:20px;vertical-align:middle}input{margin:0 5px 0 0;width:100px;}

<label for=i>Current: </label><input id=i type=time><label for=j>Target: </label><input id=j type=time><pre id=o>

---

व्याख्या

(शीघ्र ही अद्यतन किया जाएगा।)

(g,l,h,m)=>

बेनामी समारोह मापदंडों के माध्यम से तर्क के रूप में पूर्णांक लेने g, l, hऔर m, जहां gऔर lकर रहे हैं, क्रमशः, घंटे और वर्तमान समय के मिनट और hऔर mघंटे और लक्ष्य समय के मिनट कर रहे हैं।

2+h+m

सबसे पहले, हम गणना करते हैं कि अगर हम घड़ी को रीसेट करते हैं तो कितने बटन प्रेस की आवश्यकता होती है, जो कि बस 2 है (रीसेट के लिए) साथ ही लक्ष्य घंटे और लक्ष्य मिनट।

h-g+24*(h<g)

अगला हम गणना करते हैं कि लक्ष्य घंटे तक पहुंचने के लिए कितने बटन प्रेस की आवश्यकता है। हम इसे वर्तमान घंटे को लक्ष्य घंटे से घटाकर करते हैं। हालाँकि, यदि वर्तमान समय लक्ष्य से कम है, तो यह हमें एक ऋणात्मक संख्या देगा, इसलिए हम यह सुधारते हैं कि 24 को जोड़कर जाँच करें कि क्या h<g(जो एक बूलियन लौटाता है, लेकिन निहित रूप से पूर्णांक में डाली जाती है 1, यदि सही है, या 0यदि गलत है गणितीय कार्य।

+m-l+60*(m<l)

हम वर्तमान मिनट से लक्ष्य मिनट तक पहुंचने के लिए प्रेस की संख्या की गणना करने के लिए और घंटे के प्रेस में जोड़ने के लिए एक समान सूत्र का उपयोग करते हैं।

Math.min()

अंत में, हमें अपना परिणाम देने के लिए न्यूनतम 2 नंबर मिलते हैं।

Comments

क्या आप कर सकते हैं (h-g+24)%24+(m-l+60)%60?

— अरनौलद

Answer 3

पायथ , 29 बाइट्स

यह चुनौती स्पष्ट रूप से गोल्फ भाषाओं का लाभ नहीं देती है, इसीलिए यह इतनी लंबी है। दूसरी ओर, इस तथ्य से सुधार होता है कि पायथन पायथन-आधारित है, इसलिए हम इसके नकारात्मक मापांक का दुरुपयोग कर सकते हैं।

hS,+%-eQ@Q1 60%-@Q2hQ24+2s>Q2

परीक्षण सूट। _{पायथ में संख्याएँ अग्रणी शून्य का समर्थन नहीं करती हैं।}

Answer 4

जेली , 19 बाइट्स

_⁵%24µ+⁴_⁶%60µ«³+⁴¤

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

4 पूर्णांक (अंत-घंटा, समाप्ति-मिनट, प्रारंभ-घंटा, प्रारंभ-मिनट) के रूप में इनपुट

Comments

i.stack.imgur.com/mYVF7.jpg

— ETHproductions

@ETHproductions ಠ_ಠ

— हायपरनेट्रिनो

Answer 5

सी # (.NET कोर) , 56 बाइट्स

(H,M,h,m)=>Math.Min(((h+24-H)%24)+((m+60-M)%60),(2+h+m))

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

जावास्क्रिप्ट उत्तर के समान। C # में बॉल्स आसानी से संख्याओं में परिवर्तित नहीं होते हैं, इसलिए [diff]+24*(H<h)मैंने इसके बजाय ([diff]+24)%24जो प्रभावी रूप से एक ही काम किया है।

Comments

आप 2+h+m-2 बाइट्स के लिए कोष्ठक को हटा सकते हैं ।

— केविन क्रूज़सेन

मैंने जावा 8 में आपके उत्तर का एक पोर्ट बनाया है , और देखा कि आप अधिक कोष्ठक को हटाकर एक अतिरिक्त चार बाइट्स को (H,M,h,m)=>Math.Min((h+24-H)%24+(m+60-M%60),2+h+m)

— गोल

क्या आपको इसे बनाना नहीं पड़ेगा System.Math.Min?

— लीफडेविन

Answer 6

हास्केल, 41 बाइट्स

(a#b)c d=min(a+b+2)$mod(a-c)24+mod(b-d)60

बहुत सीधा। 24-घंटे के समय का उपयोग करते हुए चार तर्कों के रूप में इनपुट लेता है: अंत समय, अंत मिनट, प्रारंभ घंटे, प्रारंभ मिनट।

Answer 7

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

lambda a,b,c,d:min((c-a)%24+(d-b)%60,2+c+d)

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

4 पूर्णांक (प्रारंभ-घंटा, प्रारंभ-मिनट, अंत-घंटा, अंत-मिनट) के रूप में इनपुट

Comments

@ स्टीफन व्हूप्स। आसान तय।

— हाइपरन्यूट्रिनो

के लिए असफल2 01 11 00 ? आपके उत्तर में, यदि आप समय को निर्धारित करते हैं AMया PMइनपुट के रूप में नहीं लेते हैं, तो आप कैसे निर्धारित करते हैं ?

— श्री एक्सकोडर

@ Mr.Xcoder; मुझे 13TIO का उपयोग करके उस इनपुट के लिए मिलता है , जो सही है (रीसेट + 11 <9 + 59)।

— झबरा

है %हमेशा पायथन में एक धनात्मक संख्या वापसी?

— झबरा

@ यह हमेशा सही पक्ष का संकेत देता है %। 1%24= 1, 1%-24= -23। यह इस प्रश्न के लिए बहुत उपयोगी है।

— स्टीफन

Answer 8

जावा 8, 54 50 बाइट्स

(h,m,H,M)->Math.min((H-h+24)%24+(M-m+60)%60,H+M+2)

पोर्ट @KamilDrakari के C # उत्तर ( 2 गोल्फ बाइट्स के बाद)।

स्पष्टीकरण:

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

(h,m,H,M)->       // Method with four integer parameter and integer return-type
  Math.min(       //  Return the lowest of the following two:
                  //   The hours:
   (H-h           //    Second hours - first hours inputs
       +24)       //    +24 so we won't have negative numbers
           %24    //    mod-24 to get the hours
   +              //   And add the minutes:
    (M-m          //    Second minutes - first minutes inputs
         +60)     //    +60 so we won't have negative numbers
             %60  //    mod-60 to get the minutes
    ,H+M          //  And compare it to the second hours + second minutes inputs
        +2)       //   +2 for the added +24 and +60 to get the positive modulo arguments

Answer 9

पर्ल 5 , 71 +2 (-प) = 73 बाइट्स

($w,$x,$y,$z)=@F;$_=($r=2+$y+$z)>($c=($y-$w+24)%24+($z-$x+60)%60)?$c:$r

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

24 घंटे के प्रारूप (सैन्य समय) में इनपुट लेता है, रिक्त स्थान द्वारा अलग किया जाता है, समय पहले शुरू करते हैं, अंत समय दूसरा: एचएच एमएम एचएच मिमी

Answer 10

रेटिना , 106 बाइट्स

\d+
$*
 (1*):(1*)
 24$*1$1:60$*1$2#11$1$2
(1*):(1* )\1(1{24})?
$2
(1*) (1*):\1(1{60})?
$2
(1+)#(?!\1)

\G1

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण मामले शामिल हैं। दो बार अलग करने वाले स्थान के साथ नियमित 24 घंटे के समय में वर्तमान और वांछित समय के रूप में इनपुट लेता है। स्पष्टीकरण:

\d+
$*

यूनीरी में बदलें।

 (1*):(1*)
 24$*1$1:60$*1$2#11$1$2

यह दो काम करता है; यह वांछित घंटों और मिनटों में 24 घंटे और 60 मिनट जोड़ता है, और यह मूल वांछित घंटों और मिनटों के योग में 2 भी जोड़ता है, अर्थात रीसेट का उपयोग करके सेट करने के लिए बटन प्रेस की संख्या।

(1*):(1* )\1(1{24})?
$2

वर्तमान घंटों को वांछित घंटों से घटाएं, और यदि हम कर सकते हैं तो 24 को जोड़ दें।

(1*) (1*):\1(1{60})?
$2

इसी तरह मिनटों के लिए। यह दो परिणामों को एक साथ जोड़ता है।

(1+)#(?!\1)

यदि वर्तमान समय का उपयोग करके सेट करने के लिए प्रेस की संख्या रीसेट का उपयोग करके सेट करने के लिए प्रेस की संख्या से अधिक है, तो इसे हटा दें।

\G1

पहली शेष संख्या को वापस दशमलव में बदलें।