मुझे वास्तव में ऐसे समय पसंद हैं जो कुछ पैटर्न का पालन करते हैं। विशेष रूप से, मैं ऐसे समय को पसंद करता हूं जहां सभी अंक समान होते हैं, या सभी अंक अंकगणित में बाएं से दाएं बढ़ते हैं। इसके अलावा, जब लोग मेरे समय में पत्र डालते हैं, तो मैं स्पष्ट रूप से घृणा करता हूं, इसलिए वह सभी एएम / पीएम बकवास मेरे लिए मर चुका है। इस प्रकार, मेरे पसंदीदा समय हैं:

0000 0123 1111 1234 2222 2345

मेरे मन की शांति के लिए, मुझे आपको एक एकल प्रोग्राम लिखने की आवश्यकता है, जो इनपुट के रूप में वर्तमान समय को देखते हुए, दोनों: (ए) अगर यह अब मेरे पसंदीदा समय में से एक नहीं है , तो मुझे दोनों को बताएं (i) कितने मिनट मेरे अंतिम पसंदीदा समय के साथ-साथ (ii) अब से कितने मिनट बाद मेरा अगला पसंदीदा समय होगा; और (बी) यदि यह है अब मेरी पसंदीदा बार में से एक, एक 'संकेत मान' आपूर्ति करती है।

इनपुट

आपके कार्यक्रम को stdinनिम्न में से किसी भी प्रारूप में वर्तमान समय में (जो भी विधि: फ़ंक्शन तर्क, कमांड लाइन तर्क, आदि) स्वीकार करना चाहिए :

एक स्ट्रिंग के रूप में चार अंकों का समय
एक पूर्णांक जो एक स्ट्रिंग के रूप में चार अंकों का समय बनाने के लिए बाईं ओर शून्य-गद्देदार हो सकता है
चार (या कम) पूर्णांक का एक क्रम, इस तरह का आदेश दिया कि अनुक्रम में पहला पूर्णांक समय इनपुट में सबसे बाईं ओर (महत्वपूर्ण) अंक है (जैसे, 0951वैध रूप से [0, 9, 5, 1]या के रूप में प्रतिनिधित्व किया जा सकता है [9, 5, 1])
- 0000शून्य-लंबाई अनुक्रम के रूप में प्रतिनिधित्व स्वीकार्य है

एक स्ट्रिंग इनपुट के मामले में, इसमें केवल अंक, कोई कॉलन या अन्य विराम चिह्न नहीं होना चाहिए । इनपुट को हमेशा 24 घंटे के वैध होने का अनुमान लगाया जा सकता है: HHMM कहां 0 <= HH <= 23और कहां 0 <= MM <= 59। एक छलांग दूसरे की संभावना की उपेक्षा करें।

उत्पादन

आपके कार्यक्रम को आपूर्ति (फ़ंक्शन रिटर्न, stdoutआदि सभी ठीक हैं) या तो (ए) या (बी) हैं , जैसा कि इनपुट मूल्य लक्ष्य समय है या नहीं।

के लिए):

किसी भी समझदार प्रारूप में दो संख्यात्मक मूल्यों की आपूर्ति करें, जैसे:

एक उपयुक्त सीमांकक के साथ एकल-स्ट्रिंग आउटपुट
अनुक्रमिक पूर्णांक / स्ट्रिंग आउटपुट, उदाहरण के लिए, bashदो पंक्तियों को मुद्रित करना stdout:
```
49
34
```
लंबाई-दो का आदेश दिया गया रिटर्न मान, जैसे कि पायथन सूची, एक सी सरणी, आदि।: [49, 34]

मूल्य या तो क्रम में आ सकते हैं। उदाहरण के लिए, निम्नलिखित में से दोनों इनपुट के लिए मान्य आउटपुट होंगे 1200:

49 34
34 49

आदेश और विभाजक सभी इनपुट मूल्यों के लिए समान होना चाहिए, हालांकि!

के लिए (बी):

अन्यथा अप्राप्य परिणाम का उत्पादन करें। एक ही परिणाम लक्ष्य समय के सभी छह के लिए उत्पादन किया जाना चाहिए, हालांकि। अनंत छोरों को बाहर रखा गया है।

