कब तक बचा है?

21

कब तक बचा है?

हाल ही में, मैं अपने फोन पर 5 मिनट के टाइमर का उपयोग करके पिज्जा बना रहा था। जब कोई अंदर चला गया और मुझसे पूछा कि कब तक छोड़ दिया गया, तो मुझे एक पल के लिए उलझन हुई कि सवाल का जवाब कैसे दिया जाए। आप देखें, यदि वर्तमान समय में टाइमर 3:47 पर था, तब तक मैं 'तीन मिनट और सैंतालीस सेकंड' पढ़ चुका था, समय बदल गया होगा। इसलिए, मुझे एक समय खोजने की जरूरत है कि टाइमर ठीक उसी तरह पहुंच जाए जैसे मैं इसे पढ़ता हूं।

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

आगे के नियम

  • आपको प्रत्येक के सिलेबल्स में से 'मिनट' और 'सेकंड' की गिनती करनी चाहिए, साथ ही उनके बीच एक 'और' भी।
  • पिज्जा खाना पकाने के लिए 59:59 से अधिक कभी नहीं लेगा।
  • '11 मिनट और 0 सेकंड '10 सिलेबल्स नहीं है: आपको '11 मिनट्स' (यानी 5 सिलेबल्स) को सरल बनाना होगा। एक ही मिनट के साथ चला जाता है: '0 मिनट और 7 सेकंड' को केवल 4 सिलेबल्स के रूप में गिना जाता है।
  • आपका प्रोग्राम किसी भी प्रारूप में आउटपुट दे सकता है: एक सरणी [minutes, seconds], या यहां तक ​​कि <minutes> minutes and <seconds> seconds(सामान्य पाठ के रूप में लिखा गया)।
  • मानक खामियां लागू होती हैं।
  • यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।

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

सभी इनपुट के रूप में (minutes, seconds)

(4, 47) = (4, 38) (Four MiNutes And ThirTy Eight SeConds - 9 syllables/seconds)
(1, 1) = (0, 56) (FifTy-Six SeConds - 5 syllables/seconds)
(59, 57) = (59, 46) (FifTy Nine Minutes And Forty Six SeConds - 11 syllables/seconds)
(0, 10) = null/error/0 (no positive answer)

शब्दांश गणना संदर्भ

संदर्भ के लिए, यहां 59 तक प्रत्येक संख्या में शब्दांश की संख्या है।

0,0 (does not need to be counted)
1,1
2,1
3,1
4,1
5,1
6,1
7,2
8,1
9,1
10,1
11,3
12,1
13,2
14,2
15,2
16,2
17,3
18,2
19,2
20,2
21,3
22,3
23,3
24,3
25,3
26,3
27,4
28,3
29,3
30,2
31,3
32,3
33,3
34,3
35,3
36,3
37,4
38,3
39,3
40,2
41,3
42,3
43,3
44,3
45,3
46,3
47,4
48,3
49,3
50,2
51,3
52,3
53,3
54,3
55,3
56,3
57,4
58,3
59,3
code-golf  date  natural-language  text-processing 
— गीज़ा केरेसेनी
स्रोत
आपके पहले परीक्षण के मामले में, 4:37 भी एक वैध आउटपुट होगा, क्योंकि यह कहने के लिए 10 शब्दांश होगा?
— क्विन
1
@ क्विन, युक्ति बताती है कि हमें जल्द से जल्द समय का उत्पादन करना चाहिए ।
— झबरा
1
@ शागिर्द उफ़, तो यह धन्यवाद करता है - जब तक मैं अपना जवाब नहीं देता, मुझे लगता है कि मेरा पिज्जा जला दिया जाएगा
— क्विन
क्या हमें यह मानने की अनुमति है कि इनपुट को गद्देदार किया जा सकता है, अर्थात 4 मिनट और 43 सेकंड को "04:43" कहा जा सकता है?
— वेदवर्त १
1
@ Vedvart1 ठीक है, यह ठीक है
— गीज़ा

जवाबों:

4

जावास्क्रिप्ट (ईएस 6),  112 106  105 बाइट्स


@DaniilTutububin द्वारा सहेजे गए 6 और बाइट्स @EmbodimentofIgnorance के सुझाव पर आधारित एक छोटा संस्करण

(minutes)(seconds)[minutes, seconds]0

m=>d=F=s=>m|s?(g=n=>n&&(n%10!=7)-7+(n-11?n<13?2:n<21|n%10<1:0))(m)+g(s)^~d?F(s?s-1:m--&&59,d=-~d):[m,s]:0

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

जावास्क्रिप्ट (ईएस 6),  126  119 बाइट्स

(minutes)(seconds)[minutes, seconds]0

m=>d=F=s=>m|s?(g=n=>n&&2+(30774612>>2*n%(n>12?20:26)&3)+(n>12)+(n>19))(m)+g(s)+!!(m*s)^d?F(s?s-1:m--&&59,d=-~d):[m,s]:0

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

टिप्पणी की गई

m =>                  // m = minutes
d =                   // d = delta in seconds between the initial time and the current time,
                      //     initialized to a non-numeric value (zero-ish)
