परिचय:

घर पर हमारे पास एक घड़ी होती है जो प्रत्येक घंटे में बताई गई राशि पर हमला करती है, लेकिन हर आधे घंटे में एक बार हमला करती है। तो 0:00 से 12:00 तक और इस क्रम में यह भी शामिल है:

1, 1, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11, 1, 12

चुनौती:

पूर्णांक को देखते हुए n, समय-फ़्रेमों की एक सूची तैयार करना जिसमें कुल स्ट्राइक बराबर होती है n। इसके अलावा, हमेशा इस समय-सीमा से कम से कम 1 मिनट पहले शुरू करें और इस समय-सीमा (और अधिकतम 29 मिनट) के बाद कम से कम 1 मिनट समाप्त करें।
उदाहरण के लिए, यदि इनपुट है n=8, तो आउटपुट हो सकता है:

[00:59-03:01, 01:29-03:31, 02:59-04:01, 05:29-06:31, 06:29-07:01, 06:59-07:31, 07:59-08:01]

जिसके लिए इन समय-फ़्रेमों में निम्नलिखित योग हैं, सभी समान हैं 8:

[1+1+2+1+3, 1+2+1+3+1, 3+1+4, 1+6+1, 1+7, 7+1, 8]

चुनौती नियम:

आउटपुट लचीला है। आप कर सकते हैं उत्पादन समय (या दिनांक / DATETIME) वस्तुओं, timestamps तार (के साथ या अग्रणी शून्य के बिना) के रूप में, दशमलव के साथ .29/ .31/ .59/ .01(यानी 0.29-3.01बजाय 00:29-03:01), आदि जब तक यह स्पष्ट है कि यह पहले और समय-सीमा के बाद है ।
इसके अलावा, आप राशि स्वयं चुन सकते हैं। मेरी सभी उदाहरणों में मैं 1 मिनट का उपयोग करें, लेकिन आप यह भी 5 मिनट, 15 मिनट, आदि का चयन कर सकते यह भी मतलब है कि आप उपयोग कर सकते हैं .4/ .6/ .9/ .1(यानी 0.4-3.1बजाय 00:24-03:06) उदाहरण के लिए। सूची भी लचीली है। एक सूची / संग्रह, सरणी, सीमांकक-पृथक स्ट्रिंग, प्रति पंक्ति मुद्रण STDOUT, आदि के लिए हो सकता है। कृपया बताएं
कि आपने कौन सा आउटपुट विकल्प चुना है।नोट: आपको ऊपर दिए गए टाइम-फ्रेम की रकम का उत्पादन करने की अनुमति नहीं है, यह केवल स्पष्टीकरण के रूप में उल्लिखित है। आपको समय-फ़्रेम को आउटपुट करना होगा, जिसमें थोड़ा पहले और बाद में भी शामिल है।
हमलों से लपेट है 12:00करने के लिए 00:30। तो n=14, दो समय के तख्ते हैं 11:29-00:31और 11:59-01:01।
इनपुट सीमा में होगा 1 <= n <= 90, जहां 90 सभी संभावित हमलों का कुल योग है।
आपके द्वारा लौटाया गया समय-सीमा किसी भी क्रम में हो सकता है।

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

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

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

(सभी समय-सीमा से पहले और बाद के 1 मिनट का उपयोग करते हुए)

Input: 8
Ouput:
[00:59-03:01, 01:29-03:31, 02:59-04:01, 05:29-06:31, 06:29-07:01, 06:59-07:31, 07:59-08:01]

Input: 14
Output:
[00:29-04:01, 00:59-04:31, 02:59-05:01, 04:29-06:31, 05:59-07:01, 11:29-00:31, 11:59-01:01]

Input: 90
Output:
[00:29-00:01, 00:59-00:31, 01:29-01:01, 01:59-01:31, 02:29-02:01, 02:59-02:31, 03:29-03:01, 03:59-03:31, 04:29-04:01, 04:59-04:31, 05:29-05:01, 05:59-05:31, 06:29-06:01, 06:59-06:31, 07:29-07:01, 07:59-07:31, 08:29-08:01, 08:59-08:31, 09:29-09:01, 09:59-09:31, 10:29-10:01, 10:59-10:31, 11:29-11:01, 11:59-11:31]

