प्रतिबिंबित डिजिटल घड़ी

19

कई डिजिटल घड़ियां सरलीकृत अंकों का उपयोग करके समय प्रदर्शित करती हैं, जिसमें केवल सात अलग-अलग रोशनी शामिल होती हैं जो या तो चालू या बंद होती हैं:

जब क्षैतिज रूप से प्रतिबिंबित किया जाता है, तो अंक 018नहीं बदलते क्योंकि वे सममित हैं। इसके अलावा, अंक 2और 5बदली, 2बनने 5और इसके विपरीत। मिरर किए जाने पर अन्य सभी अंक अमान्य हो जाते हैं।

इस प्रकार, 24 घंटे की डिजिटल घड़ी को देखते हुए, कई घड़ी रीडिंग हैं जैसे कि डिजिटल डिस्प्ले की मिरर की गई छवि भी एक मान्य घड़ी रीडिंग है। आपका कार्य मिरर किए गए रीडिंग के साथ ऐसी सभी घड़ी रीडिंग को आउटपुट करना है।

उदाहरण के लिए, 22:21बन जाता है 15:55, और 00:15बन जाता है 21:00। दूसरी ओर, 12:34या 16:27अब मान्य नहीं हैं जब दर्पण (अंक 34679अमान्य हो जाते हैं), और न ही हैं 22:22या नहीं 18:21, क्योंकि, दिन में केवल 24 घंटे और एक घंटे में 60 मिनट होते हैं, कोई भी घड़ी प्रदर्शित नहीं होती है 55:55या 12:81।

कार्य

एक प्रोग्राम या एक फ़ंक्शन लिखें जो कोई इनपुट नहीं लेता है और सभी वैध जोड़े को आरोही क्रम में आउटपुट करता है जैसा कि नीचे दिखाया गया है:

00:00 - 00:00
00:01 - 10:00
00:05 - 20:00
00:10 - 01:00
00:11 - 11:00
00:15 - 21:00
00:20 - 05:00
00:21 - 15:00
00:50 - 02:00
00:51 - 12:00
00:55 - 22:00
01:00 - 00:10
01:01 - 10:10
01:05 - 20:10
01:10 - 01:10
01:11 - 11:10
01:15 - 21:10
01:20 - 05:10
01:21 - 15:10
01:50 - 02:10
01:51 - 12:10
01:55 - 22:10
02:00 - 00:50
02:01 - 10:50
02:05 - 20:50
02:10 - 01:50
02:11 - 11:50
02:15 - 21:50
02:20 - 05:50
02:21 - 15:50
02:50 - 02:50
02:51 - 12:50
02:55 - 22:50
05:00 - 00:20
05:01 - 10:20
05:05 - 20:20
05:10 - 01:20
05:11 - 11:20
05:15 - 21:20
05:20 - 05:20
05:21 - 15:20
05:50 - 02:20
05:51 - 12:20
05:55 - 22:20
10:00 - 00:01
10:01 - 10:01
10:05 - 20:01
10:10 - 01:01
10:11 - 11:01
10:15 - 21:01
10:20 - 05:01
10:21 - 15:01
10:50 - 02:01
10:51 - 12:01
10:55 - 22:01
11:00 - 00:11
11:01 - 10:11
11:05 - 20:11
11:10 - 01:11
11:11 - 11:11
11:15 - 21:11
11:20 - 05:11
11:21 - 15:11
11:50 - 02:11
11:51 - 12:11
11:55 - 22:11
12:00 - 00:51
12:01 - 10:51
12:05 - 20:51
12:10 - 01:51
12:11 - 11:51
12:15 - 21:51
12:20 - 05:51
12:21 - 15:51
12:50 - 02:51
12:51 - 12:51
12:55 - 22:51
15:00 - 00:21
15:01 - 10:21
15:05 - 20:21
15:10 - 01:21
15:11 - 11:21
15:15 - 21:21
15:20 - 05:21
15:21 - 15:21
15:50 - 02:21
15:51 - 12:21
15:55 - 22:21
20:00 - 00:05
20:01 - 10:05
20:05 - 20:05
20:10 - 01:05
20:11 - 11:05
20:15 - 21:05
20:20 - 05:05
20:21 - 15:05
20:50 - 02:05
20:51 - 12:05
20:55 - 22:05
21:00 - 00:15
21:01 - 10:15
21:05 - 20:15
21:10 - 01:15
21:11 - 11:15
21:15 - 21:15
21:20 - 05:15
21:21 - 15:15
21:50 - 02:15
21:51 - 12:15
21:55 - 22:15
22:00 - 00:55
22:01 - 10:55
22:05 - 20:55
22:10 - 01:55
22:11 - 11:55
22:15 - 21:55
22:20 - 05:55
22:21 - 15:55
22:50 - 02:55
22:51 - 12:55
22:55 - 22:55

