Bu dizeyi 24 saat ve 12 saat kez yazdıran veya döndüren girdi içermeyen bir program veya işlev yazın :

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

Dize tam olarak burada göründüğü gibi çıkarılmalıdır. Bunun tek istisnası isteğe bağlı olarak tek bir izleyen yeni hatta sahip olabilir.

Yani çıktınızın MD5 karma olması gerekir

827ae6e2dbb1df494930baedb3ee2653

Sonunda yeni bir hattınız yoksa ve

cd4c3d18abee9bafb495f390a919a13f

yaparsan. (Sisteminiz başka bir tür yeni satır kullanıyorsa karmaşanız farklı olabilir, ancak sorun değil.)

Bayt cinsinden en kısa kod kazanır. Tiebreaker daha erken bir cevaptı.

Bash + coreutils, 43 30

• @Yossarian sayesinde 7 bayt kaydedildi
• @AndersKaseorg sayesinde 3 bayt kaydedildi

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

• seq her satıra bir tane olmak üzere 0-23 tam sayılarını üretir.
• dateHer satırı bir tarih tarihi olarak yorumlar. Çıplak tamsayılar, günün saatleri olarak tanınması için yeterli görünmektedir date. datedaha sonra uygun zaman formatı belirticilerini kullanarak istenen formatta her zaman çıktılar .

Bu meta cevabıLANG=C uyarınca, yerel ayarlar varsayılır .

Ideone.

Python 2, 66 bayt

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

C, 73 bayt

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

MIllIbyte bu cevabı tekrar yazmak için çok temiz bir yol buldu. Teşekkürler!

MATL, 46 42 34 bayt

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

Önceden, 42 bayt, 12tEt:q2M/736330+t15XObZ"!b16XOhhkw14:X~Z)ve 46 bayt 736330 24t:qw/+t15XO' '24TX"b16XOhhk14: 12X~Z),. Elbette 736330'a ihtiyaç yoktu, bu delilik!

Not: TryItOnline ile çalışmıyor, Matlab ve Octaves uygulaması arasında bir uyumluluk sorunu olduğunu düşünüyorum datestr.

datestrBir tarihin sayı temsilini alır ve o tarihin dize temsiline dönüştürür. Günün saati sayının kesirli kısmıdır, yani 0.0 00:00:00, 1.0 ise 0 Ocak 0000'e, 1.0 00: 00'a 1 Ocak 0000'e karşılık gelir. 1/24 01:00, 2/24 02

açıklama

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

Matlab'da çalıştığını göstermek için, işte ekran görüntüsü

/// , 160 bayt

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

Çevrimiçi deneyin!

Ungolfed

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 1:00
14:00 2:00
15:00 3:00
16:00 4:00
17:00 5:00
18:00 18:00
19:00 7:00
20:00, 20:00
21:00 9:00
22:00, 10:00
23:00, 11:00

MarioLANG, 965 834 bayt

Çevrimiçi deneyin

peki bu gülünç karmaşıktı.

Teknik olarak çıktı geçerlidir ancak pratikte MarioLANG için Tio, ':' ile bir sayı bastığımızda "n" yerine "n" olur.

zaman bulursam, tahminimce Tio'da düzgün çıktı olan programın (muhtemelen çok daha uzun) bir sürümünü yapmaya çalışacağım.

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

Açıklama:

Buradaki asıl sorunumuzda 6 NaN karakterimiz olması (newLine, Space,:, a, p, m).

marioLANG'da karakter basmak için ascii değerine ihtiyacımız var:

• newLine 10
• Boşluk 32
• : 58
• a 97
• p 112'dir
• m 109

Yani yapılacak ilk şey hafızayı ayarlamak:

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

Bununla, hafıza gibi görünüyor:

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

Biz dönüştürecek bir içine p programının geri kalanında

o zaman gerçek çıktıyı yaparız:

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

Julia, 88 71 66 64 bayt

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

Bu, dizeyi tek bir izleyen yeni satır ile yazdıran tam bir programdır.

Çevrimiçi deneyin!

Dennis'e Sp3000 ve 2 sayesinde 5 bayt kaydedildi!

C # işlevi, 100 bayt

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

Ungolfed versiyonu:

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() çok fazla karakter alır!

JavaScript (ES2015), 147 138 137 134 133 bayt

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

Bu sürümde, uzun .slice () ve .join () yöntemlerinden kurtulmak için String.repeat () yönteminden faydalandım ve döngü içinde artan artışlar yaptım.

Önceki versiyon:

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

İzleyen yeni satır ile çıktı verir. Firefox Scratchpad'de test edilmiştir. Argümanların IIFE'ye iletilmesinin “giriş yok” kuralıyla tamam olup olmadığından emin değil.

Bu benim ilk gönderim, bu yüzden herkese merhaba! :)

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

Çevrimiçi deneyin!

İlk deneme, biraz daha uzun, ama bir liner:

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

Çevrimiçi deneyin!

Perl 5, 58

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