Input: 1
Output:
[00:29-00:31, 00:59-01:01, 01:29-01:31, 02:29-02:31, 03:29-03:31, 04:29-04:31, 05:29-05:31, 06:29-06:31, 07:29-07:31, 08:29-08:31, 09:29-09:31, 10:29-10:31, 11:29-11:31]

Input: 2
Output:
[00:29-01:01, 00:59-01:31, 01:59-02:01]

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

1

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

— 10

@ मान लीजिए कि आप सही हैं। मैंने उसी के अनुसार अपना उत्तर संपादित किया है। तुम्हें पता है, कम से कम 1 मिनट और सबसे 29 मिनट पर होना चाहिए ताकि .4/ .6/ .9/ .1अनुमति दी है (किया जा रहा 6 मिनट आप की तरह कहा गया है: :24/ :36/ :54/ :06)।

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

1

शायद उल्लेख है कि समय जोड़े किसी भी क्रम में वापस आ सकते हैं?

— आदम

ओके एन 0..90 में है, मुझे यह स्पष्ट नहीं है कि एन स्ट्राइक की गणना के लिए समय अवधि क्या है: यह 12 घंटे है? वे 24 घंटे हैं? 48 घंटे हैं? प्रारूप में थान को वापसी का समय 0..24: 0..60 है?

— रोजलू पी

@RosLuP समय सीमा एक नियमित एनालॉग घड़ी है, इसलिए 00:01 से 12:00 बजे तक। इसलिए 0..24: 0..60 के बजाय, यह 0..12: 0..60 होना चाहिए। यह कैसे किसी भ्रम को साफ करता है।

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

3

एपीएल (Dyalog क्लासिक) , 34 बाइट्स ^SBCS

∪12|.4 .1∘+¨.5×⍸⎕=⍉∘.-⍨+\,⍪⍨1,⍪⍳12

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

यह समाधान ⎕io←1(1-आधारित अनुक्रमण) का उपयोग करता है ।

दांये से बांये तक:

⍳12 है 1 2 3...12

⍪ इसे एक लंबे पतले 12x1 मैट्रिक्स में बदल देता है

1, बाईं ओर 1s का एक स्तंभ जोड़ता है

⍪⍨ एक ही मैट्रिक्स को लंबवत रूप से जोड़ता है, इसलिए यह अब 24x2 मैट्रिक्स है

, पंक्ति-प्रमुख क्रम में मैट्रिक्स को समतल करता है, यह आकार 48 का वेक्टर बन जाता है: 1 1 1 2 1 3...1 12 1 1 1 2...1 12

+\ आंशिक रकम: 1 2 3 5 6 9...

∘.-⍨ तत्वों की प्रत्येक जोड़ी के बीच अंतर, एक 48x48 मैट्रिक्स

⍉ पक्षांतरित

⎕=जहाँ भी मूल्यांकन किया इनपुट ( ⎕) होता है 1s साथ 48x48 बूलियन मैट्रिक्स

⍸ निर्देशांक के जोड़े जहां 1s हैं

.5× उन्हें आधा कर दिया

.4 .1∘+¨ प्रत्येक जोड़ी में 0.4 से पहले और 0.1 से दूसरे समन्वय को जोड़ें

12| modulo 12

∪ अद्वितीय

— NGN
स्रोत

.1आउटपुट में किस समय अंतराल का प्रतिनिधित्व किया जाता है? साथ ही, अच्छा जवाब।

— E:२६ पर आउटगोल्फ़र

2

ओह, और यह वही है जो 34 बाइट्स के लिए संभव बनाता है, शायद इसे लिंक करना चाहते हैं या <sup>SBCS</sup>Adám के उत्तर की तरह लिख सकते हैं ।

— आउटगोल्फर