एक अनुगामी या एक प्रमुख न्यूलाइन की अनुमति है। एक लाइनफीड से पहले सीधे कुछ रिक्त स्थान रखने की भी अनुमति है। समय प्रारूप में होना चाहिए hh:mm, जब आवश्यक हो तो शून्य के साथ गद्देदार।

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

code-golf  kolmogorov-complexity  clock 
— Steadybox
स्रोत
क्लीन में, ए Stringकी एक सरणी है Char। यह स्वीकार्य है अगर मेरा उत्तर एक देता है सूची की Char? नंगे-छपे होने पर प्रकार समान दिखते हैं।
— Οवस
@ ओह, मुझे लगता है कि यह ठीक है। मेटा पर आम सहमति है कि एक स्ट्रिंग वर्णों का एक क्रम है लगता है, और वर्णों की एक सूची है क्या कि के।
— स्टेडीबॉक्स
इस सात-खंड के प्रदर्शन में, अंक 1इसकी दर्पण छवि के बिल्कुल समान नहीं है क्योंकि आप यह बता सकते हैं कि दाएं-सबसे सेगमेंट या बाएं-सबसे सेगमेंट का उपयोग ऊर्ध्वाधर "लाइन" बनाने के लिए किया जाता है जो अंक बनाता है। मैं समझता हूं कि हम उन्हें यहां समान मानते हैं।
— जेपी स्टिग नीलसन
@JeppeStigNielsen आइए दिखाते हैं ओपी ने 7seg के बजाय 14seg डिस्प्ले के साथ एक छवि का उपयोग किया, इसलिए 1इसे केंद्रित किया जा सकता था।
— शुक्राणु
3
@Steadybox वाह, मेरे पास हाल ही में यह सटीक विचार था। मैं प्रोग्रामिंग साक्षात्कार के दौरान लोगों पर इसका उपयोग करने की योजना बना रहा हूं। BTW मेरे पास एक माइक्रोवेव ओवन है जिसमें एक घड़ी की घड़ी नहीं है और आप 83:75 :-) जैसी चीजों को निर्दिष्ट करने की अनुमति देता है
— JohnEye

जवाबों:

2

05AB1E , 34 बाइट्स

0125DâDâεÂ5n‡í)}ʒ€н25‹P}':ý… - ý»

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

व्याख्या

0125                                # push "0125"
    Dâ                              # cartesian product with itself
      Dâ                            # cartesian product with itself
        ε       }                   # apply to each
         Â                          # bifurcate
          5n                       # push 25 bifurcated
             ‡                      # transliterate
              í                     # reverse each
               )                    # wrap in a list
                 ʒ      }           # filter each on
                  €н                # head of each
                    25‹             # less than 25
                       P            # product
                         ':ý        # merge on ":"
                            … - ý   # merge on " - "
                                 »  # join on newlines
— Emigna
स्रोत
5

एपीएल (Dyalog यूनिकोड) , 84 बाइट्स SBCS

STDOUT में पूरा कार्यक्रम आउटपुट। आवश्यक ⎕IO( मैं ndex हे rigin) होने के लिए 0जो कई सिस्टम पर डिफ़ॉल्ट है।

