Kürzeste Antwort gewinnt.

Es muss sortiert sein und innerhalb von 24 Stunden. Die letzte Zeile enthält kein Komma.

Die Ausgabe sollte wie folgt sein:

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

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

Demonstration.

Wir beginnen mit dem kartesischen Produkt von range(24)( U24) mit der Zeichenkette "03".

Anschließend ordnen wir diese Werte der entsprechenden Zeichenfolge zu, die die Substitution ( m%"'%02d:%s0',"d) bildet.

Anschließend werden die resultierenden Zeichenfolgen mit dem Zeilenumbruchzeichen ( jb) verbunden.

Zum Schluss entfernen wir das nachstehende Komma ( P) und drucken.

Befunge-93, 63 Bytes

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

^{(Animation gemacht mit BefunExec )}

Bash: 58 47 46 Zeichen

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

CJam, 31 30 29 Bytes

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

Mit printf-Formatierung geht das ganz einfach:

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

Probieren Sie es hier online aus

Python 2, 58 56 Bytes

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

Wie die Antwort von sentiao, aber mit einer forSchleife, bei der das Komma entfernt wird. Vielen Dank an @grc für das Ausschalten von zwei Bytes.

Java - 119 Bytes

Ich habe mit dem StringJoiner von Java 8 angefangen, aber das bedeutet, dass ich eine import-Anweisung einfügte. Deshalb habe ich beschlossen, es auf die alte Weise zu tun:

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

Vielleicht kann dies verbessert werden, indem die mehrfachen Vorkommen Stringund SystemSchlüsselwörter beseitigt werden.

Ruby, 94 61 56 51

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

Vielen Dank an @blutorange (wieder) für seine Hilfe beim Golfen!

Perl, 52, 50, 48, 45B

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

Mit Hilfe von ThisSuitIsBlackNot :)

JAVA 95 94 Bytes

Ich liebe die Tatsache, dass printf in Java existiert:

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 Ersetzt das ','mit44

Pyth, 32 31 Bytes

Ich habe etwas in Python gespielt, aber es stellte sich heraus, dass es genau so war wie die Antwort von Sp3000. Also habe ich beschlossen, es mit Pyth zu versuchen:

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

Es ist eine genaue Übersetzung der Sp3000-Antwort:

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

Es ist mein erster Versuch in Pyth, also klären Sie mich bitte über diese 1-Byte-Einsparung auf.

PHP, 109 Bytes

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

Ruby, 54 51 Bytes

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

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

Ist möglicherweise in der Lage, ein paar weitere Bytes davon abzukratzen ...

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

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

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

Pyth, 34 Bytes

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

Dies kann definitiv verbessert werden.

Probieren Sie es online aus: Pyth Compiler / Executor

Erläuterung:

     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 Bytes

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

Ganz offensichtlich, aber hier ist eine Erklärung:

• mit double-for-loop
• Das Wechseln zwischen '0'und '3'im Zeichenfolgenformat ist kürzer als eine Liste
• %02d macht die Polsterung für h
• mEs ist kein Auffüllen erforderlich, da sich das abwechselnde Zeichen an einer festen Position befindet
• '\n'.join() löst die Final-Line-Anforderungen

Ich habe keine Ahnung, ob es kürzer geht (in Python 2).

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

Haskell, 85 Bytes

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

Benötigt leider printfein 19 Byte import, daher kann ich es nicht verwenden.

Julia: 65 64 61 Zeichen

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

Julia: 64 Zeichen

(Hier gehalten, um Julias nette forSyntax zu zeigen .)

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

Standardmissbrauch von Typen & Voraussetzung nur für das Final endzum Kompilieren. Leider ist aufgrund der impliziten Formatierung '(a)'die printAngabe in der Schlusserklärung erforderlich. Trotzdem besser als die C und C ++ Antworten;)

JavaScript (ES6), 77 86 + 1 Byte

Wusste nicht, dass es in jeder Zeile Anführungszeichen geben muss (+1 ist für -pFlag mit Knoten):

"'"+Array.from(Array(48),(d,i)=>(i>19?"":"0")+~~(i/2)+":"+3*(i&1)+0).join("',\n'")+"'"

alte Lösung:

Array.from(Array(48),(d,i)=>~~(i/2).toFixed(2)+":"+3*(i&1)+"0").join(",\n")

ungolfed version (mit einem for loop statt 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 Zeichen

~@n=0,47w(S.q("'%02d:%d0'%c",n/2,n%2*3,n<47&44|0))$

Verwenden von ASCII 44 = , und 0 speichert ein Leerzeichen ein Zeichen.

Eine ungolfed Lua Version wäre

for h=0,47 do
   print(string.format("'%02d:%d0'%c",h/2,h%2*3, if h<47 and 44 or 0))
end

Die ifAnweisung ist dem ternären Operator sehr ähnlich a > b ? 44 : 0.

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

Probieren Sie es hier online aus .

𝔼𝕊𝕄𝕚𝕟, 39 Zeichen / 67 Byte (nicht konkurrierend)

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

Try it here (Firefox only).

Kein einziges alphabetisches Zeichen in Sicht ...

PHP, 69 70 62 Bytes

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

Probieren Sie es online aus

Ausgabe '23:30' am Ende ist etwas lahm und schließt den PHP-Kontext mit, ?>ohne ihn zu öffnen oder erneut zu öffnen. Eine sauberere Alternative (aber 65 Bytes) wäre:

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

Probieren Sie es online aus

Danke @Dennis für die Tipps. Alternative inspiriert durch den Beitrag von @ ismael-miguel.

Schnell, 74 Bytes

Aktualisiert für Swift 2/3 ... und mit neuer 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

Wir generieren eine 2-zeilige Zeichenfolge für jede Stunde unter Verwendung der Textformatierung:

print',\n'.join("'%02u:00',\n'%02u:30'"%(h,h)for h in range(24))

Dieser Code ist ziemlich klar, aber die clevere Indizierungs- und Ganzzahl-Mathematik in der Antwort von Sp3000 bietet eine kürzere Lösung.