@EriktheOutgolfer समस्या को स्पष्ट रूप से अनुमति देता है .1 / .4 / .6 / .9 के बजाय: 01 /: 29 /: 31 /: 59। मुझे इस उत्तर के लिए विशेष एन्कोडिंग की आवश्यकता नहीं है, यह Dyalog Classic में है जिसका अपना एकल-बाइट एन्कोडिंग है।

— ngn

⍸Dyalog Classic में नहीं है। और हाँ, मुझे पता है कि यह स्पष्ट रूप से अनुमति दी गई है, मैं सिर्फ यह जानना चाहता था 0.1कि आउटपुट में कितने मिनट हैं ?)

— एरिक आउटगोल्फर

@EriktheOutgolfer "SBCS" जोड़ा गया, धन्यवाद; .1 × 60 मिनट 6 मिनट है

— ngn

5

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

H.MM,H.MMप्रारूप में प्रिंट समय अंतराल ।

F=(n,f=0,s=n,t=f++)=>t<f+23?F(n,f,s-=t&1||t/2%12+1,++t,s||alert([f/2%12+.01,-~t/2%12+.01])):f<24&&F(n,f)

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

गैर-पुनरावर्ती संस्करण के रूप में अनिवार्य रूप से समान एल्गोरिथ्म का उपयोग करता है।

गैर-पुनरावर्ती संस्करण, 117 बाइट्स

H.MM,H.MMप्रारूप में समय अंतराल के एक अंतरिक्ष-सीमांकित स्ट्रिंग को आउटपुट करता है।

n=>[...Array(24)].map((_,f,a)=>a.map(_=>(s-=t++&1||t/2%12+.5)||(r+=[-~f/2%12+.01,-~t/2%12+.01]+' '),s=n,t=f),r='')&&r

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

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

let f =

n=>[...Array(24)].map((_,f,a)=>a.map(_=>(s-=t++&1||t/2%12+.5)||(r+=[-~f/2%12+.01,-~t/2%12+.01]+' '),s=n,t=f),r='')&&r

console.log(f(8))
console.log(f(14))
console.log(f(90))
console.log(f(1))
console.log(f(2))

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

टिप्पणी की गई

n =>                           // n = input
  [...Array(24)].map((_, f, a) // FOR f = 0 TO 23:
    => a.map(_ =>              //   FOR t = f TO f + 23:
      (                        //     update s
        s -=                   //       by subtracting:
          t++ & 1 ||           //         - 1 if t is odd (half hour)
          t / 2 % 12 + .5      //         - the current hour if t is even
      ) || (                   //     if s is equal to zero:
        r += [                 //       update the result string by appending:
          -~f / 2 % 12 + .01   //         - the formatted 'from' time
          ,                    //         - a comma
          -~t / 2 % 12 + .01   //         - the formatted 'to' time
        ] + ' '                //       and a padding space
      ),                       //     inner map() initialization:
      s = n,                   //     - s = target number of strikes
      t = f                    //     - 'to' time = 'from' time
    ),                         //   end of inner map()
    r = ''                     //   start with r = empty string
  )                            // end of outer map()
  && r                         // return r

— Arnauld
स्रोत

4

एपीएल (डायलॉग यूनिकोड) , 62 59 बाइट्स ^{एसबीसीएस}

पूरा कार्यक्रम निकाय के लिए संकेत देता है n। दशमलव घंटे का उपयोग करके दो-तत्व सूची की प्रिंट्स सूची।

∪(⎕=∊l+/¨⊂48⍴∊1,¨⍳12)/(¯.1 .1+⊃,⊢/)¨⊃,/(l←⍳48),/¨⊂.5×48⍴⍳24

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

⍳24 ɩ ndices 1… 24

48⍴ चक्रीय r लंबाई 48, यानी 1 ... 12,1 ... 12 eshape

.5× उससे आधा गुणा करें

⊂ संलग्न करें (प्रत्येक बाएं तर्क के लिए इस संपूर्ण सरणी को सही तर्क के रूप में उपयोग करने के लिए)

(... ),/¨ निम्न में से प्रत्येक के लिए, कि लंबाई के सभी उप-सूचियों वापसी:

