[Question]
  [
Shortest answer wins.
It must be sorted, and in 24hr time. The final line does not have a comma.
Output should be as follows:
```
'00:00',
'00:30',
'01:00',
'01:30',
'02:00',
'02:30',
'03:00',
'03:30',
'04:00',
'04:30',
'05:00',
'05:30',
'06:00',
'06:30',
'07:00',
'07:30',
'08:00',
'08:30',
'09:00',
'09:30',
'10:00',
'10:30',
'11:00',
'11:30',
'12:00',
'12:30',
'13:00',
'13:30',
'14:00',
'14:30',
'15:00',
'15:30',
'16:00',
'16:30',
'17:00',
'17:30',
'18:00',
'18:30',
'19:00',
'19:30',
'20:00',
'20:30',
'21:00',
'21:30',
'22:00',
'22:30',
'23:00',
'23:30'
```
  
[Answer]
# Pyth, 26 bytes
```
Pjbm%"'%02d:%s0',"d*U24"03
```
[Demonstration.](https://pyth.herokuapp.com/?code=Pjbm%25%22%27%2502d%3A%25s0%27%2C%22d*U24%2203&debug=0)
We start with the cartesian product of `range(24)` (`U24`) with the string `"03"`.
Then, we map these values to the appropriate string formating substitution (`m%"'%02d:%s0',"d`).
Then, the resultant strings are joined on the newline character (`jb`).
Finally, we remove the trailing comma (`P`) and print.
[Answer]
# Befunge-93, 63 bytes
```
0>"'",:2/:55+/.55+%.":",:2%3*v
 ^,+55,","<_@#-*86:+1,"'".0. <
```
 
![animation](https://i.stack.imgur.com/gRVfh.gif)
*(animation made with [BefunExec](https://github.com/Mikescher/BefunExec))*
[Answer]
# Bash: ~~58~~ ~~47~~ 46 characters
```
h=`echo \'{00..23}:{0,3}0\'`
echo "${h// /,
}"
```
[Answer]
# CJam, ~~31 30~~ 29 bytes
```
24,[U3]m*"'%02d:%d0',
"fe%~7<
```
This is pretty straight forward using printf formatting:
```
24,                              e# get the array 0..23
   [U3]                          e# put array [0 3] on stack
       m*                        e# do a cartesian product between 0..23 and [0 3] array
                                 e# now we have tuples like [[0 0], [0 3] ... ] etc
         "'%02d:%d0',
"fe%                             e# this is standard printf formatting. What we do here is
                                 e# is that we format each tuple on this string
    ~7<                          e# unwrap and remove comma and new line from last line
                                 e# by taking only first 7 characters
```
[Try it online here](http://cjam.aditsu.net/#code=24%2C%5BU3%5Dm*%22%27%2502d%3A%25d0%27%2C%0A%22fe%25%7E7%3C)
[Answer]
# Python 2, ~~58~~ 56 bytes
```
for i in range(48):print"'%02d:%s0',"[:57-i]%(i/2,i%2*3)
```
Like [sentiao's answer](https://codegolf.stackexchange.com/a/49742/21487) but using a `for` loop, with slicing to remove the comma. Thanks to @grc for knocking off two bytes.
[Answer]
# Java - 119 bytes
I started with Java 8's StringJoiner, but that means including an import statement, so I decided to do it the old way:
```
void f(){String s="";for(int i=0;i<24;)s+=s.format(",\n'%02d:00',\n'%02d:30'",i,i++);System.out.print(s.substring(2));}
```
Perhaps this can be improved by getting rid of the multiple occuring `String` and `System` keywords.
[Answer]
# Ruby, ~~94~~ ~~61~~ ~~56~~ 51
```
$><<(0..47).map{|i|"'%02d:%02d'"%[i/2,i%2*30]}*",
"
```
Thanks to @blutorange (again) for his help in golfing!
[Answer]
# Perl, ~~52~~ ~~50~~ ~~48~~ 45B
```
$,=",
";say map<\\'$_:{0,3}0\\'>,"00".."23"
```
With help from ThisSuitIsBlackNot :)
[Answer]
## JAVA ~~95~~ 94 bytes
I love the fact that printf exists in Java:
```
void p(){for(int i=0;i<24;)System.out.printf("'%02d:00',\n'%02d:30'%c\n", i,i++,(i<24)?44:0);}
```
Ungolfed
```
void p(){
    for(int i=0;i<24;)
        System.out.printf("'%02d:00',\n'%02d:30'%c\n", i,i++,(i<24)?44:0);
}
```
EDIT
Replaced the `','` with `44`
[Answer]
# Pyth, ~~32~~ 31 bytes
I golfed something in python but it turned out to be exactly the same as Sp3000's answer. So I decided to give Pyth a try:
```
V48<%"'%02d:%d0',",/N2*3%N2-54N
```
It's a exact translation of Sp3000 answer:
```
for i in range(48):print"'%02d:%d0',"[:57-i]%(i/2,i%2*3)
```
It's my first go at Pyth, so please do enlighten me about that 1 byte saving.
[Answer]
# PHP, 109 bytes
```
foreach(new DatePeriod("R47/2015-05-07T00:00:00Z/PT30M")as$d)$a[]=$d->format("'H:i'");echo implode(",\n",$a);
```
[Answer]
# Ruby, ~~54~~ 51 bytes
```
puts (0..23).map{|h|"'#{h}:00',
'#{h}:30'"}.join",
"
```
[Answer]
# C, ~~116~~,~~115~~,~~101~~,~~100~~,~~95~~,~~74~~,~~73~~, 71
May be able to scrape a few more bytes off this...
```
main(a){for(;++a<50;)printf("'%02d:%d0'%s",a/2-1,a%2*3,a<49?",\n":"");}
```
[Answer]
# T-SQL, ~~319~~ ~~307~~ 305 bytes
```
WITH t AS(SELECT t.f FROM(VALUES(0),(1),(2),(3),(4))t(f)),i AS(SELECT i=row_number()OVER(ORDER BY u.f,v.f)-1FROM t u CROSS APPLY t v),h AS(SELECT i,h=right('0'+cast(i AS VARCHAR(2)),2)FROM i WHERE i<24)SELECT''''+h+':'+m+CASE WHEN i=23AND m='30'THEN''ELSE','END FROM(VALUES('00'),('30'))m(m) CROSS APPLY h
```
Un-golfed version:
```
WITH
t AS(
    SELECT
        t.f
    FROM(VALUES
         (0),(1),(2),(3),(4)
    )t(f)
),
i AS(
    SELECT
        i = row_number() OVER(ORDER BY u.f,v.f) - 1
    FROM t u 
    CROSS APPLY t v
),
h AS(
    SELECT
        i,
        h = right('0'+cast(i AS VARCHAR(2)),2)
    FROM i
    WHERE i<24
)
SELECT
    '''' + h + ':' + m + CASE WHEN i=23 AND m='30' 
                              THEN '' 
                              ELSE ',' 
                         END
FROM(
    VALUES('00'),('30')
)m(m)
CROSS APPLY h
```
[Answer]
# Pyth, 34 bytes
```
j+\,bmjk[\'?kgd20Z/d2\:*3%d2Z\')48
```
This can definitely be improved. 
Try it online: [Pyth Compiler/Executor](https://pyth.herokuapp.com/?code=j%2B%5C%2Cbmjk%5B%5C%27%3Fkgd20Z%2Fd2%5C%3A*3%25d2Z%5C%27)48&debug=0)
### Explanation:
```
     m                          48   map each d in [0, 1, ..., 47] to:
        [                      )       create a list with the elements:
         \'                              "'"
           ?kgd20Z                       "" if d >= 20 else 0
                  /d2                    d / 2
                     \:                  ":"
                       *3%d2             3 * (d%2)
                            Z            0
                             \'          "'"
      jk                               join by "", the list gets converted into a string
j+\,b                                join all times by "," + "\n"
```
[Answer]
# Python 2, 69 bytes
```
print',\n'.join(["'%02d:%s0'"%(h,m)for h in range(24)for m in'03'])
```
Quite obvious, but here's an explanation:
* using double-for-loop
* alternating between `'0'` and `'3'` in string format is shorter than a list
* `%02d` does the padding for `h`
* `m`doesn't need padding as the alternating character is on a fixed position
* `'\n'.join()` solves the final-line requirements
I have no idea if it can be done shorter (in Python 2).
**by Sp3000, 61 bytes :**
`print',\n'.join("'%02d:%s0'"%(h/2,h%2*3)for h in range(48))`
[Answer]
# Haskell, 85 bytes
```
putStr$init$init$unlines$take 48['\'':w:x:':':y:"0',"|w<-"012",x<-['0'..'9'],y<-"03"]
```
Unfortunately `printf` requires a 19 byte `import`, so I cannot use it.
[Answer]
# Julia: ~~65~~ ~~64~~ 61 characters
```
[@printf("'%02d:%d0'%s
",i/2.01,i%2*3,i<47?",":"")for i=0:47]
```
### Julia: 64 characters
(Kept here to show Julia's nice `for` syntax.)
```
print(join([@sprintf("'%02d:%d0'",h,m*3)for m=0:1,h=0:23],",
"))
```
[Answer]
# Fortran 96
```
do i=0,46;print'(a1,i2.2,a,i2.2,a2)',"'",i/2,":",mod(i,2)*30,"',";enddo;print'(a)',"'23:30'";end
```
Standard abuse of types & requirement only for the final `end` for compiling. Sadly, due to implicit formatting, the `'(a)'` in the final `print` statement is required. Still, better than the C and C++ answers ;)
[Answer]
# JavaScript (ES6), 77 86+1 bytes
Didn't realize there had to be quotes on each line (+1 is for `-p` flag with node):
```
"'"+Array.from(Array(48),(d,i)=>(i>19?"":"0")+~~(i/2)+":"+3*(i&1)+0).join("',\n'")+"'"
```
old solution:
```
Array.from(Array(48),(d,i)=>~~(i/2).toFixed(2)+":"+3*(i&1)+"0").join(",\n")
```
ungolfed version (using a for loop instead of `Array.from`):
```
var a = [];
// there are 48 different times (00:00 to 23:30)
for (var i = 0; i < 48; i++) {
    a[i] =
        (i > 19 ? "" : "0") +
            // just a ternary to decide whether to pad
            // with a zero (19/2 is 9.5, so it's the last padded number)
        ~~(i/2) +
            // we want 0 to 24, not 0 to 48
        ":" +  // they all then have a colon
        3*(i&1) +
            // if i is odd, it should print 30; otherwise, print 0
        "0" // followed by the last 0
}
console.log(a.join(",\n"));
```
[Answer]
# [golflua](http://mniip.com/misc/conv/golflua/) ~~52~~ 51 chars
```
~@n=0,47w(S.q("'%02d:%d0'%c",n/2,n%2*3,n<47&44|0))$
```
Using ascii 44 = `,` and 0 a space saves a character.
An ungolfed Lua version would be
```
for h=0,47 do
   print(string.format("'%02d:%d0'%c",h/2,h%2*3, if h<47 and 44 or 0))
end
```
The `if` statement is much like the ternary operator `a > b ? 44 : 0`.
[Answer]
# C# - 120 bytes
```
class P{static void Main(){for(var i=0;i<24;i++)System.Console.Write("'{0:00}:00',\n'{0:00}:30'{1}\n",i,i==23?"":",");}}
```
[Answer]
# Python, ~~60 58~~ 64 bytes
```
for i in range(24):print("'%02d:00,\n%02d:30'"%(i,i)+', '[i>22])
```
Ungolfed:
```
for i in range(24):
    if i <23:
        print( ('0'+str(i))[-2:] + ':00,\n' + str(i) + ':30,')
    else:
        print( ('0'+str(i))[-2:] + ':00,\n' + str(i) + ':30')
```
Try it online [here](http://repl.it/nBQ/5).
[Answer]
# ùîºùïäùïÑùïöùïü, 39 chars / 67 bytes (non-competing)
```
‚Ü∫;·∏Ä‚ß∫<·∏∞;)·µñ`'‚¶É·∏Ä<·∏î?0:‚¨Ø}‚¶É0|·∏Ä/2}:‚¶É·∏Ä%2*3}0',‚Äù
```
`[Try it here (Firefox only).](http://molarmanful.github.io/ESMin/interpreter.html?eval=false&input=&code=%E2%86%BA%3B%E1%B8%80%E2%A7%BA%3C%E1%B8%B0%3B%29%E1%B5%96%60%27%E2%A6%83%E1%B8%80%3C%E1%B8%94%3F0%3A%E2%AC%AF%7D%E2%A6%830%7C%E1%B8%80%2F2%7D%3A%E2%A6%83%E1%B8%80%252*3%7D0%27%2C%E2%80%9D)`
*Not a single alphabetical character in sight...*
[Answer]
# PHP, 69 70 62 bytes
```
for($x=-1;++$x<47;)printf("'%02d:%d0',
",$x/2,$x%2*3)?>'23:30'
```
[Try it online](https://3v4l.org/j44mV)
Outputting `'23:30'` at the end is a bit lame, and so is closing the php context using `?>` without opening or re-opening it. An cleaner alternative (but 65 bytes) would be:
```
for($x=-1;++$x<48;)printf("%s'%02d:%d0'",$x?",
":'',$x/2,$x%2*3);
```
[Try it online](https://3v4l.org/JfJ3C)
Thank you @Dennis for the tips. Alternative inspired by the contribution of @ismael-miguel.
[Answer]
# Swift, 74 bytes
Updated for Swift 2/3...and with new string interpolation...
```
for x in 0...47{print("'\(x<20 ?"0":"")\(x/2):\(x%2*3)0'\(x<47 ?",":"")")}
```
[Answer]
# Javascript, 89 bytes
```
for(i=a=[];i<24;)a.push((x="'"+("0"+i++).slice(-2))+":00'",x+":30'");alert(a.join(",\n"))
```
[Answer]
## Python 2: 64 bytes
```
print ',\n'.join(['%02d:00,\n%02d:30'%(h,h) for h in range(24)])
```
[Answer]
**Ruby - 52 bytes**
```
puts (0..47).map{|i|"'%02d:%02d'"%[i/2,i%2*30]}*",
"
```
[Answer]
# Python 2, ~~74~~ 65 bytes
We generate a 2 line string for each hour, using text formatting:
```
print',\n'.join("'%02u:00',\n'%02u:30'"%(h,h)for h in range(24))
```
This code is fairly clear, but the clever indexing and integer maths in the answer by Sp3000 gives a shorter solution.
]