नमूना इनपुट / आउटपुट

YAY!!! यहां एक प्रदर्शनकारी उदाहरण के रूप में उपयोग किया जाता है और यह निर्धारित नहीं है।

Input      Output
------    --------
 0000      YAY!!!
 0020      20 63
 0105      65 18
 0122      82 1
 0123      YAY!!!
 0124      1 587
 0852      449 139
 1111      YAY!!!
 1113      2 81
 1200      49 34
 1234      YAY!!!
 1357      83 505
 1759      325 263
 1800      326 262
 1801      327 261
 2222      YAY!!!
 2244      22 61
 2345      YAY!!!
 2351      6 9

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा कोड है। मानक खामियों को अस्वीकार कर दिया जाता है।

code-golf date

— hBy2Py
स्रोत

क्या पसंदीदा समय के लिए कुछ भी वापस करना ठीक है?

— जेम्स होल्डरनेस

1

@JamesHolderness काल्पनिक-मुझे एक आवेदन से वापस कुछ भी नहीं मिलने पर चींटियां हो जाती हैं (क्या होगा अगर दुभाषिया गड़बड़ हो?!?), इसलिए कुछ मूल्य या आउटपुट उत्पन्न करना होगा।

— hBy2Py

2

जेली , 34 33 32 31 28 बाइट्स

मिस्टर एक्सकोडर .ịऔर ³ट्रिक्स के लिए 3 बाइट्स धन्यवाद ।

d³ḅ60;15j83,588ṁ5¤_\ṠÞAµ.ịxẠ

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

कुछ हिस्से जोनाथन एलन के उत्तर के समान हैं , लेकिन मैं इसे पोस्ट कर रहा हूं क्योंकि मुझे लगता है कि यह पर्याप्त रूप से इससे अलग है और स्वतंत्र रूप से मेरे पाइथ उत्तर के आधार पर लिखा गया है (और कम: डी) के । सुधार की गुंजाइश भी होनी चाहिए।

इनपुट एक पूर्णांक है, आउटपुट पिछले और अगली बार की सरणी है या विशेष समय के लिए खाली सरणी है।

व्याख्या

उदाहरण इनपुट का उपयोग करना 1200।

d³आधार को 100, घंटे और मिनट में परिवर्तित करता है [12,0]:।
ḅ60कुल 60 मिनट पाने के लिए बेस 60 से धर्मान्तरित 720:।
;15जोड़े इसे 15 के साथ [720, 15]:।
83,588सरणी बनाता है [83, 588]।
ṁ5इसकी लंबाई 5: है [83, 588, 83, 588, 83]।
¤उपरोक्त दोनों क्रियाओं को जोड़ती है। बस एक तकनीकीता।
jइस जोड़ी को सरणी के साथ जोड़ देता है [720, 83, 588, 83, 588, 83, 15]:।
_\प्रत्येक सरणी मान को पहले से घटाता है और मध्यवर्ती परिणाम प्राप्त करता है [720, 637, 49, -34, -622, -705, -720]:।
ṠÞ स्थिरतापूर्वक Signum द्वारा इन प्रकार: [-34, -622, -705, -720, 720, 637, 49]।
Aपूर्ण मान लेता है [34, 622, 705, 720, 720, 637, 49]:।
µएक नई मौद्रिक श्रृंखला शुरू करता है। फिर से, एक तकनीकीता।
.ịअंतिम और पहला आइटम लेता है [49, 34]:।
×Ạदोहराता है कि एक बार यदि शून्य नहीं हैं, या शून्य बार अन्यथा [49, 34]:।

— PurkkaKoodari
स्रोत

@JamesHolderness कोई आकार परिवर्तन (बदल के लिए फिक्स्ड ,करने ;के बाद से यह एक सूची शाब्दिक रूप में उठाया जा रहा था)।

— पुरकाकूदरी

