पलक झपकते बारह


43

कई इलेक्ट्रॉनिक उपकरण, विशेष रूप से पुराने, एक निमिष दिखाएगा 12:00जब समय निर्धारित नहीं किया गया है। इस चुनौती का उद्देश्य इसे फिर से बनाना है।

विशेष रूप से, कार्य एक अनंत लूप में प्रदर्शित करना 12:00और --:--वैकल्पिक रूप से करना है

अवधि 1 सेकंड, 0.5 सेकंड का दो अवधि में समान रूप से विभाजित किया जाना चाहिए। यहाँ "1 सेकंड" और "समान रूप से" की शिथिल व्याख्या की जा सकती है। उदाहरण के लिए, यह स्वीकार्य है यदि कोड स्ट्रिंग को प्रदर्शित करने के बीच 0.5 सेकंड के लिए रुकता है, भले ही परिणामी अवधि 1 सेकंड से थोड़ी अधिक हो। पहला स्ट्रिंग प्रदर्शित करने से पहले एक प्रारंभिक ठहराव स्वीकार्य है।

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

बाइट्स में सबसे छोटा कोड जीतता है।


1
क्या यह कोल्मोगोरोव-जटिलता के रूप में गिना जाता है ?
FlipTack

@ फीलटैक मुझे ऐसा लगता है, लेकिन मुझे यकीन नहीं था। विचार, कोई भी?
लुइस मेंडो

@LuisMendo मुझे ऐसा नहीं लगता, मुझे लगता है कि KG टैग ज्यादातर एक निश्चित स्ट्रिंग के लिए है। यह इसके लिए और अधिक है, प्रतीक्षा और वैकल्पिक तार।
R

क्या प्रारंभिक आउटपुट दिखाने से पहले सबमिशन 0.5 सेकंड प्रतीक्षा कर सकता है?
FlipTack

1
IMHO, कथन "प्रत्येक नई स्ट्रिंग को पूर्व स्ट्रिंग की जगह या एक नई पंक्ति में प्रदर्शित किया जा सकता है" ने इस चुनौती को मजेदार नहीं बनाया।
सेटप

जवाबों:


4

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

.“12:00“--:--”ṄœS¥€ß

यह काम किस प्रकार करता है

.“12:00“--:--”ṄœS¥€ß  Main link. No arguments.

.                     Set the return value to 0.5.
 “12:00“--:--”        Yield ["12:00", "--:--"].
                 ¥    Combine the two links to the left into a dyadic chain.
              Ṅ       Print the left argument.
               œS     Sleep as many seconds as the right argument specifies.
                  €   Map the created dyadic chain over the string array, with
                      right argument equal to the return value, i.e., 0.5.
                   ß  Recursive call the main link.

तो तुम, मूल रूप से सूची में दोनों तार बदल रहे हैं अपने स्वयं के लिंक में, एक अतिरिक्त स्लीप-कमांड के साथ? मिठाई।
स्टेनबर्घ

32

HTML / CSS, 131 108 106 101 + 18 17 = 149 126 125 123 118 बाइट्स

a{background:#FFF;margin:-5ch;animation:a 1s steps(2,start)infinite}@keyframes a{to{visibility:hidden
<tt>--:--<a>12:00

संपादित करें: @insertusernamehere के लिए 23 बाइट्स सहेजे गए। स्विच करके 1 बाइट सहेजा <pre>करने के लिए <tt>। सहेजे गए 2 बाइट्स @darrylyeo के लिए धन्यवाद। @DBS के लिए 5 बाइट्स को सहेजा गया।


1
@insertusernamehere Bah, मैं दूर गया a{position:absolute}लेकिन पूरी तरह से भूल गया pre...
नील

क्या आपको अभी भी पूर्व टैग की आवश्यकता है? सीएसएस केवल एक उल्लेख है।
ev3commander

@ ev3commander मैंने स्विच करके एक बाइट को बचाया <tt>
नील

आप फाइनल को }}पूरी तरह से हटा सकते हैं ।
darrylyeo

मुझे लगता है कि आप को आसान बनाने के लिए सक्षम होना चाहिए margin-leftकरने के लिए marginआप काम कर रहे हैं के बाद से ऊपर से वैसे भी छोड़ दिया margin:-5ch;एक ही प्रभाव होना चाहिए।
DBS

15

शेल और pv, 26 बाइट्स

यह yesमानक उपकरण और pv शेल पाइपलाइन तत्व का उपयोग मीटर डेटा से गुजर रहा है

yes '12:00
--:--'|pv -qlL2

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

1
यह एक अच्छी चाल है! (जो मुझे लगता है कि @ डेजीटल ट्रॉमा द्वारा यहां अग्रणी किया गया था )। इस मामले में यद्यपि यह चुनौती की भावना के खिलाफ थोड़ा महसूस होता है, जैसा कि मिशन का बयान "12:00 और -: - वैकल्पिक रूप से" (निमिष प्रदर्शन की नकल करते हुए) प्रदर्शित करना था, लेकिन यह कोड सिर्फ चरित्र द्वारा आउटपुट चरित्र होगा इसके बजाय लगातार 12 वर्ण प्रति सेकंड की दर से। जिसका अर्थ है कि "12:00" केवल 1/12 (0.08) सेकंड ("12: 0 _" = 1 / 12s => "12:00" = 2 / 12s => "-") स्क्रीन पर रहेगा।
जेपेलिन

संदर्भों के लिए @zeppelin धन्यवाद: I'mv ने इस्तेमाल किया @ DigitalTrauma के नमूने -qlL2को 2 पंक्तियों के बजाय सेकंड के लिए बनाने के लिए -qL12: 12 chars द्वारा सेकंड। पटकथा की लंबाई समान है
F. Hauri

15

पायथन 2, 80 75 73 69 67 66 बाइट्स

import time
n=0
while[time.sleep(.5)]:print"1-2-::0-0-"[n::2];n^=1

मैंने देखा कि मेरे स्ट्रिंग मैजिक को एक अरेंज से स्ट्रिंग चुनने की तुलना में थोड़ा लंबा लगा। कोई बात नहीं, यह पता लगा।

