Scrivi un programma o una funzione senza input che stampa o restituisce questa stringa di 24 ore e 12 ore :

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

La stringa deve essere emessa esattamente come appare qui. L'unica eccezione è che può avere facoltativamente una sola nuova riga finale.

Quindi dovrebbe essere l' hash MD5 dell'output

827ae6e2dbb1df494930baedb3ee2653

se non si dispone di una nuova riga finale e

cd4c3d18abee9bafb495f390a919a13f

se fate. (Il tuo hash potrebbe essere diverso se il tuo sistema utilizza un altro tipo di newline ma va bene.)

Vince il codice più breve in byte. Tiebreaker è la risposta precedente.

Bash + coreutils, 43 30

• Salvato 7 byte grazie a @Yossarian
• Salvato 3 byte grazie a @AndersKaseorg

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

• seq genera numeri interi 0-23, uno per riga.
• dateinterpreta ogni riga come un datetime. Gli interi nudi sembrano essere sufficienti per essere riconosciuti come ore del giorno entro date. datequindi genera ogni volta con la formattazione richiesta utilizzando gli identificatori di formato ora disponibili .

Assume le impostazioni LANG=Clocali, come da questa meta risposta .

Ideone.

Python 2, 66 byte

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

C, 73 byte

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

mIllIbyte ha trovato un modo particolarmente accurato per riscrivere questa risposta. Grazie!

MATL, 46 42 34 byte

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

In precedenza, 42 byte 12tEt:q2M/736330+t15XObZ"!b16XOhhkw14:X~Z)e 46 byte, 736330 24t:qw/+t15XO' '24TX"b16XOhhk14: 12X~Z). Ovviamente il 736330 non era necessario, era pazzesco!

Nota: non funziona con TryItOnline, penso che ci sia un problema di compatibilità tra l'implementazione di Matlab e Octaves datestr.

datestraccetta la rappresentazione numerica di una data e la converte nella rappresentazione in formato stringa di quella data. L'ora del giorno è la parte frazionaria del numero, quindi 0,0 corrisponde allo 0 gennaio 0000, alle ore 00:00:00 e 1.0 corrisponde al 1 gennaio 0000, alle 00:00:00. 1/24 è 1am, 2/24 2am ecc.

Spiegazione

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

Per dimostrarlo funziona in Matlab, ecco uno screenshot

/// , 160 byte

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

Provalo online!

Ungolfed

00:00 12:00 am
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 am
11:00 11:00
12:00 12:00 pm
13:00 13:00
14:00 2:00 pm
15:00 3:00 pm
16:00 4:00 pm
17:00 17:00
18:00 alle 18:00
19:00 19:00
20:00 20:00
21:00 21:00
22:00 10:00 pm
23:00 23:00

MarioLANG, 965 834 byte

Provalo online

bene questo è stato ridicolmente complicato.

Tecnicamente l'output è valido ma in pratica il Tio per MarioLANG produce "n" invece di "n" quando stampiamo un numero con ':'

se trovo il tempo immagino che proverò a fare una versione (probabilmente molto più lunga) del programma che viene emessa correttamente su Tio

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

Spiegazione :

il nostro problema principale qui è il fatto che abbiamo 6 caratteri NaN (newLine, Space,:, a, p, m)

in marioLANG, per stampare il carattere, abbiamo bisogno del loro valore ASCII:

• newLine è 10
• Lo spazio è 32
• : ha 58 anni
• a è 97
• p è 112
• m è 109

Quindi la prima cosa da fare è impostare la memoria:

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

con questo, la memoria assomiglia a:

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

trasformeremo a in p durante il resto del programma

quindi eseguiamo l'output effettivo:

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

Julia, 88 71 66 64 byte

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

Questo è un programma completo che stampa la stringa con una nuova riga finale.

Provalo online!

5 byte salvati grazie a Sp3000 e 2 grazie a Dennis!

Funzione C #, 100 byte

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

Versione non golfata:

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() prende troppi personaggi!

JavaScript (ES2015), 147 138 137 134 133 byte