पर्याप्त रूप से, मैंने जेली को आपके पाइथ उत्तर को पोर्ट करने की कोशिश की और मुझे 28 बाइट्स मिले । मुझे नहीं लगता कि यह एक अलग उत्तर होना पर्याप्त है, इसलिए इसका उपयोग करने के लिए स्वतंत्र महसूस करें (और प्यारा परीक्षण सूट: पी)। (ध्यान दें कि का उपयोग कर ³के बजाय 100है की अनुमति दी ) YAY!!!मूल्य है [0, 0], हमेशा एक ही।

— मिस्टर एक्सकोडर

अच्छा धन्यवाद! मुझे लगता है कि मुख्य सुधार आधी-अनुक्रमणिका चाल है, मैंने उस बारे में कभी नहीं सोचा।

— पुरकाकूदरी

क्या आप मेरे सुझावों के साथ अपडेट करने की योजना बना रहे हैं? (बस एक अनुस्मारक, मुझे लगता है कि आप संपादित करना भूल गए हैं?)

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

@ Mr.Xcoder हाँ, संपादित करना भूल गया। मैं xẠशून्य फ़िल्टर के रूप में उपयोग करूँगा क्योंकि मैं इसे []अधिक पसंद करता हूं [0, 0]क्योंकि यह अधिक स्पष्ट रूप से अलग है।

— पुरकाकूदरी

2

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

@ L4m2 के लिए धन्यवाद 4 बाइट्स सहेजे गए

एक स्ट्रिंग के रूप में इनपुट लेता है। 0या तो या 2-तत्व सरणी देता है।

t=>[i=0,83,588,83,588,83,15].every(d=>(k=t-(t/25>>2)*40)>(j=i,i+=d))|i-k&&[k-j,i-k]

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

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

let f =

t=>[i=0,83,588,83,588,83,15].every(d=>(k=t-(t/25>>2)*40)>(j=i,i+=d))|i-k&&[k-j,i-k]

console.log(f('0000')) // YAY!!!
console.log(f('0020')) // 20 63
console.log(f('0105')) // 65 18
console.log(f('0122')) // 82 1
console.log(f('0123')) // YAY!!!
console.log(f('0124')) // 1 587
console.log(f('0852')) // 449 139
console.log(f('1111')) // YAY!!!
console.log(f('1113')) // 2 81
console.log(f('1200')) // 49 34
console.log(f('1234')) // YAY!!!
console.log(f('1357')) // 83 505
console.log(f('1759')) // 325 263
console.log(f('1800')) // 326 262
console.log(f('1801')) // 327 261
console.log(f('2222')) // YAY!!!
console.log(f('2244')) // 22 61
console.log(f('2345')) // YAY!!!
console.log(f('2351')) // 6 9

स्निपेट का विस्तार करें

कैसे?

हम .every()लूप के परिणाम की परवाह नहीं करते हैं । बशर्ते कि इनपुट मान्य है, यह हमेशा गलत होगा। जब हम इस लूप से बाहर निकलते हैं तो हमें वास्तव में किस चीज में रुचि होती है ।

जैसे ही हम एक पसंदीदा समय i(मिनटों में व्यक्त) पाते हैं, जो संदर्भ समय k( tमिनटों में परिवर्तित इनपुट समय ) से अधिक या बराबर है । हम तो लौट 0यदि i == kया 2 देरी अन्यथा।

— Arnauld
स्रोत

2

t%100+(t/25>>2)*60=>t-(t/100|0)*40

— l4m2

2

बेगुंज -93, 88 85 86 80 74 बाइट्स

&:"d"/58**-:"S"-:"b"6*-:"S"v
@._v#!:<\-*53:-"S":-*6"b":-<
:$#<$$\^@.._\#`0

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

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

— जेम्स होल्डरनेस
स्रोत

1

सी, 121 बाइट्स

*p,l[]={0,83,671,754,1342,1425,1440};f(t){t=t%100+t/100*60;for(p=l;t>*p;++p);*p-t?printf("%d %d",t-p[-1],*p-t):puts("");}

यदि कोई पसंदीदा समय है, तो एक नई पंक्ति का उत्पादन करता है।

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

— Steadybox
स्रोत

1