स्पष्टीकरण :

  • मैंने एक काउंटर n 0 पर सेट किया है , जिसे 0 और 1 के बीच टॉगल किया जाएगा।

  • मैं लूप के साथ अंतहीन रूप से लूप करता हूं while 1

  • मैं एक स्ट्रिंग बनाता हूं 1-2-::0-0-, जिसमें स्ट्रिंग 12:00और --:--इंटरलेप्ड होता है।

    • 2 के एक चरण के साथ सूचकांक 0 से शुरू, हमें मिलता है: 12:00

    • 2 के एक चरण के साथ सूचकांक 1 से शुरू, हमें मिलता है: --:--

  • मैं दोहराया अनुक्रम 0 , 1 , 0 , 1 , 0 बनाने के लिए n का उपयोग करता हूं ... जो स्ट्रिंग का शुरुआती सूचकांक होगा।

    • n^=1प्रत्येक लूप का उपयोग करके , हमें वह क्रम मिलता है। ^XOR- ऑपरेटर होने के नाते।
    • यदि n == 0 -> n^=11 में परिणाम
    • यदि n == 1 -> n^=10 में परिणाम
  • मैं स्ट्रिंग प्रिंट करता हूं, और नींद ( .5-> 0.5) सेकंड।

@FlipTack ने बचाए 4 बाइट्स! -> लूप को एक लाइन में रखें।

@Rod ने 2 बाइट्स बचाए! -> n+=1करने के लिए n^=1, इस प्रकार n%2के लिए n

@xnor ने बाइट को बचा लिया! -> while 1-> while[time.sleep(.5)]


7
आप के n+=1साथ बदल सकते हैं n^=1, और फिर उपयोग करते हैं [n::2], 2 बाइट्स बचाता है और बड़ी संख्या से बचते हैं c:
Rod

4
आप बदलना है, तो print"1-2-::0-0-"[n::2]करने के लिए print"\b"*6+"1-2-::0-0-"[n::2],यह कुछ बाइट्स जोड़ना होगा, लेकिन यह जगह में ब्लिंक करेगा
बज़

1
@ बज़ आप लाइन की शुरुआत में जाने के \rबजाय उपयोग कर सकते हैं \b\b\b...। लेकिन वैसे भी, यह केवल वर्तमान समाधान पर बाइट्स जोड़ देगा।
21

आप एक बाइट को करके बचा सकते हैं while[time.sleep(.5)]:
xnor

@xnor मुझे इतना यकीन था, कि यह अधिक गोल्फ नहीं हो सकता। यह साइट मुझे विस्मित करती है। धन्यवाद!
यति

15

ऑक्टेव, 63 62 61 55 बाइट्स

c='--:--00:21';while c=flip(c)disp(c(1:5));pause(.5)end

टॉम बढ़ई के लिए धन्यवाद दो बाइट्स सहेजे गए! एक सेल ऐरे में दो स्ट्रिंग्स के बजाय सिंगल स्ट्रिंग का उपयोग करना कम था।

स्पष्टीकरण:

c='--:--00:21';  % A string where the 5 first characters are --:-- or 12:00 when reversed
while c=flip(c)  % A string is always considered true in Octave, so this will loop forever
                 % while flipping the order of the string each time
 disp(c(1:5)     % display the 5 first characters of the string c
 pause(.5)       % Pause 0.5 second
end              % End loop

कुछ बाइट्स सहेजे गए क्योंकि ऑक्टेव के बीच flip(c)और disp(), और बीच pause(.5)और एक बृहदान्त्र या अर्धविराम की आवश्यकता नहीं है end


1
flipएक काउंटर के बजाय उपयोग करने के लिए अच्छा विचार है !
लुइस मेंडो

11

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

y=1;setInterval('console.log(["12:00","--:--"][y^=1])',500)

व्याख्या

setInterval('...',500) प्रत्येक 500 मिलीसेकंड, या 1/2 सेकंड में कोड को निष्पादित करने के लिए एक अंतराल सेट करता है।

y=1yशुरू में 1 तक , एक चर सेट करता है । इस तरह, पहली चीज़ जो छपी है, वह है 12:00क्योंकि yइसका उपयोग सरणी तक पहुँचने के लिए किया जाता है।

console.log(...)लॉग जो कुछ कंसोल के लिए, यह या तो में 12:00या --:--

["12:00","--:--"][y^=1]दोनों राज्यों वाले तारों के साथ एक सरणी बनाता है। फिर, yतत्वों में से एक का उपयोग करने के लिए उपयोग किया जाता है। अंत में ^=, या XOR कंपाउंड ऑपरेटर करता है y = y ^ 1। यह केवल बिट को निष्क्रिय करता1 ^ 1 है क्योंकि 0 है, और 0 ^ 11 है, जो @TuukkaX के समान है । इस तरह, स्ट्रिंग दो तत्वों के बीच सरणी में लॉग इन करती है और इस तरह ब्लिंकिंग प्रभाव पैदा करती है।


इस के साथ एक बाइट को बचाने में सक्षम था:y=1;setInterval('console.log(y?"12:00":"--:--");y=!y',500)
woutr_be

मेरे जवाब पर ETHproductions टिप You can save some bytes with setInterval(...,i=500) :-):। हमारे पास मूल रूप से एक ही जवाब है और यह आपके लिए भी काम करता है।
क्रिस्टोफ

11

वी , 31 30 27 25 24 बाइट्स

के आदेश को स्वैप करके @ nmjcman101 में सहेजा गया 5 बाइट्स धन्यवाद 12:00और --:--इतना है कि kको हटाने के द्वारा किसी भी हटाया जा सकता है òइतना है कि यह अंत में परोक्ष जोड़ा जा सकता है

दोनों बाइट को एक लाइन में 12:00और @DJMcMayhem को 1 बाइट का धन्यवाद--:--

i12:00--:--<ESC>bDòVp:sl500m

पुराना समाधान:

i12:00<ESC>ò:sl500m
Óä/-
:sl500m
uò

<ESC> है 0x1b

Hexdump:

00000000: 6931 323a 3030 2d2d 3a2d 2d1b 6244 f256  i12:00--:--.bD.V
00000010: 703a 736c 3530 306d                      p:sl500m

व्याख्या

i12:00--:--<ESC>   inserts 12:00\n--:--
bD                 go to the beginning of --:-- and delete it
ò                  recursively do:
 Vp                 select line and paste (effectively doing a replace)
 :sl500m            sleep for 500 milliseconds
                   the last ò is added implicitly at the end

Gif (पुराना)

नोट: मैंने हाइलाइटिंग चालू किया है

GIFF


7
आपने उस जीआईएफ में शाब्दिक रूप से पलक झपकते हुए :-)
लुइस मेंडो