{0::⋄∧/23 59≥⍎¨(':'≠t)⊆t←⌽'015xx2xx8x:'[⎕D⍳i←∊⍺':'⍵]:⎕←1↓⍕i'-'t}⌿1↓¨⍕¨100+0 60⊤⍳1440

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

⍳1440 कि कई many ntegers

0 60⊤ मिश्रित-बेस ∞, 60 में बदलें

100+ 100 जोड़ें (यह आवश्यक 0 पैड डालता है)

⍕¨ प्रारूप (कठोर) प्रत्येक

1↓¨ प्रत्येक से पहला वर्ण छोड़ें (यह अग्रणी 1s निकालता है)

{… }⌿ निम्नलिखित अनाम फ़ंक्शन कॉलम-वार लागू करें ( ⍺यह शीर्ष घंटे है, ⍵मिनट है)

 0:: यदि कोई त्रुटि होती है, तो कुछ भी नहीं लौटाएं

 ⋄ प्रयत्न:

  '015xx2xx8x:'[... ] इस स्ट्रिंग को इसके साथ अनुक्रमित करें:

   ∊⍺':'⍵ε nlisted (चपटा) घंटे, बृहदान्त्र, मिनट की सूची

   i← में संग्रहीत i( मैं nput के लिए)

   ⎕D⍳ ɩ की सूची में प्रत्येक चरित्र के ndices डी igits

  ⌽ उसे उल्टा करो

  t← स्टोर के रूप में t( टी ime के लिए)

  (… )⊆ समूह चलता है जहां:

   ':'≠t बृहदान्त्र से अलग है t

⍎¨ निष्पादित (मूल्यांकन) प्रत्येक

 23 59≥ प्रत्येक के लिए बूलियन कि क्या वे क्रमशः 23 और 59 से कम या बराबर हैं

 ∧/ क्या दोनों सच हैं?

 : यदि ऐसा है, तो:

  ⍕i'-'t इनपुट, डैश, टाइम की प्रारूपित (स्पेस-सेपरेटेड) सूची

  1↓ पहला (स्थान) गिराएं

  ⎕← STDOUT में आउटपुट

— एडम
स्रोत
4

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


 - 
+m`^.{3,9}$
0$&0¶1$&1¶2$&5¶5$&2
A`\b2?5
\b\d.
$&:
O`

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


 -

विभाजक डालें।

+m`^.{3,9}$
0$&0¶1$&1¶2$&5¶5$&2

चार प्रतिबिंबित अंकों के सभी संभव सेट उत्पन्न करें।

A`\b2?5

अवैध घंटे वालों को हटाओ।

\b\d.
$&:

कॉलोन्स डालें।

O`

क्रम में क्रमबद्ध करें।

— नील
स्रोत
4

पायथन 2 , 279 277 255 बाइट्स

for h in range(1440):
 q=[[[0,(a+"52")[(a=="2")+(a=="5")*2]][a in"01825"]for a in c]for c in[("%02d"%e)[::-1]for e in[h%60,h/60]]]
 if all(q[0]+q[1]):
	z=[int(''.join(j))for j in q]
	if(z[1]<60)*(z[0]<24):print"%02d:%02d - %02d:%02d"%(h/60,h%60,z[0],z[1])

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

क्रेडिट

  • 279 बाइट्स से 256 करने के लिए कम dylnan ।

  • FlipTrack द्वारा 256 बाइट्स घटाकर 255 किया गया ।

— नील
स्रोत
— फ्लिपकार्ट
3

स्वच्छ , 269 ... 172 170 बाइट्स

import StdEnv
?n=toChar n+'0'
$c|c<2=c=7-c
n=[0,1,2,5]
t=flatlines[u++[' - ':v]\\[u,v]<-[[map?[a,b,10,x,y],map?[$y,$x,10,$b,$a]]\\a<-n,b<-n,x<-n,y<-n]|['23:59']>=max u v]

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

Ungolfed:

import StdEnv
numeral n = toChar (n+48)
mirror 2 = 5
mirror 5 = 2
mirror c = c
digits = [0, 1, 2, 5]
times
    = flatlines [ // flatten with interspersed newlines
        original ++ [' - ' : reflection] // insert separator
        \\ // generate all pairs of times and their mirrored copies
        [original, reflection] <- [
            [map numeral [a, b, 10, x, y], map (numeral o mirror) [y, x, 10, b, a]]
            \\ // generate every combination of display digits
            a <- digits,
            b <- digits,
            x <- digits,
            y <- digits
            ]
        | ['23:59'] >= max original reflection // make sure both times actually exist
        ]
— Οurous
स्रोत
2

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

Lj\:c2bjf!:T"5.:|25:"0mj" - ",ydyX_d`25)^"0125"4

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

के सभी संभावित संयोजनों को उत्पन्न करता है 0125और फिर उन्हें समय में हेरफेर करता है। ये सही क्रम में हैं क्योंकि ये लेक्सिकोग्राफिक क्रम में उत्पन्न होते हैं। अंत में, लाइनों है कि रेगुलर एक्सप्रेशन से मेल निकाल कर बाहर अतिरिक्त अमान्य बार इस फिल्टर 5.:या 25:। अफसोस की बात है, ऐसा नहीं लगता कि संपीड़न इस प्रोग्राम का उपयोग करने वाले किसी भी स्ट्रिंग्स पर अच्छी तरह से काम करता है, जब तक कि मैंने कोई त्रुटि या निरीक्षण नहीं किया है।

— FryAmTheEggman
स्रोत
2

जाप v2 (+ -R), 51 बाइट्स

G²Çs4 ùT4 i':2î+" - "+Zw r\d_^Z>1})r3,5Ãkf/5.|25):

इसे ऑनलाइन टेस्ट करें!

व्याख्या

G²Ç   s4 ùT4 i':2à ®   +" - "+Zw r\d_  ^Z>1})r3,5à kf/5.|25):
G²oZ{Zs4 ùT4 i':2} mZ{Z+" - "+Zw r\dZ{Z^Z>1})r3,5} kf/5.|25):/   Ungolfed

G²              Calculate 16**2, or 256.
  oZ{       }   Create the range [0...256) and map each integer Z to:
Zs4               Convert Z to a base-4 string.  [0, 1, 2, 3, 10, ..., 3331, 3332, 3333]
    ùT4           Pad-left with 0's to length 4. [0000, 0001, 0002, ..., 3331, 3332, 3333]
        i':2      Insert a colon at index 2.     [00:00, 00:01, 00:02, ..., 33:31, 33:32, 33:33]

mZ{      }      Map each string Z in the resulting array to:
Zw r\dZ{     }    Reverse Z, and replace each digit Z' with
        Z^Z>1       Z' xor'd with (Z>1). This turns 2 to 3 and vice versa.
                  We now have [00:00, 10:00, 30:00, 20:00, 01:00, ..., 12:22, 32:22, 22:22]
Z+" - "+          Append this to Z with " - " in between. This gives
                    [00:00 - 00:00, 00:01 - 10:00, 00:02 - 30:00, ..., 33:32 - 32:22, 33:33 - 22:22]
r3,5              Replace all 3s in the result with 5s.
                    [00:00 - 00:00, 00:01 - 10:00, 00:02 - 50:00, ..., 55:52 - 52:22, 55:55 - 22:22]

k               Remove all results that
 f/5.|25):/       match the regex /(5.|25):/g. This removes times with impossible hours.

                Implicit: output result of last expression, joined with newlines (-R)
— ETHproductions
स्रोत
1

चारकोल , 59 बाइट्स

Ｆ012Ｆ0125Ｆ0125Ｆ015¿›‹⁺ικ25⁼⁺λμ25«ικ:λμ - Ｆ⟦μλ3κι⟧§015::2Ｉν⸿

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｆ012Ｆ0125Ｆ0125Ｆ015

बिना अंक वाले अंकों के लिए चार नेस्टेड लूप बनाएं।

¿›‹⁺ικ25⁼⁺λμ25«

जाँच करें कि न तो घंटे और न ही मिनट 25 है। (25 मिनट को प्रतिबिंबित करने से 25 घंटे का परिणाम होगा, इसलिए यह एक नहीं है।)

ικ:λμ -

अनमैरिड समय प्रिंट करें।

Ｆ⟦μλ3κι⟧§015::2Ｉν⸿

3स्ट्रिंग से पूर्णांक तक उलटे अंकों (या बृहदान्त्र के लिए) को परिवर्तित करके और उन्हें एक अनुवाद तालिका में देखकर मिरर किए गए समय को प्रिंट करें ।

वैकल्पिक रूप से, 59 बाइट्स के लिए भी:

Ｆ¹¹Ｆ¹⁶¿⁻¹¹κ¿⁻²﹪κ⁴«≔⟦÷ι⁴﹪ι⁴¦⁴÷κ⁴﹪κ⁴⟧θＦθ§0125:λ - Ｆ⮌θ§0152:λ⸿

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｆ¹¹Ｆ¹⁶

घंटे और मिनट के लिए छोरों बनाएँ।

¿⁻¹¹κ¿⁻²﹪κ⁴«

बाहर निकालें 25और किसी भी मिनट को समाप्त करें 2।

≔⟦÷ι⁴﹪ι⁴¦⁴÷κ⁴﹪κ⁴⟧θ

घंटे और मिनटों को आधार 4 में बदलें।

Ｆθ§0125:λ

अनुवाद तालिका में अंकों को प्रिंट करें।

 -

विभाजक प्रिंट करें।

Ｆ⮌θ§0152:λ⸿

उलटे हुए अंकों को प्रिंट करके अनुवाद की गई तालिका में देखा।

— नील
स्रोत
1

जेली , 72 66 62 55 बाइट्स

®ṢiЀUị®
“0152:”©ṢṖp`⁺ḣ176j€“:”µ;"Ç€⁾25ẇ$ÐṂœs€2j€“ - ”Y

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

