Tay trái so với tay phải - Thử thách đánh máy


32

Nhiệm vụ của bạn là đặt hai bên của bàn phím với nhau và xây dựng hai chương trình, trong cùng một ngôn ngữ, một sử dụng chỉ các phím ở phía bên trái của bàn phím tiêu chuẩn xuất ra Pollinium milk; plump pumpkin; lollipop?và một sử dụng các phím ở bên phải xuất ra Weatherheaded sweetheart haberdasheress!.

Quy tắc

Các khóa chính xác được phép cho chương trình bên trái là:

123456!@#$%^QWERTYqwertyasdfghASDFGH`zxcvb~ZXCVB

và cho chương trình bên tay phải:

7890-=&*()_+uiop[]UIOP{}jkl;'\JKL:"|nm,./NM<>?

Có bốn khóa miễn phí Esc( \x1b), Tab( \x09), Space( \x20) và Enter( \x0avà / hoặc \x0d) có thể được sử dụng trong cả hai, hoặc cả hai giải pháp.

Điểm của bạn sẽ là tổng số byte cho cả hai chương trình. Trong khi tôi đã sử dụng thuật ngữ này program, các bài nộp của bạn có thể là chương trình đầy đủ hoặc chức năng như bình thường và cả hai có thể là các loại khác nhau (ví dụ: một chương trình đầy đủ và một chức năng).

Kết quả của bạn phải bao gồm văn bản mong muốn, bất kỳ số lượng khoảng trắng hàng đầu và dấu kiểm nào đều ổn, miễn là văn bản chính xác xuất hiện trong đó.

Sơ hở tiêu chuẩn bị cấm .

Các giải pháp ngắn nhất trong mỗi ngôn ngữ giành chiến thắng.


6
Tại sao H là tay trái?
tsh

1
@tsh Tôi muốn chia bàn phím 6/6 (hoặc càng gần càng tốt) chỉ để thử và giữ số lượng ký hiệu chẵn hơn cho mỗi "bàn tay".
Dom Hastings

8
// Có lẽ tôi nên học khoảng trắng và quay lại sau ...
tsh

@tsh, tôi đoán một câu trả lời khoảng trắng là không thể tránh khỏi! Không chắc chắn làm thế nào nó sẽ cạnh tranh mặc dù! Có lẽ tôi nên giải quyết điều đó, quá muộn bây giờ!
Dom Hastings

Có ổn không nếu chương trình có đầu ra khác (không phải khoảng trắng), miễn là nó bao gồm các văn bản được yêu cầu?
Grzegorz Oledzki

Câu trả lời:


12

Perl 5 , 261 = 88 + 173 byte

Đây là một ví dụ trong đó "tùy chọn ngôn ngữ không được tính" là một vấn đề. Các giải pháp bên cứng sử dụng -p, bên trái không. Vậy nó có được tính là cùng một ngôn ngữ hay không? Và các tùy chọn có nên đến từ bộ ký tự trái / phải không?

Còn lại 88

sử dụng -M5.10.0(hoặc -Etừ dòng lệnh) để kích hoạt sayMột lần nữa có thể tranh cãi nếu tùy chọn này được tính là mã và sẽ đến từ phía bên trái hoặc nếu nó nằm trong "tùy chọn để đặt phiên bản ngôn ngữ không được tính"

say eYYYYZYEYWYYYYYWQYEYQWQEYQYYZYWYYYYYQYQW^q%565504004w4052bw!504!w!04!204bw56550!6!h%

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

Đúng 173