⍳48 ɩ ndices 1… 48

l← में स्टोर l( एल engths के लिए)

अब हमारे पास प्रत्येक संभावित रन-लेंथ के लिए समय के रनों की सभी संभावित सूचियाँ हैं।

,/ उप-सूचियों की सूचियों को संक्षिप्त करना (प्रकाशित करना

⊃ खुलासा (क्योंकि कमी ने रैंक को 1 से घटाकर 0 कर दिया)

(… )¨ प्रत्येक के लिए निम्नलिखित फ़ंक्शन लागू करें:

⊢/ अंतिम (दायाँ-घटाएँ) तत्व (अंतिम समय)

⊃, पहला तत्व (शुरुआती समय)

¯.1 .1+ उन पर नकारात्मक और सकारात्मक दसियों को जोड़ें

(… )/ उन आरंभ-अंत वाले जोड़ों को फ़िल्टर करें:

⍳12 ɩ ndices 1… 12

1,¨ एक पहले जोड़ें 1प्रत्येक के लिए

∊ fl nlist (समतल)

48⍴ चक्रीय रूप से r 48, यानी 1,1,1,2… 1,11,1,12 लंबाई तक जाती है

⊂ संलग्न करें (प्रत्येक बाएं तर्क के लिए इस संपूर्ण सरणी को सही तर्क के रूप में उपयोग करने के लिए)

l+/¨ प्रत्येक l(1… 48) के लिए उस लंबाई के सभी उप-सूचियों के रकम लौटाते हैं

∊ fl nlist (समतल)

⎕= संख्यात्मक इनपुट की तुलना करें

∪ केवल अनूठे तत्वों को वापस करें (शुरुआती-अंत जोड़े)

— एडम
स्रोत

0.1 0.5बन सकता है.1 .5

— user41805

@ सहवास हाँ, मैंने भी देखा। हालांकि धन्यवाद।

— Adám

3

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

lambda n:[(a/2+.4,b%24/2+.1)for a in range(24)for b in range(48)if sum((sum(zip([1]*12,range(1,13)),())*2)[a:b])==n]

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

एक समय सीमा के रूप में प्रतिनिधित्व किया है (t1, t2), t1और t2घंटे का प्रतिनिधित्व दशमलव हो रहा है। ऑफसेट .1या 6 मिनट है।

— OVS
स्रोत

1

बैच, 196 बाइट्स

@for /l %%i in (0,1,23)do @set s=%1&for /l %%j in (0,1,23)do @call:c %%i %%j
:c
@set/at=%2+%1,s-=t%%2*(t/2%%12)+1,h=%1/2,i=%1%%2*30+15,t=-~t%%24/2,u=-~t%%2*30+15
@if %s%==0 echo %h%:%i% %t%:%u%

स्पष्टीकरण: tआधे घंटे का समय है, जिसके लिए शुरुआत हो रही 0है 00:30। समय टी पर हमलों की संख्या तो है 1, 1, 1, 2, 1, 3आदि घटाकर 1अनुक्रम देता है 0, 0, 0, 1, 0, 2आदि जो पूर्णांकों शून्य के साथ interleaved है। यह तो अनुक्रम की termwise गुणा करके प्राप्त की जा सकती है 0, 0, 1, 1, 2, 2अनुक्रम के साथ आदि 0,1 , 0, 1, 0, 1आदि इन दृश्यों के दोनों आसानी से सापेक्ष और (पूर्णांक) विभाजन का प्रयोग कर गणना।

तब यह सभी 23 संभावित शुरुआती समय में लूप रहता है, फिर सभी 24 हड़ताली बार और इनपुट से स्ट्राइक की संख्या को घटाते हुए, परिणाम शून्य होने पर कई बार प्रिंट करता है।

लूप के बाद कोड गिरता है लेकिन कोई नुकसान नहीं होता है क्योंकि इनपुट 90 से अधिक नहीं हो सकता है।

— नील
स्रोत

1

एपीएल नार, 559 बाइट्स

∇r←l w;t;i;j;c;k;m;p
p←{0=2∣¯1+⍵:.01+2÷⍨¯1+⍵⋄¯0.19+2÷⍨¯1+⍵}
m←{0=2∣¯1+⍵:¯.41+2÷⍨¯1+⍵⋄¯0.21+2÷⍨¯1+⍵}
   r←⍬⋄i←0⋄t←∊(¯1+⍳13),¨13⍴1⋄t←t,2↓t⋄k←⍴t
A: j←i+←1⋄→0×⍳i≥k⋄c←0
B: c+←j⊃t⋄:if(c=w)∧(0≤(m i))∧(24≥(p j))⋄r←r,⊂(m i),(p j)⋄:endif⋄→A×⍳c≥w⋄j+←1⋄→B×⍳j≤k⋄→A
∇
∇r←g w;v;i;k;m
   v←{12≤⌊⍵:⍵-12⋄⍵}
   i←1⋄k←⍴w⋄r←⍬
A: →0×⍳i>k⋄r←r,⊂v¨i⊃w⋄i+←1⋄→A
∇   
h←g∘l

h (n) या l (n) 0-24 घंटे में सभी प्रतिनिधि अंतराल देता है जिसमें n क्लॉक स्ट्राइक होता है। h (n) का क्लॉक फॉर्मेट 0..11.0..59 है; इसके बजाय l (n) का क्लॉक फॉर्मेट 0..23.0..59 टेस्ट के रूप में है

  h 8
    0.59 3.01  1.29 3.31  2.59 4.01  5.29 6.31  6.29 7.01  6.59 7.31  
    7.59 8.01  0.59 3.01  1.29 3.31  2.59 4.01  5.29 6.31  6.29 7.01  
    6.59 7.31  7.59 8.01 
  h 14
    0.29 4.01  0.59 4.31  2.59 5.01  4.29 6.31  5.59 7.01  11.29 0.31  
    11.59 1.01  0.29 4.01  0.59 4.31  2.59 5.01 4.29 6.31  5.59 7.01 
  h 90
    0.29 0.01  0.59 0.31  1.29 1.01  1.59 1.31  2.29 2.01  2.59 2.31  
    3.29 3.01  3.59 3.31  4.29 4.01  4.59 4.31  5.29 5.01  5.59 5.31  
    6.29 6.01  6.59 6.31  7.29 7.01  7.59 7.31  8.29 8.01  8.59 8.31  
    9.29 9.01  9.59 9.31  10.29 10.01  10.59 10.31  11.29 11.01  11.59 11.31    
  h 1
    0.29 0.31  0.59 1.01  1.29 1.31  2.29 2.31  3.29 3.31  4.29 4.31  
    5.29 5.31  6.29 6.31  7.29 7.31  8.29 8.31  9.29 9.31  10.29 10.31  
    11.29 11.31  0.29 0.31  0.59 1.01  1.29 1.31  2.29 2.31  3.29 3.31  
    4.29 4.31  5.29 5.31  6.29 6.31  7.29 7.31  8.29 8.31  9.29 9.31  
    10.29 10.31  11.29 11.31 
  h 2
    0.29 1.01  0.59 1.31  1.59 2.01  0.29 1.01  0.59 1.31  1.59 2.01 
  l 2
    0.29 1.01  0.59 1.31  1.59 2.01  12.29 13.01  12.59 13.31  13.59 14.01

— RosLuP
स्रोत

स्ट्राइकिंग क्लॉक का मिलान करें

परिचय:

चुनौती:

चुनौती नियम:

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

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

एपीएल (Dyalog क्लासिक) , 34 बाइट्स SBCS

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

गैर-पुनरावर्ती संस्करण, 117 बाइट्स

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

टिप्पणी की गई

एपीएल (डायलॉग यूनिकोड) , 62 59 बाइट्स एसबीसीएस

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

बैच, 196 बाइट्स

एपीएल नार, 559 बाइट्स

एपीएल (Dyalog क्लासिक) , 34 बाइट्स ^SBCS

एपीएल (डायलॉग यूनिकोड) , 62 59 बाइट्स ^{एसबीसीएस}