क्लीन , 126 बाइट्स

import StdEnv
f=[1440,1425,1342,754,671,83,0]
?t#t=t rem 100+t/100*60
=(\(a,b)=(t-hd b,last a-t))(span(\a=t<a||isMember t f)f)

फ़ंक्शन को परिभाषित करता है ?, ले रहा है Intऔर लौट रहा है (Int, Int)।
जब तर्क पसंदीदा समय होता है, तो यह कॉलिंग प्रोग्राम को क्रैश कर देता है hd of []।

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

— Οurous
स्रोत

1

पायथ, 48 45 42 बाइट्स

&*FJ.u-NY+P*3,83 588 15isMcz2 60,eK._DJ_hK

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

कोड एक समय स्ट्रिंग में लेता है और पिछली और अगली बार सरणी के रूप में आउटपुट करता है, या 0 यदि समय विशेष है।

दिलचस्प है, एक अनिवार्य दृष्टिकोण भी 42 बाइट्स है:

V+_isMcz2 60+P*3,83 588 15KZIg0=-ZNIZK)_ZB

व्याख्या

cz2 विभाजन इनपुट (z ) दो-चरित्र टुकड़ों में।
sM उन्हें पूर्णांक के रूप में मूल्यांकन करता है।
i... 60परिणामी दो-आइटम सरणी को आधार 60 के रूप में बताता है।
,83 588सरणी का प्रतिनिधित्व करता है [83, 588]।
*3के लिए triplicates [83, 588, 83, 588, 83, 588]।
Pआखिरी निकालता है 588।
+… अंत में 15जोड़ता 15है।
.u-NYपार्स की गई संख्या से शुरू होता है, इसमें से प्रत्येक संख्या को सरणी में घटाता है और मध्यवर्ती मान लौटाता है। ये प्रत्येक विशेष समय के अंतर हैं।
J को ये अंतर सौंपता है J ।
*Fमतभेदों के उत्पाद की गणना करता है। यह 0 होगा यदि समय विशेष था।
& यहाँ मूल्यांकन बंद कर देता है और यदि समय विशेष था तो 0 लौटाता है।
._DJ स्थिर-चिह्न द्वारा अंतरों को छांटें।
K उस एरे को बचाता है K ।
e सरणी में अंतिम आइटम लेता है।
_hK सरणी में पहला आइटम लेता है और इसे नकारता है।
, एक सरणी के रूप में दो लौटाता है।

— PurkkaKoodari
स्रोत

और यह नकारात्मक संकेत को अवशोषित करने का एक बढ़िया, डरपोक तरीका है।

— hBy2Py

स्विच करके एक बाइट सहेजें cz2 60करने के लिए c2z60(वे 4-तत्व सूचियों के लिए बराबर हैं)

— श्री Xcoder

1

जेली , 33 32 34 बाइट्स

+3 +2 बाइट्स को ठीक करने के लिए ताकि सभी पसंद किए गए समय आउटपुट बराबर हों।

^{एक छोटा रास्ता होना चाहिए!}

s2Ḍḅ60
83,588ṁ5“¡Ð‘j+\ṡ2>E¥ÞÇḢạÇa\

चार अंकों की एक सूची लेने और दो पूर्णांकों से युक्त सूची को वापस करने वाला एक विवादास्पद लिंक
- यदि यह एक पसंदीदा समय है तो दोनों प्रविष्टियों का परिणाम शून्य होगा।

इसे ऑनलाइन आज़माएं! या देखें परीक्षण-सूट देखें ।

कैसे?

s2Ḍḅ60 - helper link, getMinuteOfDay: list of digits, D   e.g. [1,2,3,3]
 2     - literal two                                           2
s      - split into chunks of length                           [[1,2],[3,3]]
  Ḍ    - un-decimal (convert from base 10) (vectorises)        [12,33]
    60 - literal sixty                                         60
   ḅ   - un-base (convert from base)                           753