Chạy với -ptùy chọn (cũng bao gồm các ký tự bên phải)

}{*_=\(uuuuuuuuuuuuuiuuuuuuuuuuiuuuuuuuuuuuuuui&Uiipjipjiijij0puiipjiipp0jijipjipjipipp7|Ouiujujjuiuuu0kouuujuiju0jijujuikjujukk7&"7oulio7iouloli77ooliou7liiu7o7lu7io7o77i")

Điều này gần như chắc chắn có thể được cải thiện, nhưng bây giờ thật khó để làm cho một cái gì đó hoạt động. Không có quyền truy cập vào print, say, $_sub{}làm cho đầu ra khó khăn

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


Không quan tâm đến cờ, tôi rất vui vì điều này là hợp lệ. Một giải pháp ngắn hơn nhiều so với những gì tôi đã mày mò khi tôi gọi evalqua &{(u&I.._)[9-7].O.(P|'"'&_).("U::u"&"o::o").("&"|p).(uo&il).(u&i.._)[9-8].("{|o"&"}uu").(j..u)[9]}!
Dom Hastings

12

Khoảng trắng , 1175 1143 655 645 638 632 639 578 (293 + 285) byte

Nó đã được thực hiện ..; p
Chắc chắn có thể được đánh gôn bằng cách điền vào ngăn xếp đảo ngược và in tất cả ở cuối trong một số vòng lặp, nhưng đây chỉ là chương trình Whitespace thứ hai của tôi, vì vậy tôi vẫn chưa tìm ra .. CHỈNH SỬA: Chơi gôn.

+7 byte vì tôi viết sai chính tả pumpkinpumkin.. (Cảm ơn bạn đã chú ý, @ fəˈnɛtɪk .)

Chữ cái S(dấu cách), T(tab) và N(dòng mới) được thêm vào dưới dạng chỉ tô sáng.
[..._some_action]chỉ thêm vào giải thích.

Mặt trái Pollinium milk; plump pumpkin; lollipop?:

[S S T  T   S T T   T   T   N
_Push_-47_?][S S S T    S N
_Push_2_p][S S S T  N
_Push_1_o][S T  S S T   N
_Copy_1st_p][S S T  T   S T N
_Push_-5_i][S S T   T   S N
_Push_-2_l][S N
S _Duplicate_-2_l][S S S T  N
_Push_1_o][S T  S S T   N
_Copy_1st_l][S S T  T   S S T   T   T   S N
_Push_-78_space][S S T  T   T   S S T   T   N
_Push_-51_;][S S S N
_Push_0_n][S S T    T   S T N
_Push_-5_i][S S T   T   T   N
_Push_-3_k][S S S T S N
_Push_2_p][S S T    T   N
_Push_-1_m][S S S T T   T   N
_Push_7_u][S S S T  S N
_Push_2_p][S S T    T   S S T   T   T   S N
_Push_-78_space][S S S T    S N
_Push_2_p][S S T    T   N
_Push_-1_m][S S S T T   T   N
_Push_7_u][S S T    T   S N
_Push_-2_l][S S S T S N
_Push_2_p][S S T    T   S S T   T   T   S N
_Push_-78_space][S S T  T   T   S S T   T   N
_Push_-51_;][S S T  T   T   N
_Push_-3_k][S S T   T   S N
_Push_-2_l][S S T   T   S T N
_Push_-5_i][S S T   T   N
_Push_-1_m][S S T   T   S S T   T   T   S N
_Push_-78_space][S S T  T   N
_Push_-1_m][S S S T T   T   N
_Push_7_u][S S T    T   S T N
_Push_-5_i][S S S N
_Push_0_n][S S T    T   S T N
_Push_-5_i][S S T   T   S N
_Push_-2_l][S N
S _Duplicate_-2_l][S S S T  N
_Push_1_o][S S T    T   T   T   T   S N
_Push_-30_P][N
S S N
_Create_Label_LOOP][S S S T T   S T T   T   S N
_Push_110][T    S S S _Add][T   N
S S _Print_as_char][N
S N
N
_Jump_to_Label_LOOP]

Dùng thử trực tuyến (chỉ có khoảng trắng, tab và dòng mới).

Bên phải Weatherheaded sweetheart haberdasheress!:

[S S T  T   S S S T S S N
_Push_-68_!][S S S T    T   T   S N
_Push_14_s][S N
S _Duplicate_14_s][S S S N
_Push_0_e][S S S T  T   S T N
_Push_13_r][S S S N
_Push_0_e][S S S T  T   N
_Push_3_h][S S S T  T   T   S N
_Push_14_s][S S T   T   S S N
_Push_-4_a][S S T   T   N
_Push_-1_d][S S S T T   S T N
_Push_13_r][S S S N
_Push_0_e][S S T    T   T   N
_Push_-3_b][S S T   T   S S N
_Push_-4_a][S S S T T   N
_Push_3_h][S S T    T   S S S T S T N
_Push_-69_space][S S S T    T   T   T   N
_Push_15_t][S S S T T   S T N
_Push_13_r][S S T   T   S S N
_Push_-4_a][S S S N
_Push_0_e][S S S T  T   N
_Push_3_h][S S S T  T   T   T   N
_Push_15_t][S S S N
_Push_0_e][S N
S _Duplicate_0_e][S S S T   S S T   S N
_Push_18_w][S S S T T   T   S N
_Push_14_s][S S T   T   S S S T S T N
_Push_-69_space][S S T  T   N
_Push_-1_d][S S S N
_Push_0_e][S S T    T   N
_Push_-1_d][S S T   T   S S N
_Push_-4_a][S S S N
_Push_0_e][S S S T  T   N
_Push_3_h][S S S T  T   S T N
_Push_13_r][S S S N
_Push_0_e][S S S T  T   N
_Push_3_h][S S S T  T   T   T   N
_Push_15_t][S S T   T   S S N
_Push_-4_a][S S S N
_Push_0_e][S S T    T   T   T   S N
_Push_-14_W][N
S S N
_Create_Label_LOOP][S S S T T   S S T   S T N
_Push_101][T    S S S _Add][T   N
S S _Print_as_char][N
S N
N
_Jump_to_Label_LOOP]

Dùng thử trực tuyến (chỉ có khoảng trắng, tab và dòng mới).


Giải trình:

Nó đầu tiên xây dựng các ngăn xếp đảo ngược. Đẩy một số được thực hiện như sau:

  • S khi bắt đầu: Kích hoạt thao tác ngăn xếp
  • S: Đẩy những gì sau số như vào ngăn xếp
  • S/ T: Dấu bit ở đâu Slà dương và Tâm
  • Một số TStheo sau là N: Đặt số dưới dạng nhị phân vào ngăn xếp ( T=1S=0).

Sau đó, nó sẽ lặp qua ngăn xếp đảo ngược và in mọi thứ dưới dạng ký tự. Nó thực hiện điều này như sau:

  1. Đẩy 0 ( SSSN)
  2. Đẩy tất cả các số chỉ các ký tự đảo ngược như được giải thích ở trên
  3. Tạo một Label_0( NSSN)
    1. Nhân đôi đỉnh của ngăn xếp ( SNS)
    2. Nếu giá trị này là 0: Nhảy tới Label_1( NTSTN)
    3. Khác: Pop và in đầu ngăn xếp dưới dạng ký tự ( TNSS)
    4. Chuyển đến Label_0( NSNN)
  4. Tạo Label_1( NSSTN)

Đây là cách bố trí mặc định cho cả hai chương trình. Dưới đây là nhật ký thay đổi cho bố cục mặc định này làm giảm số lượng byte hơn nữa:

  1. Tất cả các số được hạ xuống cùng một lượng ( trong chương trình đầu tiên và trong lần thứ hai) để giảm các chữ số nhị phân được sử dụng cho các số thấp hơn hiện tại và giữa bước 3.2 và 3.3, hai bước phụ sau được thêm vào:100 110102 101

    • Đẩy 110 ( SSSTTSTTTSN) trong chương trình 1 hoặc 101 ( SSSTTSSTSTN) trong chương trình 2
    • Bật và thêm hai giá trị trên cùng của ngăn xếp với nhau và kết quả là đỉnh mới của ngăn xếp ( TSSS)
  2. Tôi cũng đã sử dụng SNStrong một số trường hợp để lặp lại phía trên cùng của ngăn xếp, được sử dụng để golf ll, ll, eess.

  3. Ngoài ra, bước 4 (tạo Label_1) đã được gỡ bỏ hoàn toàn. Nó sẽ thoát với một lỗi, nhưng vẫn sẽ xuất mọi thứ chính xác ( được phép theo meta ).

  4. Có thể sao chép ngiá trị thứ 'từ đầu ngăn xếp (có chỉ số STS+ 0 n), ngắn hơn so với việc tạo số mới trong một số trường hợp.
    Trong chương trình đầu tiên tôi đã thực hiện điều này cho: lần thứ hai ptrong pop( STSSTN(bản sao thứ 1) ngắn hơn SSSTTSSN(tạo số cho 'p')), lần thứ hai ltrong lol( STSSTN(bản sao thứ 1) ngắn hơn SSSTSSSN(tạo số cho 'l' )), thứ hai ptrong p p( STSSTN(copy 1) ngắn hơn SSSTTSSN(tạo số cho 'p')), thứ hai ptrong pumlp( STSSTTN(bản sao thứ 3) là ngắn hơn SSSTTSSN(tạo số cho 'p')), thứ hai ptrong pmup( STSSTSN( bản sao thứ 2) ngắn hơnSSSTTSSN(tạo số cho 'p')), số thứ hai mtrong m m( STSSTN(bản sao thứ 1) ngắn hơn SSSTSSTN(số tạo cho 'm')), số thứ hai itrong ini( STSSTN(bản sao thứ 1) ngắn hơn SSSTSTN(tạo số cho 'i') ).
    Trong chương trình thứ hai, điều này không được thực hiện cho bất kỳ. Khoảng cách giữa một số khá ngắn, như erehoặc ded, nhưng việc tạo số cho 'e' ( SSTTN) hoặc 'd' ( SSTTSN) đều ngắn hơn hoặc có độ dài bằng nhau như bản sao 1st ( STSSTN), vì vậy tôi không thể áp dụng thủ thuật này trong chương trình thứ hai để lưu byte. LƯU Ý: Sau khi chơi golf bước 7, không phải tất cả những điều này áp dụng nữa.

  5. Trong cả hai chương trình, tôi đã thay đổi bước 1 của vòng lặp từ SSSN(Đẩy 0) thành SSN(Đẩy lỗi_value) và xóa các bước 3.1 ( SNSSao y) và 3.2 ( NTSTNNếu 0: Thoát). Bây giờ nó sẽ thoát một cách đơn giản với một lỗi SSNkhông xác định ngay khi nó cố gắng truy cập nó.

  6. Đã xóa SSNhoàn toàn (error_value) trong cả hai chương trình. Bây giờ nó sẽ dừng với lỗi " Không thể làm Infix Plus " khi nó cố gắng thực hiện chức năng Thêm mà không còn gì trên ngăn xếp.

  7. Thay đổi các giá trị không đổi của 100102đến 110101tương ứng. Ở đây chương trình Java được sử dụng để tạo 110hằng số; và ở đây chương trình Java được sử dụng để tạo 101hằng số. Lưu ý rằng hiện tại có ít Sao chép được sử dụng hơn so với mô tả tại điểm 4 ở trên, vì trong nhiều trường hợp, các giá trị mới ngắn hơn các bản sao, do đó việc đẩy lại chúng ngắn hơn.


Công cụ ST chỉ đẩy số dưới dạng nhị phân, với khoảng trắng là 0, tab là 1. Đầu ra là TNSS, do đó bạn có thêm hai khoảng trắng ở đầu mỗi chương trình. Nó cũng có thể lưu byte để nhân đôi và sau đó cộng / trừ cho mỗi ký tự và lặp lại các giá trị ở cuối.
Jo King

1
Bạn sai bí ngô.
fnɛtɪk

@ fəˈnɛtɪk Rất tiếc lol .. Nên sửa ngay bây giờ, cảm ơn vì đã chú ý.
Kevin Cruijssen

4

Lenguage, điều này nhiều byte

Phía bên trái là 65721878296123796350462639500449228197646164622176218219262161264085219054330862921130017235140285847450697804123168755463678390611789188813352602373675420824698785508893489685489807676509031860196742608788337382365939621331808044899882497347443262020486908162559376082705672994569868 lặp lại của các anhân vật, đó là tương đương với chương trình Brainfuck sau:

-[--->+<]>-----.[--->+<]>-.---..---.+++++.-----.++++++++++++.--------.[->+++++<]>-.+[----->+<]>.----.+++.-.--[->+++<]>.+[-->+<]>++.[-->+++++++<]>.----.+++++++++.--------.+++.[------->++<]>.[-->+++++++<]>.+++++.--------.+++.-----.--.+++++.[-->+<]>++++.+[-->+<]>++.++[--->++<]>.+++.---..---.+++++++.-.+.[--->++++<]>-.

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

Phía bên tay phải là 636605880289050800007960838028215177632402180834140124157618258152393860687206680356620669530585999501769442445842690365640523699585001167392310123764258380235064746704898152544431842440556280249638840374132783257375880144623575829131522611446544303839106505176776161206935275549421170646618266717893044911373119804737614528140 lặp lại của các pnhân vật, đó là tương đương với chương trình Brainfuck sau:

+[--->++<]>+.++[->++++<]>+.----.--[--->+<]>-.------------.---.+++++++++++++.----------.---.----.+++.+.-.-[--->+<]>-.---[->++++<]>-.++++.[->+++<]>..[--->+<]>---.------------.---.----.--[--->+<]>---.++.[---->+<]>+++.-[--->++<]>--.-------.+.+++.+++++++++++++.--------------.---.--[--->+<]>--.-----------.---.+++++++++++++.-------------.[--->+<]>----..+[-->+++++<]>-.

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


3

CJam , 128 + 192 = 320 byte

64G^c111c111Z^cT$111c6^111X^c1$116X^c111Y^c32c1$6$Y3#$111c4^56Z^c32c112c13$A$A$3$5$1$4$4$4$12$22$22$14$32c13$111c1$T$7$A$4$1$63c

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

'U))'i(((('_))'u('i('i(((('p))'i('i(((('_))'_)))))'i(((('_)))))'&(((((('u(('u))'i(((('i(((('u('i('i(((('_))'p))'u('&(((((('i('_))'_)))'i(((('p))'_)))))'_))'u(('i('i(((('p))'i(((('u(('u(('&(((((

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


3

Phân hạch , 958 + 752 = 1710 byte

._.

Trái

D
z
^@$$$$$$$$$$$$$$$$$$$@!@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@!@~~~@!!@~~~@!@$$$$$@!@~~~~~@!@$$$$$$$$$$$$@!@~~~~~~~~@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@!@~~~~@!@$$$@!@~@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@!@~~~~@!@$$$$$$$$$@!@~~~~~~~~@!@$$$@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@!@$$$$$@!@~~~~~~~~@!@$$$@!@~~~~~@!@~~@!@$$$$$@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@!@$$$@!@~~~@!!@~~~@!@$$$$$$$@!@~@!@$@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@!V

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

Đúng

                                           } \} \    } \      } \    } \   } \   } \    } \   } \       } \    } \   } \ } \       } \   } \                                           } \   } \    } \    } \   } \   } \   } \} \      } \    } \    } \                                           } \ } \ } \   } \    } \   } \   } \    } \   } \   } \   } \    } \      } \ 
