Schreiben Sie ein Programm oder eine Funktion ohne Eingabe, die diese Zeichenfolge 24-Stunden- und 12-Stunden- Mal ausgibt oder zurückgibt :

00:00 12:00am
01:00  1:00am
02:00  2:00am
03:00  3:00am
04:00  4:00am
05:00  5:00am
06:00  6:00am
07:00  7:00am
08:00  8:00am
09:00  9:00am
10:00 10:00am
11:00 11:00am
12:00 12:00pm
13:00  1:00pm
14:00  2:00pm
15:00  3:00pm
16:00  4:00pm
17:00  5:00pm
18:00  6:00pm
19:00  7:00pm
20:00  8:00pm
21:00  9:00pm
22:00 10:00pm
23:00 11:00pm

Der String muss genau so ausgegeben werden , wie er hier erscheint. Die einzige Ausnahme ist, dass es optional eine einzelne nachgestellte Newline geben kann.

So sollte der MD5-Hash Ihrer Ausgabe sein

827ae6e2dbb1df494930baedb3ee2653

wenn Sie keinen abschließenden Zeilenumbruch haben und

cd4c3d18abee9bafb495f390a919a13f

wenn Sie tun. (Ihr Hash könnte anders sein, wenn Ihr System einen anderen Newline- Typ verwendet, aber das ist in Ordnung.)

Der kürzeste Code in Bytes gewinnt. Tiebreaker ist frühere Antwort.

Bash + Coreutils, 43 30

• 7 Bytes gespart dank @Yossarian
• 3 Bytes gespart dank @AndersKaseorg

seq 0 23|date -f- +%R\ %l:00%P

• seq Erzeugt ganze Zahlen von 0 bis 23, eine pro Zeile.
• dateinterpretiert jede Zeile als Datum / Uhrzeit. Bloße ganze Zahlen scheinen ausreichend zu sein, um als Stunden des Tages von erkannt zu werden date. dateAnschließend wird jedes Mal mit der erforderlichen Formatierung unter Verwendung der verfügbaren Zeitformatspezifizierer ausgegeben .

Nimmt das LANG=CGebietsschema gemäß dieser Meta-Antwort an .

Ideone.

Python 2, 66 Bytes

for i in range(24):print'%02d:00%3d:00%sm'%(i,12+i%-12,'ap'[i>11])

C 73 Bytes

m(i){for(i=25;--i;)printf("%02d:00%3d:00%cm\n",24-i,12-i%12,"pa"[i/13]);}

mIllIbyte hat eine besonders gute Möglichkeit gefunden, diese Antwort umzuschreiben. Vielen Dank!

MATL, 46 42 34 Bytes

12tEt:qy/t15XObZ"!b16XOhhkw14:X~Z)

Zuvor 42 Byte 12tEt:q2M/736330+t15XObZ"!b16XOhhkw14:X~Z)und 46 Byte 736330 24t:qw/+t15XO' '24TX"b16XOhhk14: 12X~Z). Natürlich wurde der 736330 nicht benötigt, das war verrückt!

Hinweis: Funktioniert nicht mit TryItOnline. Ich denke, dass es ein Kompatibilitätsproblem zwischen Matlab und Octaves gibt datestr.

datestrNimmt die Zahlendarstellung eines Datums und konvertiert sie in die Zeichenfolgendarstellung dieses Datums. Die Tageszeit ist der Bruchteil der Zahl, sodass 0.0 dem 0. Januar 0000 zur Zeit 00:00:00 entspricht und 1.0 dem 1. Januar 0000 um 00:00:00 entspricht. 1/24 ist 1 Uhr morgens, 2/24 2 Uhr morgens usw.

Erläuterung

12t         % push a 12 onto the stack and duplicate
Et          % double the 12 and duplicate the 24 (stack now has 12, 24, 24, bottom to top)
:q          % make vector 1:24 and decrement by 1, stack has 12, 24, 0:23
y           % duplicate second element on stack (24)
/           % divide, for (0:23)/24
t           % duplicate elements
15XO        % string representation of date, 15 specifies format
b           % bubble up element in stack (gets a 24 on top of the stack)
Z"!         % makes a column of 24 spaces, to put between columns of times
b           % bubble up another (0:23)/24 
16XO        % string representation of date, 16 for a different format
hh          % concatenate two time vectors and the column of spaces
k           % convert string to lowercase, because CO gives AM/PM not am/pm
w           % swap elements in stack, that first 12 is now on top
14:         % vector of equally spaced values 1:14
X~          % set exclusive-or, returns [1 2 3 4 5 6 7 8 9 10 11 13 14]
Z)          % get the right columns of the string array to remove extra column of blanks
            % implicit display