दूसरे òको स्पष्ट रूप से दिया गया है, इसलिए आप इसे हटा सकते हैं।
DJMcMayhem

@DJMcMayhem यह किसी कारण से, दूसरे के बिना काम नहीं करता है ò। यह केवल एक बार चलता है
क्रिक्सी लिथोस

2
अपने इनपुट के क्रम को स्वैप करें ताकि आपको पहले की आवश्यकता न हो k। फिर pkddआप के बजाय बस का उपयोग कर सकते हैं Vp, के रूप pमें दृश्य चयन मोड में प्रभावी रूप से डिफ़ॉल्ट रजिस्टर के साथ चयन स्वैप।
nmjcman101

1
मुझे पता है कि आपको इसे हटाने में समस्याएँ हैं ò, लेकिन अगर यह अब काम करता है, तो मुझे लगता है कि आपको इसे बदलने में सक्षम होना चाहिए òVp:sl500mऔर वी ^Mòको 2 बाइट्स के लिए जोड़ना चाहिए ।
nmjcman101

11

बैश, 58 56 45 बाइट्स

1 आरजी के रूप में दबाने के --बाद 3 बाइट को बचाया setएक नंबर है।

set 12:00 --:--;for((a=1;;a=3-a)){ echo ${!a};sleep .5;}

@DigitalTrauma सिंटैक्स का उपयोग करके 16 बाइट सहेजे गए :

f()(echo $1;sleep .5);f 12:00;f --:--;exec $0

फिर zeppelin की टिप्पणी के कारण 5 बाइट्स खोना

यह कमांड लाइन पर परीक्षण नहीं किया जा सका। जैसा कि हम शामिल करते हैं $0, इसे चलाने के लिए एक स्क्रिप्ट में लिखा जाना चाहिए।

डाइवर्ट

थोड़ी तैयारी के साथ, यह अच्छा ( 412 बाइट्स ) बन सकता है :

set -- "         ▗▖         
▗▄▄▖▗▄▄▖ ▝▘ ▗▄▄▖▗▄▄▖
         ▗▖         
         ▝▘         " " ▟▌ ▟▀▜▖ ▗▖ ▗▛▙ ▗▛▙ 
 ▐▌  ▗▟▘ ▝▘ █▗▐▌█▗▐▌
 ▐▌ ▗▛▗▖ ▗▖ ▜▖▟▘▜▖▟▘
▝▀▀▘▀▀▀▘ ▝▘  ▀▘  ▀▘ "
r=`tput cup 0`
clear;for((a=1;;a=3-a)){ printf "$r${!a}";sleep .5;}

या एक ही दो पंक्तियों के साथ लेकिन:

set -- '                                            






      HM!          .o#HMMMMM#o.                 .o#MMMMH#\\         .d#MMMMH#\\
    _HMMi         ?MMH*"""`"MMMb               dMMH"""`*MMH,      dMMH"""`*MMH.
