Godziny 24 i 12 godzin

24

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ź.

Hobby Calvina
źródło

Odpowiedzi:

13

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.

Cyfrowa trauma
źródło
2
Możesz nawet zrobić seq 0 23i zapisać 7 bajtów
Yossarian
1
I %H:00%Rzapisuje kolejne 3.
Anders Kaseorg
@AndersKaseorg, nop, %Rwstawia wiodące zero, którego nie chce OP.
rexkogitans
@rexkogitans zerem jest chcieliśmy (w pierwszej kolumnie, która jest jednym mówię).
Anders Kaseorg
@AndersKaseorg, och, mówiłeś o pierwszym ... oczywiście masz rację. Poprawiłem mój komentarz powyżej.
rexkogitans
12

Python 2, 66 bajtów

for i in range(24):print'%02d:00%3d:00%sm'%(i,12+i%-12,'ap'[i>11])
kennytm
źródło
1
modulo -12 jest sprytny!
Erik the Outgolfer
Na wypadek, gdyby ktoś się zastanawiał: i=0;exec"print'%02d:00%3d:00%cm'%(i,~-i%12+1,97+i/12*15);i+=1;"*24zmienia kod na trzy różne sposoby, ale każda zmiana ma tę samą długość.
Sp3000
8

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!

Lynn
źródło
Fajnie - nigdy nie wiedziałem o?:
Digital Trauma
Nie wiedziałem! Ciekawy. Naprawiłem to :)
Lynn
Achh, cóż , uważam, że ?:jest to najbliższy odpowiednik Perla ||. C ||jest bardziej podobny (a || b) ? 1 : 0.
Lynn
1
i++,i%12?:12,"ap"[i/12])brakuje punktu sekwencyjnego. Nie można być pewnym, kiedy i++nastąpi. Być możefor(i=0;i<24;i++) ...i,i%12?:12,"ap"[i/12]...
chux
i++<24jest lepszy - nie dodaje więcej bajtów do kodu źródłowego
anatolyg
6

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

wprowadź opis zdjęcia tutaj

David
źródło
5

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

Erik the Outgolfer
źródło
Ciekawostka: przekształcenie :00zamiennika jest o jeden bajt dłużej ... TIO
steenbergh
@steenbergh To dlatego, że :00jest 3-bajtowym ciągiem, który pojawia się 3 razy. 3 × 3 = 9, wykonanie wymiany w twoim przypadku kosztuje 3 + 1 + 3 = 7, ponieważ używa 1-bajtowego aliasu, a używasz go 3 razy, więc 7 + 3 = 10. 9 <10, więc nie wymienię go.
Erik the Outgolfer
5

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:

