Écrivez un programme ou une fonction sans entrée qui imprime ou renvoie cette chaîne de 24 heures et de 12 heures :

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 chaîne doit être sortie exactement telle qu'elle apparaît ici. La seule exception est qu'il peut éventuellement avoir une seule nouvelle ligne de fin.

Le hachage MD5 de votre sortie doit donc être

827ae6e2dbb1df494930baedb3ee2653

si vous ne disposez pas d'un saut de ligne et

cd4c3d18abee9bafb495f390a919a13f

si tu fais. (Votre hachage peut être différent si votre système utilise un autre type de nouvelle ligne mais c'est OK.)

Le code le plus court en octets gagne. Tiebreaker est une réponse antérieure.

Bash + coreutils, 43 30

• 7 octets enregistrés grâce à @Yossarian
• Enregistré 3 octets grâce à @AndersKaseorg

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

• seq génère des entiers 0-23, un par ligne.
• dateinterprète chaque ligne comme un datetime. Les entiers nus semblent suffisants pour être reconnus comme des heures de la journée par date. datesort ensuite à chaque fois avec la mise en forme requise en utilisant les spécificateurs de format d'heure disponibles .

Suppose des LANG=Cparamètres régionaux, selon cette méta-réponse .

Ideone.

Python 2, 66 octets

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

C, 73 octets

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

mIllIbyte a trouvé un moyen particulièrement soigné de réécrire cette réponse. Merci!

MATL, 46 42 34 octets

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

Auparavant, 42 octets, 12tEt:q2M/736330+t15XObZ"!b16XOhhkw14:X~Z)et 46 octets 736330 24t:qw/+t15XO' '24TX"b16XOhhk14: 12X~Z). Bien sûr, le 736330 n'était pas nécessaire, c'était fou!

Remarque: ne fonctionne pas avec TryItOnline, je pense qu'il y a un problème de compatibilité entre l'implémentation de Matlab et Octaves datestr.

datestrprend la représentation numérique d'une date et la convertit en représentation sous forme de chaîne de cette date. L'heure du jour est la partie fractionnaire du nombre, donc 0,0 correspond au 0 janvier 0000, à l'heure 00:00:00, et 1.0 correspond au 1er janvier 0000, à 00:00:00. 1/24 est 1h du matin, 2/24 2h du matin etc.

Explication

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

Pour montrer que cela fonctionne dans Matlab, voici une capture d'écran

/// , 160 octets

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

Essayez-le en ligne!

Non golfé

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

MarioLANG, 965 834 octets

Essayez-le en ligne

eh bien, c'était ridiculement compliqué.

Techniquement, la sortie est valide, mais en pratique, la sortie Tio pour MarioLANG "n" ​​au lieu de "n" lorsque nous imprimons un nombre avec ':'

si je trouve le temps, je suppose que je vais essayer de faire une version (probablement beaucoup plus longue) du programme qui sort correctement sur Tio

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

Explication:

notre principal problème ici est le fait que nous avons 6 caractères NaN (newLine, Space,:, a, p, m)

dans marioLANG, pour imprimer des caractères, nous avons besoin de leur valeur ascii:

• newLine a 10 ans
• L'espace est de 32
• : est 58
• a est 97
• p est 112
• m est 109

La première chose à faire est donc de régler la mémoire:

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

avec cela, la mémoire ressemble à:

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

nous transformerons a en p pendant le reste du programme

puis nous faisons la sortie réelle:

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

Julia, 88 71 66 64 octets

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

Il s'agit d'un programme complet qui imprime la chaîne avec une seule nouvelle ligne de fin.

Essayez-le en ligne!

5 octets enregistrés grâce à Sp3000 et 2 grâce à Dennis!

Fonction C #, 100 octets

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

Version non golfée:

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() prend trop de caractères!

JavaScript (ES2015), 147 138 137 134 133 octets

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

Dans cette version, j'ai profité de la méthode String.repeat () pour se débarrasser des longs .slice () et .join () et déplacé l'incrémentation dans la boucle.

La version précédente:

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

Donne une sortie avec une nouvelle ligne de fin. Testé dans Firefox Scratchpad. Je ne sais pas si la transmission d'arguments à IIFE est OK avec la règle "pas d'entrée".

C'est ma première soumission, alors bonjour à tous! :)

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

Essayez-le en ligne!

Première tentative, un peu plus longue, mais à une ligne:

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

Essayez-le en ligne!

Perl 5, 58

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

Javascript, 122 octets , 120 octets

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

