Escriba un programa o función sin entrada que imprima o devuelva esta cadena de 24 horas y 12 horas :

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 cadena debe salir exactamente como aparece aquí. La única excepción es que, opcionalmente, puede tener una nueva línea final.

Entonces el hash MD5 de su salida debería ser

827ae6e2dbb1df494930baedb3ee2653

si no tiene una nueva línea final y

cd4c3d18abee9bafb495f390a919a13f

si lo haces. (Su hash podría ser diferente si su sistema usa otro tipo de nueva línea, pero está bien).

El código más corto en bytes gana. Tiebreaker es la respuesta anterior.

Bash + coreutils, 43 30

• Guardado 7 bytes gracias a @Yossarian
• Guardado 3 bytes gracias a @AndersKaseorg

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

• seq genera enteros 0-23, uno por línea.
• dateinterpreta cada línea como una fecha y hora. Los enteros desnudos parecen ser suficientes para ser reconocidos como horas del día date. dateluego sale cada vez con el formato requerido usando los especificadores de formato de tiempo disponibles .

Asume la LANG=Cconfiguración regional, según esta meta respuesta .

Ideona

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 encontró una forma particularmente clara de reescribir esta respuesta. ¡Gracias!

MATL, 46 42 34 bytes

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

Anteriormente, 42 bytes, 12tEt:q2M/736330+t15XObZ"!b16XOhhkw14:X~Z), y 46 bytes, 736330 24t:qw/+t15XO' '24TX"b16XOhhk14: 12X~Z). Por supuesto, el 736330 no era necesario, ¡eso era una locura!

Nota: No funciona con TryItOnline, creo que hay un problema de compatibilidad entre la implementación de Matlab y Octaves datestr.

datestrtoma la representación numérica de una fecha y la convierte en la representación de cadena de esa fecha. La hora del día es la parte fraccionaria del número, por lo que 0.0 corresponde al 0 de enero de 0000 a las 00:00:00 y 1.0 corresponde al 1 de enero de 0000 a las 00:00:00. 1/24 es 1am, 2/24 2am etc.

Explicación

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

Para mostrar que funciona en Matlab, aquí hay una captura de pantalla

/// , 160 bytes

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

Pruébalo en línea!

Sin golf

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

MarioLANG, 965 834 bytes

Pruébalo en línea

Bueno, esto era ridículamente complicado.

Técnicamente, la salida es válida, pero en la práctica el Tio para MarioLANG muestra "n" en lugar de "n" cuando imprimimos un número con ':'

si encuentro el tiempo, supongo que intentaré hacer una versión (probablemente mucho más larga) del programa que salga correctamente en Tio

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

Explicacion:

Nuestro principal problema aquí es el hecho de que tenemos 6 caracteres NaN (newLine, Space,:, a, p, m)

en marioLANG, para imprimir caracteres, necesitamos su valor ascii:

• newLine es 10
• El espacio es 32
• : es 58
• a es 97
• p es 112
• m es 109

Entonces, lo primero que debe hacer es configurar la memoria:

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

con esto, el recuerdo se ve así:

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

transformaremos a en p durante el resto del programa

entonces hacemos la salida real:

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

Julia, 88 71 66 64 bytes

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

Este es un programa completo que imprime la cadena con una nueva línea final.

Pruébalo en línea!

¡Ahorré 5 bytes gracias a Sp3000 y 2 gracias a Dennis!

Función C #, 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");}}

Versión sin golf:

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() ¡Toma demasiados personajes!

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

En esta versión aproveché el método String.repeat () para deshacerme de los largos .slice () y .join () y moví el incremento dentro del bucle.

Versión previa:

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

Da salida con la nueva línea final. Probado en Firefox Scratchpad. No estoy seguro si pasar argumentos a IIFE está bien con la regla "no input".

Es mi primera presentación, ¡hola a todos! :)

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

Pruébalo en línea!

Primer intento, un poco más largo, pero de una sola línea:

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

Pruébalo en línea!

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

Editar: pequeño error corregido + salida:

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

Pruébalo en línea!