O________________________________________I'/O\/O\__u'/O\____i'/O\++p'/O\___/O\_i'/O\__u'/O\___/O\_____i'/O\++p'/O\+++/O\+/O\_______/O\_i'/O\_________________________________________I'/O\_u'/O\++p'/O\____/O\___/O\_i'/O\_u'/O\/O\____i'/O\++u'/O\__u'/O\_________________________________________I'/O\_/O\+/O\+++/O\____/O\___/O\_i'/O\++p'/O\___/O\_i'/O\_u'/O\____/O\____i'/O\+++++++P'L

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

OK, ở đây chúng tôi rất may mắn, thực sự ._.
Tính năng thú vị đầu tiên của Phân hạch là nó có 4 lệnh để tạo con trỏ lệnh, các nguyên tử AKA: RLDUvì vậy tôi có hai lệnh cho các nhóm trái và phải.
Bùa may mắn thứ hai là 2 lệnh cho đầu ra !O, xảy ra trong các nhóm khác nhau.
Lần thứ ba quyến rũ. Cả hai đều xuất ra các đầu ra ASCII tương đương với khối lượng của các nguyên tử. Vì vậy, tôi cần phải thay đổi nó một số cách. May mắn cho tôi Cả hai + (+1 mass)_ (-1 mass)nằm trong một nhóm và tất cả cần ba $ (+1 energy), ~ (-1 energy), @ (swap mass and energy)nằm trong nhóm khác.

