La réponse la plus courte l'emporte.

Il doit être trié et dans les 24 heures. La dernière ligne n'a pas de virgule.

La sortie doit être la suivante:

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

Pyth, 26 octets

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

Manifestation.

Nous commençons par le produit cartésien de range(24)( U24) avec la chaîne "03".

Ensuite, nous mappons ces valeurs à la substitution de formatage de chaîne appropriée ( m%"'%02d:%s0',"d).

Ensuite, les chaînes résultantes sont jointes sur le caractère de nouvelle ligne ( jb).

Enfin, nous supprimons la virgule de fin ( P) et imprimons.

Befunge-93, 63 octets

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

^{(animation réalisée avec BefunExec )}

Bash: 58 47 46 caractères

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

CJam, 31 30 29 octets

24,[U3]m*"'%02d:%d0',
"fe%~7<

C'est assez simple en utilisant le formatage printf:

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

Essayez-le en ligne ici

Python 2, 58 56 octets

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

Comme la réponse de sentiao mais en utilisant une forboucle, avec découpage pour supprimer la virgule. Merci à @grc d'avoir supprimé deux octets.

Java - 119 octets

J'ai commencé avec StringJoiner de Java 8, mais cela signifie inclure une instruction d'importation, j'ai donc décidé de le faire à l'ancienne:

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

Peut-être que cela peut être amélioré en se débarrassant des multiples mots String- Systemclés et occurrences.

Rubis, 94 61 56 51

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

Merci à @blutorange (encore) pour son aide au golf!

Perl, 52 50 48 45B

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

Avec l'aide de ThisSuitIsBlackNot :)

JAVA 95 94 octets

J'adore le fait que printf existe en 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 Remplacé le ','par44

Pyth, 32 31 octets

J'ai joué au golf en python, mais il s'est avéré être exactement la même chose que la réponse du Sp3000. J'ai donc décidé d'essayer Pyth:

V48<%"'%02d:%d0',",/N2*3%N2-54N

C'est une traduction exacte de la réponse Sp3000:

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

C'est mon premier essai sur Pyth, alors s'il vous plaît, éclairez-moi à propos de cette économie d'un octet.

PHP, 109 octets

foreach(new DatePeriod("R47/2015-05-07T00:00:00Z/PT30M")as$d)$a[]=$d->format("'H:i'");echo implode(",\n",$a);

Rubis, 54 51 octets

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

C, 116 , 115 , 101 , 100 , 95 , 74 , 73 , 71

Peut être en mesure de gratter quelques octets de plus de cela ...

main(a){for(;++a<50;)printf("'%02d:%d0'%s",a/2-1,a%2*3,a<49?",\n":"");}

T-SQL, 319 307 305 octets

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

Version non-golfée:

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

Pyth, 34 octets

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

Cela peut certainement être amélioré.

Essayez-le en ligne: Pyth Compiler / Executor

Explication:

     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"

Python 2, 69 octets

print',\n'.join(["'%02d:%s0'"%(h,m)for h in range(24)for m in'03'])

C'est assez évident, mais voici une explication:

• utilisation de double for-loop
• l'alternance entre '0'et '3'au format chaîne est plus courte qu'une liste
• %02d fait le rembourrage pour h
• mn'a pas besoin de rembourrage car le caractère alterné est sur une position fixe
• '\n'.join() résout les exigences de la ligne finale

Je n'ai aucune idée si cela peut être fait plus court (en Python 2).

par Sp3000, 61 octets: print',\n'.join("'%02d:%s0'"%(h/2,h%2*3)for h in range(48))

Haskell, 85 octets

putStr$init$init$unlines$take 48['\'':w:x:':':y:"0',"|w<-"012",x<-['0'..'9'],y<-"03"]

Nécessite malheureusement printfun octet 19 import, donc je ne peux pas l'utiliser.

Julia: 65 64 61 caractères

[@printf("'%02d:%d0'%s
",i/2.01,i%2*3,i<47?",":"")for i=0:47]

Julia: 64 caractères

(Conservé ici pour montrer la belle forsyntaxe de Julia .)

print(join([@sprintf("'%02d:%d0'",h,m*3)for m=0:1,h=0: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 ;)

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

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.

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?"":",");}}

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.

𝔼𝕊𝕄𝕚𝕟, 39 chars / 67 bytes (non-competing)

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

Try it here (Firefox only).

Not a single alphabetical character in sight...

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.

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 ?",":"")")}

Javascript, 89 bytes

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

Python 2: 64 bytes

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

Ruby - 52 bytes

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

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.