83,588ṁ5“¡Ð‘j+\ṡ2>E¥ÞÇḢạÇa\ - Link: list of digits        e.g. [1,2,3,3]
83,588                      - literal list of integers         [83,588]
       5                    - literal five                     5
      ṁ                     - mould like (implicit range of) [83,588,83,588,83]
        “¡Ð‘                - code-page index list             [0,15]
            j               - join                           [0,83,588,83,588,83,15]
              \             - cumulative reduce with:
             +              -   addition                     [0,83,671,754,1342,1425,1440]
                2           - literal two                      2
               ṡ            - overlapping slices of length     [[0,83],[83,671],[671,754],[754,1342],[1342,1425],[1425,1440]]
                     Ç      - last link (1) as a monad f(D)    753
                    Þ       - sort by:
                   ¥        -   last two links as a dyad:
                 >          -     greater than? (vectorises)    [0, 0] [ 0,  0] [  0,  1] [  1,   1] [   1,   1] [   1,   1]
                  E         -     equal?                          1       1         0         1           1           1
                            -                             -->  [[671,754],[0,83],[83,671],[754,1342],[1342,1425],[1425,1440]]
                      Ḣ     - head                             [671,754]
                        Ç   - last link (1) as a monad f(D)    753
                       ạ    - absolute difference (vectorises) [ 82,  1]
                          \ - cumulative reduce with:
                         a  -   AND                            [ 82,  1]
                            -   -- such that if "liked" then the [0,x] result becomes [0,0] so they are all equal

— जोनाथन एलन
स्रोत

मुझे नहीं लगता कि प्रश्न में इनपुट प्रारूप (अंक सरणी) की अनुमति है, न ही विशेष समय के लिए बदलते आउटपुट।

— पुरकाकूदरी

फिक्स्ड, लेकिन मुझे नहीं पता कि क्या इस तरह के परिवर्तनों की आवश्यकता के लिए सही इरादे थे ...

— जोनाथन एलन

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

— पुरकाकूदरी

@ Pietu1998 मूल रूप से मैंने कभी भी एक उपयोगी इनपुट फॉर्म के रूप में अंकों की सूची पर विचार नहीं किया। मुख्य टिप्पणियों में प्रति चर्चा, मैंने अनुक्रम-अंक के इनपुट की अनुमति देने के लिए चुनौती को औपचारिक रूप से संशोधित किया है।

— hBy2Py

1

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

?↑2↑0Πṙ_1†aÖ±↔Ġ-::15t*3e588 83B60†d½

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

चैट में टर्नरीज़ कैसे काम करते हैं, यह बताने के लिए ज़र्ब का धन्यवाद । गोल्फ के लिए कोशिश कर रहा है ↑0, लेकिन मैं इसे किसी कारण से काम करने के लिए नहीं मिला (?)। यह मेरा पहला गैर-तुच्छ उत्तर है, और उपरोक्त बातों को एक तरफ रखकर, मैं इससे बहुत संतुष्ट हूं। के बदले उपयोग किया गया मानYAY!!! है [](लेकिन मुझे आशा है कि गोल्फ के उद्देश्यों के लिए बदल जाएगा)।

व्याख्या