Ngoài ra còn có gương để điều khiển các nguyên tử trong cả hai nhóm! Nhưng tôi đã không sử dụng chúng trong chương trình đầu tiên

Vì vậy, không có gì ngăn cản tôi, nhưng nó không thể nhỏ gọn, thiết lập từng bước một.

Chương trình đầu tiên

Chương trình đầu tiên chỉ bao gồm Dz^@$~!V

D   create atom, going down
z   set its mass to ASCII code of 'z'
^   split atom in 2, dividing their mass. One goes left, second - right

Bắt đầu có thể đơn giản hơn (chỉ R), nhưng sử dụng phép chia sẽ tiết kiệm một số byte cho chữ cái đầu tiên.
Atom, điều đó đã đi vòng quanh và gặp gỡ V, khiến anh ta đi xuống và quấn vô thời hạn, không làm gì cả.
Nguyên tử thứ hai trở nên cứng nhắc và sẽ gặp phải một loạt các mẫu lặp đi lặp lại @...@!cho mỗi chữ cái xuất ra.

@   swap atom's mass and energy
... increament or decrement energy until it would match desired ASCII code
@   swap again
!   print character by atoms mass

Cuối cùng, nó sẽ gặp Vvà chia sẻ số phận của nguyên tử đầu tiên. Không có cách nào để phá hủy chúng hoặc dừng lại với phần bên trái của bàn phím.

