Many electronic devices, specially old ones, will show a blinking 12:00 when the time has not been set. The purpose of this challenge is to recreate this.

Specifically, the task is to display 12:00 and --:-- alternatively in an infinite loop.

The period should be 1 second, divided evenly in two periods of 0.5 seconds. Here "1 second" and "evenly" can be interpreted loosely. For example, it is acceptable if the code pauses for 0.5 seconds between displaying the strings, even if the resulting period will then be a little higher than 1 second. An initial pause before displaying the first string is acceptable.

Each new string can be displayed either by replacing the former string or in a new line. Trailing whitespace is allowed, except that if each new string is on a different line there should be no empty lines between consecutive strings.

Shortest code in bytes wins.

  • 1
    \$\begingroup\$ does this count as kolmogorov-complexity? \$\endgroup\$
    – FlipTack
    Jan 2, 2017 at 12:36
  • \$\begingroup\$ @FlipTack I think so, but I wasn't sure. Thoughts, anyone? \$\endgroup\$
    – Luis Mendo
    Jan 2, 2017 at 12:45
  • 1
    \$\begingroup\$ @LuisMendo I don't think so, I think the KG tag is mostly for a fixed string. This has more to it, the waiting and alternating strings. \$\endgroup\$
    – Riker
    Jan 2, 2017 at 13:25
  • \$\begingroup\$ Can submissions wait 0.5 seconds before showing initial output? \$\endgroup\$
    – FlipTack
    Jan 2, 2017 at 18:20
  • 1
    \$\begingroup\$ IMHO, the statement "Each new string can be displayed either by replacing the former string or in a new line" made this challenge not fun. \$\endgroup\$
    – Setop
    Jan 3, 2017 at 0:53

71 Answers 71


HTML/CSS, 131 108 106 101 + 18 17 = 149 126 125 123 118 bytes

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

Edit: Saved 23 bytes thanks to @insertusernamehere. Saved 1 byte by switching from <pre> to <tt>. Saved 2 bytes thanks to @darrylyeo. Saved 5 bytes thanks to @DBS.

  • 1
    \$\begingroup\$ @insertusernamehere Bah, I golfed away the a{position:absolute} but completely forgot about the pre... \$\endgroup\$
    – Neil
    Jan 2, 2017 at 18:45
  • \$\begingroup\$ Do you still need the pre tag? the css only mentions a. \$\endgroup\$
    – user46167
    Jan 2, 2017 at 23:38
  • \$\begingroup\$ @ev3commander I saved a byte by switching to <tt>. \$\endgroup\$
    – Neil
    Jan 3, 2017 at 0:51
  • \$\begingroup\$ You can remove the final }} completely. \$\endgroup\$
    – darrylyeo
    Jan 3, 2017 at 2:30
  • \$\begingroup\$ I think you should be able to simplify margin-left to margin since you're working from the top left anyway margin:-5ch; should have the same effect. \$\endgroup\$
    – DBS
    Jan 4, 2017 at 16:27

Shell and pv, 26 bytes

This use yes standard tool and pv Shell pipeline element to meter data passing through

yes '12:00
--:--'|pv -qlL2
  • 2
    \$\begingroup\$ Nice solution, but the language should probably be stated as "Shell and pv", since (to my knowledge anyway) pv isn't included in any shell nor is it part of the GNU or BSD core utilties. \$\endgroup\$ Jan 2, 2017 at 21:01
  • 1
    \$\begingroup\$ That's a nice trick ! (which I believe was pioneered by @Digital Trauma here ). Albeit in this case it feels a bit against the spirit of the challenge, as the mission statement was to "display 12:00 and --:-- alternatively" (imitating a blinking display), but this code will just output character by character at a constant rate of 12 chars per second instead. Which means that "12:00" will stay on the screen only for 1/12 (0.08) seconds ("12:0_"=1/12s=>"12:00"=2/12s=>"-"). \$\endgroup\$
    – zeppelin
    Jan 3, 2017 at 16:24
  • \$\begingroup\$ @zeppelin thanks for references: I'v used @DigitalTrauma's sample -qlL2 for making 2 lines by secs instead of -qL12: 12 chars by sec. Length of script is same \$\endgroup\$ Jan 3, 2017 at 16:50

Python2, 80 75 73 69 67 66 bytes

import time

