Napisz program lub funkcję bez danych wejściowych, które drukują lub zwracają ciąg 24-godzinny i 12-godzinny :

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

Ciąg musi być wyprowadzany dokładnie tak , jak tu się pojawia. Jedynym wyjątkiem jest to, że opcjonalnie może mieć jeden końcowy znak nowej linii.

Tak więc skrót MD5 twojego wyjścia powinien być

827ae6e2dbb1df494930baedb3ee2653

jeśli nie masz końcowego nowego wiersza i

cd4c3d18abee9bafb495f390a919a13f

Jeśli zrobisz. (Twój skrót może być inny, jeśli Twój system używa innego rodzaju znaku nowej linii, ale to jest OK.)

Najkrótszy kod w bajtach wygrywa. Tiebreaker to wcześniejsza odpowiedź.

Bash + coreutils, 43 30

• Zaoszczędź 7 bajtów dzięki @Yossarian
• Zaoszczędź 3 bajty dzięki @AndersKaseorg

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

• seq generuje liczby całkowite 0–23, po jednej w wierszu.
• dateinterpretuje każdą linię jako datę i godzinę. Nagie liczby całkowite wydają się wystarczające do rozpoznania jako godziny dnia do dnia date. datenastępnie wypisuje za każdym razem wymagane formatowanie przy użyciu dostępnych specyfikatorów formatu czasu .

Zakłada LANG=Custawienia regionalne, zgodnie z tą meta odpowiedzią .

Ideone.

Python 2, 66 bajtów

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

C, 73 bajty

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

MIllIbyte znalazł szczególnie fajny sposób na przepisanie tej odpowiedzi. Dzięki!

MATL, 46 42 34 bajtów

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

Wcześniej 42 bajtów 12tEt:q2M/736330+t15XObZ"!b16XOhhkw14:X~Z), oraz 46 bajtów 736330 24t:qw/+t15XO' '24TX"b16XOhhk14: 12X~Z). Oczywiście 736330 nie był potrzebny, to było szalone!

Uwaga: Nie działa z TryItOnline, myślę, że istnieje problem kompatybilności między implementacją Matlaba i Octavesa datestr.

datestrpobiera reprezentację liczbową daty i konwertuje ją do reprezentacji ciągu tej daty. Pora dnia jest ułamkową częścią liczby, więc 0,0 odpowiada 0 stycznia 0000, o godzinie 00:00:00, a 1,0 odpowiada 1 stycznia 0000 o 00:00:00. 1/24 to 1 rano, 2/24 2 rano itp.

Wyjaśnienie

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

Aby pokazać, że działa w Matlabie, oto zrzut ekranu

/// , 160 bajtów

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

Wypróbuj online!

Bez golfa

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

MarioLANG, 965 834 bajtów

Wypróbuj online

to było absurdalnie skomplikowane.

Technicznie dane wyjściowe są poprawne, ale w praktyce Tio dla MarioLANG wyświetla „n” zamiast „n”, gdy wypisujemy liczbę za pomocą „:”

jeśli znajdę czas, zgadnę, że spróbuję zrobić (prawdopodobnie znacznie dłuższą) wersję programu, która poprawnie wyprowadza na Tio

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

Objaśnienie:

naszym głównym problemem jest to, że mamy 6 znaków NaN (newLine, Space,:, a, p, m)

w marioLANG, aby wydrukować postać, potrzebujemy jej wartości ascii:

• newLine ma 10
• Miejsce to 32
• : wynosi 58
• a wynosi 97
• p wynosi 112
• m wynosi 109

Pierwszą rzeczą do zrobienia jest ustawienie pamięci:

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

dzięki temu pamięć wygląda następująco:

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

zamienimy a na p podczas reszty programu

następnie robimy rzeczywiste wyjście:

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

Julia, 88 71 66 64 bajtów

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

Jest to pełny program, który drukuje ciąg z pojedynczym znakiem nowej linii.

Wypróbuj online!

Zaoszczędzono 5 bajtów dzięki Sp3000 i 2 dzięki Dennisowi!

Funkcja C #, 100 bajtów

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

Wersja bez golfa:

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() zajmuje zbyt wiele znaków!

JavaScript (ES2015), 147 138 137 134 133 bajty

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

W tej wersji skorzystałem z metody String.repeat (), aby pozbyć się długich .slice () i .join () i przeniosłem przyrost wewnątrz pętli.

Poprzednia wersja:

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

Daje wynik z końcowym znakiem nowej linii. Przetestowano w przeglądarce Firefox Scratchpad. Nie jestem pewien, czy przekazywanie argumentów do IIFE jest w porządku z regułą „bez wprowadzania danych”.

To moje pierwsze zgłoszenie, więc cześć wszystkim! :)

TSQL (SQLServer 2012) 146 124 121

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

Wypróbuj online!

Pierwsza próba, nieco dłuższa, ale jednoliniowa:

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

Wypróbuj online!

Perl 5, 58

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

JavaScript, 122 bajtów , 120 bajtów

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

Edycja: Mały błąd naprawiony + wyjście:

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 bajtów

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

Wypróbuj online!