Javascript, 122 Bayt , 120 Bayt

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

Düzenleme: Küçük hata düzeltildi + çıktı:

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 bayt

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

Çevrimiçi deneyin!

Bu girmek zor olabileceğinden, burada geri dönüşümlü bir hexdump:

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.

Bir rakip olmayan versiyonu size her iki tekrarlamalarını değiştirmek eğer 2 kısa bayt trivially olduğu G$ile Laynı olması gerekiyordu ama bir hata vardı.

Açıklama:

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 bayt

Carusocomputing sayesinde iki bayt kurtardı

Kod:

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

Çevrimiçi deneyin!

açıklama

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 bayt

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

Dan Döngüler 0..23ve her döngü setleri ile bir dize -foperatörü. Birincisi {0:D2}, sıfırları {1,3}hazırladığımızdan, ikincisi ise orta sütun için dolgulu boşluklar olmasını sağlar. {0}Bir karşılık $_ait -foperatörü ise {1}sözde üçlü karşılık gelir arasındaki seçer $_%12veya 12olmasına bağlı olarak $_%12sıfırdan farklı olmadığını (biz de eğer yani olduğunu $_=13, bu seçecektir 11:00 için). Daha sonra concatenate, uygun seçer başka sözde üçlü ile am/ pm.

Benim cevap aksine yarım saat hızında Listesi'nde günde tüm kere , aslında daha kısa burada önemli ölçüde daha ucuz dolgu almak beri numaralar brute-zorlarlar. İşte tarih işlevlerini kullanarak, 78 baytlık cevap

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

C ++, 81 79 bayt

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

Bu kod using namespace stdondan önce bir yere ihtiyaç duyuyor .

0 ... 23 değerlerinde bir döngü yapar. Her bir değeri 3600 ile çarpar, bir tmyapıya dönüştürür ve yazdırır. Baskı formatı %R24 saatlik ve dakikayı verir; baskı , 12 saatlik parçaları biçimlendirir %lve %Pçıkarır; onlar gerektiren GNU .

Çalışan bir çevrimiçi sürüm burada .

Ruby, 66 62 bayt

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

Yeni sürüm

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

JavaScript (ES6), 119 116 bayt

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

Sclipting, 76 bayt

Program, girişin boş olduğunu (veya '0'tam sayıya dönüştüren herhangi bir şeyi) varsayar 0.

Bayt sayısı, UTF-16 kodlamasını varsayar.

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

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

Döngünün her yinelemesi yığın üzerinde çok sayıda küçük dizge bırakır; sonunda hepsi otomatik olarak birleştirilir.

JavaScript, 97 95 bayt

Bu, starcorder'ın cevabına dayanıyor . 2 baytlık bir gelişme için George Reith'e teşekkürler .

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

Toplu iş, 167 bayt

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

Elbette geliştirilebilir.

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 bayt

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

Biraz şaşırmış, ($i < 10 ? $s : "") . "$i:00"biti bir işleve dönüştürmeye çalıştı , ama ~ 25 karakter ekleyerek yaralandı . Oraya gitmek yok.

Swift, 85 bayt

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

C İşlevi, 82 bayt

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

Kullanım, 94 Bayt

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 Bayt

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

Windows'da çalışıyor:

C Programı, 85 bayt

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 bayt

Oldukça kaba kuvvet yaklaşımı; Burada zekice bir şey yok (birkaç noktada denedim ama sonuçta daha kısa olmamıştı), sadece Foo'ya bir şans vermek istedim. Foo otomatik olarak tırnak içindeki her şeyi yazdırır. $c10Satır sonu yazdırır. (## ... )geçerli hücre eşit olana kadar döngüler ##.

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

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

Çevrimiçi deneyin

Javascript (harici kütüphaneyi kullanarak - Numaralandırılabilir) (107 bayt)

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

Kütüphaneye bağlantı: https://github.com/mvegh1/Enumerable/

Kod açıklaması: 0'dan 23'e kadar bir tamsayı dizisi oluşturun, her biri için yüklemeye göre bir satır yazın. Bu, geçerli val'in 10'dan küçük olup olmadığını kontrol eder ve 0 ile doldurur, aksi takdirde geçerli val'i olduğu gibi kullanır. Sonra dakika dizesini buna ekler. O zaman temelde orduyu am / pm zamanına dönüştürmek için biraz kandırmaca ve am / pm zamanları 10'dan daha az bir süre için doldurma işlemi yapılır.

SmileBASIC, 73 bayt

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

Biri benim eskisinden 24-> 12 saat daha iyi bir formül buldu, bu da başka bir programda 3 byte ve 5 byte tasarruf sağlıyor.

PHP, 67 65 64 bayt

Bu IBM-850 kodlamasını kullanır.

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

Kodlanmamış dizeyle (66 bayt):

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

Bu şekilde koş:

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

Düzenlemeler

• Sprintf biçimini geliştirerek 2 bayt kaydedildi
• Gereksiz yerlerden kurtularak bir bayt kurtarıldı (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

gösteri