Um zu zeigen, dass es in Matlab funktioniert, ist hier ein Screenshot

/// 160 Bytes

/Z/:00 //S/Z //A/:00am
//P/:00pm
/00Z12A01S1A02S2A03S3A04S4A05S5A06S6A07S7A08S8A09S9A10Z10A11Z11A12Z12P13S1P14S2P15S3P16S4P17S5P18S6P19S7P20S8P21S9P22Z10P23Z11P

Probieren Sie es online!

Ungolfed

00:00 00:00 Uhr
01:00 - 1:00 Uhr
02:00 bis 02:00 Uhr
03:00 - 3:00 Uhr
04:00 bis 04:00 Uhr
05:00 bis 05:00 Uhr
06:00 bis 06:00 Uhr
07:00 - 7:00 Uhr
08:00 bis 08:00 Uhr
09:00 - 9:00 Uhr
10:00 bis 10:00 Uhr
11:00 bis 11:00 Uhr
12:00 bis 12:00 Uhr
13.00 bis 13.00 Uhr
14:00 - 14:00 Uhr
15:00 bis 15:00 Uhr
16:00 bis 16:00 Uhr
17:00 - 17:00 Uhr
18:00 - 18:00 Uhr
19:00 bis 19:00 Uhr
20:00 bis 20:00 Uhr
21:00 - 21:00 Uhr
22:00 - 22:00 Uhr
23.00 bis 23.00 Uhr

MarioLANG, 965 834 Bytes

Probieren Sie es online aus

Nun, das war lächerlich kompliziert.

Technisch gesehen ist die Ausgabe gültig, aber in der Praxis gibt Tio for MarioLANG "n" ​​anstelle von "n" aus, wenn wir eine Zahl mit ":" ausgeben.

Wenn ich die Zeit finde, werde ich wahrscheinlich versuchen, eine (wahrscheinlich viel längere) Version des Programms zu erstellen, die korrekt auf Tio ausgegeben wird