I noticed that my string magic got a little longer than picking the string from an array. Nevermind, figured it out.


  • I set a counter n to 0, which will be toggled between 0 and 1.

  • I loop endlessly with the loop while 1.

  • I create a string 1-2-::0-0-, which contains the string 12:00 and --:-- interlapped.

    • Starting from the index 0 with a step of 2, we get: 12:00

    • Starting from the index 1 with a step of 2, we get: --:--

  • I use n to make the repeated sequence 0, 1, 0, 1, 0... which will be the starting index of the string.

    • Using n^=1, in each loop, we get that sequence. ^ being the XOR-operator.
    • If n == 0 --> n^=1 results in 1
    • If n == 1 --> n^=1 results in 0
  • I print the string, and sleep (.5 -> 0.5) seconds.

@FlipTack saved 4 bytes! --> Put the loop in one line.

@Rod saved 2 bytes! --> n+=1 to n^=1, thus n%2 to n.

@xnor saved a byte! --> while 1 --> while[time.sleep(.5)].

  • 7
    \$\begingroup\$ you can replace n+=1 with n^=1, and then use [n::2], saves 2 bytes and avoid big numbers c: \$\endgroup\$
    – Rod
    Jan 2, 2017 at 12:45
  • 4
    \$\begingroup\$ if you change the print"1-2-::0-0-"[n::2] to print"\b"*6+"1-2-::0-0-"[n::2], it will add a few bytes but it will blink in place \$\endgroup\$
    – Buzz
    Jan 3, 2017 at 20:58
  • 1
    \$\begingroup\$ @Buzz you can use \r instead of \b\b\b... to move to the beginning of the line. But anyway, this would only add bytes onto the current solution. \$\endgroup\$
    – FlipTack
    Jan 4, 2017 at 21:22
  • \$\begingroup\$ You can save a byte by doing while[time.sleep(.5)]:. \$\endgroup\$
    – xnor
    Jan 7, 2017 at 9:28
  • \$\begingroup\$ @xnor I was so sure, that this couldn't be golfed more. This site continues to amaze me. Thanks! \$\endgroup\$
    – Yytsi
    Jan 7, 2017 at 11:36

Octave, 63 62 61 55 bytes

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

Saved two bytes thanks to Tom Carpenter! Using a single string instead of two strings in a cell array was shorter.


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

A few bytes saved because Octave doesn't require a colon or semicolon between flip(c) and disp(), and between pause(.5) and end.

  • 1
    \$\begingroup\$ Nice idea to use flip instead of a counter! \$\endgroup\$
    – Luis Mendo
    Jan 2, 2017 at 12:59

JavaScript, 59 bytes



setInterval('...',500) sets an interval to execute code in the string every 500 milliseconds, or 1/2 a second.

y=1 sets a variable, y, to 1 initially. That way, the first thing that is printed is 12:00 because y is used to access the array.

console.log(...) logs whatever to the console, in this either 12:00 or --:--.

["12:00","--:--"][y^=1] creates an array with strings containing both states. Then, y is used to access one of elements. Finally, ^=, or XOR compound operator does y = y ^ 1. This just inverts the bit because 1 ^ 1 is 0, and 0 ^ 1 is 1, similar to what @TuukkaX did. This way, the string logged alternates between the two elements in the array and thus creates the blinking effect.

  • \$\begingroup\$ Was able to save a byte with this: y=1;setInterval('console.log(y?"12:00":"--:--");y=!y',500) \$\endgroup\$
    – woutr_be
    Jan 3, 2017 at 9:55
  • \$\begingroup\$ ETHproductions tip at my answer: You can save some bytes with setInterval(...,i=500) :-). We basically have the same answer and it works for yours, too. \$\endgroup\$
    – Christoph
    Jan 3, 2017 at 12:30

V, 31 30 27 25 24 bytes

Saved 5 bytes thanks to @nmjcman101 by swapping the order of 12:00 and --:-- so that k can be removed any by removing ò so that it could be added implicitly at the end

Saved 1 byte thanks to @DJMcMayhem by putting both 12:00 and --:-- in one line


Old Solution:


<ESC> is 0x1b


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 (outdated)