Ponieważ wprowadzenie tego może być trudne, oto odwracalny zrzut heksowy:

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.

Wersja noncompeting jest trywialnie 2 bajty krótszy jeśli zastąpić oba wystąpienia G$z L, który miał być taki sam, ale miał problem.

Wyjaśnienie:

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 bajtów

Zaoszczędzono dwa bajty dzięki carusocomputing

Kod:

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

Wypróbuj online!

Wyjaśnienie

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 bajtów

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

Pętle zi 0..23każda pętla ustawia ciąg z -foperatorem. Pierwszy {0:D2}zapewnia, że ​​wstawiliśmy zera, drugi {1,3}gwarantuje, że mamy wypełnione spacje dla środkowej kolumny. W {0}jednym odpowiada $_na -foperatora, natomiast {1}odpowiada pseudo-trójskładnikowego która wybierze pomiędzy $_%12lub 12na podstawie tego, czy $_%12jest niezerowe, czy nie (czyli czy jesteśmy na $_=13to zdecyduje 1o 1:00 pm). Następnie łączymy to z innym pseudo-trójka, który wybiera odpowiedni am/ pm.

W przeciwieństwie do mojej odpowiedzi na liście przez cały czas w ciągu pół godziny , w rzeczywistości jest tu krócej , aby brutalnie wymuszać liczby, ponieważ otrzymujemy znacznie tańsze wypełnienie. Oto odpowiedź przy użyciu funkcji daty o długości 78 bajtów

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

C ++, 81 79 bajtów

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

Ten kod wymaga using namespace stdgdzieś go poprzedzającego.

Wykonuje pętlę na wartościach 0 ... 23. Mnoży każdą wartość przez 3600, konwertuje na tmstrukturę i drukuje ją. Format wydruku %Rgeneruje 24 godziny i minuty; drukuje formaty %li %Pwyprowadza odpowiednie 12-godzinne części; wymagają GNU .

Działająca wersja online jest tutaj .

Rubin, 66 62 bajtów

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

Nowa wersja

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

JavaScript (ES6), 119 116 bajtów

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

Sclipting, 76 bajtów

Program zakłada, że ​​wejście jest puste ( '0'lub cokolwiek, co konwertuje na liczbę całkowitą 0).

Liczba bajtów zakłada kodowanie UTF-16.

군 上 ❶ 겠 小 꼀 虛 嗎 ❷ 꾣 갰글 ❷ 결 加 곀 剩 增 ❶ 겠 小 글 虛 虛 댆밁 ⓷ 꾣갰 ⓷⓼ 곀 小 掘 닐밊 終

Nie golfowany:

군 // 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

Każda iteracja pętli pozostawia wiele małych łańcuchów na stosie; na koniec wszystkie są automatycznie łączone.

JavaScript, 97 95 bajtów

Jest to oparte na odpowiedzi StarCorder . Podziękowania dla George'a Reitha za poprawę o 2 bajty.

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

Nie golfowany:

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

Partia, 167 bajtów

@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 bajtów

Na pewno można to poprawić.

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 bajtów

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

Nieco zaskoczony, próbował zmienić ($i < 10 ? $s : "") . "$i:00"bit w funkcję, ale skończyło się na dodaniu ~ 25 znaków. Nie idź tam.

Szybki, 85 bajtów

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

Funkcja C, 82 bajty

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

Użycie, 94 bajty

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

Niegolfowany, 337 bajtów

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

działa w systemie Windows:

Program C, 85 bajtów

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 bajty

Całkiem brutalne podejście; nic sprytnego tutaj (próbowałem w kilku miejscach, ale okazało się, że jest krótszy, aby tego nie robić), po prostu chciałem dać szansę Foo. Foo automatycznie drukuje wszystko w cudzysłowie. $c10drukuje podział linii. (## ... )zapętla się, aż bieżąca komórka się wyrówna ##.

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

Ungolfed trochę:

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

Wypróbuj online

JavaScript (przy użyciu zewnętrznej biblioteki - Enumerable) (107 bajtów)

_.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 do biblioteki: https://github.com/mvegh1/Enumerable/

Objaśnienie kodu: Utwórz tablicę liczb całkowitych od 0 do 23, dla każdego napisz wiersz zgodnie z predykatem. Predykat sprawdza, czy bieżąca wartość jest mniejsza niż 10, i uzupełnia ją wartością 0, w przeciwnym razie używa bieżącej wartości bez zmian. Następnie dodaje ciąg minut. Następnie w zasadzie robi małą sztuczkę, aby przekonwertować wojsko na czas AM / PM i obsługuje wypełnianie dla AM / PM razy mniej niż 10.

SmileBASIC, 73 bajty

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

Ktoś znalazł lepszy 24-> 12-godzinny wzór niż mój stary, który oszczędza 3 bajty i 5 bajtów w innym programie

PHP, 67 65 64 bajtów

Używa kodowania IBM-850.

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

Z niekodowanym ciągiem (66 bajtów):

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

Uruchom tak:

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

Poprawki

• Zaoszczędzono 2 bajty, poprawiając format sprintf
• Zapisano bajt, pozbywając się niepotrzebnego miejsca (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

próbny