? Ö 2 Πṙ 0Πṙ_1 † a↑ ↔Ġ :: - :: 15t * 3e588 83B60 ↑ d60 | CLA से अंकों की सूची के रूप में इनपुट, STDOUT में आउटपुट।

                                   ½ | सूची को दो हिस्सों में विभाजित करें।
                                 † डी | प्रत्येक आधे को आधार -10 पूर्णांक में बदल दें।
                              B60 | आधार 60 से परिवर्तित करें।
                : | उपरोक्त को [([15, 83, 588, 83, 588, 83]) में जोड़ें।
                       e588 83 | दो तत्व सूची बनाएं [588, 83]।
                     * 3 | तीन बार दोहराएं।
                    टी | पहला तत्व निकालें।
                 : 15 | एक 15 प्रस्तुत करना।
              Ġ- | दाईं ओर से संचयी घटाव लागू करें।
             ↔ | उल्टा।
           ± ± | संकेत द्वारा स्थिर क्रम (-1, 0 या 1)।
         † ए | नक्शा निरपेक्ष मूल्य।
      ṙ_1 | एक सही घुमाएँ।
? Π | यदि उत्पाद सत्य है, तो:
 ↑ 2 | पहले दो तत्वों को लें।
   ↑ 0 | अन्यथा खाली सूची लौटाएं।

— मिस्टर एक्सकोडर
स्रोत

1

कोटलिन , 293 बाइट्स

{fun i(l:List<Int>)=l.all{it==l[0]}|| l.mapIndexed{a,b->b-a}.all{it==l[0]}
val a=(0..1439+0).map{val h=it/60
val m=it%60
listOf(h/10,h%10,m/10,m%10)}+listOf(listOf(0,0,0,0))
val s=a.indexOf(it)
if(i(it))0 to 0 else
s-a.subList(0,s).indexOfLast{i(it)}to a.subList(s,a.size).indexOfFirst{i(it)}}

सजा हुआ

{
    fun i(l:List<Int>)=l.all { it ==l[0] } || l.mapIndexed { a, b -> b - a }.all { it ==l[0] }
    val a = (0..1439 + 0).map {
        val h = it/60
        val m = it%60
        listOf(h/10,h%10,m/10,m%10)
    } + listOf(listOf(0,0,0,0))
    val s = a.indexOf(it)
    if (i(it)) 0 to 0 else
        s - a.subList(0, s).indexOfLast {i(it)} to a.subList(s, a.size).indexOfFirst {i(it)}
}

परीक्षा

var t:(i:List<Int>)-> Pair<Int, Int> =
{fun i(l:List<Int>)=l.all{it==l[0]}|| l.mapIndexed{a,b->b-a}.all{it==l[0]}
val a=(0..1439+0).map{val h=it/60
val m=it%60
listOf(h/10,h%10,m/10,m%10)}+listOf(listOf(0,0,0,0))
val s=a.indexOf(it)
if(i(it))0 to 0 else
s-a.subList(0,s).indexOfLast{i(it)}to a.subList(s,a.size).indexOfFirst{i(it)}}

data class Test(val input: List<Int>, val output: Pair<Int, Int>)

val TEST = listOf(
    Test(listOf(0,0,0,0), 0 to 0),
    Test(listOf(0,0,2,0), 20 to 63),
    Test(listOf(0,1,0,5), 65 to 18),
    Test(listOf(0,1,2,2), 82 to 1),
    Test(listOf(0,1,2,3), 0 to 0),
    Test(listOf(0,1,2,4), 1 to 587),
    Test(listOf(0,8,5,2), 449 to 139),
    Test(listOf(1,1,1,1), 0 to 0),
    Test(listOf(1,1,1,3), 2 to 81),
    Test(listOf(1,2,0,0), 49 to 34),
    Test(listOf(1,2,3,4), 0 to 0),
    Test(listOf(1,3,5,7), 83 to 505),
    Test(listOf(1,7,5,9), 325 to 263),
    Test(listOf(1,8,0,0), 326 to 262),
    Test(listOf(1,8,0,1), 327 to 261),
    Test(listOf(2,2,2,2), 0 to 0),
    Test(listOf(2,2,4,4), 22 to 61),
    Test(listOf(2,3,4,5), 0 to 0),
    Test(listOf(2,3,5,1), 6 to 9)
)

fun main(args: Array<String>) {
    for (t in TEST) {
        val v = t(t.input)
        if (v != t.output) {
            throw AssertionError("$t $v")
        }
    }
}

TIO

TryItOnline

— jrtapsell
स्रोत

मेरा पसंदीदा टाइम्स ढूँढना

इनपुट

उत्पादन

नमूना इनपुट / आउटपुट

जेली , 34 33 32 31 28 बाइट्स

व्याख्या

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

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

कैसे?

बेगुंज -93, 88 85 86 80 74 बाइट्स

सी, 121 बाइट्स

क्लीन , 126 बाइट्स

पायथ, 48 45 42 बाइट्स

व्याख्या

जेली , 33 32 34 बाइट्स

कैसे?

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

व्याख्या

कोटलिन , 293 बाइट्स

सजा हुआ

परीक्षा

TIO