Note: I have highlighting turned on


  • 7
    \$\begingroup\$ You took blinking literally in that gif :-) \$\endgroup\$
    – Luis Mendo
    Jan 2, 2017 at 14:04
  • \$\begingroup\$ The second ò is given implicitly, so you can remove it. \$\endgroup\$
    – DJMcMayhem
    Jan 2, 2017 at 18:32
  • \$\begingroup\$ @DJMcMayhem It, for some reason, doesn't work without the second ò. It only runs once \$\endgroup\$
    – user41805
    Jan 2, 2017 at 18:33
  • 2
    \$\begingroup\$ Swap the order of your inputs so you don't need the first k. Then instead of pkdd you can just use Vp, as p in visual select mode effectively swaps the selection with the default register. \$\endgroup\$
    – nmjcman101
    Jan 3, 2017 at 14:53
  • 1
    \$\begingroup\$ I know you have problems removing the ò, but if that works now, I think you should be able to change it to òVp:sl500m and let V add the ^Mò for 2 bytes. \$\endgroup\$
    – nmjcman101
    Jan 3, 2017 at 18:00

bash, 58 56 45 41 bytes

New version 2022, (not very system friendly), but...

bash <(yes "read -t.5 -p"{--:--,12:00}\;)

or with newline: 45

bash <(yes "read -t.5 -p'

or with carrier return: 47

bash <(yes "read -t.5 -p$'\r"{--:--,12:00}"';")

saved 3 byte by suppressing -- after set as 1st arg is a number.

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

Saved 16 byte by using @DigitalTrauma's syntax:

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

Then loosing 5 bytes because of zeppelin's comment.

This could not be tested on command line. As we involve $0, this must be written into a script to run.


With a little preparation, this could become nice (412 bytes):

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

Or even same two lines but with:

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"
      "`          "     ` ` ` `                   """"`""            """"""    ' '

               ______.  ._______.            ________.  ._______.               
               MMMMMM:  {MMMMMMM|            &MMMMMMM:  |MMMMMMM[               
  • 3
    \$\begingroup\$ s(){ echo $1;sleep .5;};for((;;)){ s 12:00;s --:--;} \$\endgroup\$
    – manatwork
    Jan 2, 2017 at 13:53
  • 2
    \$\begingroup\$ @manatwork Nice! I think it's not same script! You have to publish them as an answer! \$\endgroup\$ Jan 2, 2017 at 14:09
  • \$\begingroup\$ I gotta admit, that ASCII art is absolutely gorgeous... Did you use a tool to create it, or did you make it by hand? \$\endgroup\$ Jan 2, 2017 at 18:29
  • 2
    \$\begingroup\$ @ETHproductions I use 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 ;-) \$\endgroup\$ Jan 2, 2017 at 22:13
  • 1
    \$\begingroup\$ ...or f()(echo $1;sleep .5);f 12:00;f --:--;$0 \$\endgroup\$ Jan 3, 2017 at 22:12

Perl, 49 bytes


Perl's sleep can't sleep for duration bellow 1 sec, hence the use of select undef, undef, undef, .5 (golfed by replacing undef with $,) to sleep .5 second.
Other interesting thing: $| can only hold 0 or 1. So $|-- just toggles its value, from 0 to 1.
And finally, {... ;redo} acts like an infinite loop.

  • \$\begingroup\$ You can cut two bytes using while instead of redo: Try it online! \$\endgroup\$
    – Xcali
    Jan 2, 2021 at 3:23

Noodel, 16 bytes

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

Noodel is still very much a work in progress. Just trying to get my feet wet with a couple of challenges.

Try it:)

How It Works

--:--            # 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.

Here is a code snippet:)

<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>

  • \$\begingroup\$ Can you explain the encoding? It adds up to much more than 16 in UTF-8. \$\endgroup\$
    – devRicher
    Jan 4, 2017 at 0:09
  • \$\begingroup\$ @devRicher I made my own code page to get closer to how I wanted the language to work. Do I need to say something about it? Sorry, I am new:) \$\endgroup\$
    – tkellehe
    Jan 4, 2017 at 0:25
  • 1
    \$\begingroup\$ I looked at your link, it doesnt explain the encoding. You see, not all characters are 1 byte by "default" (UTF-8). Specify an existing encoding or make one, elsewise this is a wrong byte count. There should be a meta post somewhere about this. Unless you define an encoding, this is UTF-8 and is 22 bytes. @tkellehe \$\endgroup\$
    – devRicher
    Jan 4, 2017 at 0:32
  • \$\begingroup\$ @devRicher Thank you, I will look into it:) \$\endgroup\$
    – tkellehe
    Jan 4, 2017 at 0:35
  • 1
    \$\begingroup\$ Found the meta post, btw. \$\endgroup\$
    – devRicher
    Jan 4, 2017 at 0:37

*><>, 43 42 bytes


Try it here!

I feel like I should be able to make this shorter, I have a couple ideas to try ... Basically this makes a stack of :1200----. It isolates the : and flips the stack, inserting the : in the middle of either ---- or 1200 (depending on whichever is at the end of the stack).

I should also note that the only *><> instruction this uses is S (sleep), otherwise this is a proper ><> program.

Update: Saved 1 byte by shifting the : to the right instead of protecting it with a register.




Here we build the stack we'll be using for the life of the program.

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

Output time


This is the section where the time is actually outputted. First 5 is pushed to the stack so the loop below knows to run 5 times.



 >       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"



      <       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"

Recover and swap

S      >~r@@}r5

Here we recover the : from the position it results in after the output, and we end up with a reversed stack. This actually exits into "output time" nicely, causing an infinite loop.

       >         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 byte solution


Try it here!

This one is also basically a ><> program.

I really thought it'd be able to save some bytes with this approach. This quite simply outputs 12:00, then --:--. I save bytes by reusing the output routine o/!?l (I even reuse that mirror as both entry and exit). I utilise multiple stacks to store the state (has output 12 or --), and select which state I should output with v>]?v.

Explanations coming soon! (1/2)


HTML/CSS (Chrome only), 80 + 4 = 84 bytes

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

Edit: The "content" attribute is not animatable by the CSS specification, but is on Chrome desktop browser.

  • 1
    \$\begingroup\$ Seems to be Chrome specific. At least not works on Firefox. This is not a problem, the solution is still valid, just would be nice to specify it. \$\endgroup\$
    – manatwork
    Jan 4, 2017 at 11:57

Jelly, 20 bytes


How it works

.“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.
  • \$\begingroup\$ So you;re basically turning both strings in the list into links of their own, with an added sleep-command? Sweet. \$\endgroup\$
    – steenbergh
    Jan 4, 2017 at 15:10

QBIC, 37 33 bytes

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

QBasic unfortunately can only sleep for whole seconds. I'll see about devising a method to allow for more flexibility soon. I've input 1 as 01 to simulate .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>

In older builds of QBIC, $ and (space) were reserved characters. Calling a QBasic function that needed spaces (like sleep x) or $ (left$(..)) required a code literal:


Code in a code literal block is passed directly to QBasic without being parsed by QBIC. By offloading functions from those symbols ($ became ', and newlines are now (alt-217) instead of ) the symbols are no longer seen by QBIC as special chars and simply passed on. The same is effectively true for the lowercase alphabet: it's used to represent numeric variables in both QBIC and QBasic and are left unchanged. Using QBasic functionality that is not implemented in QBIC (like SLEEP) is therefor simply a matter of not using QBIC reserved chars. This is made easier with the recent changes in the command symbols.


LibreLogo, 100 bytes (Non-Competing)


ht point fontsize 99 repeat [ cs sleep 500 if repcount % 2 [ label '12:00' ] else [ label '--:--' ]]


ht                            ; Hide Turtle (Unnecessary... Added for visual clarity)
point                         ; Draw a point with size and color of the pen
fontsize 99                   ; Font Size = 99 pt (Unnecessary... Added for visual clarity)
repeat [                      ; Endless Loop
    cs                        ; Clear Screen
    sleep 500                 ; Wait for 500 ms
    if repcount % 2 [         ; If the Repetition Count is Even...
        label '12:00'         ; Draw '12:00'
    else [                    ; Otherwise...
        label '--:--'         ; Draw '--:--'


enter image description here


JavaScript, 77 76 72 bytes


Thanks to Kritixi Lithos for 1 byte and L. Serne for 4 bytes!

  • \$\begingroup\$ 1000 can be shortened to 1e3 \$\endgroup\$
    – user41805
    Jan 2, 2017 at 13:27
  • 2
    \$\begingroup\$ setInterval and setTimeout accept a string with code as a first argument, so you can save another 4B: setInterval('l=console.log,l("12:00"),setTimeout("l(--:--)",500)',1e3) \$\endgroup\$
    – Luke
    Jan 2, 2017 at 13:45
  • \$\begingroup\$ The `s mean this is now ES6, whereas the previous answer only needed ES5. \$\endgroup\$
    – Neil
    Jan 2, 2017 at 18:51

Python 2, 88 85 73 71 bytes

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

Try it here!

By borrowing Stewie Griffin's idea of flipping the list, the program was made possible. Ungolfed version with explanation:

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

Thanks @FlipTack for saving 14 bytes!

  • 1
    \$\begingroup\$ You can golf it even shorter using string slicing, like this \$\endgroup\$
    – FlipTack
    Jan 2, 2017 at 14:21

PHP, 51 50 47


1 byte saved due to manatwork and another 3 saved by insertusernamehere. Thanks!

  • 1
    \$\begingroup\$ If you move the usleep(5e5) call to for's 3rd parameter, the , separator becomes unnecessary, saving 1 character. \$\endgroup\$
    – manatwork
    Jan 2, 2017 at 16:19
  • \$\begingroup\$ @manatwork thanks ! I had while(1) at first. \$\endgroup\$
    – Christoph
    Jan 2, 2017 at 17:02
  • 2
    \$\begingroup\$ You can save 3 more bytes: Remove the white space between echo and $i and replace \n with an actual newline. \$\endgroup\$ Jan 2, 2017 at 18:17
  • \$\begingroup\$ @insertusernamehere even at golfing this hurts my eyes :D but hey it works. \$\endgroup\$
    – Christoph
    Jan 3, 2017 at 6:29

Pyth, 23 bytes


In pseudocode:

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

Uses preinitialized variable Z as the flip-flop, and inverts its state every time if tries to check the condition.

  • \$\begingroup\$ put .d5 in the front of the loop and remove the end quote \$\endgroup\$
    – Maltysen
    Jan 12, 2017 at 0:39

Mathematica, 38 bytes




Outputs a clock variable that cycles continuously from 0 to 1 every second.


If the clock variable is greater than .5, output "12:00." If not, output "--:--".

Dynamic@ ...

Make the program dynamic (constantly updating)


ruby, 47 42 bytes

No ruby answer yet, so here is my first try:

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

GNU sed, 39 bytes


  • Swapped sleep and i12:00 (to make source code look a bit nicer)


s/^/sleep .5/


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.

Try It Online !


dc (bash), 37 bytes

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

This works by pushing the two strings "12:00" and "--:--" on the stack and then repeatedly swapping the values, printing the item at the top of the stack, and sleeping half a second.

To run this, you can save it in a file and then type

dc filename

or you can run it directly from the bash command line by typing

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


Perl 6,  48 41  34 bytes

loop {print "\r",<--:-- 12:00>[$_=!$_];sleep .5}
loop {put <--:-- 12:00>[$_=!$_];sleep .5}
sleep .put/2 for |<12:00 --:-->xx*
  • \$\begingroup\$ using a for loop can make it a little shorter: for |<12:00 --:-->xx* {sleep .5;.say} \$\endgroup\$
    – smls
    Jan 15, 2017 at 11:18
  • \$\begingroup\$ Even shorter if you make use of the fact that say returns 1: sleep .say/2 for |<12:00 --:-->xx* \$\endgroup\$
    – smls
    Jan 15, 2017 at 11:24

Vim, 32 keystrokes


Python 3, 75 bytes

import time
for i in x:x+=[i];print(i);time.sleep(.5)

Jelly, 22 bytes


Doesn't work on TIO. Getting Jelly to run on Android with QPython3 was also a fun experience.


®‘©ị“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
    \$\begingroup\$ Does this sleep? Can you add an explanation? \$\endgroup\$
    – steenbergh
    Jan 2, 2017 at 15:44
  • 1
    \$\begingroup\$ @steenbergh Added. Sorry for the delay, editing those indents for the explanation is a bit hard on the SE app with a non-monospace font. \$\endgroup\$ Jan 2, 2017 at 16:16

Javascript, 57 55


2 bytes saved thanks to ETHproductions

  • 3
    \$\begingroup\$ You can save some bytes with setInterval(...,i=500) :-) \$\endgroup\$ Jan 2, 2017 at 18:28

Javascript (in browser), 174 160 159 122 112 111 109 107 66 (91) bytes

I've taked of pre because using monotyped font is not part of requirement, so my new count is 66. Some chars are added to use monospaced font but as this is not needed, I won't count this 25 more chars.

Thanks to ETHproductions for saving 14 bytes,

to Kritixi Lithos for saving 1 byte,

to manatwork for saving 1 3 byte,

to Christoph for saving two more bytes and

to myself for saving 37 bytes by using [..][b^=1] instead of setTimeout... and 10 more by replacing function(){..} by double-quotes...


... worse:

From 66 to something more...

... but for fun, in the spirit of a blinking display:

s=["1200","----"];p=0;function d(n){for(i=n.length;i>0;i--) {
#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)" />

  • 1
    \$\begingroup\$ 1000 can become 1e3 \$\endgroup\$
    – user41805
    Jan 2, 2017 at 16:49
  • 1
    \$\begingroup\$ You can save a bunch of bytes by removing all instances of window.; window.setTimeout is the same as setTimeout. \$\endgroup\$ Jan 2, 2017 at 18:27
  • 1
    \$\begingroup\$ tt is shorter than pre and also implies the use of monospace font. (Just it is inline element, not block, but this should make no difference here.) b=document.body.append(a=document.createElement('tt')) \$\endgroup\$
    – manatwork
    Jan 3, 2017 at 9:37
  • 1
    \$\begingroup\$ d=document;d.body.append(a=d.createElement('tt'));setInterval("a.innerHTML=++b%2?'12:00':'--:--'",b=500) saves 5 bytes \$\endgroup\$
    – Christoph
    Jan 3, 2017 at 12:38
  • 1
    \$\begingroup\$ Is there a reason to generate an element? setInterval("document.body.innerHTML=++b%2?'12:00':'--:--'",b=500) only lags the fancy monospace but is only 66 bytes. \$\endgroup\$
    – Christoph
    Jan 3, 2017 at 12:45

QuickBASIC, 167 bites (yummy)

IF b%>99THEN b%=b%-99
IF c%=a% THEN PRINT"--:--"
IF c%=b% THEN PRINT"12:00"

I was never going to win anyways. QB doesn't have a floor(), and also doesn't have a function to sleep for x milliseconds. Therefore, this works by grabbing the floating point portion of the TIMER (returns seconds elapsed since midnight, plus a fraction of the current second expressed as a two-digit decimal). We then add a loop-around "50 units" to it to determine when the phase should switch from "--:--" to "12:00", and use the original TIMER decimal for the switch from "12:00" to "--:--".

Finally, even running this complied in QB4.5, in DOSBox on a rather powerful machine will skip beats. That's because QB really isn't fast enough to perform the DO-LOOP and evaluations inside of the MS we're doing the comparison in. Would need a box from the FUTURE!

Anyway, I now look 100, and I made every American University student happy since they probably have an answer for their Comp Sci class -- since they're still teaching this...

  • \$\begingroup\$ Can you remove some of the spaces? i.e b% = b% - 99 to b%=b%-99? \$\endgroup\$
    – Riker
    Jan 5, 2017 at 22:04
  • \$\begingroup\$ Yea I'm pretty sure I could, but I used the original IDE which, after you hit enter at the end of the line, would add them back in. I'd have to edit it outside of the IDE in DOS, and then figureout the parameters for the linker/compiler to check if my solution still worked... So it can be shorter, but not within my frame of effort. \$\endgroup\$ Jan 5, 2017 at 22:13
  • \$\begingroup\$ Well, you need to golf this code or else it's not a valid answer and will be deleted. Sorry about that. (I completely understand what you mean, but the community as a whole has decided against non-golfed answers) \$\endgroup\$
    – Riker
    Jan 5, 2017 at 22:15
  • \$\begingroup\$ Good point, I'll remove the spaces. \$\endgroup\$ Jan 5, 2017 at 22:16

Clojure, 79 62 bytes


-17 bytes by changing from an awful indexing loop to looping over an infinite list.

Creates an infinite list of "12:00" and "--:--" repeating over and over again, then uses doseq to constantly pull the next message, and print it.

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


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

I couldn't think of a good way to compact the "12:00" and "--:--" constants, so I had to just hard code them.


(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

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.