Niladic कार्यक्रम। मुझे Emigna द्वारा 05AB1E उत्तर'0125' से विचार का दोहरा उत्पाद मिला है, लेकिन बाकी जो मैंने परामर्श के बिना किया, क्योंकि उसके बाद भाषाएं अलग हो जाती हैं। संभवत: बहुत से गोल्फिंग के अवसर हैं।

व्याख्या

कार्यक्रम निम्नानुसार काम करता है:

  • पात्रों की सूची के '0125'साथ लंबाई चार के सभी उत्पादों को लें “0152:”©ṢṖp`⁺। ©स्ट्रिंग '0152:'को बाद में उपयोग के लिए रजिस्टर में कॉपी करता है । ṢṖतो सॉर्ट करता स्ट्रिंग → के अंतिम तत्व पॉप '0125'। ⁺उत्पाद लिंक को डुप्लिकेट करता है।

  • ḣ176प्रारूप के साथ किसी भी समय निकालता है 25xxया 5xxx(वैध घंटे नहीं)।

  • j€“:”अंकों की प्रत्येक जोड़ी को a के साथ जोड़ता है ':'। उदा ['05'],['21']]→ '05:12'।

  • Ç€इनमें से प्रत्येक के लिए पहली कड़ी लागू होती है। यह स्ट्रिंग में प्रत्येक वर्ण का सूचकांक पाता है, '0125:'फिर उन सभी सूचकांकों के लिए स्ट्रिंग में वर्ण प्राप्त करता है '0152:'और इसे उलट देता है। यह मिरर ऑपरेशन (उलट और स्वैपिंग 2एस और 5एस) है।

  • µ;" मिरर किए गए समय के साथ मूल समय को समाप्‍त करता है → '05:2115:20'

  • ⁾25ẇ$ÐṂप्रतिस्थापन के साथ समय को फ़िल्टर करता है '25'। यह किसी भी समय जोड़े को आधा 25:xxया दर्पण के साथ पकड़ता है 5x:xx। नोट : मुझे नहीं पता कि क्यों $आवश्यक है। शायद कोई इसे उचित वाक्यविन्यास के साथ बाहर निकाल सकता है लेकिन मुझे यकीन नहीं है।

  • इनमें से प्रत्येक को दो हिस्सों में विभाजित करें ( œs€2) फिर उन्हें स्ट्रिंग ' - '( j€“ - ”) के साथ जोड़ दें । '05:2115:20'→ '05:21 - 15:20'।

  • अंत में, Yएक नई रेखा के साथ सभी तार जुड़ते हैं और सब कुछ अंतर्निहित रूप से मुद्रित होता है।

पुराने संस्करणों

62 बाइट्स

i@€®ị“:0152”
“:0125”©Ḋp`⁺ḣ176j€“:”µ,"UÇ€$F€⁾25ẇ$ÐṂœs€2j€“ - ”Y

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

