text:
Generate an ASCII Padovan Spiral
This is the ASCII version of this challenge. The initial post was separated per request by Martin Ender
Introduction
Similar to the Fibonacci Sequence, the Padovan Sequence (OEIS A000931) is a sequence of numbers that is produced by adding previous terms in the sequence. The initial values are defined as:
P(0) = P(1) = P(2) = 1

The 0th, 1st, and 2nd terms are all 1. The recurrence relation is stated below:
P(n) = P(n - 2) + P(n - 3)

Thus, it yields the following sequence:
1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37, 49, 65, 86, 114, 151, 200, 265, 351, ...

Using these numbers as side lengths of equilateral triangles yields a nice spiral when you place them all together, much like the Fibonacci Spiral:

Image courtesy of Wikipedia

Task
Your task is to write a program that recreates this spiral by ASCII art, with input corresponding to which term. Since a triangle of side length 1 (1 character) is impossible to represent nicely in ASCII, the side lengths have been dilated by a factor of 2. Thus, the triangle of side length 1 is actually represented like so:
 /\
/__\

So, for example, if the input was 5 (the 5th term), the output should be:
   /\
  /  \
 /    \
/______\
\      /\
 \    /__\
  \  /\  /
   \/__\/

The first 5 terms were 1, 1, 1, 2, 2, so the triangle had side lengths 2, 2, 2, 4, 4 due to dilation. Another example for input 8:
     __________
   /\          /\
  /  \        /  \
 /    \      /    \
/______\    /      \
\      /\  /        \
 \    /__\/          \
  \  /\  /            \
   \/__\/______________\
    \                  /
     \                /
      \              /
       \            /
        \          /
         \        /
          \      /
           \    /
            \  /
             \/

Rules

You must print the result, and input must be an integer corresponding to term number
Trailing and leading newlines are allowed, trailing spaces after lines are allowed also
Your submission must be able to handle at least up to the 10th term (9)
Your submission must be a full program or function that takes input and prints the result
Rotations of the output are allowed, in 60 degree multiples, but the size of the triangles must remain the same, along with the representation
Going counter-clockwise is also allowed
Standard loopholes are forbidden

You may assume that input will be >0 and that correct format of input will be given.
Scoring
This is code-golf, so the shortest code in bytes wins. Happy New Years everyone!

my language Turtlèd can take base 10 input, and process it fine, but this challenge would be so much easier if it took input as unary. would that be allowed?

@DestructibleWatermelon Yes. The input just has to be integer, in some kind of form.

cool. I'll start working on it now

wait actually it's still really hard

Befunge, 871 836 798 bytes
&00p45*:10p20p030p240p050p060p9010gp9110gp1910gp1-91+10gpv
<v-g03+g06*2g041g055_v#!:%6:p06p05+p04g05g06:g04<p*54+292<
->10g:1\g3+:70p110gv >:5- #v_550g:01-\2*40g+1-30g
/\110:\-g03:\1:g055 _v#!-4:<vp01:-1g01-g03-1\-
^1<v07+1:g07< p08p < >:1-#v_550g:01-\40g+60g+1-30g-50g>v
 _0>p80gp:5-|v1\+66\:p\0\9:$<:p02:+1g02-g03+g06-\g04\1:<
0v|-g00:+1$$<>\p907^>p:!7v>3-#v_550g:30g+:30p1\0\-
1>10g+::0\g3-:70p\0^^07<v<>50#<g::30g+:30p-1-01-\
v >\$0gg> :1+10gg1- #v_^>0g10gg*+\:!2*-70g2+10gv>:#->#,"_"$#1_:1#<p
+1+g03$_^#`gg011+3:+3<g07\+*2+*`0:-\gg01+5g07:g<>1#,-#*:#8>#4_$#:^#
>55+,p30g40p10gg10g1>#v_
#v:#p0$#8_:$#<g!#@_0^ >
 >>:180gg`>>#|_:2+80gg:!v
3+^g\0p08:<vgg08+2::+3<$_100p1-v>g,\80gg+\80gp:2+90g:!01p\80gp
!#^_80g:1+^>\180gg`+!#^_20g80g`
5*g10!g09p04-1-\0\+g04:gg08:p09<^3`0:gg08+1:::$$_1#!-#\\:,#\<g

Try it online!
As is often the case with Befunge, the trick is coming up with an algorithm that allows us to render the pattern from top to bottom, since it's just not feasible to render it into memory first with the limited space available.
The way this works is by first building up a simple data structure representing the edges needed to draw the spiral. The second stage then parses that structure from top to bottom, rendering the edge fragments required for each line of output.
Using this technique, we can support up to n=15 in the reference implementation before we start having overflow issue in the 8-bit memory cells. Interpreters with a larger cell size should be able to support up to n=25 before running out of the memory.

that is very impressive... but do you find you are able to read these programs? lol to me it looks so random. how does it build the data structure? what kind of data structure does it use? thanks!

go, 768 bytes
func 卷(n int){
    数:=0
    p:=[]int{1,1,1}
    for i:=3;i<n;i++ {p=append(p,p[i-2]+p[i-3])}
    宽:=p[len(p)-1]*10+10
    素:=make([]int,宽*宽)
    for 数=range 素 {素[数]=32}
    for i:=0;i<数;i+=宽 {素[i]=10}
    态:=[]int{1,1,宽/2,宽/2,92}
    表:=[70]int{}
    s:="SRSQTSPQQ!QOQP~QQQQQQSQR~ORQR!OPOPTSQRQ$QPPQNQPPPXQQQQQQRRQXQRRRNOQPQ$"
    for i:=range s {表[i]=int(s[i])-33-48}
    表[49],表[59]=48,48
    for i:=0;i<4*n;i++ {
        梴:=p[i/4]*2
        if 态[1]==0 {梴=梴*2-2}
        for k:=0;k<梴;k++ {
            址:=(态[2]+态[3]*宽)%len(素)
            if 素[址]==32 {素[址]=态[4]}
            态[2]+=态[0]
            态[3]+=态[1]
        }
        数=((态[0]+1)*2+态[1]+1)*5
        if i%4>2 {数+=35}
        for k:=0;k<5;k++ {态[k]+=表[数+k]}
    }
    for i:=0;i<宽*宽;i++ {fmt.Printf("%c",rune(素[i]))}
}

This is of course not optimal, but it's not a bad start. I know it's probably a bit simple for the golfing standards, but it was fun and I hope it's not minded if I leave some notes to future self.
How it works
Basically I simulate a 'drawing turtle' like in LOGO on an ASCII pixel grid, but the turtle can only do these three commands:
rt   - right turn, turn 120 degrees right (1/3 of a Turn)
rth  - right turn half, turn  60 degrees right (1/6 of a Turn)
fd n - forward, go forward n steps, drawing a trail of _, /, or \

Now for each triangle, I go like this, where P is 2x the nth Padovan number:
fd P
rt
fd P
rt
fd P
rt
fd P
rth

The fourth 'fd' means I am re-tracing the first side of each triangle. This helps get back to a nice starting point for the next triangle. The half-right-turn makes sure that the next triangle will be in the proper orientation.

To golf the turtle I store 5 state variables in array 态 : x position, y position, x velocity, y velocity, and 'drawing rune'. At each animation frame, x+= x velocity, y += y velocity, and the rune is drawn.
Then I set up table 表 which tells how to actually perform the turn. The turn code is tricky because of the way ASCII art works. It is not a straightforward movement like on a pixel display. The direction of the turtle, determined by x and y velocity, determine the changes necessary to get the turn to look proper.
To turn, it looks at the current x and y velocity, and combines them into an index.
xv = x velocity, yv = y velocity.
i.e. a turtle facing down and to the right has
xv of 1, and yv of 1. It can only face 6
different directions. Formula is (xv+1)*2+yv+1

xv  yv    index
-1  -1    0
-1   0    1
-1   1    2
 1  -1    4
 1   0    5
 1   1    6

This index is used to lookup a set of 5 values in table 表. Those 5 values in table 表 are then added to each of the 5 variables in state 态. The turtle is then effectively turned, and ready for the next 'fd'.
For rth, half the right turn, there is a separate section of the 表 table. It is offset by 7*5, or 35, entries from the first table in 表.
Lastly I did some simple encoding of the table's integers into an ascii string.
I know I could 'save bytes' by removing the Hanzi but like I said, this is not optimal and there is more golfing possible... I will remove them when there is no other possible optimization. Those Hanzi actually have meaning loosely based on their actual meaning, and even though I don't know Chinese, it helps me think about the program.
数  index number
宽  screen width
素  pixel data
梴  length of side of triangle
态  current state
址  address of pixel
表  state transition table

To test the code you will need full golang file, with this header
package main
import "fmt"

and this footer
func main ()  {
    for i := 0; i<15; i++ {
       卷(i)
    }
}

thanks

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Blinking twelve
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.

does this count as [tag:kolmogorov-complexity]?

@FlipTack I think so, but I wasn't sure. Thoughts, anyone?

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

Can submissions wait 0.5 seconds before showing initial output?

@FlipTack Yes, edited

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.

@Setop Do you mean that I should have required replacing the strings instead of allowing each string on a new line? Well, some languages or interpreters have difficulty with the concept of clearing the screen or deleting previous output; that's why I gave some flexibility

Question! Would it be okay as answer to use DOS as platform and exploit the text-mode's feature of blinking for this?

@z0rberg's I think it would, yes. Please provide a gif with the result

Jelly, 20 bytes
.“12:00“--:--”ṄœS¥€ß

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.

So you;re basically turning both strings in the list into links of their own, with an added sleep-command? Sweet.

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
<tt>--:--12:00

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

@insertusernamehere Bah, I golfed away the a{position:absolute} but completely forgot about the pre...

Do you still need the pre tag? the css only mentions a.

@ev3commander I saved a byte by switching to <tt>.

You can remove the final }} completely.

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.

@DBS Thanks, I think it works because the text gets aligned on the baseline so the top and bottom margins don't have a visible effect.

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

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.

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=>"-").

@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

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

Nice idea to use flip instead of a counter!

Python2, 80 75 73 69 67 66 bytes
import time
n=0
while[time.sleep(.5)]:print"1-2-::0-0-"[n::2];n^=1

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

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)].

you can replace n+=1 with n^=1, and then use [n::2], saves 2 bytes and avoid big numbers c:

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

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

You can save a byte by doing while[time.sleep(.5)]:.

@xnor I was so sure, that this couldn't be golfed more. This site continues to amaze me. Thanks!

I was trying to do the same thing as @FlipTack but had to add sys.stdout.flush(). Does someone have it working without?

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'
"{--:--,12:00}"';")

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

                                      MHM|
                                      HHH|

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

                                      ###|
                                      MMM|
                                                                               '

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

@manatwork Nice! I think it's not same script! You have to publish them as an answer!

I gotta admit, that ASCII art is absolutely gorgeous... Did you use a tool to create it, or did you make it by hand?

@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 ;-)

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

@DigitalTrauma Well! Shorted than manatwork's one! Same remark; you have to publish you own answer!

With $0 your program will keep allocating resources and will fail eventually (i.e. this is not  an infinite loop). You can probably replace it with exec $0 to make each iteration reuse the same process.

@zeppelin Usualy, I upvote comments who made me make an edit, but, for your last comment, I will make such an exception. Sorry ;-)

@F.Hauri Ha ha :) Anyway, it all looks good now, so you got my +1.

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

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
i12:00--:--<ESC>bDòVp:sl500m

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

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

Explanation
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

You took blinking literally in that gif :-)

The second ò is given implicitly, so you can remove it.

@DJMcMayhem It, for some reason, doesn't work without the second ò. It only runs once

@: probably tries to repeat the substitution, as that uses :s under the covers.

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.

@nmjcman101 Thanks for the tip, TIL about V :)

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.

@nmjcman101 Aah, I didn't know that ^M is added along with ò. Thanks again for the tip :)

@KritixiLithos Yup, V adds a lot of things implicitly. ^M, <esc> and ò or ñ are all added implicitly, and you can also end any operator implicitly. (for example, d at the end of a program, macro, or global command will delete a line)

You could do i12:00--:--<esc>bDòVp:sl500m to save one more byte.

@DJMcMayhem I was thinking about putting them in one line, but didn't know of a 1-byte command to go to the middle. Thanks!

JavaScript, 59 bytes

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

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

Was able to save a byte with this: y=1;setInterval('console.log(y?"12:00":"--:--");y=!y',500)

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.

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

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.

You can cut two bytes using while instead of redo: Try it online!

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

Can you explain the encoding? It adds up to much more than 16 in UTF-8.

@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:)

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

@devRicher Thank you, I will look into it:)

Found the meta post, btw.

@devRicher What would be the best way to indicate in the answer that it uses its own code page? Similar to that of Jelly or APL?

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

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.
Explanation
Initialisation
<v":1200----"

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
 >@5dov
1&}o:&<^!?:-

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

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

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

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

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.

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.
Explanation:
{         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:
'QBASIC CODE`

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)
Code:
ht point fontsize 99 repeat [ cs sleep 500 if repcount % 2 [ label '12:00' ] else [ label '--:--' ]]