##HMMMMMi        |MMP"       9MML             ?MMP      `MMM.    dMM?      `MMM.
`""`"9MM|        dMM!        -MMR     HMH}   .MMM        |MM}   .MMH        |MM|
     |MM|         "`         JMMT     dHH}   |MM|         MMM   |MM|        -MMM
     |MM!                 .,HMM*             |MM|         MMM.  ]MM|         MMM
     |MMi              _o#MMH*"              |MM|         MMM   {MM|         MMM
     |MMi           .dHMM#""                 |MM|         MMM"  {MM|        .MMM
     |MMi         .HMM*"                     `MM6        ,MMR   |MM}        |MMF
     |MMi        ,MMP"                        9MM,       dMM|    HMM,       dMM"
     {MMi        MMM?\\o,\\\\\\\\\\\\\\\\,     q##+    `HMM\\    .dMM?     `HMH\\    .dMM?
     |MM|       :MMMMMMMMMMMMMMM[     HMMk     `*HMM##MMM#"       `*HMM##MMMP"
      "`          "     ` ` ` `                   """"`""            """"""    ' '









                                      MHM|                                      
                                      HHH|                                      

               ______.  ._______.            ________.  ._______.               
               MMMMMM:  {MMMMMMM|            &MMMMMMM:  |MMMMMMM[               


                                      ###|                                      
                                      MMM|                                      
                                                                               '

3
s(){ echo $1;sleep .5;};for((;;)){ s 12:00;s --:--;}
13

2
@manatwork अच्छा लगा! मुझे लगता है कि यह एक ही स्क्रिप्ट नहीं है! आपको उन्हें एक उत्तर के रूप में प्रकाशित करना होगा!
एफ। होरी

मैं मानता हूँ, कि ASCII कला बिल्कुल भव्य है ... क्या आपने इसे बनाने के लिए एक उपकरण का उपयोग किया था, या आपने इसे हाथ से बनाया था?
ETHproductions

2
@ETHproductions मैं Ghostscript का उपयोग करता हूं ; printf '%%\041\n/Helvetica findfont\n24 scalefont\nsetfont\nnewpath\n%s %s moveto\n(%s) show\nshowpage\n' -2.456 0.550003 12:00 | gs -sDEVICE=pnmraw -r600 -g470x146 -sOutputFile=- -q - | pnmscale -width 160 | ppmtopgm | pgmtopbm | pbmtoascii -2x4;-)
F. Hauri

1
... याf()(echo $1;sleep .5);f 12:00;f --:--;$0
डिजिटल ट्रॉमा

9

पर्ल, 49 बाइट्स

{select$,,$,,$,,0.5;say$|--?"12:00":"--:--";redo}

पर्ल sleep1 सेकंड की अवधि के लिए सो नहीं सकते, इसलिए सोने के लिए select undef, undef, undef, .5(गोल्फ की जगह के undefसाथ $,) .5 सेकंड का उपयोग करें।
अन्य दिलचस्प बात: $|केवल पकड़ 0या कर सकते हैं 1। तो $|--बस अपने मूल्य को टॉगल करता है, से 0करने के लिए 1
और अंत में, {... ;redo}एक अनंत लूप की तरह काम करता है।


6

* <<> , ४३ ४२ बाइट्स

<v":1200----"
S>@5dov>~r@@}r5
1&}o:&<^!?:-

यहाँ यह कोशिश करो!

मुझे लगता है कि मुझे इसे छोटा बनाने में सक्षम होना चाहिए, मेरे पास कोशिश करने के लिए कुछ विचार हैं ... मूल रूप से यह एक स्टैक बनाता है :1200----। यह :स्टैक को अलग करता है और फ़्लिप करता है, या :तो ( ----या 1200स्टैक के अंत में जो भी हो) के आधार पर सम्मिलित करता है।

मुझे यह भी ध्यान देना चाहिए कि केवल *> <> निर्देश इस उपयोग S(नींद) है, अन्यथा यह एक उचित> <> कार्यक्रम है।

अद्यतन: 1 बाइट :को एक रजिस्टर से बचाने के बजाय दाईं ओर शिफ्ट करके सहेजा गया ।

व्याख्या

initialisation

<v":1200----"

यहां हम उस स्टैक का निर्माण करते हैं जिसका उपयोग हम कार्यक्रम के जीवन के लिए कर रहे हैं।

<              move the IP left
  ":1200----"  push ":1200----" to the stack
 v             move the IP down into "output time"

आउटपुट समय

 >@5dov
1&}o:&<^!?:-

यह वह खंड है जहां समय वास्तव में आउटपुट होता है। पहले 5 को स्टैक पर धकेल दिया जाता है, इसलिए नीचे का लूप 5 बार चलना जानता है।

Initialisation:

 >@5dov

 >       move the IP right
  @      move the ":" back two spaces in the stack
   5     push 5 to the stack (let's call this `i`)
    do   output carriage return
      v  move IP down into "loop"

Loop:

1&}o:&<^!?:-

      <       move the IP left
     &        place i onto the register
  }o:         output a character and shift the stack left
 &            place i back onto the stack
1          -  decrement i by 1
       ^!?:   if i == 0, exit to "recover and swap"

पुनर्प्राप्त करें और स्वैप करें

S      >~r@@}r5

यहां हम :आउटपुट के बाद की स्थिति से उबरते हैं, और हम एक उलट स्टैक के साथ समाप्त होते हैं। यह वास्तव में "आउटपुट टाइम" में अच्छी तरह से बाहर निकलता है, जिससे एक अनंत लूप पैदा होता है।

       >         move the IP right
        ~        remove trailing i from stack
         r@@     reverse the stack and move ":" to the front
            }r   reverse the stack again, keeping ":" on the front
S             5  sleep for 500ms

45 बाइट का घोल

<v[5"12:00"1
d/S5
o/!?l
v>]?v
 00.>0"--:--"5[

यहाँ यह कोशिश करो!

यह भी मूल रूप से एक> <> कार्यक्रम है।

मैंने वास्तव में सोचा था कि यह इस दृष्टिकोण के साथ कुछ बाइट्स को बचाने में सक्षम होगा। यह काफी सरलता से आउटपुट है 12:00, फिर --:--। मैं आउटपुट रूटीन का पुन: उपयोग करके बाइट्स को बचाता हूं o/!?l(मैं प्रवेश और निकास दोनों के रूप में उस दर्पण का पुन: उपयोग करता हूं)। मैं राज्य को स्टोर करने के लिए कई स्टैक्स का उपयोग करता हूं (आउटपुट 12या --), और चुनें कि मुझे किस राज्य के साथ आउटपुट करना चाहिए v>]?v

स्पष्टीकरण जल्द ही आ रहा है! (1/2)


6

HTML / CSS (केवल Chrome), 80 + 4 = 84 बाइट्स

tt:after{content:"--:--";animation:a 1s infinite}@keyframes a{to{content:"12:00"
<tt>

संपादित करें : सीएसएस विनिर्देश द्वारा "सामग्री" विशेषता एनिमेट नहीं है , लेकिन क्रोम डेस्कटॉप ब्राउज़र पर है।


1
लगता है कि क्रोम विशिष्ट है। कम से कम फ़ायरफ़ॉक्स पर काम नहीं करता है। यह कोई समस्या नहीं है, समाधान अभी भी मान्य है, बस इसे निर्दिष्ट करना अच्छा होगा।
11

6

नूडल , 16 बाइट्स नॉनकंपेटिंग

--:-- 12:00ḷçėḍh

नूडल अभी भी बहुत काम है। बस कुछ चुनौतियों के साथ अपने पैरों को गीला करने की कोशिश कर रहा हूं।

कोशिश करो:)

यह काम किस प्रकार करता है

--:--            # Creates the string literal "--:--" and places i into the front of the pipe.
                 # Space is a NOP command to separate the string literals.
      12:00      # Creates the string literal "12:00" and places it into the front of the pipe.
           ḷ     # Loop the following code unconditionally.
            ç    # Clear the screen and print a copy of what is in the pipe.
             ė   # Take what is in the front of the pipe and put it into the back.
              ḍh # Delay for half a second.

यहाँ एक कोड स्निपेट है :)

<div id="noodel" code="--:-- 12:00ḷçėḍh" input="" cols="10" rows="2"></div>

<script src="https://tkellehe.github.io/noodel/noodel-latest.js"></script>
<script src="https://tkellehe.github.io/noodel/ppcg.min.js"></script>


2
यदि दुभाषिया बाद की तारीखों को चुनौती देता है तो कृपया इसे "गैर-प्रतिस्पर्धी" :) के रूप में चिह्नित करें। नूडल हालांकि साफ-सुथरा दिखता है, लेकिन इसे जरूर देखें।
Redstarcoder

@redstarcoder उफ़! धन्यवाद, कि डाल भूल गया।
tkellehe

क्या आप एन्कोडिंग की व्याख्या कर सकते हैं? यह UTF-8 में 16 से अधिक जोड़ता है।
देवरीचेर

1
मैंने आपके लिंक को देखा, यह एन्कोडिंग की व्याख्या नहीं करता है। आप देखें, "डिफ़ॉल्ट" (UTF-8) द्वारा सभी वर्ण 1 बाइट नहीं हैं। किसी मौजूदा एन्कोडिंग को निर्दिष्ट करें या एक बनाएं, इसे समाप्त करें यह एक गलत बाइट काउंट है। इस बारे में कहीं न कहीं एक मेटा पोस्ट होना चाहिए। जब तक आप एक एन्कोडिंग को परिभाषित नहीं करते हैं, यह UTF-8 है और 22 बाइट्स है। @tkellehe
devRicher


5

QBIC , 37 33 बाइट्स

{sleep 01?@12:00`┘sleep 01?@--:--

QBasic दुर्भाग्य से पूरे सेकंड के लिए सो सकता है। मैं जल्द ही और अधिक लचीलेपन की अनुमति देने के लिए एक विधि तैयार करने के बारे में देखूंगा। मैंने 01अनुकरण करने के लिए 1 इनपुट किया है .5

स्पष्टीकरण:

{         Starts DO loop
sleep 01  Sleeps for 1 second
?@12:00`  Creates A$, sets value to "12:00" and prints A$
┘         Newline: a string literal doesn't break the line, so we need a newline to 
          control the compiled QBasic syntax
          <Rinse and repeat for "--:--">
          <DO-LOOP implicitly closed by QBIC>

QBIC के पुराने बिल्ड में, $और (स्थान) आरक्षित वर्ण थे। एक QBasic फ़ंक्शन को कॉल करना जिसमें रिक्त स्थान की आवश्यकता होती है (जैसे sleep x) या $( left$(..)) को एक कोड शाब्दिक आवश्यकता होती है:

'QBASIC CODE`

कोड शाब्दिक ब्लॉक में कोड QBIC द्वारा पार्स किए बिना सीधे QBasic को पास कर दिया जाता है। उन प्रतीकों से कार्यों को लोड करके ( $बन गए हैं ', और अब के बजाय newlines (alt-217) हैं ) प्रतीकों को अब QBIC द्वारा विशेष वर्णों के रूप में नहीं देखा गया है और बस पर पारित किया गया है। लोअरकेस वर्णमाला के लिए समान रूप से सच है: यह QBIC और QBasic दोनों में संख्यात्मक चर का प्रतिनिधित्व करने के लिए उपयोग किया जाता है और अपरिवर्तित छोड़ दिया जाता है। QBIC (जैसे SLEEP) में कार्यान्वित नहीं किया गया QBasic कार्यक्षमता का उपयोग करना QBIC आरक्षित वर्णों का उपयोग न करने की बात है। कमांड सिंबल में हाल के बदलावों से यह आसान हो गया है।


4

जावास्क्रिप्ट, 77 76 72 बाइट्स

setInterval('l=console.log,l("12:00"),setTimeout("l(`--:--`)",‌​500)',1e3)

1 बाइट के लिए कृति लिथोस और 4 बाइट्स के लिए एल सर्न का धन्यवाद!


1000को छोटा किया जा सकता है1e3
क्रिति लिथोस

2
setIntervalऔर setTimeoutपहले तर्क के रूप में कोड के साथ एक स्ट्रिंग स्वीकार करते हैं, ताकि आप एक और 4 बी बचा सकें: setInterval('l=console.log,l("12:00"),setTimeout("l(-: -)",500)',1e3)
ल्यूक

`रों मतलब यह अब ES6 है, जबकि पिछले जवाब केवल ES5 की जरूरत है।
नील

4

अजगर 2, 88 85 73 71 बाइट्स

import time
c="--:--00:21"
while 1:print c[:5];c=c[::-1];time.sleep(.5)

यहाँ यह कोशिश करो!

सूची को फ़्लिप करने के स्टिव ग्रिफिन के विचार को उधार लेकर, कार्यक्रम संभव बनाया गया था। स्पष्टीकरण के साथ अनगुल्ड संस्करण:

import time                      # Import time module
c = "--:--00:21"                 # String with two values
while 1:                         # Infinite Loop
    print c[::5]                 # Print the first 5 chars in string
    c = c[::-1]                  # Flip the string
    time.sleep(.5)               # Wait 0.5 seconds

14 बाइट्स बचाने के लिए धन्यवाद @FlipTack!


1
आप इसे स्ट्रिंग
स्लाइस

4

पीएचपी, 51 50 47

for(;;usleep(5e5))echo$i++%2?"--:--
":"12:00
";

1 बाइट मैनटवर्क के कारण बची और 3 अन्य इन्सर्टसर्नमीयर द्वारा बचाई गई। धन्यवाद!


1
यदि आप usleep(5e5)कॉल को for3 के पैरामीटर पर ले जाते हैं, तो ,विभाजक अनावश्यक हो जाता है, जिससे 1 वर्ण बच जाता है।
manatwork

@manatwork धन्यवाद! मेरे पास while(1)पहले था।
क्रिस्टोफ

2
आप 3 और बाइट्स बचा सकते हैं : बीच की सफेद जगह को हटा दें echoऔर एक वास्तविक नई रेखा के साथ $iबदल दें \n
इन्सुरेस्नामेयर

@ गोल्फरुर्नामेयर पर भी इस गोल्फ ने मेरी आंखों को नुकसान पहुंचाया: डी लेकिन यह काम करता है।
क्रिस्टोफ

3

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

#?=!Z"12:00""--:--".d.5

छद्मकोश में:

                Z = 0
#               while 1:
 ?=!Z               if ( Z = not Z ):
     "12:00"            print("12:00")
                    else:
     "--:--"            print("--:--")
 .d.5               sleep(0.5)

Zफ्लिप-फ्लॉप के रूप में पूर्व- निर्धारित चर का उपयोग करता है , और हर बार ifस्थिति की जांच करने की कोशिश करता है।


.d5 को लूप के सामने रखें और अंतिम उद्धरण हटा दें
Maltysen

3

माणिक, 47 42 बाइट्स

अभी तक कोई माणिक जवाब नहीं है, इसलिए यहां मेरा पहला प्रयास है:

%w{12:00 --:--}.cycle{|a|puts a;sleep 0.5}

3

GNU sed, 39 बाइट्स

संपादन:

  • बदली नींद और I12: 00 (मेक स्रोत कोड के लिए थोड़ा अच्छे लग रहे)

golfed

s/^/sleep .5/
h
i12:00
e
i--:--
x
e
G
D

व्याख्या की

s/^/sleep .5/   #Put 'sleep .5' to the pattern space
h               #Copy pattern space to hold space
i12:00          #Print "12:00" (insert before a line) 
e               #Execute command that is found in pattern space
i--:--          #Print "--:--"
x               #Exchange the contents of the hold and pattern spaces
e               #Execute command that is found in pattern space

G               #Append a newline to the contents of the pattern 
                #space, and then append the contents of the hold
                #space to that of the pattern space.

D               #Delete text in the pattern space up to the 
                #first newline, and restart cycle with the 
                #resultant pattern space, without reading a new 
                #line of input.

यह ऑनलाइन की कोशिश करो!


3

डीसी (बैश), 37 बाइट्स

[12:00][--:--][[rp!sleep .5]xlax]dsax

यह स्टैक पर दो स्ट्रिंग्स "12:00" और "-: -" को धक्का देकर काम करता है और फिर बार-बार मानों की अदला-बदली करता है, स्टैक के शीर्ष पर आइटम को प्रिंट करता है, और आधा सेकंड सोता है।

इसे चलाने के लिए, आप इसे एक फ़ाइल में सहेज सकते हैं और फिर टाइप कर सकते हैं

डीसी फाइलनाम

या आप इसे सीधे bash कमांड लाइन से टाइप करके चला सकते हैं

dc <<< '[12:00] [-: -] [[आरपी! नींद .5] xlax] dsax'


3

पर्ल 6 ,  48 41  34 बाइट्स

loop {print "\r",<--:-- 12:00>[$_=!$_];sleep .5}
loop {put <--:-- 12:00>[$_=!$_];sleep .5}
sleep .put/2 for |<12:00 --:-->xx*

एक forलूप का उपयोग करने से यह थोड़ा छोटा हो सकता है:for |<12:00 --:-->xx* {sleep .5;.say}
स्मेल करता है

यहां तक कि कम अगर आप तथ्य यह है कि का उपयोग कर sayरिटर्न 1:sleep .say/2 for |<12:00 --:-->xx*
SMLS

2

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

®‘©ị“12:00“--:--”ṄœS.ß

TIO पर काम नहीं करता है। QPython3 के साथ एंड्रॉइड पर चलने के लिए जेली प्राप्त करना भी एक मजेदार अनुभव था।

व्याख्या

®‘©ị“12:00“--:--”ṄœS.ß    Main link. No arguments. 
®                         Read the register. Initially 0.
 ‘                        Increment. 
  ©                       Save to the register.
   ị                      Get the n'th (wrapping) item of...
    “12:00“--:--”         ["12:00", "--:--"]
                 Ṅ        Print the string and a newline. 
                  œS      Sleep for...
                    .     ...0.5 seconds. (. is an alias for 0.5)
                     ß    Call this link again. 

1
क्या यह सोता है? क्या आप एक स्पष्टीकरण जोड़ सकते हैं?
स्टेनबर्घ

1
@steenbergh गयी। देरी के लिए क्षमा करें, स्पष्टीकरण के लिए उन संकेत को संपादित करना गैर-मोनोस्पेस फ़ॉन्ट के साथ एसई ऐप पर थोड़ा कठिन है।
पुरकाकूदरी

2

गणितज्ञ, 38 बाइट्स

Dynamic@If[Clock[]>.5,"12:00","--:--"]

व्याख्या

Clock[]

एक घड़ी चर का उत्पादन करता है जो हर सेकंड 0 से 1 तक लगातार चक्र करता है।

If[Clock[]>.5,"12:00","--:--"]

यदि क्लॉक वैरिएबल .5 से अधिक है, तो आउटपुट "12:00।" यदि नहीं, तो आउटपुट "-: -"।

Dynamic@ ...

कार्यक्रम को गतिशील बनाएं (लगातार अद्यतन)


2

जावास्क्रिप्ट, 57 55

setInterval('console.log(++i%2?"12:00":"--:--")',i=500)

2 बाइट्स ETHproductions के लिए धन्यवाद बचा लिया


3
आप कुछ बाइट्स setInterval(...,i=500):-) के साथ बचा सकते हैं
ETHproductions

2

पोस्टस्क्रिप्ट 225 214

केवल मनोरंजन के लिए! इसे असली प्रिंटर पर न भेजें !!

/Courier findfont 9 scalefont setfont{usertime 500 mod 5 lt{newpath 9 9 moveto 1 setgray 99 setlinewidth 99 99 lineto stroke 0 setgray}if newpath 9 9 moveto usertime 999 mod 500 lt{(--:--)}{(12:00)}ifelse show}loop

कोशिश करो:

gs -c '/Courier findfont 9 scalefont setfont{usertime 500 mod 5 lt{newpath 9 9 moveto 1 setgray 99 setlinewidth 99 99 lineto stroke 0 setgray}if newpath 9 9 moveto usertime 999 mod 500 lt{(--:--)}{(12:00)}ifelse show}loop'

या

cat <<eops >/tmp/blinkingTwelve.ps
%!
/Courier findfont
9 scalefont
setfont
{
  usertime 500 mod 5 lt {
    newpath
    9 9 moveto
    1 setgray
    99 setlinewidth
    99 99 lineto
    stroke
    0 setgray
  } if
  newpath
  9 9 moveto
  usertime 999 mod 500 lt {
    (--:--)
  } {
    (12:00)
  } ifelse
  show
} loop
eops

फिर

gs /tmp/blinkingTwelve.ps
gv /tmp/blinkingTwelve.ps

लेकिन इसे और अधिक परिष्कृत दर्शक के साथ खोलने और डेस्कटॉप थंबनेलर की देखभाल करने की कोशिश न करें!


यदि gs -c '...'एक श्वेत पृष्ठ का आदेश दिया जाता है, तो आपको डिस्प्ले विंडो gs -r45 -c '...'बढ़ानी पड़ सकती है या एक छोटे रिज़ॉल्यूशन का उपयोग करना पड़ सकता है: या छोटे कागज़ का उपयोग करेंgs -r600 -g360x200 -c '...'
F.

2

जावास्क्रिप्ट (ब्राउज़र में), 174 160 159 122 112 111 109 107 66 (91) बाइट्स

मैंने इस बात का ध्यान रखा है preक्योंकि मोनोटाइप्ड फॉन्ट का उपयोग करना आवश्यकता का हिस्सा नहीं है, इसलिए मेरी नई गिनती 66 है । मोनोसेप्ड फॉन्ट का उपयोग करने के लिए कुछ चार्ट जोड़े जाते हैं, लेकिन जैसा कि यह आवश्यक नहीं है, मैं इस 25 और चार्ट की गिनती नहीं करूंगा ।

14 बाइट बचाने के लिए ETHproductions का धन्यवाद ,

1 बाइट बचाने के लिए कृति लिथोस को ,

करने के लिए manatwork को बचाने के लिए 1 3 बाइट,

करने के लिए क्रिस्टोफ दो और बाइट्स को बचाने के लिए और

खुद को 37 बाइट्स बचाने के लिए ... और 10 के [..][b^=1]बजाय डबल-कोट्स setTimeoutद्वारा प्रतिस्थापित function(){..}करके ...

setInterval("document.body.innerHTML=++b%2?'12:00':'--:--'",b=500)
body{font-family:Courier}

... और भी बुरा:

66 से कुछ अधिक ...

... लेकिन मज़ेदार के लिए, एक निमिष प्रदर्शन की भावना में:

SVG="http://www.w3.org/2000/svg";XLNK="http://www.w3.org/1999/xlink";
s=["1200","----"];p=0;function d(n){for(i=n.length;i>0;i--) {
  document.getElementById('n'+i).setAttribute('class','n'+n[i-1])}
  document.getElementById('sz').setAttribute('class','n'+n[0])}
setInterval("p=1-p;d(s[p])",500);
#svg2 { --c: #FF6;stroke:#432;stroke-width:12;stroke-linecap:round;stroke-linejoin:round; stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none; } path.b { fill:#543;stroke:none; } .blue     { --c: #68F; } .green    { --c: #6F8; } .red      { --c: #F88; } .dec rect  { stroke: var(--c); } .n1 #B { stroke: var(--c); }  .n1 #C { stroke: var(--c); } .n2 #A { stroke: var(--c); }  .n2 #B { stroke: var(--c); } .n2 #D { stroke: var(--c); }  .n2 #E { stroke: var(--c); } .n2 #G { stroke: var(--c); }  .n3 #A { stroke: var(--c); } .n3 #B { stroke: var(--c); }  .n3 #C { stroke: var(--c); } .n3 #D { stroke: var(--c); }  .n3 #G { stroke: var(--c); } .n4 #B { stroke: var(--c); }  .n4 #C { stroke: var(--c); } .n4 #F { stroke: var(--c); }  .n4 #G { stroke: var(--c); } .n5 #A { stroke: var(--c); }  .n5 #C { stroke: var(--c); } .n5 #D { stroke: var(--c); }  .n5 #F { stroke: var(--c); } .n5 #G { stroke: var(--c); } .n6 #A { stroke: var(--c); }  .n6 #C { stroke: var(--c); } .n6 #D { stroke: var(--c); }  .n6 #E { stroke: var(--c); } .n6 #F { stroke: var(--c); }  .n6 #G { stroke: var(--c); } .n7 #A { stroke: var(--c); }  .n7 #B { stroke: var(--c); } .n7 #C { stroke: var(--c); } .n8 #A { stroke: var(--c); }  .n8 #B { stroke: var(--c); } .n8 #C { stroke: var(--c); }  .n8 #D { stroke: var(--c); } .n8 #E { stroke: var(--c); }  .n8 #F { stroke: var(--c); } .n8 #G { stroke: var(--c); } .n9 #A { stroke: var(--c); }  .n9 #B { stroke: var(--c); } .n9 #C { stroke: var(--c); }  .n9 #D { stroke: var(--c); } .n9 #F { stroke: var(--c); }  .n9 #G { stroke: var(--c); } .n0 #A { stroke: var(--c); }  .n0 #B { stroke: var(--c); } .n0 #C { stroke: var(--c); }  .n0 #D { stroke: var(--c); } .n0 #E { stroke: var(--c); }  .n0 #F { stroke: var(--c); } .n11 #B { stroke: var(--c); } .n11 #C { stroke: var(--c); } .n11 #E { stroke: var(--c); } .n11 #F { stroke: var(--c); } .nA #A { stroke: var(--c); }  .nA #B { stroke: var(--c); } .nA #C { stroke: var(--c); }  .nA #E { stroke: var(--c); } .nA #F { stroke: var(--c); }  .nA #G { stroke: var(--c); } .nB #C { stroke: var(--c); }  .nB #D { stroke: var(--c); } .nB #E { stroke: var(--c); }  .nB #F { stroke: var(--c); } .nB #G { stroke: var(--c); } .nC #A { stroke: var(--c); }  .nC #D { stroke: var(--c); } .nC #E { stroke: var(--c); }  .nC #F { stroke: var(--c); } .nD #B { stroke: var(--c); }  .nD #C { stroke: var(--c); } .nD #D { stroke: var(--c); }  .nD #E { stroke: var(--c); } .nD #G { stroke: var(--c); } .nE #A { stroke: var(--c); }  .nE #D { stroke: var(--c); } .nE #E { stroke: var(--c); }  .nE #F { stroke: var(--c); } .nE #G { stroke: var(--c); } .nF #A { stroke: var(--c); }  .nF #E { stroke: var(--c); } .nF #F { stroke: var(--c); }  .nF #G { stroke: var(--c); } .nR #E { stroke: var(--c); }  .nR #G { stroke: var(--c); } .nO #C { stroke: var(--c); }  .nO #D { stroke: var(--c); } .nO #E { stroke: var(--c); }  .nO #G { stroke: var(--c); } .n- #G { stroke: var(--c); }  .n1 #y { stroke: var(--c); } .n1 #z { stroke: var(--c); }
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="100%" height="100%" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 645 230" id="svg2"> <defs id="dfs4"><g id="n"><path d="M 15,5 155,5 145,225 5,225 z" class="b"/> <path id="A" d="M 45,15 125, 15"/><path id="B" d="M 135,25 125,105"/><path id="C" d="M 125,125 115,205"/><path id="D" d="M 25,215 105,215"/><path id="E" d="M 25,125 15,205"/><path id="F" d="M 35,25 25,105"/><path id="G" d="M 35,115 115,115"/><rect id="P" width="5" height="5" ry="2.5" x="130" y="205"/></g><g id="s"><path d="M 10,5 35,5 25,225 0,225 z" id="a" class="b"/><rect id="y" width="5" height="5" ry="2.5" x="13.5" y="145"/><rect id="z" width="5" x="17" height="5" ry="2.5" y="75"/></g></defs><use id="n1" xlink:href="#n" /><use id="n2" xlink:href="#n" transform="translate(150,0)" /><use xlink:href="#s" id="sz" transform="translate(305,0)"/><use id="n3" transform="translate(335,0)" xlink:href="#n" /><use id="n4" xlink:href="#n" transform="translate(485,0)" />
</svg>


1
1000बन सकते हैं1e3
कृति लिथोस

1
आप सभी उदाहरणों को हटाकर बाइट्स का एक गुच्छा बचा सकते हैं window.; window.setTimeoutके रूप में ही है setTimeout
ETHproductions

1
ttकी तुलना में कम है preऔर मोनोस्पेस फॉन्‍ट का उपयोग भी करता है। (बस यह इनलाइन एलिमेंट है, ब्लॉक नहीं, लेकिन इससे यहां कोई फर्क नहीं b=document.body.append(a=document.createElement('tt'))
पड़ना

1
d=document;d.body.append(a=d.createElement('tt'));setInterval("a.innerHTML=++b%2?'12:00':'--:--'",b=500)5 बाइट्स बचाता है
क्रिस्टोफ

1
क्या कोई तत्व उत्पन्न करने का कोई कारण है? setInterval("document.body.innerHTML=++b%2?'12:00':'--:--'",b=500)केवल फैंसी मोनोसेप्स को पीछे छोड़ता है लेकिन केवल 66 बाइट्स है।
क्रिस्टोफ़

2

क्विकबेस , 167 दंश (स्वादिष्ट)

a%=VAL(RIGHT$(STR$(TIMER*100),2))
b%=a%+50
IF b%>99THEN b%=b%-99
DO
c%=VAL(RIGHT$(STR$(TIMER*100),2))
IF c%=a% THEN PRINT"--:--"
IF c%=b% THEN PRINT"12:00"
LOOP

मैं वैसे भी कभी जीतने वाला नहीं था। QB में एक मंजिल () नहीं है, और x मिलीसेकंड के लिए सोने के लिए फ़ंक्शन भी नहीं है । इसलिए, यह टिमर के फ्लोटिंग पॉइंट हिस्से को पकड़कर काम करता है (आधी रात के बाद से वापस लौटा सेकंड, प्लस टू-डिजिट दशमलव के रूप में व्यक्त वर्तमान दूसरे का एक अंश)। हम तब एक लूप-चारों ओर "50 इकाइयों" को जोड़ते हैं, यह निर्धारित करने के लिए कि चरण को "-: -" से "12:00" पर स्विच करना चाहिए, और "12:00" से स्विच के लिए मूल टाइमर दशमलव का उपयोग करें। सेवा "--:--"।

अंत में, यहां तक ​​कि QB4.5 में इस कंप्लायंस को चलाने पर, DOSBox में एक शक्तिशाली मशीन पर बीट्स को छोड़ दिया जाएगा। ऐसा इसलिए है क्योंकि QB वास्तव में MS के अंदर DO-LOOP और मूल्यांकन करने के लिए पर्याप्त तेज़ नहीं है जिसकी हम तुलना कर रहे हैं। FUTURE से एक बॉक्स की आवश्यकता होगी!

वैसे भी, मैं अब 100 का दिख रहा हूं, और मैंने हर अमेरिकी विश्वविद्यालय के छात्र को खुश किया क्योंकि उनके पास शायद उनके कॉम्प साइंस वर्ग के लिए एक उत्तर है - क्योंकि वे खुद को पढ़ा रहे हैं ...


क्या आप कुछ जगहों को हटा सकते हैं? यानी b% = b% - 99करने के लिए b%=b%-99?
22

हाँ, मुझे पूरा यकीन है कि मैं कर सकता था, लेकिन मैंने मूल आईडीई का उपयोग किया था, जो लाइन के अंत में प्रवेश करने के बाद, उन्हें वापस जोड़ देगा। मुझे आईडीई के बाहर डॉस में संपादित करना होगा, और फिर लिंकर / कंपाइलर के मापदंडों की जांच करें कि क्या मेरा समाधान अभी भी काम कर रहा है ... इसलिए यह छोटा हो सकता है, लेकिन मेरे प्रयास के दायरे में नहीं।
राबर्ट लर्नर

ठीक है, आपको इस कोड को गोल्फ करने की आवश्यकता है अन्यथा यह एक मान्य उत्तर नहीं है और इसे हटा दिया जाएगा। उसके लिए माफ़ करना। (मैं पूरी तरह से समझता हूं कि आपका क्या मतलब है, लेकिन एक पूरे के रूप में समुदाय ने गैर-गोल्फ जवाबों के खिलाफ फैसला किया है)
Rɪᴋᴇʀ

अच्छी बात है, मैं रिक्त स्थान हटा दूंगा।
राबर्ट लर्नर

2

क्लोजर, 79 62 बाइट्स

V2

-17 बाइट्स एक भयावह अनुक्रमण लूप से एक अनंत सूची पर पाशन में बदलकर।

की एक अनंत सूची बनाता है "12:00"और "--:--"अधिक दोहरा और फिर से, तो का उपयोग करता है doseqलगातार अगले संदेश खींच, और यह मुद्रित करने के लिए।

(doseq[m(cycle["12:00""--:--"])](Thread/sleep 500)(println m))

V1

(loop[i 0](Thread/sleep 500)(println(["12:00""--:--"]i))(recur(if(= 0 i)1 0))))

मैं "12:00" और "- -" स्थिरांक को कॉम्पैक्ट करने के लिए एक अच्छा तरीका नहीं सोच सकता था, इसलिए मुझे उन्हें केवल कठिन कोड देना पड़ा।

Ungolfed:

(loop [i 0] ; Track which sign we showed last
    (Thread/sleep 500)
    (println (["12:00" "--:--"] i)) ; Index the vector to get the string to print
    (recur (if (= 0 i)1 0))) ; Swap the index, and loop again

2

पुष्य , 22 बाइट्स (गैर-प्रतिस्पर्धात्मक)

`--:`wO`12:0`&["500oWF

यह उत्तर दो ढेर का उपयोग करता है, उन दोनों के बीच फ्लिप करके, पात्रों को बारी-बारी से प्रिंट करता है:

`--:`    \ Push these characters to stack 1
 w       \ Mirror around center, yielding "--:--"
 O       \ On the second stack...
 `12:0`  \ Push these characters
 &       \ Duplicate the last (for :00)

 [        \ Infinitely:
  "       \   Print the current stack
  500oW   \   Wait 500 milliseconds
  F       \   Swap stacks
          \ (Implicit end loop)

oWआदेश प्रयोगात्मक आदेशों चुनौती postdate, इस सवाल का जवाब गैर प्रतिस्पर्धा बनाने का एक सेट का हिस्सा है।


2

Windows PowerShell, 46 55 बाइट्स

function a{sleep -m 500;cls};for(){"12:00";a;"--:--";a}

मूल कोड:

a{sleep -m 500;cls};for(){"12:00";a;"--:--";a}
^ this won't work on other PCs. No idea why.
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.