++<>) +++@++++>   [!) >)>((((::(.)::((.))+:+:--(.)::)).).).)+++++++++
++""+ +"=====""====#) "+"============================================
+++)+ +>>+++++- <+<)->+++ ![-).).).))(::)).(:(:)))..(((::)).(:+(:((((<
+>+++ ++"====<( ")")-"!+++#=========================================="
+(+++>++!++)<+( ++++-+++++>
 -))+)=(#==="+( ++++)+++++"==========================================!
 [!!+-[!(+++!!! !+!<+!++!>(((((+:(.))::(((.
==##===#====###=#=#"=##=#"=================<
++++)))+++++++++++++++(((![-).).).)::)).(:))   >
>========================#==================   "
+>+ >
+"+ "=======================================[   =====================#===============[
+!> ! -).).).))(::)).)):+(..(((::)).(:+(((((<++!-).).).))(::)).)):+(.(((::)).(:+(((((<
=#==#======================================="==#======================================
Ether Frog
źródło
4

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!

Alex A.
źródło
4

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!

STLDev
źródło
Witaj i witaj w PPCG! Używam trochę C #, ale co prowadzi $do łańcucha?
NoOneIsHere
3
@NoOneIsHere - To się nazywa „interpolacja ciągów” i jest to nowa funkcja w C # 6.0. Możesz przeczytać więcej na ten temat tutaj https://msdn.microsoft.com/en-us/library/dn961160.aspx .
STLDev
3

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! :)

Leibrug
źródło
3

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!

t-clausen.dk
źródło
1
Zmniejszony do 121 znaków: spróbuj online
Ross Presser
@RossPresser jeszcze raz pomogłeś mi, ucząc się dużo tutaj
t-clausen.dk
2

Perl 5, 58

map{printf"%02u:00%3u:00%sm
",$_,$_%12||12,$_>11?p:a}0..23
msh210
źródło
2

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
StarCorder
źródło
2

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"
DJMcMayhem
źródło
2

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
Emigna
źródło
codegolf.stackexchange.com/questions/103242/… ;). Pytanie, czy można to zoptymalizować poniżej 50, jest już kwestią haha.
Magic Octopus Urn
23Ýzamiast 24L<na 1 bajt. A jak długo ëistnieje? Czuję się tak głupio, że do tej pory nie wiedziałem o innych stwierdzeniach w 05AB1E.
Magic Octopus Urn
@carusocomputing: Dzięki! jeszcze istniało od jakiegoś czasu, ale czasami było wadliwe. Zwłaszcza podczas zagnieżdżania ifs.
Emigna
1

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)}
AdmBorkBork
źródło
1

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 .

anatolig
źródło
1

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]}
Gosha U.
źródło
1
24.timesjest krótszy. Nie ma potrzeby otaczania przestrzeni puts.
manatwork
Można wymienić (i-1)ze ~-iprzez 2 bajty.
Jordan
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`
`
Tylko ASCII
źródło
1

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.

Timwi
źródło
1

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')
Timwi
źródło
Możesz zapisać 2 bajty, przepisując n < 10jako 9 < ni zmieniając trójskładnikowe skrzynki
George Reith,
1

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
Neil
źródło
1

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))}
Rames
źródło
0

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";}
widok rozstrzelony
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.

ricdesi
źródło
0

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))}
GoatInTheMachine
źródło
To nie działa, przynajmniej nie dla mnie w Swift 2.2. Wyjście
JAL
Musiałem zmienić ciąg formatu:String(format: "%02d:00 %2d:00\(x<12 ?"a":"p")m", x, x%12 != 0 ? x%12 : 12)
JAL
0

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:

w ostrzeżeniu można znaleźć cały program

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++);}
Giacomo Garabello
źródło
Może być konieczna inicjalizacja i=0wersji funkcji. A w przypadku wersji programu możesz włożyć kod bezpośrednio do main- nie ma potrzeby definiowania tam funkcji!
anatolyg
Dzięki! edytowane !! FYI: W wersji funcion, jeśli używasz jej bez parametrów, jest ona automatycznie inicjowana na 0!
Giacomo Garabello,
i%12==0?12:i%12->i%12?i%12:12
chux - Przywróć Monikę
„W wersji funcion, jeśli używasz jej bez parametrów, jest ona automatycznie inicjowana na 0!” To nie wydaje się być standardem C. Czy jest jakieś odniesienie do tego?
chux - Przywróć Monikę
zauważyłem, że działa tylko na gcc, które zainstalowałem w moim systemie Windows .. mój znajomy z Linuksem powiedział mi, że to nie działa na jego komputerze, ale nie wiem, jak to naprawić dla Linuksa ...
Giacomo Garabello
0

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

SnoringFrog
źródło
0

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.

wprowadź opis zdjęcia tutaj

applejacks01
źródło
0

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

12Me21
źródło
0

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)
aross
źródło
Możesz użyć -nzamiast -d error_reporting=30709. Przed am/ nie powinno być spacji pm. Zapisz jeden bajt w niezakodowanej wersji z fizycznym podziałem wiersza.
Tytus
0

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

sergiol
źródło