List all times in the day at a half hour rate

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 1

Pyth, 26 bytes

Pjbm%"'%02d:%s0',"d*U24"03

Demonstration.

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 2

Befunge-93, 63 bytes

0>"'",:2/:55+/.55+%.":",:2%3*v
 ^,+55,","<_@#-*86:+1,"'".0. <

 

^{(animation made with BefunExec)}

Answer 3

Bash: 58 47 46 characters

h=`echo \'{00..23}:{0,3}0\'`
echo "${h// /,
}"

Answer 4

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

Answer 5

Python 2, 58 56 bytes

for i in range(48):print"'%02d:%s0',"[:57-i]%(i/2,i%2*3)

Like sentiao's answer but using a for loop, with slicing to remove the comma. Thanks to @grc for knocking off two bytes.

Answer 6

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 7

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 8

Perl, 52 50 48 45B

$,=",
";say map<\\'$_:{0,3}0\\'>,"00".."23"

With help from ThisSuitIsBlackNot :)

Answer 9

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 10

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 11

Ruby, 54 51 bytes

puts (0..23).map{|h|"'#{h}:00',
'#{h}:30'"}.join",
"

Answer 12

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 13

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 14

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 15

Pyth, 34 bytes

j+\,bmjk[\'?kgd20Z/d2\:*3%d2Z\')48

This can definitely be improved.

Try it online: Pyth Compiler/Executor

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 16

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 17

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
• mdoesn'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 18

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 19

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 20

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.

Answer 21

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 22

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 23

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 24

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 25

, 39 chars / 67 bytes (non-competing)

↺;Ḁ⧺<Ḱ;)ᵖ`'⦃Ḁ<Ḕ?0:⬯}⦃0|Ḁ/2}:⦃Ḁ%2*3}0',”

Try it here (Firefox only).

Not a single alphabetical character in sight...

Answer 26

PHP, 69 70 62 bytes

for($x=-1;++$x<47;)printf("'%02d:%d0',
",$x/2,$x%2*3)?>'23:30'

Try it online

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

Thank you @Dennis for the tips. Alternative inspired by the contribution of @ismael-miguel.

Answer 27

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.

Answer 28

Javascript, 89 bytes

for(i=a=[];i<24;)a.push((x="'"+("0"+i++).slice(-2))+":00'",x+":30'");alert(a.join(",\n"))

Answer 29

Python 2: 64 bytes

print ',\n'.join(['%02d:00,\n%02d:30'%(h,h) for h in range(24)])

Answer 30

Ruby - 52 bytes

puts (0..47).map{|i|"'%02d:%02d'"%[i/2,i%2*30]}*",
"

Answer 31

PHP 89 88 87 85 bytes

<?for($i=0;$i<24;$i++){$a=sprintf("%02d",$i);echo"'$a:00',\n'$a:30'",$i<23?",\n":'';}

I tried but it isn't the shortest in PHP.

Old code:

<?for($i=0;$i<24;$i++){($i<10?$a="0$i":$a=$i);echo"'$a:00',\n'$a:30'".($i==23?'':",\n");}

Answer 32

PowerShell, 69 Bytes

$d=date 0;(0..47|%{"'{0:HH:mm}'"-f$d;$d=$d.AddMinutes(30)})-join",`n"

I love how it's shorter to use actual date functions than simply try to brute force the numbers with .ToString operators to pad zeroes and logic to decide if we're in a 00 or a 30 output.

Sets a new date $d to be 00:00:00 Jan 1 0000, then goes into a loop 48 times with 0..47|%{..}. Each time in the loop we generate our output using the -f operator. The HH:mm format for dates gives us 24-hour time with minutes, just as we want. Then, we addMinutes(30) to prep us for the next go-round. Outside the loop, we -join everything together with a comma and a newline.

Answer 33

TreeHugger, 1433 Bytes

TreeHugger is a bf variant that uses a binary tree instead of a linear tape. Read about it here and you can run scripts on the implementation here. As for how this program works, here is a rough run down:

• Store the characters needed
  • In the first loop, get within 5 of the desired value
  • Manually adjust to the correct value
• Walk through the tree and print the proper characters in the proper order
  • WARNING: This step is a little tedious

++++++++++[>++++++>+++++>+++++>++++>++++>+^^^^^<+++++>+++++^^^<++++>+++++>+++++^<+++++^^<+++++>+++++>++++++^<++++++^^<+++++>++++++^<+++++^^^^-]>-->+>-->->++++>^^^^^<+++>++^^^<->->+++^<++^^<-->+>---^<----^^<>-----^<++++^^^^<.<..^^>.>>.[.>]^^^^^^^^<.<..^^>[.>]^^^^^^^^<.<.^>.^^>.>>.[.>]^^^^^^^^<.<.^>.^^>[.>]^^^^^^^^<.<.<.^^^>.>>.[.>]^^^^^^^^<.<.<.^^^>[.>]^^^^^^^^<.<.>.^^^>.>>.[.>]^^^^^^^^<.<.>.^^^>[.>]^^^^^^^^<.<.^><.^^^>.>>.[.>]^^^^^^^^<.<.^><.^^^>[.>]^^^^^^^^<.<.^>>.^^^>.>>.[.>]^^^^^^^^<.<.^>>.^^^>[.>]^^^^^^^^<.<.<<.^^^^>.>>.[.>]^^^^^^^^<.<.<<.^^^^>[.>]^^^^^^^^<.<.<>.^^^^>.>>.[.>]^^^^^^^^<.<.<>.^^^^>[.>]^^^^^^^^<.<.><.^^^^>.>>.[.>]^^^^^^^^<.<.><.^^^^>[.>]^^^^^^^^<.<.>>.^^^^>.>>.[.>]^^^^^^^^<.<.>>.^^^^>[.>]^^^^^^^^<.>.^<.^^>.>>.[.>]^^^^^^^^<.>.^<.^^>[.>]^^^^^^^^<.>..^^>.>>.[.>]^^^^^^^^<.>..^^>[.>]^^^^^^^^<.>.^<<.^^^>.>>.[.>]^^^^^^^^<.>.^<<.^^^>[.>]^^^^^^^^<.>.^<>.^^^>.>>.[.>]^^^^^^^^<.>.^<>.^^^>[.>]^^^^^^^^<.>.<.^^^>.>>.[.>]^^^^^^^^<.>.<.^^^>[.>]^^^^^^^^<.>.>.^^^>.>>.[.>]^^^^^^^^<.>.>.^^^>[.>]^^^^^^^^<.>.^<<<.^^^^>.>>.[.>]^^^^^^^^<.>.^<<<.^^^^>[.>]^^^^^^^^<.>.^<<>.^^^^>.>>.[.>]^^^^^^^^<.>.^<<>.^^^^>[.>]^^^^^^^^<.>.^<><.^^^^>.>>.[.>]^^^^^^^^<.>.^<><.^^^^>[.>]^^^^^^^^<.>.^<>>.^^^^>.>>.[.>]^^^^^^^^<.>.^<>>.^^^^>[.>]^^^^^^^^<.<<.^.^^>.>>.[.>]^^^^^^^^<.<<.^.^^>[.>]^^^^^^^^<.<<.^^>.^^>.>>.[.>]^^^^^^^^<.<<.^^>.^^>[.>]^^^^^^^^<.<<..^^^>.>>.[.>]^^^^^^^^<.<<..^^^>[.>]^^^^^^^^<.<<.^>.^^^>.>>.[.>]^^^^^^^^<.<<.^>.^^^>.>.>.>.

---

Un-Golfed

The three digit numbers are the ASCII values we're aiming for in the approximation and adjustment phases. The numbers in the print phase, indicate the hour that we are printing.

# Approximation
+++++ +++++ [
058 > +++++ +
051 > +++++
048 > +++++
039 > ++++
044 > ++++
010 > +
^^^^^ 
053 < +++++ 
052 > +++++
^^^
039 < ++++
049 > +++++
053 > +++++
^
052 < +++++
^^
048 < +++++
051 > +++++
057 > +++++ +
^
056 < +++++ + 
^^
050 < +++++ 
055 > +++++ +
^
054 < +++++
^^^^ -
]
# Adjustment
058 > --
051 > +
048 > --
039 > -
044 > ++++
010 >
^^^^^ 
053 < +++ 
052 > ++
^^^
039 < -
049 > -
053 > +++
^
052 < ++
^^
048 < --
051 > +
057 > ---
^
056 < ----
^^
050 < 
055 > -----
^
054 < ++++ 
^^^^
# Print
0
<.<..^^     >.>>.[.>] ^^^^^ ^^^
<.<..^^     >[.>] ^^^^^ ^^^
1
<.<.^>.^^   >.>>.[.>] ^^^^^ ^^^
<.<.^>.^^   >[.>] ^^^^^ ^^^
2
<.<.<.^^^   >.>>.[.>] ^^^^^ ^^^
<.<.<.^^^   >[.>] ^^^^^ ^^^
3
<.<.>.^^^   >.>>.[.>] ^^^^^ ^^^
<.<.>.^^^   >[.>] ^^^^^ ^^^
4
<.<.^><.^^^ >.>>.[.>] ^^^^^ ^^^
<.<.^><.^^^ >[.>] ^^^^^ ^^^
5
<.<.^>>.^^^ >.>>.[.>] ^^^^^ ^^^
<.<.^>>.^^^ >[.>] ^^^^^ ^^^
6
<.<.<<.^^^^ >.>>.[.>] ^^^^^ ^^^
<.<.<<.^^^^ >[.>] ^^^^^ ^^^
7
<.<.<>.^^^^ >.>>.[.>] ^^^^^ ^^^
<.<.<>.^^^^ >[.>] ^^^^^ ^^^
8
<.<.><.^^^^ >.>>.[.>] ^^^^^ ^^^
<.<.><.^^^^ >[.>] ^^^^^ ^^^
9
<.<.>>.^^^^ >.>>.[.>] ^^^^^ ^^^
<.<.>>.^^^^ >[.>] ^^^^^ ^^^
10
<.>.^<.^^   >.>>.[.>] ^^^^^ ^^^
<.>.^<.^^   >[.>] ^^^^^ ^^^
11
<.>..^^     >.>>.[.>] ^^^^^ ^^^
<.>..^^     >[.>] ^^^^^ ^^^
12
<.>.^<<.^^^ >.>>.[.>] ^^^^^ ^^^
<.>.^<<.^^^ >[.>] ^^^^^ ^^^
13
<.>.^<>.^^^ >.>>.[.>] ^^^^^ ^^^
<.>.^<>.^^^ >[.>] ^^^^^ ^^^
14
<.>.<.^^^   >.>>.[.>] ^^^^^ ^^^
<.>.<.^^^   >[.>] ^^^^^ ^^^
15
<.>.>.^^^   >.>>.[.>] ^^^^^ ^^^
<.>.>.^^^   >[.>] ^^^^^ ^^^
16
<.>.^<<<.^^^^ >.>>.[.>] ^^^^^ ^^^
<.>.^<<<.^^^^ >[.>] ^^^^^ ^^^
17
<.>.^<<>.^^^^ >.>>.[.>] ^^^^^ ^^^
<.>.^<<>.^^^^ >[.>] ^^^^^ ^^^
18
<.>.^<><.^^^^ >.>>.[.>] ^^^^^ ^^^
<.>.^<><.^^^^ >[.>] ^^^^^ ^^^
19
<.>.^<>>.^^^^ >.>>.[.>] ^^^^^ ^^^
<.>.^<>>.^^^^ >[.>] ^^^^^ ^^^
20
<.<<.^.^^      >.>>.[.>] ^^^^^ ^^^
<.<<.^.^^      >[.>] ^^^^^ ^^^
21
<.<<.^^>.^^  >.>>.[.>] ^^^^^ ^^^
<.<<.^^>.^^  >[.>] ^^^^^ ^^^
22
<.<<..^^^    >.>>.[.>] ^^^^^ ^^^
<.<<..^^^    >[.>] ^^^^^ ^^^
23
<.<<.^>.^^^    >.>>.[.>] ^^^^^ ^^^
<.<<.^>.^^^    >.>.>.>.

This can be golfed down more, I have a 1198 byte version that should work, but I think this implementation might have a bug. So stay tuned until I finish debugging my own implementation.

Answer 34

Java, 93 bytes

void t(){for(int i=0;i<24;)System.out.printf("'%02d:00',\n'%02d:30'%s",i,i,i++<23?",\n":"");}

Ungolfed

void t()
{
    for(int i = 0; i < 24; i++)
    {
        System.out.printf("'%02d:00',\n", i);
        System.out.printf(   "'%02d:30'", i);
        System.out.printf( i < 23 ?",\n":"");
    }
}

Answer 35

Java 7, 88 bytes

void c(){for(int i=0;i<48;)System.out.printf("'%02d:%s0'%s",i/2,i%2*3,i++<47?",\n":"");}

Shorter than the other three Java answers: 93 bytes & 94 bytes & 119 bytes

Explanation:

void c(){                  // Method
  for(int i=0;i<48;)       //  Loop from 0 to 48 (exclusive)
    System.out.printf(     //   Print with format:
      "'%02d:%s0'%s",      //    "'##:#0'X" (where `#` is a digit, and `X` is a String)
      i/2,                 //    (%02d) Current index divided by 2 and automatically floored
      i%2 * 3              //    (%s0) i%2 is either 0 or 1 (multiplied by 3 is either 0 or 3)
      i++<47 ? ",\n" : ""  //    (%s) A comma and new-line, unless it's the final line
                           //  End of loop
}                          // End of method

Try it here.

Answer 36

AHK, 96 bytes

t=20000101000000
Loop,48{
FormatTime,i,%t%,HH:mm
Send,'%i%',`n
EnvAdd,t,30,Minutes
}
Send,{BS 2}

AHK does not play nicely with time values so I have to store two variables: one to track the time in the format YYYYMMDDHH24MISS and another just to store the pretty text in the format HH:MI.

Answer 37

JavaScript, 127 bytes

I'm not a very good golfer :s

var r='',i,m=":00',\n",q="'"
for(i=0;i<23;i++){
h=("0"+i).slice(-2)
r+=q+h+m+q+h+":30',\n"
}
r+=q+i+m+q+i+":30'"
console.log(r)

Java, 179 bytes

public class M{public static void main(String[] a){String r="",f="'%02d:%s',\n";for(int i=0;i<24;i++)r+=String.format(f+f,i,"00",i,"30");System.out.print(r.replaceAll(".$",""));}}

ungolfed

public class M {
    public static void main(final String[] a) {
        String r = "", f = "'%02d:%s',\n";
        for (int i = 0; i < 24; i++)r += String.format(f + f, i, "00", i, "30");
        System.out.print(r.replaceAll(".$", ""));
    }
}

Answer 38

C++ - 104 bytes

I spend a while trying to find an obtuse way to remove the comma, but in the end the simple approach seemed to be by far the most efficient.

#include<cstdio>
int main(int c,char**v){for(c=-1;c++<47;printf("'%.2d:%d0'%s\n",c/2,c%2*3,c>46?"":","));}

I shouldn't need to initialize c to -1 but I couldn't get an inline postfix increment to work how I expected.

Answer 39

JavaScript (ES6), 81 77 bytes

Template strings work well for cutting down the size.

alert([...Array(48)].map((x,i)=>`'${i<20?0:''}${i/2|0}:${i%2*3}0'`).join`,
`)

Answer 40

PHP, 82 77 bytes

Nothing fancy, just abusing PHP's string capacities.

<?for($H=-1;$H++<23;)echo$H?",
'":"'",$H=str_pad($H,2,0,0),":00',
'$H:30'";

Probably there's something that I can cut off.

Old version, 82 bytes:

<?foreach(range(0,23)as$H)echo$H?",
'":"'",$H=str_pad($H,2,0,0),":00',
'$H:30'";

Answer 41

C# - lots (but give away free with windows)

using System;
using System.Collections.Generic;
using System.Linq;
class P
{
    static void Main()
    {
        Console.Write(String.Join(",\n", Enumerable.Range(0, 48).Select(i => "'" + i / 2 + ":" + (i % 2) * 3 + "0'")));
    }
}

Answer 42

PostgreSQL: 97 characters

select string_agg(to_char(x*interval'30m','''hh24:mi'''),','||chr(10))from generate_series(0,47)x

PostgreSQL: 132 131 116 characters

Kept here to show PostgreSQL's cool way to generate timestamp series.

select string_agg(to_char(x,'''hh24:mi'''),','||chr(10))from generate_series('150511','150511 23:59',interval'.5h')x

Answer 43

Python, 145 bytes

import time as t;i=48;a=t.asctime;w=3600;s=t.sleep;s(24-int(a()[11:13])*w+w-60*int(a()[14:16]));
while i:print '\''+a()[11:16]+'\',';i-=1;s(w)

I guess the code is fairly readable (altough quite long). Once you run the program it waits until actual local time is 00:00h, then prints the time and waits for 30 min, time in which the program prints the hour again. It keeps repeating this process until 00:00h of the next day is reached. Therefore, with lots of patience and no incidents that force your computer to shutdown all the times get printed.

Answer 44

Ceylon, 101 bytes

shared void run(){print(",\n".join{for(h in 0..23)for(m in[0,3])"'``"``h``".pad(2,'0')``:``m``0'"});}

Formatted:

shared void run() {
    // original:
    print(",\n".join {
            for (h in 0..23)
                for (m in [0, 3])
                    "'``"``h``".pad(2, '0')``:``m``0'"
        });
}

This uses an iterable comprehension with two for-clauses, and nested string templates. "``h``" is a shorter way of writing h.string (we can't pad an integer directly). ",\n".join(iterable) puts the commas and new-lines between the strings (this way we can avoid the , in the last line).

Unfortunately Ceylon has no printf functionality, which would certainly make things shorter (no .pad or .string necessary).

After finding that "straightforward" solution, I experimented with some variations, which unfortunately result in slightly longer shrinked solutions:

shared void run() {
    print(",\n".join(
            (0..23)
                *.string
                *.pad(2, '0')
                .map((x) => "'``x``:00',\n'``x``:30'")
        ));
}

(102 bytes)

shared void run() {
    print(",\n".join {
            for (h in 0..23)
                let (x = "``h``".pad(2, '0'))
                    "'``x``:00',\n'``x``:30'"
        });
}

(104 bytes)

shared void run() {
    print(",\n".join(
            (0..23)
                .map((i) => "``i``".pad(2, '0'))
                .map((x) => "'``x``:00',\n'``x``:30'")));
}

(111 bytes)

Answer 45

Burlesque, 30 bytes

Burlesque is sadly rather weak when it comes to formatting because it doesn't have a printf (yet).

23rzm{2'0lp}":00 :30"wdcp)\[uN

Details see here.

Answer 46

Pyth, 24 bytes

V24V2%"'%02d:%d0',",N*3H

Run code

V24                     for loop 0-23, N counter
  V2                    for loop 0-1, H counter
    %                   format string
      "'%02d:%d0',"     source string
      ,                 begin list tuple
        N               first element, hour
        *3H             second element, minutes

Every second iteration of the second for loop, H is 1, which toggles the minutes digit between 0 and 3.

Interpreted code generated by the debugger:

for N in num_to_range(24):
 for H in num_to_range(2):
  imp_print(mod("'%02d:%d0',",[N,times(3,H)]))

Answer 47

PHP, 104 96 bytes

for($h=$m=0;$h<24;){echo($h||$m?",\n":"")."'".($h<10?0:"")."$h:".($m*3)."0'";if($m)$h++;$m=!$m;}

exploded view

for ($h = $m = 0; $h < 24; ) {
  echo ($h || $m ? ",\n" : "") . "'" . // echoes ",\n" on all but the first loop
       ($h < 10 ? 0 : "") . "$h:" .    // leading 0 for 0:00 - 9:30
       ($m * 3) . "0'";                // :00 if $m=0, :30 if $m=1
  if ($m) $h++;                        // increments $h if :30
  $m = !$m;                            // swaps :00 <-> :30
}