कयामत का घड़ी हाथ

9

आप एक कुर्सी के लिए जंजीर हैं। आपके नीचे एक विशाल ज्वालामुखी है। आपके बगल में 12 घंटे की घड़ी अशुभ रूप से टिक जाती है, और आप देखते हैं कि इसमें पीछे से एक श्रृंखला तक के तार हैं, जो आपको पृथ्वी के केंद्र में छोड़ देंगे। घड़ी पर टैप किया गया एक नोट है:

प्रत्येक घड़ी हाथ में एक इलेक्ट्रोड है। जब दोनों घड़ी हाथ एक ही स्थिति में होते हैं, तो शक्ति प्रवाहित होती है और आप मर जाते हैं। यही है, जब तक कि आप मुझे सटीक समय नहीं बता सकते कि यह घटित होगा, निकटतम मिनट तक।

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

OEIS पृष्ठ के अनुसार , ग्यारह ओवरलैप समय हैं:

00:00:00 plus 0/11 s, 01:05:27 plus 3/11 s,
02:10:54 plus 6/11 s, 03:16:21 plus 9/11 s,
04:21:49 plus 1/11 s, 05:27:16 plus 4/11 s,
06:32:43 plus 7/11 s, 07:38:10 plus 10/11 s,
08:43:38 plus 2/11 s, 09:49:05 plus 5/11 s,
10:54:32 plus 8/11 s.

अगली बार 12:00:00 होगा। इस चुनौती के लिए सेकंड और उनके आंशिक भागों की आवश्यकता नहीं है। बस निकटतम मिनट के लिए गोल।

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

0:00 (Or 12:00) > 1:05
1:00 > 1:05
11:56 > 12:00 (Or 0:00)
6:45 > 7:38
5:00 > 5:27
6:30 > 6:33 (round up)

कार्यक्रम एक समारोह, या पूर्ण कार्यक्रम हो सकता है। मुझे परवाह नहीं है अगर आप चुनते हैं 0:00या 12:00, और दोनों स्वीकार्य हैं। सौभाग्य!

code-golf  date 
— Redwolf कार्यक्रम
स्रोत
टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।
— Mego

जवाबों:

6

जावास्क्रिप्ट (Node.js) , 54 47 बाइट्स (निकटतम गोल)

-7 बाइट्स। धन्यवाद @ user202729

a=>b=>[(a+=b>5.46*a)+a/11|0,a%12*65.46%60+.5|0]

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

जावास्क्रिप्ट (Node.js) , 40 33 44 बाइट्स (0 की ओर गोल)

-3 बाइट्स @Arnauld को धन्यवाद

-4 बाइट्स @ केविन क्रूज़सेन को धन्यवाद

a=>b=>[(a+=b>5.46*a)+a/11|0,a%12*65.46%60|0]

व्याख्या

a=>b=>[(a+=b>5.46*a)+a/11|0,a%12*65.46%60|0]    Full Code
a                                               Hours
   b                                            Minutes
    =>[                    ,               ]    return array with
       (a+=        )                            add to the current hour
           b>5.46*a                             1 if the minute's clock hand has 
                                                passed the hour's clock hand. Here we use
                                                equation 60*a/11 which is the same as 5.46*a
                    +a/11                       and add 1 when hour is 11
                         |0                     floor the result

                            a%12*65.46%60|0     Here we do equation ((720/11)*a) (mod 60)
                            a%12                In case of hour 12 we take 0
                                *65.46          multiply hour by 720/11 which can be shortened to
                                                65.46 to save 1 byte.
                                      %60       mod 60
                                         |0     floor the result

साइड नोट: मुझे पूरा यकीन है कि यह गणित में अधिक ज्ञान वाले किसी व्यक्ति द्वारा नीचे गोल्फ हो सकता है। मुझे मुश्किल से पता है कि कैसे योग और गुणा करना है

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