++<>) +++@++++>   [!) >)>((((::(.)::((.))+:+:--(.)::)).).).)+++++++++
++""+ +"=====""====#) "+"============================================
+++)+ +>>+++++- <+<)->+++ ![-).).).))(::)).(:(:)))..(((::)).(:+(:((((<
+>+++ ++"====<( ")")-"!+++#=========================================="
+(+++>++!++)<+( ++++-+++++>
 -))+)=(#==="+( ++++)+++++"==========================================!
 [!!+-[!(+++!!! !+!<+!++!>(((((+:(.))::(((.
==##===#====###=#=#"=##=#"=================<
++++)))+++++++++++++++(((![-).).).)::)).(:))   >
>========================#==================   "
+>+ >
+"+ "=======================================[   =====================#===============[
+!> ! -).).).))(::)).)):+(..(((::)).(:+(((((<++!-).).).))(::)).)):+(.(((::)).(:+(((((<
=#==#======================================="==#======================================

Erklärung:

Unser Hauptproblem hierbei ist die Tatsache, dass wir 6 NaN-Zeichen haben (newLine, Space,:, a, p, m).

in marioLANG benötigen wir ihren ASCII-Wert, um Zeichen zu drucken:

• newLine ist 10
• Platz ist 32
• : ist 58
• a ist 97
• p ist 112
• m ist 109

Das erste, was zu tun ist, ist den Speicher zu setzen:

++<>) +++@++++>   [!) >)> !
++""+ +"=====""====#) "+"==
+++)+ +>>+++++- <+<)->+++ 
+>+++ ++"====<( ")")-"!+++
+(+++>++!++)<+( ++++-+++++
 -))+)=(#==="+( ++++)+++++
 [!!+-[!(+++!!! !+!<+!++!>
==##===#====###=#=#"=##=#"

damit sieht die Erinnerung so aus:

                   v   
  32 58 0 0 97 109 10 0
  _  :      a   m  \n

Wir werden a im weiteren Verlauf des Programms in p umwandeln

dann machen wir die eigentliche Ausgabe:

++<>) +++@++++>   [!) >)>((((::(.)::((.))+:+:--(.)::)).).).)+++++++++
++""+ +"=====""====#) "+"============================================
+++)+ +>>+++++- <+<)->+++ ![-).).).))(::)).(:(:)))..(((::)).(:+(:((((<
+>+++ ++"====<( ")")-"!+++#=========================================="
+(+++>++!++)<+( ++++-+++++>
 -))+)=(#==="+( ++++)+++++"==========================================!
 [!!+-[!(+++!!! !+!<+!++!>(((((+:(.))::(((.
==##===#====###=#=#"=##=#"=================<
++++)))+++++++++++++++(((![-).).).)::)).(:))   >
>========================#==================   "
+>+ >
+"+ "=======================================[   =====================#===============[
+!> ! -).).).))(::)).)):+(..(((::)).(:+(((((<++!-).).).))(::)).)):+(.(((::)).(:+(((((<
=#==#======================================="==#======================================

Julia, 88 71 66 64 Bytes

[@printf "%02d:00%3d:00%cm
" i-11 i%12+1 i>22?112:97for i=11:34]

Dies ist ein vollständiges Programm, das die Zeichenfolge mit einer einzelnen nachgestellten Zeile ausgibt.

Probieren Sie es online!

5 Bytes dank Sp3000 und 2 dank Dennis gespart!

C # -Funktion, 100 Bytes

void F(){for(int i=0;i<24;i++){Console.Write($"{i:00}:00 {(i+11)%12+1,2}:00 {(i>11?"p":"a")}m\n");}}

Ungolfed-Version:

void F()
{
    for (int i = 0; i < 24; i++)
    {
        Console.Write($"{i:00}:00 {(i + 11)%12 + 1,2}:00 {(i > 11 ? "p" : "a")}m\n");
    }
}

Console.Write() braucht zu viele Zeichen!

JavaScript (ES2015), 147 138 137 134 133 Bytes

((o,x,r)=>{for(i=0;i<24;)b=i%12,c=b||12,o+='0'[r](i<10)+i+++x+' '[r]((c<10)+1)+c+x+(i<13?'a':'p')+"m\n";return o})('',':00','repeat')

In dieser Version habe ich die String.repeat () -Methode genutzt, um langwierige .slice () und .join () zu entfernen und die Inkrementierung innerhalb der Schleife zu verschieben.

Vorherige Version:

((o,x,i)=>{for(;i<24;i++){b=i%12;o+=[`0${i+x}`.slice(-5),(b||12)+x+(i<12?'a':'p')+'m'].join(' '.repeat((b>0&&b<10)+1))+"\n"}return o})('',':00',0)

Gibt eine Ausgabe mit nachfolgender Newline aus. Getestet in Firefox Scratchpad. Ich bin nicht sicher, ob die Übergabe von Argumenten an IIFE mit der Regel "Keine Eingabe" in Ordnung ist.

Es ist meine erste Einreichung, also hallo an alle! :)

TSQL (SQL Server 2012) 146 124 121

DECLARE @ DATETIME=0WHILE @<1BEGIN PRINT
CONVERT(char(5),@,108)+' '+LOWER(RIGHT(FORMAT(@,'g'),8))SET @=dateadd(hh,1,@)END

Probieren Sie es online!

Erster Versuch, etwas länger, aber ein Einzeiler:

SELECT CONVERT(char(5),n,108)+' '+LOWER(RIGHT(FORMAT(n,'g'),8))FROM(SELECT
top 24 dateadd(hh,Number,0)n FROM master..spt_values WHERE'P'=type)x

Probieren Sie es online!

Perl 5, 58

map{printf"%02u:00%3u:00%sm
",$_,$_%12||12,$_>11?p:a}0..23

Javascript, 122 Bytes , 120 Bytes

f=j=>j>12?j-12:j;for(i=0;i<24;i++)console.log('%s:00 %s:00%s',i<10?'0'+i:i,i==0?12:f(i)<10?' '+f(i):f(i),i>11?'pm':'am')

Bearbeiten: Kleiner Fehler behoben + Ausgabe:

00:00 12:00am
01:00  1:00am
02:00  2:00am
03:00  3:00am
04:00  4:00am
05:00  5:00am
06:00  6:00am
07:00  7:00am
08:00  8:00am
09:00  9:00am
10:00 10:00am
11:00 11:00am
12:00 12:00pm
13:00  1:00pm
14:00  2:00pm
15:00  3:00pm
16:00  4:00pm
17:00  5:00pm
18:00  6:00pm
19:00  7:00pm
20:00  8:00pm
21:00  9:00pm
22:00 10:00pm
23:00 11:00pm

V , 56 53 Bytes

i00:00 23ñYpñH12G$yP13G$pgvó $/am
í/pm
í 0/  
í/12

Probieren Sie es online!

Da dies schwer einzugeben sein kann, gibt es hier einen umkehrbaren Hexdump:

00000000: 6930 303a 3030 201b 3233 f159 7001 f148  i00:00 .23.Yp..H
00000010: 1631 3247 2479 5031 3347 2470 6776 f320  .12G$yP13G$pgv. 
00000020: 242f 616d 0aed 2f70 6d0a ed20 302f 2020  $/am../pm.. 0/  
00000030: 0aed 2f31 320a                           ../12.

Eine nicht konkurrierende Version ist trivial 2 Bytes kürzer, wenn Sie beide Vorkommen von G$durch ersetzen L, die eigentlich gleich sein sollten, aber einen Fehler aufwiesen.

Erläuterung:

i00:00<esc>                                     #Enter the starting text.
           23ñYp<C-a>ñ                          #Duplicate and increment 23 times
                      H                         #Move back to the beginning
                       <C-v>12G$y               #Select 12 lines horizontally
                                 P              #Horizontally paste
                                  13G$p         #Move to line 13 and Horizontally paste again
                                       gv       #Reselect the top 12 lines
                                         ó $/am #Replace a space at the end of the line with 'am'

í/pm      #Replace the previous search with 'pm'
í 0/      #Replace "Space+0" with 2 spaces
í/12      #Replace the previous search with "12"

05AB1E , 51 50 48 44 42 Bytes

Zwei Bytes dank Carusocomputing gespart

Code:

24FNgi0}N…:00©ðN12(%12+Dgiðs}®„paN12‹è'mJ,

Probieren Sie es online!

Erläuterung

24F                                         # for N in [0...23]
   Ngi0}                                    # if len(N)=1, push 0
        N                                   # push N
         …:00©                              # push ":00" and store a copy in register
             ð                              # push " "
              N12(%12+D                     # push 2 copies of N%(-12)+12
                       giðs}                # if the length of that number is 1, 
                                            # push " " and swap with the number
                            ®               # push ":00" again
                             „pa            # push "pa"
                                N12‹è       # index into that with N<12
                                     'm     # push "m"
                                       J,   # join everything and print with newline

PowerShell v2 +, 76 Byte

0..23|%{"{0:D2}:00{1,3}:00"-f$_,(($_%12),12)[!($_%12)]+('am','pm')[$_-ge12]}

Schleifen von 0..23und jede Schleife legt eine Zeichenfolge mit dem -fOperator fest. Das erste {0:D2}stellt sicher, dass wir Nullen vorangestellt haben, das zweite {1,3}stellt sicher, dass wir Leerzeichen für die mittlere Spalte aufgefüllt haben. Der {0}eine entspricht dem $_des -fOperators, während der {1}andere dem Pseudoternären entspricht, der zwischen $_%12oder 12basierend darauf auswählt, ob er $_%12nicht Null ist oder nicht (dh, wenn wir gerade dabei sind $_=13, wird dies 1für 13:00 Uhr gewählt). Wir verketten das dann mit einem anderen Pseudoternären, der das passende am/ auswählt pm.

Im Gegensatz zu meiner Antwort auf List zu jeder Tageszeit mit einer halben Stunde ist es hier tatsächlich kürzer , die Zahlen zu brachialisieren, da wir eine deutlich billigere Polsterung erhalten. Hier ist die Antwort mit Datumsfunktionen bei 78 Bytes

0..23|%{(Date -h $_ -f 'HH:00')+(Date -h $_ -f "h:00tt").ToLower().PadLeft(8)}

C ++, 81 79 Bytes

[]{for(time_t t=0,y;t<24;cout<<put_time(gmtime(&y),"%R %l:00%P\n"))y=t++*3600;}

Dieser Code muss using namespace stdirgendwo davor stehen.

Es führt eine Schleife mit den Werten 0 ... 23 durch. Jeder Wert wird mit 3600 multipliziert, in eine tmStruktur konvertiert und gedruckt. Das Druckformat %Rgibt 24 Stunden und Minuten aus. die Druckformate %lund die %PAusgabe der richtigen 12-Stunden-Teile; Sie benötigen GNU .

Eine funktionierende Online-Version ist hier .

Ruby, 66 62 Bytes

0.upto(23){|i| puts "%02d:00%3d:00#{'ap'[i/12]}m"%[i,(i-1)%12+1]}

Neue Version

24.times{|i|puts"%02d:00%3d:00#{'ap'[i/12]}m"%[i,(i-1)%12+1]}

JavaScript (ES6), 119 bis 116 Byte

_=>Array(24).fill().map((_,i)=>`${`0${i}`.slice(-2)}:00 ${` ${(i+11)%12+1}`.slice(-2)}:00${'ap'[+(i>11)]}m`).join`
`

Sclipting, 76 Bytes

Das Programm geht davon aus, dass die Eingabe leer ist ( '0'oder irgendetwas, das in eine Ganzzahl konvertiert wird 0).

Die Byteanzahl setzt die UTF-16-Codierung voraus.

終 군 上 ❶ 終 終 終 終 終 終 終 終 終 終 終 終 終 終 終 終 終 終

Ungolfed:

군 // 23
上 // for loop (goes from 0 to 23 if input is 0)
    ❶겠小꼀虛嗎 // n < 10 ? "0" : ""
    ❷          // n
    꾣갰글      // ":00 "
    ❷결加곀剩增 // k = (n+11) % 12 + 1
    ❶겠小글虛嗎 // k < 10 ? " " : ""
    댆밁       // "pa"
    ⓷         // Pull n to top of stack
    꾣갰       // ":00"
    ⓷         // Pull "pa" to top of stack
    ⓼         // Pull k to top of stack
    곀小掘     // "pa"[k < 10 ? 1 : 0]
    닐밊       // "m\n"
終 // end of for loop

Bei jeder Iteration der Schleife verbleiben viele kleine Zeichenfolgen auf dem Stapel. am Ende werden sie alle automatisch verkettet.

JavaScript, 97 95 Bytes

Dies basiert auf der Antwort von starcorder . Vielen Dank an George Reith für eine 2-Byte-Verbesserung.

for(i=0,k=12;i<24;k=i++%12+1)console.log('%s:00 %s:00%sm',i>9?i:'0'+i,k>9?k:' '+k,i>11?'p':'a')

Ungolfed:

for (i=0, k=12; i < 24; k = (i++) % 12 + 1)
    console.log('%s:00 %s:00%sm',
        i > 9 ? i : '0' + i,
        k > 9 ? k : ' ' + k,
        i > 11 ? 'p' : 'a')

Batch, 167 Bytes

@echo off
set h=11
set p=a
for /l %%a in (0,1,23)do call:e %%a
exit/b
:e
set a=0%1
set/ah=h%%12+1
set h= %h%
if %1==12 set p=p
echo %a:~-2:00 %h:~-2%:00%p%m

Kotlin , 95 Bytes

Es kann sicher verbessert werden.

fun p(){for(i in 0..23)println("%02d:00 ${(i+11)%12+1}:00${if(i>12)"p" else "a"}m".format(i))}

PHP, 110 107 Bytes

for($h=0;$h<24;){$m=($h+11)%12+1;echo($h<10?0:"")."$h:00 ".($m<10?" ":"")."$m:00".($h++<12?"a":"p")."m\n";}

for ($h=0; $h<24; ) {
  $m = ($h+11) % 12 + 1;
  echo ($h < 10 ?  0  : "") . "$h:00 " .
       ($m < 10 ? " " : "") . "$m:00"  . ($h++ < 12 ? "a" : "p") . "m\n";
}

Etwas überrascht, versuchte er, das ($i < 10 ? $s : "") . "$i:00"Bit in eine Funktion umzuwandeln, fügte jedoch ~ 25 Zeichen hinzu. Nein, geh dorthin.

Schnell, 85 Bytes

for x in 0...23{print(String(format:"%02d:00 %2d:00\(x<12 ?"a":"p")m",x,12+x % -12))}

C Funktion, 82 Bytes

m(i){for(;i<24;printf("%02d:00 %2d:00%cm\n",i,i%12==0?12:i%12,i>11?'p':'a'),i++);}

Verwendung, 94 Byte

m(i){for(;i<24;printf("%02d:00 %2d:00%cm\n",i,i%12==0?12:i%12,i>11?'p':'a'),i++);}main(){m();}

Ungolfed, 337 Bytes

#include <stdio.h>
void m(){
    int i,a;
    char c;
    for(i=0;i<24;i++){
        if (i%12==0){
            a = 12;
        }
        else{
            a = i%12;
        }
        if (i>11){
            c = 'p';
        } else{
            c = 'a';
        }
        printf("%02d:00 %2d:00%cm\n",i,a,c);
    }
}
int main(){
    m();
}

es funktioniert unter Windows:

C Programm, 85 Bytes

main(i){for(;i<24;printf("%02d:00 %2d:00%cm\n",i,i%12==0?12:i%12,i>11?'p':'a'),i++);}

Foo, 163 Bytes

Ziemlich brachialer Ansatz; Hier gibt es nichts Kluges (ich habe es an einigen Stellen versucht, aber es wurde kürzer, es nicht zu tun), ich wollte Foo nur eine Chance geben. Foo druckt automatisch alles in Anführungszeichen. $c10druckt einen Zeilenumbruch. (## ... )Schleifen, bis die aktuelle Zelle gleich ist ##.

"00:00 12:00am"$c10+1(10"0"$i":00  "$i":00am"$c10+1)(12$i":00 "$i":00am"$c10+1)"12:00 12:00pm"$c10+1(22$i":00  ">+1$i<":00pm"$c10+1)(24$i":00 ">+1$i<":00pm"$c10+1)

Ein bisschen Ungolfed:

"00:00 12:00am"$c10+1
(10"0"$i":00  "$i":00am"$c10+1)
(12$i":00 "$i":00am"$c10+1)
"12:00 12:00pm"$c10+1
(22$i":00  ">+1$i<":00pm"$c10+1)
(24$i":00 ">+1$i<":00pm"$c10+1)

Probieren Sie es online aus

Javascript (mit externer Bibliothek - Enumerable) (107 Bytes)

_.Range(0,24).WriteLine(x=>((x<10?"0"+x:x)+":00 "+(((h=((x+11)%12)+1))<10?" "+h:h)+":00"+(x<12?"am":"pm")))

Link zur Bibliothek: https://github.com/mvegh1/Enumerable/

Codeerklärung: Erstellen Sie ein Array von Ganzzahlen von 0 bis 23, und schreiben Sie für jede Zeile eine Zeile entsprechend dem Prädikat. Dieses Prädikat überprüft, ob der aktuelle Wert kleiner als 10 ist, und füllt ihn mit 0 auf, andernfalls wird der aktuelle Wert unverändert verwendet. Dann wird die Minutenzeichenfolge hinzugefügt. Im Grunde genommen ist es dann ein kleiner Trick, das Militär in AM / PM-Zeit umzuwandeln und das Auffüllen für AM / PM-Zeiten unter 10 zu handhaben.

SmileBASIC, 73 Bytes

FOR H=0TO 23?FORMAT$(%02D:00 %2D:00%Sm",H,(H+11)MOD 12+1,"ap"[H>11])NEXT

Jemand fand eine bessere 24-> 12-Stunden-Formel als meine alte, die 3 Bytes und 5 Bytes in einem anderen Programm spart

PHP, 67 65 64 Bytes

Dies verwendet die IBM-850-Codierung.

for(;$i<24;)printf(~┌¤═ø┼¤¤┌╠ø┼¤¤┌îƧ,$i,$i%12?:12,$i++>11?p:a);

Mit der unverschlüsselten Zeichenfolge (66 Bytes):

for(;$i<24;)printf("%02d:00%3d:00%sm\n",$i,$i%12?:12,$i++>11?p:a);

Laufen Sie wie folgt:

php -n -r 'for(;$i<24;)printf(~┌¤═ø┼¤¤┌╠ø┼¤¤┌îƧ,$i,$i%12?:12,$i++>11?p:a);'

Optimierungen

• 2 Bytes gespart durch Verbesserung des Sprintf-Formats
• Ein Byte wurde gespeichert, indem unnötiger Speicherplatz entfernt wurde (thx @Titus)

tcl, 93

set i 0;time {puts [format %02d:00%3d:00[expr $i<12?"a":"p"]m $i [expr $i%-12+12]];incr i} 24

Demo