Como esto puede ser difícil de ingresar, aquí hay un hexdump reversible:

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 versión no competidores es trivialmente 2 bytes más corto si se reemplaza dos apariciones de G$la Lque se suponía que era la misma, pero tenía un error.

Explicación:

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

Ahorro de dos bytes gracias a carusocomputing

Código:

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

Pruébalo en línea!

Explicación

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 bytes

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

Bucles desde 0..23y cada bucle establece una cadena con el -foperador. El primero {0:D2}asegura que tengamos ceros antepuestos, el segundo {1,3}asegura que tengamos espacios acolchados para la columna central. El {0}uno corresponde al $_del -foperador, mientras que el {1}correspondiente al pseudoternario que elige entre $_%12o en 12función de si $_%12es distinto de cero o no (es decir, si estamos en $_=13, elegirá 1para la 1:00 pm). Luego concatenamos eso con otro pseudoternario que elige el am/ pm.

A diferencia de mi respuesta en la Lista de todas las horas del día a una velocidad de media hora , en realidad es más corto aquí para forzar los números con fuerza bruta, ya que obtenemos un relleno significativamente más barato. Aquí está la respuesta usando funciones de fecha, a 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;}

Este código requiere using namespace stdalgún lugar que lo preceda.

Hace un bucle en los valores 0 ... 23. Multiplica cada valor por 3600, lo convierte en una tmestructura y lo imprime. El formato de impresión %Rgenera las 24 horas y los minutos; los formatos de impresión %ly la %Psalida de las piezas adecuadas de 12 horas; requieren GNU .

Una versión en línea que funciona está aquí .

Ruby, 66 62 bytes

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

Nueva versión

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

JavaScript (ES6), 119116 bytes

_=>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

El programa asume que la entrada está vacía ( '0'o cualquier cosa que se convierta al entero 0).

El recuento de bytes supone la codificación UTF-16.

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

Sin golf:

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

Cada iteración del bucle deja muchas cadenas pequeñas en la pila; Al final, todos se concatenan automáticamente.

JavaScript, 97 95 bytes

Esto se basa en la respuesta de Starcorder . Gracias a George Reith por una mejora de 2 bytes.

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

Sin golf:

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

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

Se puede mejorar con seguridad.

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

Algo sorprendido, trató de convertir el ($i < 10 ? $s : "") . "$i:00"bit en una función, pero terminó agregando ~ 25 caracteres. No vayas allí.

Rápido, 85 bytes

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

Función C, 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++);}

Uso, 94 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++);}main(){m();}

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

Funciona en Windows:

Programa C, 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

Bastante enfoque de fuerza bruta; nada inteligente aquí (lo intenté en un par de lugares pero terminó siendo más corto para no hacerlo), solo quería darle una oportunidad a Foo. Foo imprime automáticamente cualquier cosa entre comillas. $c10imprime un salto de línea. (## ... )bucles hasta que la celda actual es igual ##.

"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 poco:

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

Pruébalo en línea

Javascript (usando una biblioteca externa - 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")))

Enlace a la biblioteca: https://github.com/mvegh1/Enumerable/

Explicación del código: cree una matriz de enteros del 0 al 23, para cada uno escriba una línea de acuerdo con el predicado. Ese predicado verifica si el valor actual es menor que 10 y lo rellena con 0; de lo contrario, utiliza el valor actual tal como está. Luego agrega la cadena de minutos. Luego, básicamente, hace un pequeño truco para convertir a los militares en horario de am / pm, y maneja el relleno para am / pm veces menos de 10.

SmileBASIC, 73 bytes

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

Alguien encontró una mejor fórmula de 24-> 12 horas que la anterior, que ahorra 3 bytes y 5 bytes en otro programa

PHP, 67 65 64 bytes

Esto utiliza la codificación IBM-850.

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

Con la cadena sin codificar (66 bytes):

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

Corre así:

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

Ajustes

• Ahorró 2 bytes al mejorar el formato sprintf
• Ahorró un byte al deshacerse del espacio innecesario (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

manifestación