66 बाइट्स

“0125”
i@€¢ị“0152”
UṚÇ€
Ñp`⁺ḣ176µ,"Ç€j€€“:”j€“ - ”¹⁾2 ẇ$ÐṂ⁾25ẇ$ÐṂY

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

72 बाइट्स

⁾25
i@€¢µẋ@€¢ṙ"
Ṛµ;@""Ç€Ḣ€€
“0125”p`⁺j€“:”ḣ176µ,"Ç€j€“ - ”¹⁾2 ẇ$ÐṂÑẇ$ÐṂY

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

— dylnan
स्रोत
1

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

(0..1439).map{"%02d : %02d".format(it/60,it%60)}.let{it.map{i->i to i.reversed().map{x->"25180:X52180:".let{it[it.indexOf(x)+7]}}.joinToString("")}.filter{(_,b)->it.contains(b)}.map{(a,b)->println("$a-$b")}}

सजा हुआ

    (0..1439)
        .map { "%02d : %02d".format(it / 60, it % 60) }              // Make the times
        .let { it.map {i->
                i to i.reversed().map {x->                         // Pair it with the reversed times
                    "25180:X52180:".let{ it[it.indexOf(x)+7] }     // - X means bad times are removed
                }.joinToString("")                                 // - Make the string
            }.filter {(_,b)-> it.contains(b) }                     // Remove the unpaired times
                .map { (a, b) -> println("$a - $b") }              // Print out the pairs
        }

परीक्षा

fun main(args: Array<String>) {
    f()
}

fun f() =
(0..1439).map{"%02d:%02d".format(it/60,it%60)}.let{it.map{i->i to i.reversed().map{x->"25180:X52180:".let{it[it.indexOf(x)+7]}}.joinToString("")}.filter{(_,b)->it.contains(b)}.map{(a,b)->println("$a-$b")}}

TIO

TryItOnline

संपादित करता

  • +2 Steadybox - फिक्स्ड IO स्वरूपण
— jrtapsell
स्रोत
वहाँ के दोनों किनारों पर एक जगह माना जाता है -। जोड़ने के लिए केवल दो बाइट्स खर्च होते हैं: इसे ऑनलाइन आज़माएं!
— स्टेडीबॉक्स
फिक्स्ड, मुझे आश्चर्य है कि अगर 205 बाइट्स को वापस लेने का कोई तरीका है तो बाकी कोड को कम करना होगा
— jrtapsell
0

सी, 225 बाइट्स

h,m,l,r,d=10,L[]={0,1,5,9,9,2,9,9,8,9};M(h,m){l=L[h%d]*d+L[h/d];r=L[m%d]*d+L[m/d];return L[h%d]<9&L[h/d]<9&L[m%d]<9&L[m/d]<9;}f(){for(h=0;h<24;++h)for(m=0;m<60;++m)M(h,m)&l<60&r<24&&printf("%02d:%02d - %02d:%02d\n",h,m,r,l);}

चूंकि कोई सी जवाब नहीं है, मैं अपना खुद का पोस्ट करता हूं। कुछ अन्य दृष्टिकोण कम हो सकते हैं।

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

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