— लुइस फेलिप डी जीसस मुनोज
स्रोत
: यह सही नहीं लगता है, तो आप कैसे एक असली घड़ी कार्रवाई में काम करता है ले datagenetics.com/blog/november12016/index.html
— Night2
आपके पास कुछ गोल त्रुटियां हैं। 05:00आउटपुट चाहिए , 05:27बल्कि आउटपुट 05:25चाहिए, और 06:45आउटपुट 07:38बल्कि आउटपुट 07:35चाहिए। यहाँ शायद एक उपयोगी oeis अनुक्रम: A178181
— केविन क्रूज़सेन
1
@LuisfelipeDejesusMunoz मेरे द्वारा दिए गए दो परीक्षण मामले वास्तव में अभी सही हैं, लेकिन आपका (या ) के बजाय 11:56आउटपुट लगता है । 00:0500:0012:00
— केविन क्रूज़सेन
@ केविनक्रूजसेन किया। मुझे लगता है कि a=(a+=b>=a*5)%12थोड़ा छोटा किया जा सकता है, लेकिन मैं इस पर बहुत अच्छा नहीं हूं
— लुइस फेलिप डी जीसस मुनोज़
1
Math.round(x)बस नहीं है 0|x+.5?
— user202729
5

जे , 31 बाइट्स

0.5<.@+>:@<.&.(11r720*12 60&#.)

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

J में एक संख्या को गोल करने का तरीका 0.5फर्श को जोड़ना और लेना है ( <.)। बहुत सारे बाइट्स लेता है ...

व्याख्या

12 60&#. (मिश्रित आधार रूपांतरण) [घंटे, मिनट] की एक सरणी से 0:00 के बाद पारित मिनट में परिवर्तित होता है।

ध्यान दें कि 0:00 से शुरू, प्रत्येक 12/11 घंटे (यानी, 720/11 मिनट), दोनों हाथ एक बार ओवरलैप होते हैं।

इसलिए, मिनट के मूल्य को देखते हुए, इसे 720/11 के निकटतम कई तक ही राउंड करें (खुद से अलग)। *इसे इसके द्वारा 11/720 (J के पास परिमेय संख्या शाब्दिक 11r720) द्वारा प्राप्त किया जा सकता है , फर्श <., वेतन वृद्धि लें >:, फिर इसे 720/11 से गुणा करें।

ध्यान दें कि "11/720 से गुणा करें" और "720/11 से गुणा करें" 2 रिवर्स एक्शन हैं, साथ ही "[घंटे, मिनट] से मिनट की संख्या में परिवर्तित करें" और इसके विपरीत। सौभाग्य से J में अंतर्निर्मित &.(अंडर) है, जो किसी परिवर्तन को लागू करने के बाद कुछ क्रिया को उलट देता है।

उसके बाद बस गोलाई लें: 0.5 +फिर <.।

— user202729
स्रोत
5

आर , 68 बाइट्स

a=round(1:30*720/11);a[a>sum(scan()*c(60,1))][1]%/%c(60,1)%%c(12,60)

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

  • -2 बाइट्स ग्यूसेप के लिए धन्यवाद
  • लापता गोलाई के कारण +7 बाइट्स :(

समीकरण का शोषण: 

same_position_minutes = 720/11 * index

जहां indexपहली अतिव्यापी स्थिति के लिए 0 (00:00), 2 के लिए 1 और इसी तरह ...

— digEmAll
स्रोत
1
मुझे लगता है कि आपके पास चारों ओर कोष्ठकों का एक बाहरी सेट है(a[...]...c(60,1))
— Giuseppe
@Giuseppe: हाँ, तुम सही हो ... धन्यवाद!
— digEmAll
@digEmAll यह गलत उत्तर देता है 6:30 > 6:33।
— mbomb007
@ mbomb007: आप सही कह रहे हैं;)
— digEmAll
4

आर , 88 बाइट्स

i=scan();d=1+60*i[1]+i[2];while(abs(60*(h=d%/%60%%12)-11*(m=d%%60))>5){d=d+1};paste(h,m)

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

एक मिनट तक समय बढ़ाएं। कोण चेक करता है। यदि पर्याप्त बंद नहीं है, तो एक समाधान मिलने तक लूप करें।

— Jayce
स्रोत
1
हुह, यह करने का एक अच्छा तरीका है। मैंने कभी भी वास्तविक घड़ी का अनुकरण करने के बारे में नहीं सोचा था!
— रेडवॉल्फ कार्यक्रम
3

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

यह मेरा पहला सबमिशन है, इसलिए रचनात्मक आलोचना का स्वागत है :)

-2 बाइट्स थैंक्स टू @ किंग