Chương trình thứ hai

Thứ hai đi kèm với những thăng trầm của nó. Tôi đã có các đồng chí để thay đổi khối lượng trực tiếp, nhưng lệnh đầu ra Ophá hủy các nguyên tử, vì vậy tôi cần phải bảo quản chúng bằng cách nào đó.
Chương trình bắt đầu ở bên phải từ Lvới nguyên tử đi bên trái.

Mẫu lặp lại:

} \
/O\...X'

'đặt mã ASCII của char được trang trí tiếp theo vào khối lượng của các nguyên tử, do đó mã của một số Xđược lưu trữ trước, hơn khối lượng được thay đổi theo _+thành giá trị chính xác.
Đôi khi X'được bỏ qua, nếu nó ngắn hơn để sử dụng chỉ _+.

Nguyên tử đến từ bên trái, gương hai lần và đánh }từ bên trái. Trong trường hợp này }hoạt động như cloner, gửi hai nguyên tử giống hệt nhau lên xuống. Nguyên tử xuống phản chiếu bằng gương và đi bên trái. Lên nguyên tử kết thúc, đánh cùng một gương nhưng từ bên dưới và do đó phản ánh đúng, bắt gặp Ovà in.
Cuối cùng, nguyên tử cuối cùng gặp nhau Osẽ bị phá hủy.

Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.