F = s =>              // F is a recursive function taking s = seconds
  m | s ? (           // if either m or s is not 0:
    g = n =>          //   g is a helper function taking an integer n in [0..59]
      n &&            //     return 0 if n = 0
      2 + (           //     otherwise, start with 2 for either 'mi-nutes' or 'se-conds'
        30774612 >>   //     add the base number of syllables (0 to 3) corresponding to n
        2 * n %       //     using a bitmask of 13 entries x 2-bit:
                      //       12 11 10  9  8  7  6  5  4  3  2  1  0
                      //       01 11 01 01 01 10 01 01 01 01 01 01 00
        (n > 12 ? 20  //     using n MOD 10 if n is greater than 12
                : 26) //     or just n otherwise
        & 3           //     isolate the two least significant bits
      ) +             //   
      (n > 12) +      //     add 1 syllable for '-teen' or '-ty' if n is greater than 12
      (n > 19)        //     add 1 more syllable for 'x-ty' if n is greater than 19
  )(m) +              //   invoke g for the minutes
  g(s) +              //   invoke g for the seconds
  !!(m * s)           //   add 1 syllable for 'and' if both m and s are non-zero
  ^ d ?               //   if the result is not equal to the delta:
    F(                //     otherwise, do a recursive call:
      s ? s - 1       //       decrement s if it's not 0,
        : m-- && 59,  //       or decrement m and restart with s = 59
      d = -~d         //       increment the delta
    )                 //     end of recursive call
  :                   //   else:
    [m, s]            //     success: return [m, s]
:                     // else:
  0                   //   failure: return 0
— Arnauld
स्रोत
क्या आप कृपया स्पष्टीकरण जोड़ सकते हैं?
— गीज़ा केर्केसेनी
@GezaKerecsenyi हो गया। :-)
— अरनुलड
धन्यवाद। यह ज्यादातर 30774612>>2*n%(n>12?20:26)&3हिस्सा था जिसके बारे में मुझे भ्रम था।
— गीज़ा केर्केसेनी
1
g=x=>x&&(x%10==7)+(x==11?6:x<13?4:x<21|x%10<1?5:6)काम कर सकता है (जब से इंटरनेट डाउन हो रहा है और मेरे फोन का उपयोग कर रहा है)
— इग्नोरेंस का अवतार
1
@ डानिलटुटुबलिन कूल। मैं g()विपरीत परिणाम और XOR'ing के साथ लौटने से वहाँ से एक और बाइट बचा लिया ~d।
— अरनुलद
2

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

m=int(input())
s=int(input())
y=lambda w:3+(w[-1]=='7')-(w[-1]=='0')-(w[0]in'01')*(1+(w[0]=='0'))+(w=='11')-(w=='12')
z=lambda m,s:(2+y(f'{m:02d}'))*(m!=0)+(2+y(f'{s:02d}'))*(s!=0)+(m!=0!=s)
q=lambda t: (m-(t+60-s-1)//60,(s-t)%60)
print([q(t) for t in range(s+60*m) if z(*q(t))==t][0])

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

यह एक बहुत चालाक समाधान नहीं है - यह ज्यादातर स्ट्रैगफोरवर्ड है। अलग-अलग इनपुट के रूप में 'm: s' s और s लेता है , (गद्देदार होने की जरूरत नहीं है) और आउटपुट (एम, एस) । यदि कोई मान्य आउटपुट नहीं है, तो एक त्रुटि है।

कार्यक्रम 0 और 1. अनुमानित रूप से कास्टिंग बूलियंस पर बहुत निर्भर करता है। पहली पंक्ति इनपुट लेती है। दूसरी पंक्ति एक लैम्ब्डा फंक्शन y को परिभाषित करती है जो सिलेबल्स को एक संख्या में देता है - यह 3 सिलेबल्स के आधार को मानता है, फिर 1 को जोड़ता है यदि यह 7 में समाप्त होता है, 0 में समाप्त होने पर 1 को घटाता है और 1 को घटाता है जो कि 10 के दशक में है। 2 यदि यह एकल अंकों में है। बारह और ग्यारह को मैन्युअल रूप से अंत में समायोजित किया जाता है। तीसरी पंक्ति पूरी अभिव्यक्ति में शब्दांशों के लिए एक लंबोदर है। अंत में, चौथी पंक्ति t सेकंड के बाद का समय देती है। पांचवीं पंक्ति आउटपुट है - यह सभी समय की एक सरणी बनाता है जो समस्या को पूरा करता है, और पहले वाले को आउटपुट करता है।

संपादित 1: टिप्पणियों में मैथ्यू एंडरसन के लिए धन्यवाद, 2 बाइट्स अलग से इनपुट लेने से मुंडा थे।

— Vedvart1
स्रोत
1
यदि आप दो अलग-अलग लाइनों पर इनपुट लेते हैं: m=int(input()) s=int(input())तो आप 2 बाइट्स बचा सकते हैं।
— मैथ्यू एंडरसन
1

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

ḅḶbɗ60Ṛµ“÷ṢḣxE⁻Ṇ⁹ƬƝwɼỤṡl’ḃ4+2;0⁸ịS+ṬS$’)=JTị⁸Ḣ

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

एक मौद्रिक लिंक अपने तर्क के रूप में समय ले [minutes, seconds]रहा है और उचित समय को एक मिनट से कम [minutes, seconds]या [seconds]अधिक कहने के लिए वापस कर रहा है ।

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