Explanation:
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 '--:--'
    ]
]

Result:

JavaScript, 77 76 72 bytes
setInterval('l=console.log,l("12:00"),setTimeout("l(`--:--`)",500)',1e3)

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

1000 can be shortened to 1e3

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)

The ```s mean this is now ES6, whereas the previous answer only needed ES5.

Python 2, 88 85 73 71 bytes
import time
c="--:--00:21"
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!

You can golf it even shorter using string slicing, like this

PHP, 51 50 47
for(;;usleep(5e5))echo$i++%2?"--:--
":"12:00
";

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

If you move the usleep(5e5) call to for's 3rd parameter, the , separator becomes unnecessary, saving 1 character.

@manatwork thanks ! I had while(1) at first.

You can save 3 more bytes: Remove the white space between echo and $i and replace \n with an actual newline.

@insertusernamehere even at golfing this hurts my eyes :D but hey it works.

Pyth, 23 bytes
#?=!Z"12:00""--:--".d.5

In pseudocode:
                Z = 0
#               while 1:
 ?=!Z               if ( Z = not Z ):
     "12:00"            print("12:00")
                    else:
     "--:--"            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.

put .d5 in the front of the loop and remove the end quote

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

Explanation
Clock[]

Outputs a clock variable that cycles continuously from 0 to 1 every second.
If[Clock[]>.5,"12:00","--:--"]

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

Make the program dynamic (constantly updating)

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*

using a for loop can make it a little shorter: for |<12:00 --:-->xx* {sleep .5;.say}

Even shorter if you make use of the fact that say returns 1: sleep .say/2 for |<12:00 --:-->xx*

GNU sed, 39 bytes
EDITS:

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

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

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

ruby, 47 42 bytes
No ruby answer yet, so here is my first try:
%w{12:00 --:--}.cycle{|a|puts a;sleep 0.5}

Vim, 32 keystrokes
qq:sl500m<CR>S12:00<Esc>:<UP><CR>S--:--<Esc>@qq@q

Python 3, 75 bytes
import time
x=['12:00','--:--']
for i in x:x+=[i];print(i);time.sleep(.5)

QuickBASIC, 167 bites (yummy)
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

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

Can you remove some of the spaces? i.e b% = b% - 99 to b%=b%-99?

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.

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)

Good point, I'll remove the spaces.

Clojure, 79 62 bytes
V2
-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))

V1
(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.
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

Jelly, 22 bytes
®‘©ị“12:00“--:--”ṄœS.ß

Doesn't work on TIO. Getting Jelly to run on Android with QPython3 was also a fun experience.
Explanation
®‘©ị“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.

Does this sleep? Can you add an explanation?

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

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

2 bytes saved thanks to ETHproductions

You can save some bytes with setInterval(...,i=500) :-)

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

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

... worse:
From 66 to something more...
... but for fun, in the spirit of a blinking display:

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>

1000 can become 1e3

You can save a bunch of bytes by removing all instances of window.; window.setTimeout is the same as setTimeout.

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

d=document;d.body.append(a=d.createElement('tt'));setInterval("a.innerHTML=++b%2?'12:00':'--:--'",b=500) saves 5 bytes

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.

@Christoph anyway using body and add style for body to Courier still save 16 characters, thanks!

Postscript 225 214
For fun only! Don't send this to a real printer!!
/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

Try it:
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'

or
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

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

But don't try to open this with more sophisticated viewer and care about desktop thumbnailer!

If gs -c '...' command prompt a white page, you may have to grow the display window or use a smaller resolution: gs -r45 -c '...' or smaller papersize gs -r600 -g360x200 -c '...'

QBasic (QB64) 55 53 Bytes
A$="12:00
B$="--:--
DO
?A$
_DELAY .5
SWAP A$,B$
LOOP

Saved 2 bytes as newline appears to terminate the string definitions.
SWAP makes all the difference.  For vanilla QBASIC replace _DELAY with SLEEP S where S is an integer in seconds, but then the frequency is wrong.

Disappointingly replacing DO..LOOP with 1..GOTO 1 results in the same byte count

Q/KDB+, 61 Bytes
s:("12:00";"--:--")
b:1b
.z.ts:{b::not b;show s[b]}
\t 500

Explanation:
s:("12:00";"--:--")

Assign the values we wish to show in a list.
b:1b

Assign a boolean variable to flip between 0 and 1 easily.
.z.ts:{b::not b;show s[b]}

This is a KDB+ function which is invoked in set intervals by the timer function (\t) http://code.kx.com/wiki/Reference/dotzdotts
 This executes the code inside the curly braces when \t is set. Show the value in s and then flipping the value of b between 0 and 1.
\t 500

Effectively calls .z.ts every 500ms.

Windows PowerShell, 46 55 bytes
function a{sleep -m 500;cls};for(){"12:00";a;"--:--";a}

Original Code:
a{sleep -m 500;cls};for(){"12:00";a;"--:--";a}
^ this won't work on other PCs. No idea why.

Pushy, 22 bytes (non-competing)
`--:`wO`12:0`&["500oWF

This answer makes use of the two stacks, by flipping between them, printing the characters in turn:
`--:`    \ 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)

The oW command is part of a set of experimental commands that postdate the challenge, making this answer non-competing.

Powershell, 46 45 bytes
-1 byte, thanks @AdmBorkBork
for(){('12:00','--:--')[$i++%2]
sleep -m 500}

You shouldn't need the ; in the for loop. Link.

C# (.NET Core), 138 131 127 bytes
class H{static int Main(){for(int n=1;;System.Threading.Thread.Sleep(500))System.Console.WriteLine((n^=1)>0?"--:--":"12:00");}}

Try it online!
Simple one-liner code.

C# (.NET Core), 127 bytes
class H{static int Main(){for(int n=1;;System.Threading.Thread.Sleep(500))System.Console.Write((n^=1)>0?"\r--:--":"\r12:00");}}

Try it online!
This code has same length with the code above, it does replace previous line.

-7 bytes by using for loops.
-4 bytes by using ternary operator.

Python 2, 92 bytes
import time
t=0
while 1:u=t%2;v='--'*u;w=1-u;print v+'12'*w+':'+v+'00'*w;t+=1;time.sleep(.5)

Try it online!
Explanation
import time                                   Import the time module
t=0                                           Set a counter, 't', to 0
while 1:                                      Trigger an infinite loop
    u = t%2                                   Let 'u' be the remainder of t/2. This will alternate between 0 and 1
    w = 1 - u                                 Let 'w' be the opposite of u
    v = '--'*u                                Python lets the repetition of strings by multiplying them by an int. Here we are either mulitplying by 1 (no effect) or 0 (turns it to an empty string)
    print v + '12'*w + ':' + v + '00'*w       Concatonating 4 strings and printing them. We are using string multiplication again on the '12' and '00'
    t += 1                                    Increment the counter variable
    time.sleep(0.5)                           Wait half a second

Nice answer, but take a look at this Python solution to see how you could have improved it. Also see the tips for golfing in python.

Java, 152 151 bytes (Thanks @AlexRacer)
public class c{public static void main(String[] a)throws Exception{int i=1;while(i>0){System.out.println(i++%2<1?"--:--":"12:00");Thread.sleep(500);}}}

Try it here! * (this compiler prints only once a second, couldn't find a better one)

Change while loop to for(int i=0;;){...} and also i++%2==1 to i++%2<1

Changed this part (i++%2==1), but kept the while. Using your suggestion would even lose some bytes. Thanks for the feedback ;)

You can save a few bytes by limiting this to a function, not a whole program (which is allowed): void f()throws Exception{ ... }

@Snowman oh, thanks for the advice! Next time I'll try use only the function then.

You can remove public  in front of class (-7 bytes); remove the space between String[] a (-1 byte), change the while to for so you can put the int inside it: for(int i=1;i>0;){...} (-1 byte). And welcome to PPCG! :) If you haven't checked it out yet, I can recommend looking through Tips for golfing in Java.

Wow, thanks for the tips and for the welcome, @KevinCruijssen!

Haskell, 79 bytes
import System.Posix.Unistd
m=(>>usleep 500000).putStrLn
g=m"12:00">>m"--:--">>g

m is a helper function that waits half a second before printing its argument. The main function g calls m "12:00", then m "--:--" and then itself again.

S.I.L.O.S, 61 bytes
lbla
def p printLine
p 12:00
wait 500
p --:--
wait 500
GOTO a

Try it online!
Unfortunately TIO will just do nothing forever, as it waits until execution to print this. But, if you are eager to test, you can use the GitHub link.

Arduino CC, 79 bytes
void loop(){Serial.print("12:00");delay(500);Serial.print("--:--");delay(500);}

I have no experience with C/C++, so I don't really know how I can golf this.

You could group  Serial.print and delay into one separated function.

@F.Hauri, for me it ended up being the same length

Processing, 69 bytes
void draw(){println("12:00");delay(500);println("--:--");delay(500);}

Python 2, 68 Bytes
import time
while 1:
 for i in'12:00','--:--':print i;time.sleep(.5)

Dyalog APL, 35 31 30 bytes
Full program.
{⌽⍵⊣⎕←5↑⍵⊣⎕DL÷2}⍣≡'12:00--:--'

'12:00--:--' a string
{...}⍣≡ Repeatedly apply the below anonymous function until two successive results are identical (i.e. never)
 ÷2 reciprocal of two (one half)
 ⎕DL Delay that many seconds (returns elapsed time)
 ⊣ discard that in favor of
 ⍵ the argument
 5↑ take the first five characters
 ⎕← display with newline
 ⊣ discard that in favor of
 ⌽⍵ reverse argument (implicitly returned)

C, 77 bytes
#import<windows.h>
i;f(){for(;;i^=1)Sleep(83*printf(i?"\r--:--":"\r12:00"));}

Just curious, don't you need to write the complete program i.e. include main()?

@6packkid: If not explicitly specified the default is program or function. See this meta discussion: Default for Code Golf: Program, Function or Snippet?

R  69   65  61 bytes
y=1;while(1){cat('\r',c('12:00','--:--')[y]);Sys.sleep(.5);y=(y==1)+1}
 while(1){cat('\r12:00');Sys.sleep(.5);cat('\r--:--');Sys.sleep(.5)}
f=Sys.sleep;while(1){cat('\r12:00');f(.5);cat('\r--:--');f(.5)}
First time using the f = blah_function() trick, and it saved a few bytes. Used \r to replace existing string.
Fairly simple implementation:
f = Sys.sleep;      #store function for repeated usage
while(1){
    cat('\r12:00'); #print 12
    f(.5);          #sleep
    cat('\r--:--'); #print --
    f(.5)           #sleep again
}

GameMaker Language, 47 bytes
a="12:00"if 9<c mod 20a="--:--"draw_text(0,0,a)

(Assuming a room speed of 20 fps)

Scala, 100 bytes
object C extends App{var p=1>2;while(2>1){p= !p;println(if(p)"12:00"else"--:--");Thread.sleep(500)}}

ForceLang, 79 bytes
def d datetime.wait 500
def w io.writeln
label 1
w "12:00"
d
w "--:--"
d
goto 1

And here's a version in 125 bytes that actually clears the screen each time and blinks:
set z string.char 8
def d datetime.wait 500
set z z+z+z+z+z
label 1
io.write "12:00"
d
io.write z+"--:--"
d
io.write z
goto 1

tcl, 49
while 1 {lmap x 12:00\ --:-- {puts $x;after 500}}

Can be tried on https://goo.gl/8gXPzC
Thanks to people on tcl IRC channel.

tcl, 51
while 1 {puts 12:00;after 500;puts --:--;after 500}

Can be tried on https://goo.gl/Hb3sHq

HTML + CSS, 147, 148 142 Bytes

*{font-family:Courier;left 0;background-color:white;position:absolute}@keyframes d{0%,49%{left:0}50%,to{left:-10em}}a{animation:d 1s infinite}
12:00--:--

Explanation:
Basically, this uses two HTML elements: A text node containing 12:00 and an  tag containing --:--.
The selector in the CSS applies to both elements, giving both absolute positioning 0 to the left. This allows both elements to overlap. Then, I gave both elements a monospace font, making each take up equal widths. Finally, I set the background color to white, making sure that the  tag hides the text it overlaps.
Then, I use an animation to move the  tag offscreen every .5 seconds. To do this, the animation lasts one second, and shows the tag for the first 49%, then hides it for the last 50%.
Oh - finally, Courier is shorter than monospace, saving 3 bytes, but it might not work in all browsers/operating systems.
Update: +1 Byte
Turns out that Monaco isn't on everyone's computer. changed to using Courier instead at the expense of a byte.
Update: -6 Bytes
Forgot to remove a bit of whitespace. Oops.
Non minified code:

* {
  position: absolute;
  left: 0;
  font-family: Courier;
  background-color: white;
}
@keyframes d {
  0%, 49% {
    left: 0
  }
  50%, to {
    left: -10em
  }
}
a{animation: d 1s infinite}
12:00--:--

@LuisMendo I saved 3 bytes by using the font Monaco instead of monospace :P - didn't know about support. I'll change it.

Yes, it works for me now

@LuisMendo cool. thanks a lot for letting me know.

Excel VBA (Win, Excel 32 bit Only), 97 Bytes
In a module:
Because VBA's Application.Wait() method cannot handle input for time periods of less than one second, a declaration of the kernel32 sleep method is used for the 500 ms wait period.
Declare Sub Sleep Lib "kernel32" (ByVal s&)

Note: 64-bit versions of VBA (VB7) require a PtrSafe tag after the Declare tag, and changing the ByVal s& call to ByVal s as LongPtr.
In the vbe immediates window:
Do:DoEvents:?"12:00":Sleep 500:?"--:--":Sleep 500:Loop

PHP, 48 bytes
for(;;usleep(5e5))echo($n^=1)?"
12:00":"
--:--";

Run with -nr.
Replace instead of multiple lines with \r instead of \n (+2 bytes):
for(;;usleep(5e5))echo($n^=1)?"\r12:00":"\r--:--";

REXX, 60, 54 bytes
d.='--:--'
d.1='12:00'
a=1
do b=0
  sleep(.5)
  a=\a
  say d.a
  end

(Indented for readability)
Edit: Turns out that the most naïve solution is even shorter:
do b=0
say '12:00'
sleep(.5)
say '--:--'
sleep(.5)
end

Tested with Regina REXX interpreter; some older implementations may not have the Delay function at all, or it may only support whole seconds.

*><>, 30 bytes
cn"00:"ooo5Sdo"--:--"ooooo5Sdo

Online test.
I feel this is much simpler and more different than redstarcoder's algorithm, and thus I posted it as separate.
Replaces output in-place.

Lua, 94 bytes
Unfortunately Lua has no built-in sleep function, so a loop is necessary.
x=1 z=os.clock while 1 do x=-x print(x<0 and"12:00"or"--:--") y=z()+.5 repeat until z()>y end

As a bonus, here's a Windows only one which is 109 bytes and which clears the screen each time:
x=1 z=os.clock while 1 do x=-x print(x<0 and"12:00"or"--:--") y=z()+.5 repeat until z()>y os.execute"cls"end

8th, 62 58 51  bytes
: p . cr .5 sleep ; : f "12:00" p "--:--" p recurse ;

When invoked, the word f will display blinking twelve according the "new line" format. This code leverages "tail-call elimination" implemented in 8th.
The following code (95 bytes long) will let word f display blinking twelve according the "replacing the former string" format:
: p 0 0 con:gotoxy con:print ;
: f con:cls repeat "12:00" p .5 sleep "--:--" p .5 sleep again ;

SmileBASIC, 35 bytes
WAIT 30?"12:00
WAIT 30?"--:--
EXEC.

WAIT times are in frames (1/60 second), and EXEC. restarts the program (equivilant to EXEC 0 which runs the code that's in slot 0)
Version that clears the screen and adds 6 bytes:
WAIT 30CLS?"12:00
WAIT 30CLS?"--:--
EXEC.

PKod, 26 bytes
PKod is an esoteric language that only has one accessible variable
Code:
l12=:o00yyl=-oo=:o=-ooyy<

Explanation:
l - if first char in code, print any NOP chars found
12 - two NOP chars to print
=: - set variable as :
00 - two more NOP chars
o - print variable's corresponding ascii char
y - wait 0.25 seconds
l - if not first char in code, clear the console
=-oo - set variable as - and print twice
< - go back to the start of the code

05AB1E, 23 20 19 bytes
"12:00"…--:û[s=₄;.W

Try it online.
Explanation:
"12:00"            # Push string "12:00"
       …--:        # Push string "--:"
           û       # Palindromize it to "--:--"
[                  # Loop indefinitely:
 s                 #  Swap the two values on the stack
  =                #  Print the top with trailing newline (without popping)
   ₄;              #  Push 1000 halved: 500
     .W            #  Sleep that many ms

"12:00" could alternatively be Žmy3':: for the same byte-count.

C (clang), 51 bytes
f(i){puts(i?"12:00":"--:--");usleep(500000);f(!i);}

Try it online!

This doesn't work. 5e5 is a double. The implicit declaration of usleep will cause Clang to assume it is int usleep(double), and depending on the calling convention, it will either wait for a garbage value or call it with 549606724824 (5e5 interpreted as an integer) which is an EINVAL.

Suggest 1<<19 instead of 500000

@ceilingcat 2^19 doesn't exactly equal 500,000.

Dart, 103 bytes
import'dart:io';f({i=1}){while(i>0){print(i++%2>0?"12:00":"--:--");sleep(Duration(milliseconds:500));}}

Try it online!
Sometimes I hate how verbose and strongly typed Dart has to be :D

Japt, 27 bytes
500t@ßÃOq"12:00--:--"ò5 gT°

Try it
500t@ßÃ                         :Run the programme again in 500ms
       Oq                       :Clear the output
         "12:00--:--"ò5         :Split the string "12:00--:--" into chunks of length 5
                        gT°     :Get the element at index T (initially 0), postfix incremented

Not quite real-time output, @LuisMendo; explanation added. Figured the other version wouldn't be valid for that reason, thanks for clarifying.

GNU AWK, (until version 5.0.1), 64 bytes
This piece of code prints the strings on a new line. Only works in GNU AWK up to version 5.0.1, while the time extension (module) was not obsolete.
@load"time";BEGIN{for(;;){sleep(.5);print++t%2?"12:00":"--:--"}}

Clearing the screen with clear command (80 bytes)
This example uses the clear command, not native to Awk.
@load"time";BEGIN{for(;;){sleep(.5);system("clear");print++t%2?"12:00":"--:--"}}

Clearing the screen with \33[H\33[2J\33[3J (85 bytes)
But don't despair if there is no command to clear the screen on your system. Just hard code it. \33 is the ASCII for Escape in octal.
@load"time";BEGIN{for(;;){sleep(.5);print"\33[H\33[2J\33[3J"(++t%2?"12:00":"--:--")}}

QBasic, 51 bytes
LOCATE 1
IF TIMER*2MOD 2THEN?"12:00"ELSE?"--:--
RUN

Try it at Archive.org (but note that it's an infinite loop, so there's no way to exit the program besides closing/refreshing your browser).
Displays both strings on the top line of the screen. If you're using actual QBasic rather than QB64, you'll notice that the program doesn't clear the screen first, so there may be other junk present as well. This issue can be fixed at a cost of 8 bytes: add CLS:DO: at the beginning of the program and change RUN to LOOP.
Explanation
Waiting for a fraction of a second is hard in QBasic, as other answers have mentioned, since the built-in SLEEP command only takes integers. However, TIMER (which represents the number of seconds since midnight) is a floating-point value. Whenever its fractional part is less than .5, we'll print --:--, and whenever its fractional part is greater than .5, we'll print 12:00. Conveniently, the MOD operator truncates to integer, so we can use TIMER * 2 MOD 2 and get values of 0 and 1.
This approach prints many, many times per second, but most of the time it's printing the same value over itself, so nothing changes.
Ungolfed and commented:
LOCATE 1                  ' Move the cursor to the top row
IF TIMER * 2 MOD 2 THEN   ' Alternates between 0 and 1 with a period of 1 second
  PRINT "12:00"
ELSE
  PRINT "--:--"
END IF
RUN                       ' Restart the program

Stax, 22 20 bytes
å√Φ←mp═╠╗⌐fâêÇY)♀╗}%

Run and debug it

05AB1E, 19 bytes
…--:ûŽmy3'::[=s₄;.W

Try it online! Outputs each string on a new line.

under construction, I missed the 1 second delay
awk, 3534 bytes (+11 for 12:00 --:--)
{for(;++i;i=i%2)print$(i)"\033[A"}

for loop alternates i's value between 1 and 2. echo feeds the values to the program into fields $1and $2, we then print $(i). Try it:
$ echo 12:00 --:-- | awk '{for(;++i;i=i%2)print$(i)"\033[A"}'

Edit: Thanks for the ANSI tip to @F.Hauri.

Ansi sequence use 1 as default, so the 1 is useless in \033[A.

C 79 Bytes
f(){while(1){printf("\n12:00");usleep(500000);printf("\n--:--");usleep(500000);}}

so the main would look like int main(){ f(); return 0;}

Welcome to Programming Puzzles & Code Golf! Just so you know, the downvote was cast automatically by the Community user when you edited your answer. I consider this a bug.

You have to write a full program or a function, so you'd have to wrap your code in f(){...} or something. Also, the spec allows printing each output on a separate line, so system("clear"); is not required.

You still need the while loop in your submission. Also, you cannot pass a float to usleep.

Python 3, 78 bytes
import time;x=0
while 1:x=not x;print("12:00--:--"[x*5:x*5+5]);time.sleep(0.5)

Try it online!

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Pokemon Type chart (and dual type chart)
I'm always forgetting Pokemon type matchups. This is a challenge to print the pokemon type chart!
                                            Attacking Type
                No  Fi  Fl  Po  Gr  Ro  Bu  Gh  St  Fr  Wa  Gr  El  Ps  Ic  Dr  Da  Fa
    Normal      1.0 2.0 1.0 1.0 1.0 1.0 1.0 0.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0
    Fighting    1.0 1.0 2.0 1.0 1.0 0.5 0.5 1.0 1.0 1.0 1.0 1.0 1.0 2.0 1.0 1.0 0.5 2.0
D   Flying      1.0 0.5 1.0 1.0 0.0 2.0 0.5 1.0 1.0 1.0 1.0 0.5 2.0 1.0 2.0 1.0 1.0 1.0
e   Poison      1.0 0.5 1.0 0.5 2.0 1.0 0.5 1.0 1.0 1.0 1.0 0.5 1.0 2.0 1.0 1.0 1.0 0.5
f   Ground      1.0 1.0 1.0 0.5 1.0 0.5 1.0 1.0 1.0 1.0 2.0 2.0 0.0 1.0 2.0 1.0 1.0 1.0
e   Rock        0.5 2.0 0.5 0.5 2.0 1.0 1.0 1.0 2.0 0.5 2.0 2.0 1.0 1.0 1.0 1.0 1.0 1.0
n   Bug         1.0 0.5 2.0 1.0 0.5 2.0 1.0 1.0 1.0 2.0 1.0 0.5 1.0 1.0 1.0 1.0 1.0 1.0
d   Ghost       0.0 0.0 1.0 0.5 1.0 1.0 0.5 2.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 2.0 1.0
i   Steel       0.5 2.0 0.5 0.0 2.0 0.5 0.5 1.0 0.5 2.0 1.0 0.5 1.0 0.5 0.5 0.5 1.0 0.5
n   Fire        1.0 1.0 1.0 1.0 2.0 2.0 0.5 1.0 0.5 0.5 2.0 0.5 1.0 1.0 0.5 1.0 1.0 0.5
g   Water       1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 0.5 0.5 0.5 2.0 2.0 1.0 0.5 1.0 1.0 1.0
    Grass       1.0 1.0 2.0 2.0 0.5 1.0 2.0 1.0 1.0 2.0 0.5 0.5 0.5 1.0 2.0 1.0 1.0 1.0
T   Electric    1.0 1.0 0.5 1.0 2.0 1.0 1.0 1.0 0.5 1.0 1.0 1.0 0.5 1.0 1.0 1.0 1.0 1.0
y   Psychic     1.0 0.5 1.0 1.0 1.0 1.0 2.0 2.0 1.0 1.0 1.0 1.0 1.0 0.5 1.0 1.0 2.0 1.0
p   Ice         1.0 2.0 1.0 1.0 1.0 2.0 1.0 1.0 2.0 2.0 1.0 1.0 1.0 1.0 0.5 1.0 1.0 1.0
e   Dragon      1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 0.5 0.5 0.5 0.5 1.0 2.0 2.0 1.0 2.0
    Dark        1.0 2.0 1.0 1.0 1.0 1.0 2.0 0.5 1.0 1.0 1.0 1.0 1.0 0.0 1.0 1.0 0.5 2.0
    Fairy       1.0 0.5 1.0 2.0 1.0 1.0 0.5 1.0 2.0 1.0 1.0 1.0 1.0 1.0 1.0 0.0 0.5 1.0

It has to take an optional parameter that specifies a single type and then prints the dual type chart for that type, which looks like:
                                                    Attacking Type
                        No  Fi  Fl  Po  Gr  Ro  Bu  Gh  St  Fr  Wa  Gr  El  Ps  Ic  Dr  Da  Fa
    Electric/-          1.0 1.0 0.5 1.0 2.0 1.0 1.0 1.0 0.5 1.0 1.0 1.0 0.5 1.0 1.0 1.0 1.0 1.0
    Electric/Normal     1.0 2.0 0.5 1.0 2.0 1.0 1.0 0.0 0.5 1.0 1.0 1.0 0.5 1.0 1.0 1.0 1.0 1.0
D   Electric/Fighting   1.0 1.0 1.0 1.0 2.0 0.5 0.5 1.0 0.5 1.0 1.0 1.0 0.5 2.0 1.0 1.0 0.5 2.0
e   Electric/Flying     1.0 0.5 0.5 1.0 0.0 2.0 0.5 1.0 0.5 1.0 1.0 0.5 1.0 1.0 2.0 1.0 1.0 1.0
f   Electric/Poison     1.0 0.5 0.5 0.5 4.0 1.0 0.5 1.0 0.5 1.0 1.0 0.5 0.5 2.0 1.0 1.0 1.0 0.5
e   Electric/Ground     1.0 1.0 0.5 0.5 2.0 0.5 1.0 1.0 0.5 1.0 2.0 2.0 0.0 1.0 2.0 1.0 1.0 1.0
n   Electric/Rock       0.5 2.0 0.3 0.5 4.0 1.0 1.0 1.0 1.0 0.5 2.0 2.0 0.5 1.0 1.0 1.0 1.0 1.0
d   Electric/Bug        1.0 0.5 1.0 1.0 1.0 2.0 1.0 1.0 0.5 2.0 1.0 0.5 0.5 1.0 1.0 1.0 1.0 1.0
i   Electric/Ghost      0.0 0.0 0.5 0.5 2.0 1.0 0.5 2.0 0.5 1.0 1.0 1.0 0.5 1.0 1.0 1.0 2.0 1.0
n   Electric/Steel      0.5 2.0 0.3 0.0 4.0 0.5 0.5 1.0 0.3 2.0 1.0 0.5 0.5 0.5 0.5 0.5 1.0 0.5
g   Electric/Fire       1.0 1.0 0.5 1.0 4.0 2.0 0.5 1.0 0.3 0.5 2.0 0.5 0.5 1.0 0.5 1.0 1.0 0.5
    Electric/Water      1.0 1.0 0.5 1.0 2.0 1.0 1.0 1.0 0.3 0.5 0.5 2.0 1.0 1.0 0.5 1.0 1.0 1.0
T   Electric/Grass      1.0 1.0 1.0 2.0 1.0 1.0 2.0 1.0 0.5 2.0 0.5 0.5 0.3 1.0 2.0 1.0 1.0 1.0
y   Electric/Psychic    1.0 0.5 0.5 1.0 2.0 1.0 2.0 2.0 0.5 1.0 1.0 1.0 0.5 0.5 1.0 1.0 2.0 1.0
p   Electric/Ice        1.0 2.0 0.5 1.0 2.0 2.0 1.0 1.0 1.0 2.0 1.0 1.0 0.5 1.0 0.5 1.0 1.0 1.0
e   Electric/Dragon     1.0 1.0 0.5 1.0 2.0 1.0 1.0 1.0 0.5 0.5 0.5 0.5 0.3 1.0 2.0 2.0 1.0 2.0
    Electric/Dark       1.0 2.0 0.5 1.0 2.0 1.0 2.0 0.5 0.5 1.0 1.0 1.0 0.5 0.0 1.0 1.0 0.5 2.0
    Electric/Fairy      1.0 0.5 0.5 2.0 2.0 1.0 0.5 1.0 1.0 1.0 1.0 1.0 0.5 1.0 1.0 0.0 0.5 1.0

The best dual type charts I've found is here, don't forget to list even the non-existent combinations, by clicking 'Show all types'. Types combine by multiplication, except for the same time (eg. electric/electric which is actually electric/-). White space in the output is only important between columns and rows (to remain legibility).
This is code golf so shortest bytes wins.

related and related

What about the ordering of the types?

Normally, instead of 0.3, it is actually 0.25 then you have to identify STAB bonuses...

@PythonMaster I mean the order in which they appear in the table, should they be exactly as listed by OP?

You should keep the number of spaces consistent. There are four spaces in between the first Fighting and the numbers. There are only three spaces in between the Electric/Fighting and the numbers.

@PythonMaster Not sure how 0.3 crept in there, I'd remove it but I presume the answers would be trivially different so I'll leave it in there

@busukxuan the ordering of rows is not important

@Pureferret my guess is you rounded your calculations to one decimal place, which would round 0.25 to 0.3

@PatrickRoberts indeed, it was more how did I not notice it?

In the dual type chart, does the double type need to be first?

@fliptack first only

JavaScript (ES6), 666 bytes
p=>(a=[18611524949,21853721688,27323097365,27406984278,23191686421,37066245461,26177987925,66127746385,37356070566,22827115926,22906831253,21627185429,23913388373,27196216913,18594420117,22906579204,18608379736,26936956281].map(n=>[...n.toString(4)].map(c=>(4>>c)/2)),t=`Normal,Fighting,Flying,Poison,Ground,Rock,Bug,Ghost,Steel,Fire,Water,Grass,Electric,Psychic,Ice,Dragon,Dark,Fairy`.split`,`,n=t.indexOf(p),w=` `.repeat(l=n<0?16:24),w+` `.repeat(28)+`Attacking Type
`+w+t.map(s=>s[0]+s[1]).join`  `+`
`+t.map((s,i)=>(`  Defending Type  `[i]+`   `+(n<0?s:n-i?p+`/`+s:p+`/--------`)+w).slice(0,l)+a[i].map((e,j)=>(i==n|n<0?e:e*a[n][j]).toFixed(1)).join` `).join`
`)

Explanation:
a=[18611524949,
   21853721688,
   27323097365,
   27406984278,
   23191686421,
   37066245461,
   26177987925,
   66127746385,
   37356070566,
   22827115926,
   22906831253,
   21627185429,
   23913388373,
   27196216913,
   18594420117,
   22906579204,
   18608379736,
   26936956281].map(n=>[...n.toString(4)].map(c=>(4>>c)/2)),

These are base 4 encoded numbers where each base 4 digit represents the effectiveness. The mapping is 0 - super effective, 1 - normally effective, 2 - not very effective, 3 - immune. This mapping is chosen because Normal is not super effective against any type and therefore each number will have 18 digits in base 4, but also allowing the effectiveness to be relatively easy to compute.
t is just an array of types (split from a string to save bytes). n is the index of the passed-in type, this is the easiest way to detect whether a type has been passed in but also saves a byte when checking the current row. l is the indentation of the main array, and w a string of spaces of length l. The first line is therefore just w plus a further 28 spaces plus the phrase "Attacking Type". The second line is w plus the first two characters of each type, with each pair separated by two spaces. Each row of the array is then generated. The header column is calculated using the appropriate character of phrase "Defending type", three spaces, the relevant types, and enough spaces to pad to length l. The columns are then calculated and formatted to 1 decimal place and joined with a single space as required.
There are probably further golfing opportunities but I stopped at 666 bytes because I have spent too much time on this already today.

How do you receive input for the the second table?

@PythonMaster If the parameter p is exactly one of the types in the array t then you get the second table, otherwise you get the first table.

Python 2 - 2163, 1648, 1642, 1580, 1560, 1490, 1390 bytes
s=[[1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],
[1,1,2,1,1,.5,.5,1,1,1,1,1,1,2,1,1,.5,2],
[1,.5,1,1,0,2,.5,1,1,1,1,.5,2,1,2,1,1,1],
[1,.5,1,.5,2,1,.5,1,1,1,1,.5,1,2,1,1,1,.5],
[1,1,1,.5,1,.5,1,1,1,1,2,2,0,1,2,1,1,1],
[.5,2,.5,.5,2,1,1,1,2,.5,2,2,1,1,1,1,1,1],
[1,.5,2,1,.5,2,1,1,1,2,1,.5,1,1,1,1,1,1],
[0,0,1,.5,1,1,.5,2,1,1,1,1,1,1,1,1,2,1],
[.5,2,.5,0,2,.5,.5,1,.5,2,1,.5,1,.5,.5,.5,1,.5],
[1,1,1,1,2,2,.5,1,.5,.5,2,.5,1,1,.5,1,1,.5],
[1,1,1,1,1,1,1,1,.5,.5,.5,2,2,1,.5,1,1,1],
[1,1,2,2,.5,1,2,1,1,2,.5,.5,.5,1,2,1,1,1],
[1,1,.5,1,2,1,1,1,.5,1,1,1,.5,1,1,1,1,1],
[1,.5,1,1,1,1,2,2,1,1,1,1,1,.5,1,1,2,1],
[1,2,1,1,1,2,1,1,2,2,1,1,1,1,.5,1,1,1],
[1,1,1,1,1,1,1,1,1,.5,.5,.5,.5,1,2,2,1,2],
[1,2,1,1,1,1,2,.5,1,1,1,1,1,0,1,1,.5,2],
[1,.5,1,2,1,1,.5,1,2,1,1,1,1,1,1,0,.5,1]]
e=["Normal ","Fighting","Flying  ","Poison ","Ground ","Rock   ","Bug    ","Ghost  ","Steel  ","Fire   ","Water  ","Grass  ","Electric","Psychic","Ice    ","Dragon ","Dark   ","Fairy  "]
x="\t"
t="No  Fi  Fl  Po  Gr  Ro  Bu  Gh  St  Fi  Wa  Gr  El  Py  Ic  Dr  Da  Fa"
r=range
for i in r(0,18):
  n=""
  for b in r(0,18):n+=str(float(s[i][b]))+" "
  print e[i],x,n
c=s[input()]
print x*6+"Attacking Types"
print x*3+t
for i in r(0,18):
  a=e[s.index(c)]
  n=a+"/"+e[i]+x
  if e[i]==a:n=a+"/--------"+x
  if c!=s[i]:z=[round(float(a*b),1)for a,b in zip(c,s[i])]
  else:z=c
  for b in r(0,18):n+=str(float(z[b]))+" "
  print n

Try it here!
This program has 765 bytes from hard-coding the data of the effectiveness of each type down in s. Example Output:
The chart with single types (last line is where you type in the input):

The chart with dual types:

Explanation
s holds the effectiveness stats in list per defending element (first is for the effectiveness against Normal, next against Fighting, etc.)
s=[[1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],
[1,1,2,1,1,.5,.5,1,1,1,1,1,1,2,1,1,.5,2],
[1,.5,1,1,0,2,.5,1,1,1,1,.5,2,1,2,1,1,1],
[1,.5,1,.5,2,1,.5,1,1,1,1,.5,1,2,1,1,1,.5],
[1,1,1,.5,1,.5,1,1,1,1,2,2,0,1,2,1,1,1],
[.5,2,.5,.5,2,1,1,1,2,.5,2,2,1,1,1,1,1,1],
[1,.5,2,1,.5,2,1,1,1,2,1,.5,1,1,1,1,1,1],
[0,0,1,.5,1,1,.5,2,1,1,1,1,1,1,1,1,2,1],
[.5,2,.5,0,2,.5,.5,1,.5,2,1,.5,1,.5,.5,.5,1,.5],
[1,1,1,1,2,2,.5,1,.5,.5,2,.5,1,1,.5,1,1,.5],
[1,1,1,1,1,1,1,1,.5,.5,.5,2,2,1,.5,1,1,1],
[1,1,2,2,.5,1,2,1,1,2,.5,.5,.5,1,2,1,1,1],
[1,1,.5,1,2,1,1,1,.5,1,1,1,.5,1,1,1,1,1],
[1,.5,1,1,1,1,2,2,1,1,1,1,1,.5,1,1,2,1],
[1,2,1,1,1,2,1,1,2,2,1,1,1,1,.5,1,1,1],
[1,1,1,1,1,1,1,1,1,.5,.5,.5,.5,1,2,2,1,2],
[1,2,1,1,1,1,2,.5,1,1,1,1,1,0,1,1,.5,2],
[1,.5,1,2,1,1,.5,1,2,1,1,1,1,1,1,0,.5,1]]

e holds the names of the types. There are spaces put in to maximize the usage of \t in later parts of the code.
e=["Normal ","Fighting","Flying  ","Poison ","Ground ","Rock   ","Bug    ","Ghost  ","Steel  ","Fire   ","Water  ","Grass  ","Electric","Psychic","Ice    ","Dragon ","Dark   ","Fairy  "]

This part prints the attacking types (literally too!)
print "\t\t\t\t\tAttacking Types"
print "\t\tNo  Fi  Fl  Po  Gr  Ro  Bu  Gh  St  Fi  Wa  Gr  El  Ps  Ic  Dr  Da  Fa"

This prints out the defending type and its respective stats according to the pre-made table and uses \t for uniform spacing:
for i in range(0, 18):
  n=""
  for b in range(0, 18):
    n+=str(float(s[i][b]))+" "
  print e[i],"\t",n

Take input. The input is an integer from 0 to 17 since there are 18 lists (one for each element). 0 returns s[0] which is the list for Normal type, 1 returns s[1] which is the list for Fighting type, etc. Notice how in the screenshot, 12 is used since s[12] is the list for the Electric type:
c = s[int(raw_input())]

Print out the attacking types (literally as well) again for second table:
print "\t\t\t\t\t\tAttacking Types"
print "\t\t\tNo  Fi  Fl  Po  Gr  Ro  Bu  Gh  St  Fi  Wa  Gr  El  Ps  Ic  Dr  Da  Fa"

This is where the second table starts to take place. To get the dual types' results, we must loop through every single list and prepare the string with the two types used:
for i in range(0, 18):
  n=e[s.index(c)] + "/"+e[i]+"\t"
  if e[i]==e[s.index(c)]:
    n=e[s.index(c)]+"/--------"+"\t"

Then we actually do the math. If the input matches the type the list belongs to, do nothing really. Else, start multiplying:
if c!=s[i]:
  z=[round(float(a*b), 1) for a,b in zip(c, s[i])]
else:
  z=c

Finish the table by printing out the string, n, for each dual type possibilty:
for b in range(0, 18):
  n+=str(float(z[b]))+" "
print n

Thanks @DJMcMayhem for saving 515 bytes!
Thanks @Rod for saving 20 bytes!
Thanks @Qwerp-Derp for saving 70 bytes!

Typo: Pyschic should be Psychic.

@Neil Nice catch

Did you even try and golf that massive list?

@FlipTack Yes I did

I do love a python answer!

you can assign \t to an variable and use x*6+ instead \t\t\t\t\t\t in every use. Also the types abbreviated are duplicated too, put that on variable too, even better extract from the e list ' '.join(a[:2] for a in e)

@Rod I'll try to implement that

for the effective list, you can assign .5 to a variable, and use the variable instead (~60 occurences cut by half), you can also you eval() to chop bytes like s=eval('[2aa],[1a,2]'.replace('a',',1')) to generate s=eval('[2,1,1],[1,1,2]')

or just use gzip ¯\(ツ)/¯

Also, can't that long line be condensed down to an array, then be joined by two spaces for each element? It would save bytes, I'm sure. TBH, this one doesn't seem like it's properly golfed at all.

@Qwerp-Derp I'm quite new to golfing and I am still editing...

int(raw_input()) can be reduced to input() as well, since you're using Python 2. In the second for loop, you should be able to save e[s.index(c)] as a variable inside the loop, since you're not altering it in any way. Also, you should be able to do z=[[round(float(a*b),1)for a,b in zip(c,s[i])],c][c!=s[i]] for the if/else thing. Sorry for the harsh message before, I didn't know you were new. It's just that I've seen a lot of golfs in Python over here.

@PythonMaster bro just do t=' '.join(a[:2] for a in e)

it was to big to post as comment, so here is a gzip demo

and of course this should be VERY helpfull for a new python golfer :D

Thanks ya'll... these tips should be implemented in a few hours since I have a school life :)

I count 1,390 bytes.

Did you delete the two print lines at the start on purpose? Also, the top row isn't positioned properly - there needs to be extra spaces.


text:
A twist of a trivial sequence
Introduction
Consider a sequence of integers \$f\$ defined as follows:

\$f(2) = 2\$
If \$n\$ is an odd prime, then \$f(n) = \frac{f(n-1) + f(n+1)}2\$
If \$n = p\cdot q\$ is composite, then \$f(n) = f(p)\cdot f(q)\$

It's not very hard to see that \$f(n) = n\$ for every \$n \ge 2\$, and thus computing \$f\$ wouldn't be a very interesting challenge.
Let's make a twist to the definition: halve the first case and double the second case.
We get a new sequence \$g\$ defined as follows:

\$g(2) = 1\$
If \$n\$ is an odd prime, then \$g(n) = g(n-1) + g(n+1)\$
If \$n = p\cdot q\$ is composite, then \$g(n) = g(p)\cdot g(q)\$

The task
Your task is to take an integer \$n \ge 2\$ as input, and produce \$g(n)\$ as output.
You don't have to worry about integer overflow, but you should be able to compute \$g(1025) = 81\$ correctly, and your algorithm should theoretically work for arbitrarily large inputs.
You can write a full program or a function.
The lowest byte count wins.
Example
I claimed above that \$g(1025) = 81\$, so let's compute it by hand.
The prime factorization of 1025 gives
1025 = 5*5*41 => g(1025) = g(5)*g(5)*g(41)

Since 41 is prime, we get
g(41) = g(40) + g(42)

Next, we compute the prime factorizations of 40 and 42:
40 = 2*2*2*5 => g(40) = g(2)*g(2)*g(2)*g(5) = g(5)
42 = 2*3*7 => g(42) = g(2)*g(3)*g(7) = g(3)*g(7)

For these small primes we get
g(3) = g(2) + g(4) = 1 + 1 = 2
g(5) = g(4) + g(6) = 1 + 2 = 3
g(7) = g(6) + g(8) = 2 + 1 = 3

This means that
g(41) = g(40) + g(42) = g(5) + g(3)*g(7) = 3 + 2*3 = 9

and
g(1025) = g(5)*g(5)*g(41) = 3*3*9 = 81

Test cases
Here are the values of \$g\$ up to 50.
2 -> 1
3 -> 2
4 -> 1
5 -> 3
6 -> 2
7 -> 3
8 -> 1
9 -> 4
10 -> 3
11 -> 5
12 -> 2
13 -> 5
14 -> 3
15 -> 6
16 -> 1
17 -> 5
18 -> 4
19 -> 7
20 -> 3
21 -> 6
22 -> 5
23 -> 7
24 -> 2
25 -> 9
26 -> 5
27 -> 8
28 -> 3
29 -> 9
30 -> 6
31 -> 7
32 -> 1
33 -> 10
34 -> 5
35 -> 9
36 -> 4
37 -> 11
38 -> 7
39 -> 10
40 -> 3
41 -> 9
42 -> 6
43 -> 11
44 -> 5
45 -> 12
46 -> 7
47 -> 9
48 -> 2
49 -> 9
50 -> 9

Eerily similar to A002487, and yet not (different at 15, 21, 25, 29, 33, 41, and a bunch more, but I can't find any real pattern to why.)

@GabrielBenamy Well, my sequence also satisfies a(2*n) = a(n), and a(2*n+1) = a(n) + a(n+1) holds if 2*n+1 is prime. For many other odd numbers the sequences probably agree by coincidence.

Is returning True instead of 1 acceptable?

@Dennis the challenge is about evaluating a numeric function, not a decision problem, so I would assume not.

@Pavel There's heavy support in favor though and, at least in Python, True acts like 1 for all intents and purposes.

@Dennis We'll go with the Meta consensus: True can be returned in place of 1 if it behaves as 1 in the language.

Haskell, 69 bytes
x#a|x<3=1|a>x=a#2+(x-1)#2|mod x a<1,a<x=a#2*div x a#2|b<-a+1=x#b
(#2)

Usage example: (#2) 1025 -> 81
The parameter a is counted up until it divides x or it reaches x (i.e. x is prime). It it one byte shorter to test for a > x and add a further condition (a < x) to the modulus test instead of testing for a == x, because the former binds a to x+1, which helps in the recursive call. Compare:
|a==x=(x+1)#2+(x-1)#2|mod x a<1=
|a>x=a#2+(x-1)#2|mod x a<1,a<x=

Jelly, 18 bytes
‘;’Ñ€Sµ1n2$?
ÆfÇ€P

Try it online!
This is basically just a direct translation of the specification. (After thinking about it a bit, I suspect that if there is a closed formula for finding the sequence, it'd be more bytes than the direct approach.)
Explanation
We have two mutually recursive functions. Here's the helper function (which calculates g(n) for prime n):
‘;’Ñ€Sµ1n2$?
           ?  If
        n2$     the input is not equal to 2 (parsed as a group due to $)
      µ       then do all the following (parsed as a group due to µ):
‘;’             Find the list [n+1, n-1];
   Ñ€           Call the main program on each element (i.e. [g(n+1),g(n-1)]);
     S          and return the sum of the list (i.e. g(n+1)+g(n-1)).
              Otherwise:
       1        Return 1.

And here's the main program, which calculates g(n) for any n:
ÆfÇ€P
Æf            Factorize the input into its prime factors;
  Ç€          Call the helper function on each element of that list;
    P         Then take the product.

Clearly, if we call the main program on a prime number, everything's a no-op except the Ç, so it returns g(n) in this case. The rest of the program handles the behaviour for composite n.

JavaScript (ES6), 59 bytes
f=(n,d=2)=>n-2?d<n?n%d?f(n,d+1):f(n/d)*f(d):f(n-1)+f(n+1):1

Test

f=(n,d=2)=>n-2?d<n?n%d?f(n,d+1):f(n/d)*f(d):f(n-1)+f(n+1):1

// f(2) to f(50)
for(N = 2, list = []; N <= 50; N++) {
  list.push(N + ' -> ' + f(N));
}
console.log(list.join(', '));

// f(1025)
console.log(f(1025));

Jelly, 13 bytes
Æfḟ2µ‘,’ß€€SP

Try it online!
How it works
Æfḟ2µ‘,’ß€€SP  Main link. Argument: n

Æf             Yield the array of prime factors of n.
  ḟ2           Remove all occurrences of 2.
    µ          Begin a new, monadic chain. Argument: A (array of odd prime factors)
     ‘         Increment all elements of A.
       ’       Decrement all elements of A.
      ,        Pair; yield [A+1, A-1].
        ß€€    Map the main link over all elements of A+1 and A-1.
           S   Column-wise reduce by addition.
            P  Reduce by multiplication.

Python 2, 85 69 bytes
g=lambda n,k=3:(n&~-n<1)or n%k and g(n,k+2)or(g(k+1)+g(k-1))*g(n/k,k)

Clojure, 126 bytes
(defn t[n](if(= n 2)1(let[a(+(.indexOf(for[b(range 2 n)](mod n b)2)0))](if(> a 1)(*(t(/ n a))(t a))(+(t(dec n))(t(inc n)))))))

Yay! It's almost twice as long as the Python answer!
Ungolfed and an explanation:
(defn trivial [n]
  ; Define the function.
  (if (= n 2) 1
  ; If the number is 2, return 1
    (let [a (+ 2 (.indexOf (for [b (range 2 n)] (mod n b)) 0))]
      ; Let a be the lowest prime factor of n
      (if (> a 1)
        ; The .indexOf function returns -1 if a is a prime, so -1 + 2 = 1.
        ; Checks if a is a prime.
        (* (trivial (/ n a)) (trivial a))
        ; If a is prime, return the trivial(a/n) * trivial(a).
        (+ (trivial (dec n)) (trivial (inc n)))))))
        ; Else, return trivial(n-1) + trivial(n + 1).

Cool, I didn't know you could do (.indexOf (for [...] ...) x)!

The current 118 byte version returns 11 for (t 1025), maybe that if was intended to be :when? But then nth of empty list throws IndexOutOfBoundsException.

@NikoNyrh Yeah, that shouldn't happen - I tested it too, and the code's invalid. Will revert back to original version.

Mathematica, 83 bytes
Which[#<4,#-1,PrimeQ@#,Tr[#0/@({#-1,#+1}/2)],0<1,1##&@@#0/@Divisors@#~Part~{2,-2}]&

Unnamed recursive function of one positive integer argument, returning an integer. Not all that short, in the end. Tr[#0/@({#-1,#+1}/2)] (in the case where the input is prime) calls the function on both members of the ordered pair {(#-1)/2,(#+1)/2} and adds the results; this is fine since the function has the same value at (#-1)/2 and #-1, for example. Similarly, 1##&@@#0/@Divisors@#~Part~{2,-2} calls the function on the second-smallest divisor # and its complememtary divisor (the second-larget divisor) and multiplies the answers together.

How do unnamed recursive functions work?

Check out the section about #0 in this answer.

Python 2, 62 bytes
f=lambda n,k=3:k>n or n%k and f(n,k+2)or(f(k-1)+f(k+1))*f(n/k)

Try it online!

Clojure, 120 bytes
(defn g[n](if(= n 2)1(if-let[F(first(for[i(range 2 n):when(=(mod n i)0)]i))](*(g F)(g(/ n F)))(+(g(dec n))(g(inc n))))))

Uses :when to get divisors of n, F is nil if no such divisor is found (n is prime).

Do you wish to quarrel, sir? It's on. (Friendly competition?)

R, 89 bytes
g=function(n)"if"(n<3,1,"if"(sum(y<-!n%%2:n)<2,g(n-1)+g(n+1),g(k<-1+which(y)[1])*g(n/k)))

Try it online!

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Longest domino chain
Challenge description
Dominoes is a game played with tiles with two values on it - one on the left, one on the right, for example [2|4] or [4|5]. Two tiles can be joined together if they contain a common value. The two tiles above can be joined like this:
[2|4][4|5]
We'll call a sequence of n joined tiles a chain of length n. Of course, tiles can be rotated, so tiles [1|2], [1|3] and [5|3] can be rearranged into a chain [2|1][1|3][3|5] of length 3.
Given a list of pairs of integers, determine the length of the longest chain that can be formed using these tiles. If the list is empty, the correct answer is 0 (note that you can always form a chain of length 1 from a non-empty list of tiles).
Sample input / output
[(0, -1), (1, -1), (0, 3), (3, 0), (3, 1), (-2, -1), (0, -1), (2, -2), (-1, 2), (3, -3)] -> 10
([-1|0][0|-1][-1|2][2|-2][-2|-1][-1|1][1|3][3|0][0|3][3|-3])

[(17, -7), (4, -9), (12, -3), (-17, -17), (14, -10), (-6, 17), (-16, 5), (-3, -16), (-16, 19), (12, -8)] -> 4
([5|-16][-16|-3][-3|12][12|-8])

[(1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1)] -> 7
([1|1][1|1][1|1][1|1][1|1][1|1][1|1])

[(0, 1), (2, 3), (4, 5), (6, 7), (8, 9), (10, 11)] -> 1
(any chain of length 1)

[] -> 0
(no chain can be formed)

Any restrictions on running time or memory? Think brute-forcing all permutations

@LuisMendo: Pretty sure this problem is NP, so fire up your O(n!) as you wish

I guess it's P

Brachylog, 23 bytes
s:papcb~k~c:{#=l2}al|,0

Try it online!
Explanation
s:papcb~k~c:{#=l2}al|,0
s                         Check subsets of the input (longest first).
 :pa                      Check all permutations inside the input's elements
    p                     and all permutations /of/ the input's elements.
     c                    Flatten the result;
      b                   delete the first element;
       ~k                 find something that can be appended to the end so that
         ~c               the result can be unflattened into
           :{    }a       a list whose elements each have the property:
             #=             all the elements are equal
               l2           and the list has two elements.
                   l      If you can, return that list's length.
                    |,0   If all else fails, return 0.

So in other words, for input like [[1:2]:[1:3]:[5:3]], we try to rearrange it into a valid chain [[2:1]:[1:3]:[3:5]], then flatten/behead/unkknife to produce [1:1:3:3:5:_] (where _ represents an unknown). The combination of ~c and :{…l2}a effectively splits this into groups of 2 elements, and we ensure that all the groups are equal. As we flattened (doubling the length), removed one element from the start and added one at the end (no change), and grouped into pairs (halving the length), this will have the same length as the original chain of dominoes.
The "behead" instruction will fail if there are no dominoes in the input (actually, IIRC the :pa will also fail; a dislikes empty lists), so we need a special case for 0. (One big reason we have the asymmetry between b and ~k is so that we don't also need a special case for 1.)

Goodness that's so much shorter…

Brachylog, 29 bytes
v0|sp:{|r}aLcbk@b:{l:2%0}a,Ll

Try it online!
Pretty sure this is awfully long, but whatever. This is also awfully slow.
Explanation
v0                               Input = [], Output = 0
  |                              Or
   sp:{|r}aL                     L (a correct chain) must be a permutation of a subset of the
                                   Input with each tile being left as-is or reversed
           Lcbk                  Concatenate L into a single list and remove the first and
                                   last elements (the two end values don't matter)
               @b                Create a list of sublists which when concatenated results in
                                   L, and where each sublist's elements are identical
                 :{     }a,      Apply this to each sublist:
                   l:2%0           It has even length
                           Ll    Output = length(L)

The reason this will find the biggest one is because s - subset generates choice points from the biggest to the smallest subset.

Mathematica, 191 bytes
If[#=={},0,Max[Length/@Select[Flatten[Rest@Permutations[#,∞]&/@Flatten[#,Depth[#]-4]&@Outer[List,##,1]&@@({#,Reverse@#}&/@#),1],MatchQ[Differences/@Partition[Rest@Flatten@#,2],{{0}...}]&]]]&

Can be golfed a fair bit, I'm sure. But basically the same algorithm as in Fatalize's Brachylog answer, with a slightly different test at the end.

-1 byte: Differences/@Rest@Flatten@#~Partition~2, instead of Differences/@Partition[Rest@Flatten@#,2] (Infix has higher precedence than Map)

JavaScript (Firefox 30-57), 92 bytes
(a,l)=>Math.max(0,...(for(d of a)for(n of d)if(!(l-n))1+f(a.filter(e=>e!=d),d[0]+d[1]-n)))

l is the last value, or undefined for the initial invocation. l-n is therefore a falsy value if the domino can be played.
d is the domino under consideration.
n is the end of the domino under consideration for chaining to the previous domino. The other end may readily be calculated as d[0]+d[1]-n.
0, simply handles the base case of no playable dominoes.

Haskell, 180 134 131 117 bytes
p d=maximum$0:(f[]0d=<<d)
f u n[]c=[n]
f u n(e@(c,d):r)a@(_,b)=f(e:u)n r a++(f[](n+1)(r++u)=<<[e|b==c]++[(d,c)|b==d])

Try it online! New approach turned out to be both shorter and more efficient. Instead of all possible permutations only all valid chains are build.
Edit: The 117 byte version is much slower again, but still faster than the brute-force.

Old brute-force method:
p(t@(a,b):r)=[i[]t,i[](b,a)]>>=(=<<p r)
p e=[e]
i h x[]=[h++[x]]
i h x(y:t)=(h++x:y:t):i(h++[y])x t
c%[]=[0]
c%((_,a):r@((b,_):_))|a/=b=1%r|c<-c+1=c:c%r
c%e=[c]
maximum.(>>=(1%)).p

This is a brute-force implementation which tries all possible permutations (The number of possible permutations seems to be given by A000165, the "double factorial of even numbers"). Try it online barely manages inputs up to length 7 (which is kind of impressive as 7 corresponds to 645120 permutations).
Usage:
Prelude> maximum.(>>=(1%)).p $ [(1,2),(3,2),(4,5),(6,7),(5,5),(4,2),(0,0)]
4

Python 2, 279 bytes
Golfed:
l=input()
m=0
def f(a,b):
 global m
 l=len(b)
 if l>m:m=l
 for i in a:
  k=a.index(i)
  d=a[:k]+a[k+1:]
  e=[i[::-1]]
  if not b:f(d,[i])
  elif i[0]==b[-1][1]:f(d,b+[i])
  elif i[0]==b[0][0]:f(d,e+b)
  elif i[1]==b[0][0]:f(d,[i]+b)
  elif i[1]==b[-1][1]:f(d,b+e)
f(l,[])
print m

Try it online!
Same thing with some comments:
l=input()
m=0
def f(a,b):
 global m
 l=len(b)
 if l>m:m=l                      # if there is a larger chain
 for i in a:
  k=a.index(i)
  d=a[:k]+a[k+1:]                # list excluding i
  e=[i[::-1]]                    # reverse i
  if not b:f(d,[i])              # if b is empty
                                 # ways the domino can be placed:
  elif i[0]==b[-1][1]:f(d,b+[i]) # left side on the right
  elif i[0]==b[0][0]:f(d,e+b)    # (reversed) left side on the left
  elif i[1]==b[0][0]:f(d,[i]+b)  # right side on left
  elif i[1]==b[-1][1]:f(d,b+e)   # (reversed) right side on the right
f(l,[])
print m

I'm posting because I didn't see any python answers...someone will see my answer and, in disgust, be forced to post something much shorter and efficient.

Clojure, 198 183 bytes
Update: Better handling of "maximum of possibly empty sequence"
(defn F[a C](remove(fn[i](identical? i a))C))(defn M[C](apply max 0 C))(defn L([P](M(for[p P l p](L l(F p P)))))([l R](+(M(for[r R[i j][[0 1][1 0]]:when(=(r i)l)](L(r j)(F r R))))1)))

Earlier version:
(defn F[a C](remove(fn[i](identical? i a))C))(defn M[C](apply max 1 C))(defn L([P](if(empty? P)0(M(for[p P l p](L l(F p P))))))([l R](M(for[r R[i j][[0 1][1 0]]:when(=(r i)l)](+(L(r j)(F r R))1)))))

Calling convention and test cases:
(L [])
(L [[2 4] [3 2] [1 4]])
(L [[3, 1] [0, 3], [1, 1]])
(L [[17 -7] [4 -9] [12 -3] [-17 -17] [14 -10] [-6 17] [-16 5] [-3 -16] [-16 19] [12 -8]])
(L [[0 -1] [1 -1] [0 3] [3 0] [3 1] [-2 -1] [0 -1] [2 -2] [-1 2] [3 -3]])
(L [[1 1] [1 1] [1 1] [1 1] [1 1] [1 1] [1 1]])

F returns elements of list C without the element a, M returns the max of input ingerers or 1.
L is the main function, when called with a single argument it generates all possible starting pieces and finds the max length for each of them. When called with two arguments the l is the first element of the sequence to which the next piece must match and R is rest of the pieces.
Generating permutations and "choose one element and split to rest" were quite tricky to implement succinctly.


text:
Die Hard 3 Water Jugs Problem
Introduction
The well-known "Die Hard with a Vengeance" water jugs puzzle challenges the two heroes to get 4L of water in a 5L container, provided an unlimited supply of water and another container of 3L. This problem has a solution because 4 is less or equal than the largest container and is a multiple of the gcd(5, 3) = 1 as per number theory. The same goes for other combinations of container sizes as long as the Greatest Common Divisor (GCD) requirements are satisfied for a target value.
Task
In one sentence, the task is to brute-force two solutions by filling and emptying two containers as well as transferring amounts between one another for any given container sizes and target value. The brute-force lies on repeatedly transferring amounts from one container to another, refilling the first when it runs out and emptying the second when it fills up, until any of them contain the target value.
The program should make two runs to respectively find two solutions by swapping container positions (i.e., the container receiving water from the other swaps with that one). The container states should be printed throughout all steps (refilling or emptying and transferring water).
This is code golf, so lowest byte count wins.
Examples
Examples follow below for (5, 3, 4) and (17, 5, 7) with 4 and 7 being the target values. Comments added for description purposes.
5 3 4
[5, 0] # initial state
[2, 3] # transferring
[2, 0] # emptying
[0, 2] # transferring
[5, 2] # refilling
[4, 3] # transferring, solution found
3 5 4
[3, 0]
[0, 3]
[3, 3]
[1, 5]
[1, 0]
[0, 1]
[3, 1]
[0, 4]

17 5 7
[17, 0] # initial state
[12, 5] # transferring
[12, 0] # emptying
[7, 5]  # transferring, solution found
5 17 7
[5, 0]
[0, 5]
[5, 5]
[0, 10]
[5, 10]
[0, 15]
[5, 15]
[3, 17]
[3, 0]
[0, 3]
[5, 3]
[0, 8]
[5, 8]
[0, 13]
[5, 13]
[1, 17]
[1, 0]
[0, 1]
[5, 1]
[0, 6]
[5, 6]
[0, 11]
[5, 11]
[0, 16]
[5, 16]
[4, 17]
[4, 0]
[0, 4]
[5, 4]
[0, 9]
[5, 9]
[0, 14]
[5, 14]
[2, 17]
[2, 0]
[0, 2]
[5, 2]
[0, 7]

Related: http://codegolf.stackexchange.com/q/20754/12012

Should it brute-force using any specific algorithm?

@wizzwizz4 The brute-force part refers to repeatedly refilling or emptying as necessary and transferring water from one container to another.

@dfernan What determines "as necessary"?

@wizzwizz4 It is stated in the task description. Jugs are refilled or emptied if they run out of water or are filled up, until a solution is found. I have added a few comments to the examples to better describe this.

@dfernan Should they be filled and emptied randomly?

@dfernan Or should this algorithm be used?

I think this is performing a simple naive search based on a couple of rules.  Let me see if I can code something up.

Batch, 218 bytes
@echo off
set/al=r=0
:l
echo %l% %r%
set/at=r+l
if %l% neq %3 if %r% neq %3 ((if %r%==%2 (set r=0)else if %l%==0 (set l=%1)else if %t% leq %2 (set/ar=t,l=0)else set/ar=%2,l=t-%2)&goto l)
if "%4"=="" %0 %2 %1 %3 .

Putting everything into one big if statement saves 11 bytes. %4 is just used to make the file loop twice with the arguments exchanged.

Python 2 - 222/384, 190 174/360 352 336 Bytes
This version that only outputs the solution is 174 bytes.
a,b,c=input()
d,e=0,0
for i in range(2):
 while d!=c and e!=c:
   if e<b:
     if d>0:
       if e+d<=b:e+=d;d=0
       else:n=d+e-b;e=b;d=n
     else:d=a
   else:e=0
 print d,e
 b,a,d,e=a,b,0,0

Try it here!
Example Output:

Explanation:
a,b,c=input()                      # Value of jug 1, jug 2, target value
d,e=0,0                            # Water held in each jug
for i in range(2):                 # Loop twice
  while d!=c and e!=c:             # While no solution
    if e<b:                        # If jug 2 can hold more water
      if d!=0:                     # If jug 1 has water
        if e+d<=b:e+=d;d=0         # If no overfill, pour all of jug 1 into 2
        else:n=d+e-b;e=b;d=n       # Else fill up as much as possible
      else:d=a                     # Else jug 1 has no water, fill it
    else:e=0                       # Else jug 2 is full, empty it
  print d,e                        # Print solution
  b,a,d,e=a,b,0,0                  # Switch the two jugs' values, empty all jugs

It implements this algorithm. With the new edit, the code becomes 326 bytes:
a,b,c=input(),input(),input()
d,e=0,0
g=[d,e]
for i in"xx":
 while d!=c and e!=c:
   g=[d,e]
   if e<b:
     if d!=0:
       if e+d<=b:e+=d;d=0;print"Transferring Water"
       else:n=d+e-b;e=b;d=n;print"Transferring Water"
     else:d=a;print"Filling Water"
   else:e=0;print"Emptying Water"
   print g
 print[d,e],"Solution Found"
 b,a,d,e=a,b,0,0;print"Resetting"

Try this version here
Explanation and Output
Explanation is the same except with text and g is used to output the values of the two jugs and final solution. Output:

You can save 16 bytes by changing your first two lines to a,b,c,d,e=input(),0,0 and taking input all together.

@Theo This doesn't work if I enter a number with n digits where n is not divisible by three

You don't use i so for i in range(2) can become for i in'xx':. Also d!=0 can be d>0. Saves a few.

Also use single spaces for your indents and it should go well under 200.

@ElPedro I just edited my post to use single space indents. I used double space indents in my explanation for readability

Guess you did it at the same time as I was commenting :-)

For the single input you need comma seperated values e.g. 3,5,4. Currently got this to 181 for the short version Try it here