Viết chương trình hoặc hàm không có đầu vào in hoặc trả về chuỗi thời gian 24 giờ và 12 giờ này :

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

Chuỗi phải được xuất chính xác như nó xuất hiện ở đây. Ngoại lệ duy nhất là nó có thể tùy chọn có một dòng mới duy nhất.

Vì vậy, hàm băm MD5 của đầu ra của bạn phải là

827ae6e2dbb1df494930baedb3ee2653

nếu bạn không có một dòng mới và

cd4c3d18abee9bafb495f390a919a13f

nếu bạn làm. (Băm của bạn có thể khác nếu hệ thống của bạn sử dụng một loại dòng mới nhưng không sao.)

Mã ngắn nhất tính bằng byte thắng. Tiebreaker là câu trả lời trước đó.

Bash + coreutils, 43 30

• Đã lưu 7 byte nhờ @Yossarian
• Đã lưu 3 byte nhờ @AndersKaseorg

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

• seq tạo các số nguyên 0-23, mỗi số một dòng.
• datediễn giải mỗi dòng là một datetime. Số nguyên trần dường như đủ để được công nhận là giờ trong ngày date. datesau đó xuất ra mỗi lần với định dạng được yêu cầu bằng cách sử dụng các chỉ định định dạng thời gian có sẵn .

Giả sử LANG=Cmiền địa phương, theo câu trả lời meta này .

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 tìm thấy một cách đặc biệt gọn gàng để viết lại câu trả lời này. Cảm ơn!

MATL, 46 42 34 byte

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

Trước đây, 42 byte 12tEt:q2M/736330+t15XObZ"!b16XOhhkw14:X~Z), và 46 byte , 736330 24t:qw/+t15XO' '24TX"b16XOhhk14: 12X~Z). Tất nhiên 736330 không cần thiết, điều đó thật điên rồ!

Lưu ý: Không hoạt động với TryItOnline, tôi nghĩ có vấn đề tương thích giữa việc triển khai Matlab và Octaves datestr.

datestrlấy đại diện số của một ngày và chuyển đổi nó thành biểu diễn chuỗi của ngày đó. Thời gian trong ngày là phần phân số của số, vì vậy 0,0 Corrsponds đến 0 tháng 1, 0000, tại thời điểm 00:00:00 và 1.0 tương ứng với ngày 1 tháng 1, 0000, lúc 00:00:00. 1/24 là 1 giờ sáng, 2/24 2 giờ sáng, v.v.

Giải trình

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

Để hiển thị nó hoạt động trong Matlab, đây là một ảnh chụp màn hình

/// , 160 byte

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

Hãy thử trực tuyến!

Bị đánh cắp

00:00 12:00 sáng
01:00 1:00 sáng
02:00 2:00 sáng
03:00 3:00 sáng
04:00 4:00 sáng
05:00 5:00 sáng
06:00 6:00 sáng
07:00 7:00 sáng
08:00 8:00 sáng
09:00 9:00
10:00 10:00
11:00 11:00
12:00 12:00 chiều
13:00 1:00 chiều
14:00 2:00 chiều
15:00 3:00 chiều
16:00 4:00 chiều
17:00 5:00 chiều
18:00 6:00 chiều
19:00 7:00 tối
20:00 8:00 tối
21:00 9:00 tối
22:00 10:00 tối
23:00 11:00 tối

MarioLANG, 965 834 byte

Dùng thử trực tuyến

Vâng, điều này là vô cùng phức tạp.

Về mặt kỹ thuật, đầu ra là hợp lệ nhưng trong thực tế, đầu ra Tio cho MarioLANG "n" ​​thay vì "n" khi chúng tôi in một số bằng ':'

nếu tôi tìm thấy thời gian tôi sẽ đoán tôi sẽ cố gắng thực hiện một phiên bản (có thể dài hơn nhiều) của chương trình xuất ra chính xác trên Tio

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

Giải trình :

vấn đề chính của chúng ta ở đây là thực tế là chúng ta có 6 NaN char (newLine, Space,:, a, p, m)

trong marioLANG, để in ký tự, chúng ta cần giá trị ascii của chúng:

• newLine là 10
• Không gian là 32
• : là 58
• a là 97
• p là 112
• m là 109

Vì vậy, điều đầu tiên cần làm là thiết lập bộ nhớ:

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

với điều này, bộ nhớ trông như:

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

chúng tôi sẽ chuyển đổi một thành p trong phần còn lại của chương trình

sau đó chúng tôi thực hiện đầu ra thực tế:

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

Julia, 88 71 66 64 byte

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

Đây là một chương trình đầy đủ in chuỗi với một dòng mới duy nhất.

Hãy thử trực tuyến!

Đã lưu 5 byte nhờ Sp3000 và 2 nhờ Dennis!

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

Phiên bản bị đánh cắp:

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() mất quá nhiều nhân vật!

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

Trong phiên bản này, tôi đã tận dụng phương thức String.repeat () để loại bỏ .slice () và .join () dài và di chuyển gia tăng bên trong vòng lặp.

Phiên bản trước:

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

Cung cấp đầu ra với dòng mới. Đã thử nghiệm trong Firefox Scratchpad. Không chắc chắn nếu truyền đối số cho IIFE có ổn với quy tắc "không nhập" không.

Đây là lần gửi đầu tiên của tôi, xin chào tất cả mọi người! :)

TSQL (Máy chủ SQL 2012) 146 124 121