def f(h,m):n=65.45;r=round(((60*h+m)//n%11+1)*n);print('%i:%02i'%(r//60,r%60))

इसे ऑनलाइन आज़माएं! (78) इसे ऑनलाइन आज़माएं! (80)

— काला उल्लू काई
स्रोत
2
PPCG में आपका स्वागत है! अच्छा पहला जवाब!
— mbomb007
2

जावा 8, 89 82 बाइट्स

(h,m)->(m=m<(m=(int)(h%12*720d/11%60))?m:(int)(++h%12*720d/11%60))*0+h%12%11+" "+m

फिक्स्ड। देखेंगे कि क्या मैं इसे बाद में गोल्फ (शायद एक और जवाब पोर्ट करके) कर सकता हूं।

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

स्पष्टीकरण:

करने के लिए

— केविन क्रूज़सेन
स्रोत
आपके द्वारा दिए गए उत्तर के रूप में एक ही मुद्दा (जाहिर है) - जैसे: f.apply(56).apply(10)पैदावार11 59
— जोनाथन एलन
@JonathanAllan फिक्स्ड। देखूंगा कि क्या मैं बाद में कुछ बाइट्स निकाल सकता हूं ..
— केविन क्रूज़सेन
@ केविनक्रूजसेन यह गलत उत्तर देता है 6:30 > 6:33।
— mbomb007
@ mbomb007 मुझे पता है। मैं फिक्सिंग से पहले ओपी के जवाब का इंतजार कर रहा हूं। चाहे हम फर्श, गोल, छत, या दोनों की अनुमति दें (यदि मैंने चुनौती पोस्ट की होगी तो मैं चौथे विकल्प का उपयोग करूंगा, लेकिन चलो पहले ओपी की प्रतीक्षा करें)।
— केविन क्रूज़सेन
@KevinCruijssen परीक्षण मामले को ओपी की एक टिप्पणी के कारण प्रश्न में संपादित किया गया था । दौर की सबसे आम परिभाषा का उपयोग करते हुए , ओपी का इरादा स्पष्ट है।
— mbomb007 20
2

अप्ल (डाइलॉग यूनिकोड) , 28 बाइट्स

((⍳11),⍪0,+\∊5/⊂5 6)(⍸⌷1⊖⊣)⎕

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

व्याख्या

((⍳11),⍪0,+\∊5/⊂5 6)समय का एक मैट्रिक्स है जहां हाथों को ओवरलैप किया जाता है (टियो लिंक के अंत में मुद्रित किया जाता है)
(⍸⌷1⊖⊣)⎕अंतराल पाता है जिसमें इनपुट मैट्रिक्स में होता है और इसके नीचे लपेटते हुए अनुक्रमित होता है।

— jslip
स्रोत
2

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

(h,m)=>{h%=12;int n=(5*h+h/2)%60;return (m>n||h>10)?f(h+1,0):h+":"+n;}

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

मुझे लगता है कि यह सभी परीक्षण मामलों को पारित करता है। हालांकि h = 11 केस एक तरह का बदसूरत है

स्पष्टीकरण:

(h,m)=>{ // Lambda receiving 2 integers
    h%=12; // Just to get rid of the 0/12 case
    int n=(5*h+h/2)%60; // get the minute at which the hands overlap 
                        //for current hour.
    return 
    (m>n||h>10)? // if current minute > n or h=11
        f(h+1,0) // it will happen next hour
    :
        h+":"+n; // return result
}
— F.Carette
स्रोत
यह गलत उत्तर देता है 6:30 > 6:33।
— mbomb007
@ mbomb007 धन्यवाद, मैं इस पर एक नज़र डालने जा रहा हूं। ओवरलैप समय की पूरी सूची को जोड़ने से पहले मैंने पहली कोशिश की थी।
— एफ। सिगरेट 21
यह अब ठीक होना चाहिए। चूंकि हमारे पास इस बात के बारे में स्पष्ट निर्देश नहीं है कि करंट टाइम == ओवरलैप टाइम में क्या करें, मैं इन मामलों में वर्तमान समय लौटाता हूं (दिए गए (1,5) रिटर्न "1: 5" और "2:11" नहीं) ।
— F.Cacco
1

जावास्क्रिप्ट, 41 बाइट्स

p=>q=>(p+=q>=(5.5*p|0),p%=11,[p,5.5*p|0])

कोड स्निपेट दिखाएं

— TSH
स्रोत
0

पर्ल 6 , 43 बाइट्स

(* *60+*+33).round(65.45).round.polymod(60)

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

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

व्याख्या

(* *60+*+33)   # Converts the two inputs to number of minutes
            .round(65.45)   # Round to the nearest multiple of 65.45
                         .round  # Round to the nearest integer
                               .polymod(60) # Repeatedly modulo by 60 and return the list of results
— मजाक कर रहा है
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.