((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 questa versione ho sfruttato il metodo String.repeat () per sbarazzarmi dei lunghi .slice () e .join () e ho spostato l'incremento all'interno del ciclo.

Versione precedente:

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

Fornisce output con newline finale. Testato in Firefox Scratchpad. Non sono sicuro se passare argomenti a IIFE sia OK con la regola "nessun input".

È la mia prima presentazione, quindi ciao a tutti! :)

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

Provalo online!

Primo tentativo, un po 'più lungo, ma una linea:

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

Provalo online!

Perl 5, 58

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

Javascript, 122 byte , 120 byte

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

Modifica: piccolo bug risolto + output:

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 byte

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

Provalo online!

Poiché questo può essere difficile da inserire, ecco un hexdump reversibile:

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.

Una versione non competitiva è banalmente più corta di 2 byte se si sostituiscono entrambe le occorrenze di G$con L, che doveva essere la stessa ma aveva un bug.

Spiegazione:

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 byte

Salvato due byte grazie al carusocomputing

Codice:

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

Provalo online!

Spiegazione

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]}

Cicli da 0..23e ogni ciclo imposta una stringa con l' -foperatore. Il primo {0:D2}assicura che abbiamo anteposto zeri, il secondo {1,3}assicura che abbiamo spazi imbottiti per la colonna centrale. Le {0}uno corrisponde al $_di -foperatore, mentre i {1}corrisponde alla pseudo-ternari che sceglie tra $_%12o 12in base a se $_%12è diverso da zero oppure no (se siamo a $_=13, questo sceglierà 1per 01:00). Quindi concateniamo quello con un altro pseudo-ternario che sceglie l'appropriato am/ pm.

A differenza della mia risposta su List tutte le volte del giorno a una frequenza di mezz'ora , in realtà è più breve qui forzare i numeri poiché otteniamo un'imbottitura significativamente più economica. Ecco la risposta utilizzando le funzioni di data, a 78 byte

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

C ++, 81 79 byte

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

Questo codice richiede un punto using namespace stdprecedente.

Fa un ciclo sui valori 0 ... 23. Moltiplica ogni valore per 3600, si converte in una tmstruttura e la stampa. Il formato di stampa %Rgenera 24 ore e minuti; i formati di stampa %le l' %Poutput delle parti corrette di 12 ore; richiedono GNU .

Una versione online funzionante è qui .

Rubino, 66 62 byte

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

Nuova versione

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

JavaScript (ES6), 119 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 byte

Il programma presuppone che l'input sia vuoto (o '0'o qualsiasi cosa converti all'intero 0).

Il conteggio dei byte presuppone la codifica UTF-16.

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

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

Ogni iterazione del ciclo lascia molte piccole stringhe nello stack; alla fine vengono automaticamente concatenati.

JavaScript, 97 95 byte

Questo si basa sulla risposta della starcorder . Grazie a George Reith per un miglioramento di 2 byte.

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

Lotto, 167 byte

@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 byte

Di sicuro può essere migliorato.

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 byte

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

Un po 'sorpreso, ha provato a trasformare il ($i < 10 ? $s : "") . "$i:00"bit in una funzione, ma ha finito con l' aggiunta di ~ 25 caratteri. No andateci.

Rapido, 85 byte

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

Funzione C, 82 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++);}

Utilizzo, 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 byte

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

funziona su Windows:

Programma C, 85 byte

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 byte

Approccio piuttosto bruto; niente di intelligente qui (ho provato in un paio di punti, ma alla fine è stato più corto di non farlo), volevo solo provare Foo. Foo stampa automaticamente qualsiasi cosa tra virgolette. $c10stampa un'interruzione di riga. (## ... )loop fino a quando la cella corrente è uguale ##.

"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 un po ':

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

Provalo online

Javascript (utilizzando una libreria esterna - Enumerabile) (107 byte)

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

Spiegazione del codice: creare una matrice di numeri interi da 0 a 23, per ogni scrittura di una riga in base al predicato. Quel predicato controlla se val corrente è inferiore a 10 e lo riempie di 0, altrimenti usa la val corrente così com'è. Quindi aggiunge la stringa dei minuti. Quindi fondamentalmente fa un piccolo trucco per convertire i militari in ore am / pm e gestisce il riempimento per am / pm volte meno di 10.

SmileBASIC, 73 byte

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

Qualcuno ha trovato una formula 24-> 12 ore migliore della mia precedente, che consente di risparmiare 3 byte e 5 byte in un altro programma

PHP, 67 65 64 byte

Questo utilizza la codifica IBM-850.

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

Con la stringa non codificata (66 byte):

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

Esegui in questo modo:

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

Ritocchi

• Salvato 2 byte migliorando il formato sprintf
• Salvataggio di un byte eliminando lo spazio non necessario (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

dimostrazione