DECLARE @ DATETIME=0WHILE @<1BEGIN PRINT
CONVERT(char(5),@,108)+' '+LOWER(RIGHT(FORMAT(@,'g'),8))SET @=dateadd(hh,1,@)END

Hãy thử trực tuyến!

Lần thử đầu tiên, lâu hơn một chút, nhưng một lớp lót:

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

Hãy thử trực tuyến!

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

Chỉnh sửa: Sửa lỗi nhỏ + đầu ra:

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

Hãy thử trực tuyến!

Vì điều này có thể khó nhập, đây là một hexdump có thể đảo ngược:

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.

Một phiên bản không cấu hình ngắn hơn 2 byte nếu bạn thay thế cả hai lần xuất hiện G$bằng L, được cho là giống nhau nhưng có lỗi.

Giải trình:

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

Đã lưu hai byte nhờ tính toán carusocomputing

Mã số:

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

Hãy thử trực tuyến!

Giải trình

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

Vòng lặp từ 0..23và mỗi vòng lặp thiết lập một chuỗi với -ftoán tử. Cái đầu tiên {0:D2}đảm bảo chúng ta có các số 0 được chuẩn bị trước, cái thứ hai {1,3}đảm bảo chúng ta có các khoảng đệm cho cột giữa. Các {0}một tương ứng với $_các -fnhà điều hành, trong khi {1}tương ứng với pseudo-ternary cho phép lựa chọn giữa $_%12hoặc 12dựa vào việc $_%12không phải là zero hay không (ví dụ, nếu chúng ta đang ở $_=13, điều này sẽ chọn 1cho 1:00). Sau đó, chúng tôi kết hợp điều đó với một giả ba khác mà chọn phù hợp am/ pm.

Trái ngược với câu trả lời của tôi trên Danh sách mọi lúc trong ngày với tốc độ nửa giờ , ở đây thực sự ngắn hơn để buộc các con số kể từ khi chúng tôi có được phần đệm rẻ hơn đáng kể. Đây là câu trả lời sử dụng các hàm ngày, ở mức 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;}

Mã này yêu cầu using namespace stdmột nơi nào đó trước nó.

Nó thực hiện một vòng lặp trên các giá trị 0 ... 23. Nó nhân mỗi giá trị với 3600, chuyển đổi thành một tmcấu trúc và in nó. Định dạng in %Rxuất ra 24 giờ và phút; các định dạng in %lvà %Pxuất các phần 12 giờ thích hợp; họ yêu cầu GNU .

Một phiên bản trực tuyến làm việc ở đây .

Ruby, 66 62 byte

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

Phiên bản mới

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`
`

Quét, 76 byte

Chương trình giả định rằng đầu vào trống ( '0'hoặc bất cứ thứ gì chuyển đổi thành số nguyên 0).

Số byte giả định mã hóa UTF-16.

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

Ung dung:

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

Mỗi lần lặp của vòng lặp để lại rất nhiều chuỗi nhỏ trên ngăn xếp; cuối cùng tất cả chúng được tự động nối.

JavaScript, 97 95 byte

Điều này dựa trên câu trả lời của máy quay phim . Cảm ơn George Reith đã cải thiện 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')

Ung dung:

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

Hàng loạt, 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

Nó có thể được cải thiện cho chắc chắn.

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

Hơi ngạc nhiên, đã cố gắng biến ($i < 10 ? $s : "") . "$i:00"bit thành một hàm, nhưng nó đã thêm ~ 25 ký tự. Không đến đó.

Swift, 85 byte

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

Hàm 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++);}

Cách sử dụng, 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();
}

nó hoạt động trên Windows:

Chương trình 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

Cách tiếp cận vũ phu khá; Không có gì thông minh ở đây (tôi đã thử ở một vài điểm nhưng cuối cùng nó không ngắn hơn), chỉ muốn cho Foo một phát súng. Foo tự động in bất cứ điều gì trong dấu ngoặc kép. $c10in một ngắt dòng. (## ... )các vòng lặp cho đến khi ô hiện tại bằng ##.

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

Bực mình một chút:

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

Dùng thử trực tuyến

Javascript (sử dụng thư viện bên ngoài - Có thể đếm được) (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")))

Liên kết đến thư viện: https://github.com/mvegh1/Enumerable/

Giải thích mã: Tạo mảng số nguyên từ 0 đến 23, cho mỗi dòng viết một dòng theo vị ngữ. Vị từ đó kiểm tra nếu val hiện tại nhỏ hơn 10 và đệm nó bằng 0, khác sử dụng val hiện tại. Sau đó thêm chuỗi phút vào nó. Sau đó, về cơ bản thực hiện một mẹo nhỏ để chuyển đổi quân sự sang thời gian sáng / chiều và xử lý phần đệm cho thời gian sáng / chiều dưới 10 lần.

SmileBASIC, 73 byte

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

Ai đó đã tìm thấy một công thức 24-> 12 giờ tốt hơn so với công thức cũ của tôi, giúp tiết kiệm 3 byte và 5 byte trong một chương trình khác

PHP, 67 65 64 byte

Điều này sử dụng mã hóa IBM-850.

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

Với chuỗi không được mã hóa (66 byte):

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

Chạy như thế này:

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

Tinh chỉnh

• Đã lưu 2 byte bằng cách cải thiện định dạng sprintf
• Đã lưu một byte bằng cách loại bỏ không gian không cần thiết (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

bản giới thiệu