Edit: Petit bug corrigé + sortie:

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 octets

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

Essayez-le en ligne!

Comme cela peut être difficile à saisir, voici un hexdump réversible:

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.

Une version non concurrente est trivialement 2 octets plus courte si vous remplacez les deux occurrences de G$parL , qui était censé être le même mais qui avait un bogue.

Explication:

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 octets

Enregistrement de deux octets grâce à carusocomputing

Code:

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

Essayez-le en ligne!

Explication

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 octets

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

Les boucles de 0..23et chaque boucle définissent une chaîne avec l' -fopérateur. Le premier {0:D2}garantit que nous avons des zéros ajoutés, le second {1,3}garantit que nous avons des espaces rembourrés pour la colonne du milieu. L' {0}un correspond à celui $_de l' -fopérateur, tandis que le {1}correspond au pseudo-ternaire qui choisit entre $_%12ou 12selon qu'il $_%12est différent de zéro ou non (c'est-à-dire, si nous y sommes $_=13, cela choisira 1pour 13 h). Nous concaténons ensuite cela avec un autre pseudo-ternaire qui choisit le am/ approprié pm.

Contrairement à ma réponse sur List toutes les heures de la journée à un taux d'une demi-heure , il est en fait plus court ici de forcer les chiffres, car nous obtenons un rembourrage beaucoup moins cher. Voici la réponse en utilisant les fonctions de date, à 78 octets

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

C ++, 81 79 octets

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

Ce code nécessite using namespace stdquelque part le précédant.

Il fait une boucle sur les valeurs 0 ... 23. Il multiplie chaque valeur par 3600, convertit en une tmstructure et l'imprime. Le format d'impression %Raffiche les 24 heures et les minutes; les formats d'impression %let la %Psortie des pièces de 12 heures appropriées; ils ont besoin de GNU .

Une version en ligne fonctionnelle est ici .

Rubis, 66 62 octets

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

Nouvelle version

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

JavaScript (ES6), 119 116 octets

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

Sclipting, 76 octets

Le programme suppose que l'entrée est vide (ou '0'ou tout ce qui se convertit en entier 0).

Le nombre d'octets suppose un codage UTF-16.

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

Non 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

Chaque itération de la boucle laisse beaucoup de petites chaînes sur la pile; à la fin, ils sont tous automatiquement concaténés.

JavaScript, 97 95 octets

Ceci est basé sur la réponse de Starcorder . Merci à George Reith pour une amélioration de 2 octets.

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

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

Lot, 167 octets

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

Il peut être amélioré à coup sûr.

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 octets

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 peu surpris, a essayé de transformer le ($i < 10 ? $s : "") . "$i:00"bit en fonction, mais il a fini par ajouter environ 25 caractères. Non, allez-y.

Swift, 85 octets

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

Fonction C, 82 octets

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

Utilisation, 94 octets

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

Non golfé, 337 octets

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

cela fonctionne sous Windows:

Programme C, 85 octets

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 octets

Approche assez brutale; rien d'intelligent ici (j'ai essayé à quelques endroits mais cela a fini par être plus court pour ne pas le faire), je voulais juste essayer Foo. Foo imprime automatiquement tout ce qui se trouve entre guillemets. $c10imprime un saut de ligne. (## ... )boucles jusqu'à ce que la cellule actuelle soit égale ##.

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

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

Essayez-le en ligne

Javascript (en utilisant une bibliothèque externe - énumérable) (107 octets)

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

Lien vers la bibliothèque: https://github.com/mvegh1/Enumerable/

Explication du code: créez un tableau d'entiers de 0 à 23, pour chaque écriture une ligne en fonction du prédicat. Ce prédicat vérifie si la valeur actuelle est inférieure à 10 et le remplit avec 0, sinon utilise la valeur actuelle telle quelle. Ajoute ensuite la chaîne des minutes. Ensuite, il fait essentiellement une petite ruse pour convertir les militaires en heure am / pm, et gère le rembourrage pour am / pm fois moins de 10.

SmileBASIC, 73 octets

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

Quelqu'un a trouvé une meilleure formule de 24 à 12 heures que l'ancienne, qui enregistre 3 octets et 5 octets dans un autre programme

PHP, 67 65 64 octets

Cela utilise le codage IBM-850.

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

Avec la chaîne non codée (66 octets):

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

Courez comme ceci:

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

Tweaks

• Enregistré 2 octets en améliorant le format sprintf
• Enregistrement d'un octet en supprimant l'espace inutile (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

démo