Athena 19 All

.................................................................................................
11
I.01 – Ba số ................................................................................................................................... 11
I.02 – Tam giác vuông ................................................................................................................ 11
I.03 – Chia mận ............................................................................................................................ 11
I.04 – Đồng hồ điện tử ............................................................................................................... 12
I.05 – Trước và sau ..................................................................................................................... 12
I.06 – Số bàn học ......................................................................................................................... 13
I.07 – Tổng các số lẻ................................................................................................................... 13
I.08 – An ninh lương thực......................................................................................................... 14
I.09 – Gặp nhau ............................................................................................................................ 14
I.10 – Khoảng cách ..................................................................................................................... 14
I.11 – Đuổi kịp............................................................................................................................... 15
I.12 – Phương trình bậc 3 ......................................................................................................... 15
I.13 – Lát sân ................................................................................................................................ 16
I.14 – Du lịch Phanxipan ............................................................................................................ 17
I.15 – Xuất khẩu gạo ................................................................................................................... 17
I.16 – Chữ số hàng đơn vị ........................................................................................................ 18
I.17 – Chữ số lẻ đầu tiên ........................................................................................................... 18
I.18 – Chữ số lẻ thứ k ................................................................................................................. 18
I.19 – Bữa tối ................................................................................................................................ 19
I.20 – Hamburger ......................................................................................................................... 19
I.21 – Tôm sú ................................................................................................................................ 19
I.22 – Thời gian ............................................................................................................................. 20
I.23 – Gửi tiết kiệm ....................................................................................................................... 20
................................................................................................................................ 21
.................................................................................................................... 21
................................................................................................... 22
II.01 – Số lớn nhất ....................................................................................................................... 22
II.02 – Dấu của tổng .................................................................................................................... 22
II.03 – Bàn cờ ............................................................................................................................... 23
II.04 – Năm nhuận ....................................................................................................................... 23
ATHENA XV Page 1 of 219 Nguyễn Thanh Tùng

II.05 – Tích lớn nhất .................................................................................................................... 24
II.06 – Giống nhau ....................................................................................................................... 24
II.07 – Quân hậu ........................................................................................................................... 25
II.08 – Sô cô la .............................................................................................................................. 26
II.09 – Bể bơi................................................................................................................................. 26
II.10 – Đường vành đai .............................................................................................................. 27
II.11 – Hết tiết học ....................................................................................................................... 28
II.12 – Hiệu quả ............................................................................................................................ 28
II.13 – Ốc sên ................................................................................................................................ 29
II.14 – Kim giờ .............................................................................................................................. 29
................................................................................................................................... 29
................................................................................................................................. 31
III.01 – Dãy số ............................................................................................................................... 31
III.02 – Dãy bình phương giảm dần ........................................................................................ 31
III.03 – Số chính phương ........................................................................................................... 32
III.04 – Tổng dãy số..................................................................................................................... 32
III.05 – Tổng lập phương ........................................................................................................... 32
III.06 – Giai thừa........................................................................................................................... 33
III.07 – Tổng giai thừa ................................................................................................................ 33
III.08 – Số bị thiếu........................................................................................................................ 34
III.09 – Danh sách bình phương .............................................................................................. 34
III.10 – Ước nhỏ nhất .................................................................................................................. 35
III.11 – Lũy thừa 2 ......................................................................................................................... 35
III.12 – Khởi động ......................................................................................................................... 36
III.13 – Kích thước mảng ........................................................................................................... 36
III.14 – Tổng các phần tử........................................................................................................... 37
III.15 – Giá trị trung bình ............................................................................................................ 37
III.16 – Phần tử lớn nhất ............................................................................................................. 37
III.17 – Chỉ số phần tử lớn nhất ................................................................................................ 38
III.18 – Số lượng phần tử chẵn ................................................................................................. 38
III.19 – Số phần tử lớn hơn phần tử đứng trước .............................................................. 39
III.20 – Huy chương bạc ............................................................................................................ 39
III.21 – Số phần tử đạt max ....................................................................................................... 40
III.22 – Liên tiếp bằng nhau ...................................................................................................... 41

............................................................................................................ 42
...................................................................................................................... 42
.......................................................................................................................... 43
................................................................................................................................. 44
IV.01 – Các lát cắt........................................................................................................................ 44
IV.02 – Số lượng từ .................................................................................................................... 45
IV.03 – Xâu mới ............................................................................................................................ 45
IV.04 – Vị trí ký tự ......................................................................................................................... 45
IV.05 – Lần thứ 2 ......................................................................................................................... 46
IV.06 – Xóa xâu con ..................................................................................................................... 47
IV.07 – Đảo ngược xâu con ....................................................................................................... 47
IV.08 – Thay thế ............................................................................................................................ 48
IV.09 – Xóa ký tự........................................................................................................................... 48
IV.10 – Thay thế ký tự ................................................................................................................. 48
IV.11 – Rút ngắn xâu ................................................................................................................... 49
.................................................................................................... 49
.................................................................................................................. 49
........................................................................................................................ 50
................................................................................................................. 50
............................................................................................................................. 51
................................................................................................................... 51
......................................................................................... 52
............................................................................................................................... 53
V.01 – Vị trí lẻ................................................................................................................................. 53
V.02 – Giá trị chẵn ........................................................................................................................ 53
V.03 – Lớn hơn phần tử trước ................................................................................................. 53
V.04 – Cùng dấu ........................................................................................................................... 54
V.05 – Cực đại địa phương........................................................................................................ 54
V.06 – Phần tử max..................................................................................................................... 54
V.07 – Vị trí doanh nghiệp .......................................................................................................... 55
V.08 – Số phần tử khác nhau .................................................................................................... 55
V.09 – Đổi chổ cặp phần tử ....................................................................................................... 56
V.10 – Đổi chổ Min – Max ........................................................................................................... 56
V.11 – Xóa phần tử....................................................................................................................... 56

V.12 – Chèn phần tử .................................................................................................................... 57
V.13 – Cặp phần tử trùng nhau ............................................................................................... 57
V.14 – Độ đa dạng ........................................................................................................................ 58
V.15 – Các phần tử đơn độc .................................................................................................... 58
V.16 – Bowling .............................................................................................................................. 58
............................................................................................................. 59
............................................................................................................................ 59
.................................................................................................................. 60
..................................................................................................... 60
......................................................................................... 61
............................................................................................................................................. 62
VI.01 – Độ dài đoạn thẳng .......................................................................................................... 62
VI.02 – Tính nhanh lũy thừa theo mô đun ............................................................................. 62
VI.03 – Tính nhanh tích 2 số nguyên theo mô đun p .......................................................... 63
VI.04 – Lower_bound và Upper_bound .................................................................................. 63
VI.05 – Giá trị đa thức ................................................................................................................. 64
VI.06 – Dãy số khác nhau ........................................................................................................... 64
................................................................................................................... 66
VII.01 – Số lớn nhất trong bảng................................................................................................ 66
VII.02 – Bông tuyết ....................................................................................................................... 66
VII.03 – Các đường chéo ............................................................................................................ 67
VII.04 – Đường chéo phụ ........................................................................................................... 67
VII.05 – Đổi chổ cột ...................................................................................................................... 68
................................................................................................................... 68
............................................................................................................... 69
.................................................................................................................................. 71
VIII.01 – Số phần tử khác nhau .............................................................................................. 71
VIII.02 – Số phần tử chung ........................................................................................................ 71
VIII.03 – Danh sách phần tử chung ......................................................................................... 71
VIII.04 – Số mới ............................................................................................................................ 72
VIII.05 – Bảo tàng gen ................................................................................................................. 72
VIII.06 – Số lượng từ ................................................................................................................... 73
VIII.07 – Đoán số ........................................................................................................................... 73
VIII.08 – Ngoại ngữ....................................................................................................................... 74

VIII.09 – Bãi công.......................................................................................................................... 75
............................................................................................................................... 76
................................................................................................. 77
............................................................................... 77
................................................................................................ 78
............................................................................................ 79
.................................................................... 79
................................................................................................................. 79
............................................................ 80
...................................................................... 81
...................................................................................... 81
.............................................................................. 82
......................................................................................................... 82
...................................................................................................... 83
..................................................................................................................... 83
.............................................................................................................. 84
.................................................................................................. 85
............................................................................................................. 86
..................................................... 86
................................................................ 87
............................................................................................. 87
...................................................................................................................... 88
.................................................................................... 89
................................................................................................................... 89
............................................................................................................................. 91
..................................................................................................................... 91
............................................................................................................................... 92
................................................................................................................ 93
........................................................................................................................ 94
............................................................................................................ 95
................................................................................................................. 96

.............................................................................................................................................. 97
................................................................................................. 97
I.01_S – Ba số............................................................................................................................... 97
I.02_S – Tam giác vuông ........................................................................................................... 97
I.03_S – Chia mận ....................................................................................................................... 97
I.04_S – Đồng hồ điện tử ............................................................................................................ 98
I.06_S – Số bàn học .................................................................................................................... 98
I.07_S – Tổng các số lẻ .............................................................................................................. 98
I.08_S – An ninh lương thực .................................................................................................... 99
I.09_S – Gặp nhau ....................................................................................................................... 99
I.10_S – Khoảng cách ................................................................................................................ 99
I.11_S – Đuổi kịp........................................................................................................................ 100
I.12_S – Phương trình bậc 3 .................................................................................................. 100
I.13_S – Lát sân ......................................................................................................................... 100
I.14_S – Du lịch Phanxipan ..................................................................................................... 100
I.15_S – Xuất khẩu gạo ............................................................................................................ 101
I.16_S – Chữ số hàng đơn vị.................................................................................................. 101
I.17_S – Chữ số lẻ đầu tiên..................................................................................................... 101
I.18_S – Chữ số lẻ thứ k .......................................................................................................... 102
I>19_S – Bữa tối ........................................................................................................................ 102
I.20_S – Hamburger .................................................................................................................. 102
I.21_S – Tôm sú ......................................................................................................................... 102
I.22_S – Thời gian ...................................................................................................................... 102
I.23_S – Gửi tiết kiệm ............................................................................................................... 103
I.24_S – Số chữ số .................................................................................................................... 103
.................................................................................................................. 104
................................................................................................. 105
II.01_S – Số lớn nhất ................................................................................................................ 105
II.02_S – Dấu của tổng ............................................................................................................. 105
II.03_S – Bàn cờ......................................................................................................................... 106
II.04_S – Năm nhuận................................................................................................................. 106
II.05_S – Tích lớn nhất ............................................................................................................. 106
II06_S – Giống nhau .................................................................................................................. 106
II.07_S – Quân hậu ..................................................................................................................... 107

II.08_S – Sô cô la ....................................................................................................................... 108
II.09_S – Bể bơi ........................................................................................................................... 108
II.10_S – Đường vành đai........................................................................................................ 109
II.11_S – Hết tiết học................................................................................................................. 109
II.12_S – Hiệu quả ..................................................................................................................... 109
II.13_S – Ốc sên ......................................................................................................................... 110
II.14_S – Kim giờ ....................................................................................................................... 110
II.15_S – Cấp số ......................................................................................................................... 110
............................................................................................................................... 112
III.01_S – Dãy số ........................................................................................................................ 112
III.02_S – Dãy bình phương giảm dần ................................................................................. 112
III.03_S – Số chính phương ..................................................................................................... 112
III.04_S - Tổng dãy số ................................................................................................................ 112
III.05_S – Tổng lập phương ..................................................................................................... 113
III.06_S – Giai thừa ..................................................................................................................... 113
III.07_S – Tổng giai thừa........................................................................................................... 114
III.08_S – Số bị thiếu .................................................................................................................. 114
III.09_S – Danh sách bình phương ....................................................................................... 114
III.10_S – Ước nhỏ nhất ............................................................................................................ 114
III.11_S – Lũy thừa 2 .................................................................................................................. 115
III.12_S – Khởi động .................................................................................................................. 115
III.13_S – Kích thước mảng ..................................................................................................... 115
III.14_S – Tổng các phần tử ..................................................................................................... 115
III.15_S – Giá trị trung bình ..................................................................................................... 116
III.16_S – Phần tử lớn nhất ..................................................................................................... 116
III.17_S – Chỉ số phần tử lớn nhất ........................................................................................ 116
III.18_S – Số lượng phần tử chẵn .......................................................................................... 116
III.19_S – Số phần tử lớn hơn phần tử đứng trước........................................................ 117
III.20_S – Huy chương bạc ...................................................................................................... 117
III.21_S – Số phần tử đạt max ................................................................................................ 118
III.22_S – Liên tiếp bằng .......................................................................................................... 118
III.23_S – Kiểm tra nguyên tố .................................................................................................. 118
III.24_S – Số nguyên tố ............................................................................................................. 119
.................................................................................................................... 120

............................................................................................................................... 122
IV.01_S – Các lát cắt .................................................................................................................. 122
IV.02_S – Số lượng từ............................................................................................................... 122
IV.03_S – Xâu mới ...................................................................................................................... 122
IV.04_S – Vị trí ký tự .................................................................................................................. 122
IV.05_S – Lần thứ 2.................................................................................................................... 123
IV.06_S – Xóa xâu con .............................................................................................................. 123
IV.07_S – Đảo ngược xâu con ................................................................................................ 123
IV.08_S – Thay thế ..................................................................................................................... 123
IV.09_S – Xóa ký tự.................................................................................................................... 123
IV.10_S – Thay thế ký tự........................................................................................................... 124
IV.11_S – Rút ngắn xâu............................................................................................................. 124
............................................................................................................ 125
................................................................................................................... 125
........................................................................................................... 126
....................................................................................................................... 126
.............................................................................................................. 127
................................................................................... 127
............................................................................................................................. 129
V.01_S – Vị trí lẻ.......................................................................................................................... 129
V.02_S – Giá trị chẵn ................................................................................................................. 130
V.03_S – Lớn hơn phần tử trước........................................................................................... 130
V.04_S – Cùng dấu..................................................................................................................... 130
V.05_S – Cực đại địa phương................................................................................................. 131
V.06_S – Phần tử max ............................................................................................................... 131
V.07_S – Vị trí doanh nghiệp ................................................................................................... 132
V.08_S – Số phần tử khác nhau ............................................................................................. 134
V.09_S – Đổi chổ cặp phần tử ................................................................................................ 134
V.10_S – Đổi chổ Min – Max .................................................................................................... 134
V.11_S – Xóa phần tử................................................................................................................ 135
V.12_S – Chèn phần tử ............................................................................................................. 135
V.13_S – Cặp phần tử trùng nhau.......................................................................................... 136
V.14_S – Độ đa dạng ................................................................................................................. 137
V.15_S – Các phần tử đơn độc ............................................................................................... 137

V.16_S – Bowling ....................................................................................................................... 137
V.17_S – Cập nhật danh sách ................................................................................................. 138
....................................................................................................... 139
............................................................................................... 140
................................................................................... 141
........................................................................................................................................... 144
VI.01_S – Độ dài đoạn thẳng ................................................................................................... 144
VI.02_S – Tính nhanh lũy thừa theo mô đun ...................................................................... 144
VI.03_S – Tính nhanh tích 2 số nguyên theo mô đun p ................................................... 145
................................................................................. 145
.............................................................................................................. 146
......................................................................................................... 147
................................................................................................................. 148
VII.01_S – Số lớn nhất trong bảng ......................................................................................... 148
VII.02_S – Bông tuyết ................................................................................................................ 148
VII.03_S – Các đường chéo ..................................................................................................... 149
VII.04_S – Đường chéo phụ .................................................................................................... 149
VII.05_S – Đổi chổ cột ............................................................................................................... 150
............................................................................................................. 150
......................................................................................................... 151
................................................................................................................................ 152
VIII.01_S – Số phần tử khác nhau .......................................................................................... 152
VIII.02_S – Số phần tử chung.................................................................................................. 152
VIII.03_S – Danh sách phần tử chung .................................................................................. 152
VIII.04_S – Số mới ...................................................................................................................... 152
VIII.05_S – Bảo tàng gen .......................................................................................................... 153
VIII.06_S – Số lượng từ ............................................................................................................ 154
VIII.07_S – Đoán số .................................................................................................................... 154
VIII.08_S – Ngoại ngữ................................................................................................................ 155
VIII.09_S – Bãi công ................................................................................................................... 155
........................................................................................................................ 155
............................................................................................... 157
......................................................................... 157
.............................................................................................. 159

...................................................................................... 160
.............................................................. 161
.......................................................................................................... 162
...................................................... 164
................................................................ 170
................................................................................ 171
....................................................................... 174
................................................................................................... 176
................................................................................................ 179
.............................................................................................................. 181
....................................................................................................... 183
............................................................................................ 185
...................................................................................................... 188
.............................................. 190
......................................................... 191
........................................................................................... 193
............................................................................................................... 195
.............................................................................. 197
............................................................................................................ 198
....................................................................................................................... 199
.............................................................................................................. 204
........................................................................................................................ 206
........................................................................................................ 206
.................................................................................................................. 210
...................................................................................................... 212
.......................................................................................................... 214

I.01 – Ba số
Nhập 3 số nguyên a, b, c từ bàn phím, mỗi số có thể là dương, âm hoặc bằng 0
và có số chữ số tùy ý. Đưa ra màn hình tổng 3 số và tổng bình phương 3 số đã
nhập (Có thể đưa ra chú thích tùy chọn trước mỗi phép nhập dữ liệu và trước mỗi
kết quả, Python cho phép đưa ra chú thích dưới dạng tiếng Việt có dấu).
Ví dụ:
INPUT OUTPUT
a = 2 Tổng 3 số: 10
b = 5 Tổng bình phương: 38
c = 3
I.02 – Tam giác vuông

Cho 2 số nguyên b, c – độ dài 2 cạnh góc vuông của tam giác B
vuông ABC.
c a
Tính và đưa ra:
Diện tích tam giác, A
Độ dài cạnh huyền BC
b C
Dữ liệu nhập vào từ bàn phím, kết quả - đưa ra màn hình.
Có thể đưa ra chú thích tùy chọn trước mỗi phép nhập dữ liệu và trước mỗi kết
quả, Python cho phép đưa ra chú thích dưới dạng tiếng Việt có dấu.
Ví dụ:
INPUT OUTPUT
b = 3 Diện tích tam giác: 6.0
c = 4 Độ dài cạnh huyền: 5.0
I.03 – Chia mận

Cô giáo đi du lịch ở Sa Pa mang về túi mận hậu làm quà cho cả lớp. Túi mận có
k quả, lớp có n người. Mận được chia đều để ai cũng nhận được một số lượng

quả như nhau. Nếu còn thừa, những quả còn lại sẽ được dành cho các bạn nữ ăn
chung.
Với n và k cho từ bàn phím hãy đưa ra màn hình số quả mỗi người trong lớp nhận
được và số quả dành riêng cho các bạn nữ ăn chung. Các số được đưa ra cách
nhau một dấu cách và trên cùng một dòng (Có thể đưa ra chú thích tùy chọn
trước mỗi phép nhập dữ liệu và trước mỗi kết quả, Python cho phép đưa ra chú
thích dưới dạng tiếng Việt có dấu).
Ví dụ:
INPUT OUTPUT
n = 31 Results: 3 30
k = 123
I.04 – Đồng hồ điện tử

Đồng hồ điện tử hiển thị 2 số nguyên chỉ giờ và phút, giờ có giá trị trong phạm
vi từ 0 đến 23, phút có giá trị trong phạm vi từ 0 đến 59. Một ngày mới bắt đầu
từ 0 giờ 0 phút. Khi lệnh cách ly vì Covid được dỡ bỏ từ đầu một ngày, các bạn
trẻ hồ hởi đếm từng phút một chờ lúc gặp lại nhau ở trường và khi cả lớp có mặt
đông đủ là lúc lệnh dỡ bỏ cách ly đã có hiệu lực n phút.
Hãy xác định các số hiển thị trên đồng hồ điện tử. Lưu ý, có thể là đã quá một
ngày từ lúc dỡ bỏ cách ly.
Ví dụ:
INPUT OUTPUT
n = 435 7 15
INPUT OUTPUT
n = 1875 7 15
I.05 – Trước và sau

Liên hợp quốc thống kê và đánh số từng người một theo thứ tự xuất hiện của
người đó trên trái đất. Mỗi người có một số thứ tự riêng không trùng với người
khác. Bạn có số thự tự là n (n > 0). Hãy xác định số thứ tự của người ngay trước
bạn và của người ngay sau bạn.
Dữ liệu được nhập vào từ bàn phím. Kết quả - đưa ra màn hình.

(Có thể đưa ra chú thích tùy chọn trước mỗi phép nhập dữ liệu và trước mỗi kết
quả, Python cho phép đưa ra chú thích dưới dạng tiếng Việt có dấu).
Ví dụ:
INPUT OUTPUT
n = 4037946825 Số đứng trước: 4037946824
Số đứng sau: 4037946826
I.06 – Số bàn học

Trường mới đẹp và rộng hơn trường cũ, số phòng học cũng nhiều hơn 3 so với
trước. Nhà trường dự định tuyển thêm học sinh cho 3 lớp mới với số lượng học
sinh mỗi lớp tương ứng là a, b và c. Dĩ nhiên, cần mua bàn cho các lớp mới này.
Mỗi bàn học có không quá 2 học sinh ngồi.
Hãy xác định số lượng bàn tối thiểu cần mua.
Ví dụ:
INPUT OUTPUT
a = 35 59
b = 42
c = 39
I.07 – Tổng các số lẻ

Cho 2 số lẻ a và b, 1 < a ≤ b.
Hãy tính tổng các số lẻ nằm trong đoạn [a, b] và đưa kết quả ra màn hình.
Ví dụ:
INPUT OUTPUT
Số lẻ thứ I : 5 Sum = 21
Số lẻ thứ II: 9

I.08 – An ninh lương thực
Trung bình mỗi người dân cần có a kg gạo để ăn và phục vụ chăn nuôi, chế biến
trong một năm. Để đảm bảo an ninh lương thực tổng số gạo dự trữ trong các kho
của nhà nước chia cho đầu người phải lớn hơn hoặc bằng a.
Một nước có số dân là b cần dự trữ tối thiểu bao nhiêu kg gạo?
Với a và b cho từ bàn phím hãy đưa ra màn hình số gạo tối thiểu cần dự trữ.
Ví dụ:
INPUT OUTPUT
a = 365 Results = 33246497310
b = 91086294
I.09 – Gặp nhau

Một tàu đánh cá có ngư dân bị tai nạn cần cấp cứu đã gọi điện về cơ sở y tế ở đảo
gần nhất cách đó d hải lý. Để có thể sớm sơ cứu, tàu đánh cá đổi hướng, đi thẳng
về phía đảo với vận tốc v1 hải lý/giờ, đồng thời từ đảo người ta cũng cho một tàu
cứu nạn nhằm vào hướng tàu cá đi tới với vận tốc v2 hải lý/giờ.
Hãy xác định sau bao lâu hai tàu gặp nhau. Các dữ liệu d, v1, v2 là những số
thực và được nhập vào từ bàn phím, kết quả - đưa ra màn hình.
Ví dụ:
INPUT OUTPUT
d = 63 Hai tàu gặp hau sau 1.5 giờ.
v1 = 11.5
v2 = 30.5
I.10 – Khoảng cách

Trong thiên văn người ta thường đo khoảng cách bằng đơn vị năm ánh sáng –
quảng đường ánh sáng đi được trong một năm, trong đó một năm có 365 ngày,
một ngày có 24 giờ, một giờ có 60 phút một phút có 60 giây mà mỗi giây ánh

sáng đi được 299 792 458 km. Một hành tinh mới được phát hiện có khả năng tồn
tại sự sống ở cách trái đất m năm ánh sáng.
Hãy xác định hành tinh đó cách trái đất bao nhiêu tỷ km. Kết quả được làm tròn
lên, tức là nếu số liệu tính được là 11.3 tỷ thì kết quả đưa ra là 11, còn nếu số liệu
tính được là11.5 hay 11.8 tỷ thì kết quả đưa ra là 12, 1 tỷ km = 109 km.
Ví dụ:
INPUT OUTPUT
m = 41.3 Khoảng cách: 390460730 tỷ m.
I.11 – Đuổi kịp

Một đi du lịch bụi bằng xe đạp rời khỏi khách sạn lúc h giờ m phút bằng xe đạp
với vận tốc va km/giờ. k phút sau lễ tân phát hiện một người để quên thẻ căn
cước công dân ở bàn. Khách sạn cho một nhân viên dùng xe máy đuổi theo với
tốc độ vb km/giờ (vb > va) để trao thẻ để quên.
Hãy xác định thời điểm nhân viên khách sạn đuổi kịp đoàn du lịch.
Dữ liệu là các số nguyên được nhập từ bàn phím. Kết quả được đưa ra màn hình
dưới dạng giờ và phút (đã làm tròn).
Ví dụ:
INPUT OUTPUT
h = 6 Thời điểm đuổi kịp: 7 giờ 15 phút.
m = 45
k = 20
va = 15
vb = 45
I.12 – Phương trình bậc 3

Xét phương trình bậc 3 x3+bx2+cx+d=0. Gọi x1, x2 và x3 là 3 nghiệm của
phương trình này.

Theo định lý Viet:
b = -(x1+x2+x3)
c = x1×x2+ x1×x3+ x2×x3
d = x1×x2×x3
Với các giá trị nguyên x1, x2, x3 nhập vào từ bàn phím hãy đưa ra các hệ số b,
c, d để phương trình nhận các số đã nhập là các nghiệm.
Ví dụ:
INPUT OUTPUT
x1 = 2 b = -10 c = 31 d = -30
x2 = 5
x3 = 3
I.13 – Lát sân

Một sân hình chữ nhật kích thước m×n, trong đó chiều rộng là m, chiều dài là n
và m×n là một số chẵn. Sân được lát bằng các viên
gạch kích thước 1×2, bắt đầu từ góc trên trái.
m=5
Chiều dài của viên gạch song song với cạnh dài
của sân. Mỗi viên gạch nguyên ở hàng tiếp theo
được đặt lệch 1 đơn vị so vớiviên gạch nguyên kề
cạnh ở hàng trên. Toàn sân phải lát kín vì vậy có n=8
thể phải chặt đôi một số viên gạch ban đầu thành
2 viên gạch kích thước 1×1.
Hãy xác định số viên gạch cần mua và trong số đó có bao nhiêu viên gạch cần
chặt đôi.
Các số nguyên n, m được nhập vào từ bàn phím. Kết quả tính được đưa ra trên
một dòng của màn hình, hai số cách nhau một dấu cách.
Ví dụ:
INPUT OUTPUT
m = 5 Result: 20 2
n = 8

I.14 – Du lịch Phanxipan
Để lên đỉnh Phanxipan cần mua vé cáp treo a ngàn đồng một người lớn và b
ngàn đồng với trẻ em, vé xe lửa ray u ngàn đồng/người lớn và v ngàn đồng/trẻ
em.
Đoàn du lịch có x người, trong số đó có y trẻ em.
Hãy xác định số tiền cần chuẩn bị để mua vé cho cả đoàn và đưa kết quả ra màn
hình.
Các dữ liệu a, b, u, v, x, y là nguyên (y ≤ x) được nhập vào từ bàn phím.
Ví dụ:
INPUT OUTPUT
a = 60 Tổng số tiền vé: 3850 ngàn đồng.
b = 30
u = 50
v = 25
x = 40
y = 10
I.15 – Xuất khẩu gạo

Trong n năm vừa qua, trung bình mỗi năm nước ta xuất khẩu ra thị trường thị
trường thế giới t tấn gạo. Giá mỗi tấn gạo là v USD. Hãy tính số tiền thu nhập
được nhờ xuất khẩu gạo trong n năm vừa qua,
Các giá trị n, t và v là nguyên, được nhập vào từ bàn phím. Hãy đưa ra màn
hình tổng số tiền thu được nhờ xuất khẩu gạo trong n năm theo đơn vị triệu USD.
Ví dụ:
INPUT OUTPUT
n = 5 Tổng thu nhập: 38000 triệu USD
t = 380
v = 20000000

I.16 – Chữ số hàng đơn vị
Tính tổng các số tự nhiên từ p đến q (kể cả p và q).
Hãy đưa ra màn hình chữ số cuối cùng của tổng nhận được.
Các số nguyên p và q nhập vào từ bàn phím 0 < p ≤ q.
Ví dụ:
INPUT OUTPUT
s = 6 8 Last dugit: 1
I.17 – Chữ số lẻ đầu tiên

Nhập vào từ bàn phím một số thực và đưa ra màn hình chữ số đầu tiên của phần
lẻ sau dấu chấm thập phân.
Ví dụ:
INPUT OUTPUT
x = 12.64 Result = 6
I.18 – Chữ số lẻ thứ k

Nhập vào từ bàn phím 2 số thực a và b, b ≠ 0. Hãy đưa ra màn hình chữ số thứ
𝑎
k thuộc phần lẻ sau dấu chấm thập phân của thương .
𝑏
Ví dụ:
INPUT OUTPUT
a = 45 Result = 8
b = 17
k = 6

I.19 – Bữa tối
Một đoàn tổ chức đi du lịch bằng phương tiện cá nhân. Độ dài toàn hành trình là
d km. Mỗi ngày đoàn đi được m km. Đoàn xuất phát từ buổi sáng ngày thứ nhất.
Hãy xác định ngày thứ mấy thì đoàn được ăn bữa tối đầu tiên tại điểm đích.
Dữ liệu vào là các số nguyên dương d và m.
Ví dụ:
INPUT OUTPUT
d = 92 Result = 4
m = 30
I.20 – Hamburger
Bánh hamburger là món ăn trưa phổ biến của người Mỹ. Một chiếc hamburger
giá a USD và b Cent (1 USD = 100 Cent). Văn phòng gọi điện đặt mang đến n
chiếc bánh. Hãy xác định cần phải chuẩn bị bao nhiêu đô la và bao nhiêu Cent để
thanh toán. Lưu ý số cent cần chuẩn bị phải nhỏ hơn 100.
Các số nguyên không âm a, b và n được nhập vào từ bàn phím. Kết quả - đưa ra
màn hình.
Ví dụ:
INPUT OUTPUT
s = 6 48 10 Result = 66 . 80 USD
I.21 – Tôm sú
Tôm sú được bóc vỏ, loại bỏ đầu và đóng thành từng khay, mỗi khay 10 con. Cứ
10 khay được đóng thành một thùng giấy để xuất khẩu.
Lô hàng đưa vào khâu chế biến và đóng gói có n con.
Hãy xác định còn bao nhiêu khay chưa được đóng vào thùng và bao nhiêu con
chưa được đóng vào khay sau khi chế biến xong toàn bộ tôm chuyển tới.

Từ số nguyên dương n nhập vào từ bàn phím hãy đưa ra trên một dòng của màn
hình các kết quả cần tìm.
Ví dụ:
INPUT OUTPUT
n = 1235 Result: 3 5
I.22 – Thời gian

Kim giờ làm thành góc 0 so với vị trí của nó lúc 12 giờ đúng. Hãy xác định giờ
phút giây ở thời điểm này.
Số thực  được nhập vào từ bàn phím (0 ≤  < 360). Kết quả đưa ra trên một
dòng của màn hình 3 số nguyên xác định giờ, phút và giây tìm được. Các số cách
nhau một dấu cách.
Ví dụ:
INPUT OUTPUT
s = 97.5 3 h 15 m 0 s
I.23 – Gửi tiết kiệm

Một người gửi a đồng vào ngân hàng với kỳ hạn lãi xuất p phần trăm một năm.
Cuối năm ngân hành tính tiền lãi, nhập vào số gốc hiện có làm số gốc mới cho
năm tiếp theo. Sau 2 năm số gốc trong sổ tiết kiệm là bao nhiêu?
Các số nguyên a và p được nhập vào từ bàn phím, a > 0, 0 < p < 100. Kết quả:
đưa ra màn hình dưới dạng một số nguyên.
Ví dụ:
INPUT OUTPUT
Tiền gửi: 100000000 Số tiền sau 2 năm: 116640000
Lãi suất: 8

Cho 2 số nguyên a và b, mỗi số trên một dòng.
Hãy xác định số chữ số của tổng a+b.
Ví dụ:
INPUT OUTPUT
-123108 4
128202
Tam giác Pascal xác định các hệ số của việc triển khai nhị thức (a+b)k.
Phần tử thứ m ở dòng n (m ≤ n) là tổ hợp chập m của n ( 𝐶𝑛𝑚 ). 1
1 1
Cho m và n 0 ≤ m ≤ n. Hãy xác định phần tử thứ m trên dòng n 1 2 1
1 3 3 1
của tam giác Pascal. 1 4 6 4 1
Dữ liệu: vào từ thiết bị vào chuẩn của hệ thống, gồm một dòng
chứa 2 nguyên không âm m và n.
Kết quả: : đưa ra thiết bị ra chuẩn của hệ thống số nguyên tìm được.
Ví dụ:
INPUT OUTPUT
3 5 10

II.01 – Số lớn nhất
Nhập vào từ bàn phím 3 số nguyên. Hãy đưa ra giá trị lớn nhất trong các số đã
nhập.
Xét 2 trường hợp:
Các số cần nhập được ghi mỗi số trên một dòng,
Ba số cần nhập được ghi trên một dòng, các số cách nhau it nhất một dấu
cách.
Ví dụ:
INPUT OUTPUT
a = 6 Max = 10
b = 10
c = 4
INPUT OUTPUT
6 10 4 Max = 10
II.02 – Dấu của tổng

Nhập từ bàn phím 2 số nguyên a và b. Hãy đưa ra mà hình thông báo Positive
nếu a+b > 0, Negative nếu a+b < 0 và Zero nếu a+b = 0.
(Có thể đưa ra chú thích tùy chọn trước mỗi phép nhập dữ liệu, Python cho phép
đưa ra chú thích dưới dạng tiếng Việt có dấu).
Ví dụ:
INPUT OUTPUT
a = 4 Negative
b = -10

II.03 – Bàn cờ
Bàn cờ có hình chữ nhật kích thước m×n ô (m dòng và n m = 4, n = 6
cột). Các dòng được đánh số từ 1 đến m từ dưới lên trên, 4
các cột được đánh số từ 1 đến n từ trái qua phải. Ô nằm 3
trên giao của dòng i và cột j là ô có tọa độ (i, j). Các ô 2
của bàn cờ được tô một trong hai màu W (Trắng) hoặc B 1

(Đen) và hai ô kề cạnh không cùng màu. Ô (1, 1) có màu 1 2 3 4 5 6
W. Với p và q nhập vào từ bàn phím (1 ≤ p ≤ m, 1 ≤ q ≤
n) hãy đưa ra màn hình màu của ô (p, q).
Ví dụ:
INPUT OUTPUT
Size: 4 6 W
Cell: 3 5
INPUT OUTPUT
Size: 4 6 B
Cell: 3 4
II.04 – Năm nhuận

Năm nhuận là những năm chia hết cho 400 hoặc là những năm chia hết cho 4
nhưng không chia hết cho 100 và 400. Những năm năm nhuận tháng 2 có 29 ngày.
Đặc biệt, những năm chia hết cho 3328 được đề xuất là năm nhuận kép, tháng 2
có 30 ngày!
Với số nguyên dương n nhập vào từ bàn phím hãy đưa ra mà hình thông báo No
nếu năm n không phải là năm nhuận, nếu là năm nhuận – đưa ra thông báo Leap.
Nếu n là năm nhuận kép – đưa ra thông báo Multiple leap.

Ví dụ:
INPUT OUTPUT
n = 1900 No
INPUT OUTPUT
n = 6656 Multi leap
INPUT OUTPUT
n = 2020 Leap
II.05 – Tích lớn nhất

Nhập vào từ bàn phím 3 số thực a, b và c. Hãy đưa ra màn hình giá trị lớn nhất
tích 2 số trong các số đã nhập.
Ví dụ:
INPUT OUTPUT
a = 5 Result = 74.61999999999999
b = 8.2
c = 9.1
II.06 – Giống nhau

Có 3 chiếc bánh Ga tô với giá là p1, p2 và p3. Hãy xác định có bao nhiêu chiếc
bánh có giá giống nhau.
Các giá trị p1, p2 và p3 là nguyên, được nhập vào từ bàn phím. Kết quả - đưa ra
màn hình.

Ví dụ:
INPUT OUTPUT
p1 = 25000 Result: 2
p2 = 30000
p3 = 25000
INPUT OUTPUT
p1 = 30000 Result: 0
p2 = 40000
p3 = 50000
INPUT OUTPUT
p1 = 18000 Result: 3
p2 = 18000
p3 = 18000
II.07 – Quân hậu

Quân hậu là quân mạnh nhất trên bàn cờ vua. Từ ô đang m = 4, n = 6
đứng nó có thể đi tới các ô cùng hang, cùng cột, các ô trên
4
đường chéo chính và đường chéo phụ qua ô đang đứng.
3
Cho vị trí của quân hậu (qi, qj) và tọa độ ô A (ai,aj). 2
Hãy xác định, từ vị trí đã cho quân hậu có thể tới ô A được 1
hay không và đưa ra màn hình thông báo tương ứng YES 1 2 3 4 5 6
hoặc NO. Dữ liệu được đưa vào từ bàn phím gồm 2 dòng, mỗi dòng chứa hai số
nguyên xác định tọa độ một ô và đảm bảo ô thuộc bàn cờ.
Ví dụ:
INPUT OUTPUT
sq = 2 2 Yes
sa = 1 3

INPUT OUTPUT
sq = 2 2 No
sa = 4 5
II.08 – Sô cô la
Thanh sô cô la hình chữ nhật được chia thành các miếng nhỏ bằng n-1 đường
rãnh theo chiều dọc và m-1 rãnh theo chiều ngang để giúp
người dùng dễ bẻ.
Hãy xác định có thể một lần bẻ theo chiều ngang hoặc
theo chiều dọc để tách thanh sô cô la thành 2 phần, trong
đó một phần có đúng k miếng nhỏ và đưa ra màn hình thông báo YES trong
trường hợp bẻ được hoặc NO trong trường hợp ngược lại.
Các số nguyên m, n và k được nhập vào từ bàn phím.
Ví dụ:
INPUT OUTPUT
sz = 4 6 Yes
k = 8
II.09 – Bể bơi
Alice là thành viên đội tuyển bơi nghệ thuật. Cô thường xuyên rèn luyên, tập các
động tác cơ bản ở bể bơi của câu lạc bộ. Bể bơi hình chữ nhật, kích thước m×n
mét. Sau một thời gian tập, thấm mệt, cô muốn vịn vào thành bể để nghỉ. Nhìn về
phía thành dài hơn cô thấy mình còn cách x mét (không nhất thiết là khoảng cách
nhỏ nhất tới thành dài) và cô còn cách thành ngắn y mét. Hãy xác định quảng
đường ngắn nhất cần bơi để tới thành bể.
Các số nguyên n, m, x, y được nhập từ bàn phím, dữ liệu hợp lệ đảm bảo Alice
đang trong bể bơi. Đưa ra màn hình độ dài đoạn đường ngắn nhất cần bơi.

Ví dụ:
INPUT OUTPUT
sz = 15 10 2
x = 8
y = 10
II.10 – Đường vành đai

Đường vành đai 3 của thành phố có chiều dài m km. Bên đường người ta trồng
các cột cây số 0, 1, 2, . . ., m-1 tính theo chiều ngược kim đồng hồ.
Vận động viên xe đạp xuất phát từ cột cây số 0, đi với vận tốc v km/giờ theo
chiều d ( d = ‘C’ – chiều kim đồng hồ, d = ‘A’ – ngược chiều kim đồng hồ). Sau
t giờ đi liên tục anh dừng lại nghỉ. Hãy xác định và đưa ra màn hình số ghi trên
cột cây số nơi vận động viên dừng.
Dữ liệu nhập vào từ bàn phím. Các số m và v là nguyên dương, d chỉ nhận giá trị
‘A’ hoặc ‘C’, mỗi giá trị ghi trên một dòng.
Ví dụ:
INPUT OUTPUT
m = 60 Result = 48
v = 12
t = 4
d = A
INPUT OUTPUT
m = 60 Result = 0
v = 12
t = 5
d = C

II.11 – Hết tiết học
Giờ học ở trường bắt đầu từ 7 giờ sáng. Ngày học được chia thành 10 tiết, mỗi
tiết 45 phút. Sau các tiết 1, 3, 5, 7, 9 nghỉ giải lao 5 phút. Sau các tiết 2, 4, 6, 8 –
nghỉ giải lao 15 phút.
Hãy xác định giờ và phút kết thúc tiết k (1 ≤ k ≤ 10).
Số nguyên k được nhập vào từ bàn phím. Kết quả đưa ra trên một dòng của màn
hình, hai số cách nhau một dấu cách.
(Có thể đưa ra chú thích tùy chọn trước mỗi phép nhập dữ liệu và ở mỗi kết quả
đưa ra, Python cho phép đưa ra chú thích dưới dạng tiếng Việt có dấu).
Ví dụ:
INPUT OUTPUT
k = 3 Giờ kết thúc: 9 giờ 35 phút
II.12 – Hiệu quả

Để giải quyết một vấn đề thực tế phức tạp và quan trọng người ta đã xây dựng
nhiều giải thuật khác nhau.
Giải thuật tốt nhất bắt đầu chạy từ a0 giờ b0 phút c0 giây và cho kết quả lúc a1
giờ b1 phút c1 giây. Hãy xác định chương trình đã chạy trong bao nhiêu giây,
biết rằng thời gian giải là không quá một ngày đêm.
Các giá trị nguyên a0, a1, b0, b1, c0, c1 được nhập từ bàn phím 0 ≤ a0, a1 ≤
23, 0 ≤ b0, b1 ≤ 59,0 ≤ c0, c1 ≤ 59.
Kết quả: Đưa ra màn hình một số nguyên – ghời gian chương trình chạy tính theo
giây.
(Có thể đưa ra chú thích tùy chọn trước mỗi phép nhập dữ liệu và ở mỗi kết quả
đưa ra, Python cho phép đưa ra chú thích dưới dạng tiếng Việt có dấu).
Ví dụ:
INPUT OUTPUT
Bắt đầu lúc 23 58 15 Thời gian thực hiện chương trình: 235
Kết thúc lúc 0 2 10

II.13 – Ốc sên
Ốc sên bò từ đất lên đỉnh cây sào cao h mét. Ban ngày Ốc trèo lên được a mét,
ban đêm nó bị tụt xuống b mét (0 ≤ b < a).
Hãy xác định đến ngày thứ mấy ốc sên bò được tới đỉnh cây sào. Các ngày được
đánh số bắt đầu từ 1.
Các số nguyên h, a, b được nhập vào từ bàn phím. Kết quả - đưa ra màn hình.
(Có thể đưa ra chú thích tùy chọn trước mỗi phép nhập dữ liệu và ở kết quả đưa
ra, Python cho phép đưa ra chú thích dưới dạng tiếng Việt có dấu).
Ví dụ:
INPUT OUTPUT
h,m,s: 3 15 00 Result: 3
II.14 – Kim giờ

Tại thời điểm h giờ m phút s giây hãy xác định góc kim giờ tạo thành so với vị
trí của nó lúc đúng 12 giờ.
Dữ liệu được nhập vào từ bàn phím trên một dòng 2 số nguyên h, m, s, 0 ≤ h <
12, 0 ≤ m < 60, 0 ≤ s < 60.
Kết quả đưa ra màn hình một số thực xác định góc tìm được tính theo độ.
Ví dụ:
INPUT OUTPUT
h,m,s: 3 15 00 Angle: 97.5
Cấp số cộng là dãy số, trong đó, trừ phần tử đầu tiên, mỗi số đứng sau bằng số
đứng nó cộng d với d là chung cho mọi phần tử của dãy. Ví dụ, 3, 5, 7, 9 là một
cấp số cộng với d = 2.
Cấp số nhân là dãy số, trong đó, trừ phần tử đầu tiên, mỗi số đứng sau bằng số
đứng nó nhân q với q là chung cho mọi phần tử của dãy. Ví dụ, 1, 3, 9, 27 là một
cấp số nhân với q = 3.

Cho 3 số nguyên khác 0. Hãy xác định 3 số này làm thành cấp số cộng hoặc cấp
số nhân hay không tạo thành cấp số nào trong hai loại đã xét. Đưa ra thông báo
AP (Arithmethic Progression) GP (Geometric Progression) hoặc NP (Non
progression).
Trường hợp là cấp số - đưa tiếp ra cùng dòng 2 phần tử tiếp theo của cấp số.
Ví dụ:
INPUT OUTPUT
6 9 12 AP 15 18

III.01 – Dãy số
Cho 2 số nguyên a và b, a ≤ b. Hãy đưa ra các số nguyên nằm trên đoạn [a, b]
chia hết cho 2 hoặc chia cho 3 dư 1.
Dữ liệu: Nhập vào từ bàn phím các số nguyên a và b, mỗi số trên một dòng.
Kết quả: Đưa ra màn hình các số tìm được theo trình tự tăng dần của giá trị, các
số cách nhau một dấu cách.
Ví dụ:
INPUT OUTPUT
a = 5 6 7 8 10 12 13 14
b = 15
III.02 – Dãy bình phương giảm dần

Cho 2 số nguyên dương a và b. Đưa ra theo thứ tự giá trị giảm dần bình phương
các số nguyên dương k thỏa mãn điều kiện a ≤ k ≤ b nếu a ≤ b hoặc b ≤ k ≤ a
nếu b < a.
Ví dụ:
INPUT OUTPUT
a = 5 64 49 36 25
b = 8

III.03 – Số chính phương
Cho 2 số nguyên dương a và b, a ≤ b. Đưa ra theo thứ tự tăng dần các số chính
phương k trong đoạn [a, b].
Ví dụ:
INPUT OUTPUT
a = 6 9 16 25
b = 30
III.04 – Tổng dãy số

Cho số nguyên dương n. Lần lượt nhập vào n số nguyên, mỗi số trên một dòng
và đưa ra tổng các số đã nhập.
Dữ liệu: Nhập vào từ bàn phím các số nguyên, mỗi số trên một dòng,
Kết quả: Đưa ra màn hình tổng tìm được.
Ví dụ:
INPUT OUTPUT
n = 4 Sum = 20
6
4
8
2
III.05 – Tổng lập phương

Cho 2 số nguyên a và b, 1 ≤ a ≤ b. Hãy đưa ra tổng lập phương các số nguyên
nằm trên đoạn [a, b].

Dữ liệu: Nhập vào từ bàn phím các số nguyên, mỗi số trên một dòng,
Kết quả: Đưa ra màn hình tổng tìm được.
Ví dụ:
INPUT OUTPUT
a = 3 Result: 216
b = 5
III.06 – Giai thừa

Cho số nguyên dương n, không dùng hàm của hệ thống, hãy tính
n! = 1×2×3×. . .×n.
Dữ liệu: Nhập vào từ bàn phím
Kết quả: Đưa ra giá trị tính được.
Ví dụ:
INPUT OUTPUT
25 Result:15511210043330985984000000
III.07 – Tổng giai thừa

Cho 2 số nguyên a và b, 1 ≤ a ≤ b. Hãy đưa ra tổng a!+(a+1)!+. . . +
b!.
Dữ liệu: Nhập vào từ bàn phím
Kết quả: Đưa ra giá trị tính được.

Ví dụ:
INPUT OUTPUT
a = 3 Result: 150
b = 5
III.08 – Số bị thiếu
Cho số nguyên n, n > 1. Nhập vào n-1 số nguyên khác nhau từng đôi một, mỗi
số nằm trong phạm vi từ 1 đến n.
Hãy đưa ra số nguyên x, 1 ≤ x ≤ n không có mặt trong danh sách các số đã nhập
vào.
Dữ liệu: Nhập vào từ thiết bị vào chuẩn của hệ thống, dòng đầu tiên chứa số
nguyên n, mỗi dòng trong n-1 dòng sau chứa một số nguyên cần nhập.
Kết quả: Đưa ra thiết bị ra chuẩn của hệ thống một số nguyên – số bị thiếu trong
danh sách.
Ví dụ:
INPUT OUTPUT
n = 6 Số bị thiếu: 5
4
6
1
3
2
III.09 – Danh sách bình phương

Cho các số nguyên a và b, a ≤ b.
Hãy đưa ra trên một dòng các số i2 với i  [a, b], các số đưa ra cách nhau một
dấu cách.
nguyên a, dòng thứ 2 – số nguyên b.
Kết quả: Đưa ra thiết bị ra chuẩn của hệ thống một dòng chứa các số tính được,
hai số liên tiếp ghi cách nau một dấu cách.

Ví dụ:
INPUT OUTPUT
a = 4 16 25 36 49 64
b = 8
III.10 – Ước nhỏ nhất

Cho số nguyên n, n ≥ 2. Hãy tìm ước nguyên nhỏ nhất khác 1 của n và đưa kết
quả ra màn hình.
Dữ liệu: Nhập vào từ thiết bị vào chuẩn của hệ thống gồm một dòng chứa số
nguyên n.
Kết quả: Đưa ra thiết bị ra chuẩn của hệ thống một số nguyên – giá trị tính được.
Ví dụ:
INPUT OUTPUT
n = 15 3
III.11 – Lũy thừa 2

Cho số nguyên dương n. Tìm k lớn nhất sao cho 2k ≤ n.
Đưa ra màn hình k và 2k tương ứng.
Dữ liệu: Nhập vào từ thiết bị vào chuẩn của hệ thống gồm một dòng chứa số
nguyên n.
Kết quả: Đưa ra thiết bị ra chuẩn của hệ thống 2 số nguyên - các giá trị tìm được,
hai số ghi cách nhau một dấu cách.

Ví dụ:
INPUT OUTPUT
n = 100 6 64
III.12 – Khởi động

Bắt đầu một mùa bóng mới, khi ra sân tập luyện các cầu thủ phải chạy khởi động.
Ngày đầu tiên họ phải chạy x km. Mỗi ngày tiếp theo độ dài đường chạy tăng
10% so với ngày trước đó cho đến khi độ dài đường chạy lớn hơn hoặc bằng y
km thì sẽ không tăng nữa.
Hãy xác định với các giá trị thực x và y cho trước sau bao nhiêu ngày độ dài
đường chạy khởi động sẽ được giữ nguyên.
Dữ liệu: Các số thực x, y được nhập vào từ thiết bị vào chuẩn của hệ thống mỗi
số trên một dòng.
Kết quả: Đưa ra thiết bị ra chuẩn của hệ thống một số nguyên – giá trị tìm được.
Ví dụ:
INPUT OUTPUT
10 5
15.8
III.13 – Kích thước mảng

Chương trình cần xử lý mảng số nguyên dương với kích thước mảng không biết
trước. Dấu hiệu hết mảng là phần tử bằng 0. Đây là dấu hiệu hết mảng và không
phải phần tử của mảng. Hãy xác định mảng đã cho có bao nhiêu phần tử.
Dữ liệu: Các số nguyên của mảng được nhập vào từ thiết bị vào chuẩn của hệ
thống mỗi số trên một dòng, kết thúc là dòng chứa số 0.
Kết quả: Đưa ra thiết bị ra chuẩn của hệ thống một số nguyên – số lượng số đã
nhập.
Ví dụ:
INPUT OUTPUT
5 4
3
4
6
0

III.14 – Tổng các phần tử
Lập trình đọc và tính tổng các phần tử của mảng số số nguyên. Dấu hiệu hết mảng
là số 0 (không phải phần tử của mảng cần đọc).
Kết quả: Đưa ra thiết bị ra chuẩn của hệ thống kết quả tính được dưới dạng
Sum = x , trong đó x là tổng các số đã nhập.
Ví dụ:
INPUT OUTPUT
5 Sum = 15
6
4
0
III.15 – Giá trị trung bình
Lập trình đọc và tính trung bình cộng các phần tử của mảng số số nguyên. Dấu
hiệu hết mảng là số 0 (không phải phần tử của mảng cần đọc).
Average = x , trong đó x là trung bình của các số đã nhập, x nhận giá trị thực.
Ví dụ:
INPUT OUTPUT
5 Average = 5.0
6
4
0
III.16 – Phần tử lớn nhất

Lập trình đọc và tìm phần tử lớn nhất của mảng số nguyên dương. Dấu hiệu hết
mảng là số 0 (không phải phần tử của mảng cần đọc).

Max = x , trong đó x là số lớn nhất trong các số đã nhập, x nhận giá trị nguyên.
Ví dụ:
INPUT OUTPUT
5 Max = 6
6
4
0
III.17 – Chỉ số phần tử lớn nhất

Lập trình đọc và tìm chỉ số phần tử lớn nhất của mảng số nguyên. Nếu có nhiều
phần tử cùng giá trị max thì đưa ra chỉ số nhỏ nhất của phần tử cùng đạt giá trị
max. Các phần tử của mảng được đánh số bắt đầu từ 0. Dấu hiệu hết mảng là số
0 (không phải phần tử của mảng cần đọc).
Index Max Element: i , trong đó i là chỉ số phần tử lớn nhất trong các số
đã nhập, i nhận giá trị nguyên.
Ví dụ:
INPUT OUTPUT
5 Index Max Element: 1
6
4
6
2
0
III.18 – Số lượng phần tử chẵn

Lập trình đếm số phần tử chẵn trong dãy số nguyên. Dấu hiệu hết mảng là số 0.
Even: m , trong đó m là chỉ số phần tử lớn nhất trong các số đã nhập, m nhận
giá trị nguyên.

Ví dụ:
INPUT OUTPUT
-2 Even: 2
3
4
1
5
0
III.19 – Số phần tử lớn hơn phần tử đứng trước

Xét dãy số nguyên a0, a1, a2, . . . Lập trình đếm số cặp giá trị thỏa mãn điều kiện
ai-1 < ai, i = 0, 1, 2, 3, . . . Dấu hiệu hết mảng là số 0.
Result = k , trong đó k là số lượng cặp phần tử tìm được, k nhận giá trị nguyên.
Ví dụ:
INPUT OUTPUT
3 Result = 2
-5
-2
4
1
0
III.20 – Huy chương bạc

Trong một cuộc thi có n người tham dự. Thật may mắn cho Ban tổ chức, điểm ở
những người tốp đầu khác nhau từng đôi một vì vậy rất dễ chọn các người để trao
huy chương vàng, bạc và đồng. Người đạt huy chương vàng quá xuất sắc, ai cũng
có thể đoán được. Mọi người quan tâm nhiều đến điểm của người đạt huy chương
bạc.
Hãy xác định điểm của người đạt huy chương bạc khi bảng điểm được công bố.

nguyên n, dòng thứ i trong n dòng sau chứa một số nguyên – điểm của người
thứ i. Danh sách điểm chưa được sắp xếp.
Kết quả: Đưa ra thiết bị ra chuẩn của hệ thống số nguyên Eval – điểm của người
đạt huy chương bạc dưới dạng Silver = Eval.
Ví dụ:
INPUT OUTPUT
6 Silver = 12
7
9
6
10
15
12
III.21 – Số phần tử đạt max

Một cuộc lấy ý kiến thăm dò trên mạng cho thấy rất nhiều người có cùng quan
điểm và cho điểm đánh giá cao về các vấn đề được hỏi.
Hãy xác định số lượng người cùng cho điểm đánh giá cao nhất trong số n phiếu
chọn một cách ngẫu nhiên. Có thể ghi nhận và sắp xếp dữ liệu nhưng sẽ tốn rất
nhiều thời gian và công sức. Để trả lời câu hỏi đã nêu chỉ cần xét qua mọi phiếu,
mỗi phiếu một lần và cũng không cần ghi nhận mọi giá trị đã đọc. Nói một cách
khác, cần xử lý với độ phức tạp O(n).
nguyên n, dòng thứ i trong n dòng sau chứa một số nguyên – điểm đánh giá của
người thứ i. Danh sách điểm chưa được sắp xếp.
Kết quả: Đưa ra thiết bị ra chuẩn của hệ thống số nguyên k – số phần tử đạt giá
trị lớn nhất dưới dạng Summary : k.

Ví dụ:
INPUT OUTPUT
8 Summary : 3
6
5
6
8
7
8
6
8
III.22 – Liên tiếp bằng nhau

Xét dãy số nguyên n phần tử. Hãy tìm đoạn dài nhất chứa các phần tử bằng nhau
đứng liên tiếp trong dãy.
nguyên n, dòng thứ i trong n dòng sau chứa một số nguyên – phần tử thứ i của
dãy.
Kết quả: Đưa ra thiết bị ra chuẩn của hệ thống số nguyên d – độ dài lớn nhất tìm
được. Thông tin đưa ra có dạng Max length: d.
Ví dụ:
INPUT OUTPUT
10 Max length: 3
2
3
3
1
3
3
3
5
5
5

Cho số nguyên dương n.
Hãy xác định, nếu n là số nguyên tố - đưa ra thông báo Yes, trong trường hợp
ngược lại – đưa ra thông báo No.
Dữ liệu: Nhập vào từ thiết bị vào chuẩn của hệ thống.
Kết quả: Đưa ra thiết bị ra chuẩn của hệ thống thông báo xác định được.
Ví dụ:
INPUT OUTPUT
37 Yes
Cho số nguyên dương n (0 < n ≤ 106).

Hãy xác định có bao nhiêu số nguyên tố không vượt quá n.
Dữ liệu: Nhập vào từ thiết bị vào chuẩn của hệ thống.
Kết quả: Đưa ra thiết bị ra chuẩn của hệ thống một số nguyên – số lượng tìm
được.
Ví dụ:
INPUT OUTPUT
8 Summary : 3
6
5
6
8
7
8
6
8

Với một cặp ngoặc tròn () chỉ có thể xây dựng được một biểu thức ngoặc đúng.
Với 2 cặp ngoặc tròn – có thể xây dựng được 2 biểu thức ngoặc đúng ()() và
(()). Với 3 cặp ngọc tròn – có thể xây dựng được 5 biểu thức ngoặc đúng, với
4 cặp ngoặc tròn – 14 biểu thức ngoặc đúng, . . .
Gọi ci là số lượng biểu thức ngoặc đúng có thể xây dựng với i cặp ngoặc tròn.
ci được gọi là số Catalan và dãy c1, c2, c3, . . . được gọi là dãy số Catalan. Dãy
số này đóng vai trò quan trọng trong nhiều bài toán thực tế.
Cho số nguyên n. Hãy xác định cn.
Dữ liệu: vào từ thiết bị vào chuẩn của hệ thống, gồm một nguyên dương n.
Kết quả: đưa ra thiết bị ra chuẩn của hệ thống số nguyên cn.
Ví dụ:
INPUT OUTPUT
6 132

IV.01 – Các lát cắt
Cho xâu s không chứa dấu cách.
Hãy thực hiện các công việc sau:
Đưa ra ký tự thứ 3 của xâu,
Đưa ra ký tự trước ký tự cuối cùng của s,
Đưa ra 5 ký tự đầu tiên của s,
Đưa ra toàn xâu s, trừ 2 ký tự cuối cùng,
Đưa ra các ký tự có chỉ số chẵn (chỉ số ký tự trong xâu đánh số bắt đầu từ
0),
Đưa ra các ký tự có chỉ số lẻ,
Đưa ra xâu đảo ngược vị trí của s,
Đưa ra xâu s theo trình tự đảo ngược, bắt đầu từ ký tự cuối cùng, đan xen
một ký tự đưa ra, bỏ qua một ký tự tiếp theo,
Đưa ra độ dài của xâu s.
Kết quả mỗi yêu cầu đưa ra trên một dòng, các dòng thông tin đưa ra không chứa
dấu cách.
Dữ liệu: Nhập xâu s vào từ thiết bị vào chuẩn của hệ thống.
Kết quả: Đưa ra thiết bị ra chuẩn của hệ thống, mỗi kết quả đưa ra trên một dòng.
Ví dụ:
INPUT OUTPUT
s = abcdefgh c
g
abcde
abcdef
aceg
bdfh
hgfedcba
hfdb
8

IV.02 – Số lượng từ
Từ là dãy ký tự liên tiếp không chứa dấu cách. Hai từ liên tiếp nhau trong xâu s
cách đúng một ký tự dấu cách.
Hãy đưa ra số lượng từ trong xâu s.
Kết quả: Đưa ra thiết bị ra chuẩn của hệ thống một số nguyên – số lượng từ.
Ví dụ:
INPUT OUTPUT
abc 1234 gh 5 67 ijk 6
IV.03 – Xâu mới

Cho xâu s. Tạo xâu mới bằng cách tách s thành 2 phần:
s1 chứa các ký tự đầu của s, s2 – chứa các ký tự còn lại,
Độ dài s1 bằng hoặc lớn hơn 1 so với độ dài của s2.
Tạo xâu mới bằng cách đổi chổ s1 và s2 trong s.
Kết quả: Đưa ra thiết bị ra chuẩn của hệ thống xâu nhận được sau biến đổi.
Ví dụ:
INPUT OUTPUT
123456789 678912345
IV.04 – Vị trí ký tự
Cho xâu s và ký tự c.
Nếu c xuất hiện trong s một lần – đưa ra vị trí của c trong s.
Nếu c xuất hiện nhiều lần trong s – đưa ra vị trí xuất hiện lần đầu tiên và lần cuối
cùng của c trong s.
Nếu s không chứa c – đưa ra giá trị -1.
Kết quả: Đưa ra thiết bị ra chuẩn của hệ thống kết quả nhận được.

Ví dụ:
INPUT OUTPUT
abcdabacbcad 0 10
a
INPUT OUTPUT
abcdefgh 4
e
INPUT OUTPUT
12345678 -1
a
IV.05 – Lần thứ 2
Nếu ký tự c xuất hiện trong s nhiều hơn một lần – đưa ra vị trí xuất hiện lần thứ
2, nếu c chỉ xuất hiện một lần – đưa ra -1, nếu s không chứa c – đưa ra -2.
Ví dụ:
INPUT OUTPUT
123423456234 4
2
INPUT OUTPUT
123456789 -1
2
INPUT OUTPUT
123456 -2
a

IV.06 – Xóa xâu con
Nếu c xuất hiện nhiều hơn một lần trong s thì xóa khỏi s xâu con các ký tự liên
tiếp nhau bắt đầu lần xuất hiện đầu tiên của c cho đến lần xuất hiện cuối cùng
của ký tự này.
Ví dụ:
INPUT OUTPUT
abc2efgh2ijk2lmn abclmn
2
INPUT OUTPUT
Abcdefgh abcdefgh
5
IV.07 – Đảo ngược xâu con

Cho xâu s và ký tự c. Đảm bảo c xuất hiện không ít hơn 2 lần trong s.
Hãy đảo ngược xâu con từ lần xuất hiện đầu tiên của c đến lần xuất hiện cuối
cùng của c trong s.
Ví dụ:
INPUT OUTPUT
123a1234a12345a678 123a54321a4321a678
a

IV.08 – Thay thế
Cho xâu s. Tạo xâu mới từ s bằng cách thay các ký tự ‘1’ và thay nó bằng xâu
‘one’ và giữ nguyên các ký tự còn lại.
Ví dụ:
INPUT OUTPUT
32154198176 32one54one98one76
IV.09 – Xóa ký tự
Cho xâu s. Tạo xâu mới từ s bằng xóa các ký tự bằng c.

Ví dụ:
INPUT OUTPUT
123a45a6a78 12345678
a
IV.10 – Thay thế ký tự
Cho xâu s và các ký tự c, cnew.

Thay thế trong s các ký tự c bằng cnew, trừ lần gặp đầu tiên và cuối cùng của c
trong s.
Ví dụ:
INPUT OUTPUT
123a45a678a9a34 123a45A678A9a34
a
A

IV.11 – Rút ngắn xâu
Cho xâu s. Tạo xâu mới từ s bằng cách xóa các ký tự tại các vị trí chia hết cho
3.
Ví dụ:
INPUT OUTPUT
12345678901234 235689124
Cho văn bản t. Tìm và thay thể trong t xâu con w_old bằng xâu con w_new.
Viêc thay thế sẽ được thực hiện cho đến khi văn bản không còn chứa w_old.
Dữ liệu vào:
Dòng thứ nhất chứa văn bản t,
Dòng thứ hai chứa xâu w_old,
Dòng thứ hai chứa xâu w_new.
Hãy đưa ra văn bản sau khi thay thế.
Ví dụ:
INPUT OUTPUT
Bbc Aaa bBbc aBbcaaBbc DEF BBC Aaa bBBC aBBCaaBBC DEF
Bbc
BBC
Tạo 2 số thực ngẫu nhiên, mỗi số có 6 chữ số sau dấu chấm thập phân.
Tìm và đưa ra chữ số lớn nhất của tích 2 số tạo được.

Dữ liệu vào: không có.
Kết quả: đưa ra thiết bị ra chuẩn của hệ thống 2 số thực ngẫu nhiên tạo được, tích
của chúng và chữ số lớn nhất trong tích.
Ví dụ: Một khả năng có thể của kết quả ra:
a,b,c: 788780.078337 428108.195263 337683215796.2608

Maxdigit: 9
Cho văn bản gồm các từ ghi trên một dòng. Từ là đoạn các ký tự liên tiếp không
chứa dấu cách. Các từ cách nhau ít nhất một dấu cách.
Hãy đưa ra từ có độ dài lớn nhất và độ dài của từ đó.
Dữ liệu: Nhập văn bản vào từ thiết bị vào chuẩn của hệ thống.
Kết quả: Đưa ra thiết bị ra chuẩn của hệ thống kết quả nhận được trên một dòng
gồm từ và độ dài từ tìm được, hai đại lượng ghi cách nhau một dấu cách.
Ví dụ:
INPUT OUTPUT
a2 b12 c d01 e123456 d089 e123456 7
Palindrome là xâu mà kết quả đọc các ký tự từ trái sang phải giống kết quả đọc
các ký tự từ phải sang trái.
Ví dụ s = ‘12344321’ là xâu palindrome.
Xét xâu chứa các ký tự có mã ASCII lớn hơn hoặc bằng 32.
Hãy đưa ra thông báo Yes nếu đó là xâu palindrome hoặc No trong trường hợp
ngược lại.
Ví dụ:
INPUT OUTPUT
AbdcdbA hi ih AbdcdbA Yes

Cho số nguyên n ở hệ cơ số 10 và số nguyên b (1 < b ≤ 16), mỗi số trên một
dòng. Hãy đưa ra n ở dạng cơ số b. Với b > 10, khi cần thiết sẽ sử dụng các ký
tự A, B, C, D, E, F để chỉ các số 10, 11, 12, 13, 14, 15 (ở hệ thập phân).
nguyên n, dòng thứ 2 chứa số nguyên xác định cơ số.
Ví dụ:
INPUT OUTPUT
446 1BE
16
Từ số nguyên không âm cho trước tạo số mới bằng cách cộng nó với số nhận
được bằng cách đảo ngược vị trí các chữ số, nếu tổng hai số này chưa có dạng
palindrome thì áp dụng các phép biến đổi trên cho đến khi nhận được số dạng
palindrome và đưa ra số nhận được.
Số có dạng palindrome là số khi đọc các chữ số từ trái sang phải ta được kết quả
như khi đọc từ phải sang trái. Ví dụ 20902 là một số dạng palindrome.
Dữ liệu: Nhập số nguyên n vào từ thiết bị vào chuẩn của hệ thống.
Ví dụ:
INPUT OUTPUT
91 121

Phần lớn các quốc gia trên thế giới sử dụng thang nhiệt độ Celsius (ký hiệu 0C),
nước sôi ở 1000C và đóng băng ở 00C trong điều kiện áp
suất bình thường.
Mỹ, Belize (Trung Mỹ), Cayman, Bahamas (Caribê) và
Palau (Biển Phillipine) sử dụng thang nhiệt độ Fahrenheit
(ký hiệu 0F).
Theo thang Fahrenheit nước đóng băng ở 320F và sôi ở
2120F.
Gọi tc là nhiệt độ theo thang Celsius và tf là nhiệt độ tương ứng theo thang
Fahrenheit, ta có:
𝟓
tc = (tf - 32)
𝟗
𝟗
tf = tc + 32
𝟓
Cho một xâu chứa số nguyên và kết thúc bằng ký tự chỉ thang nhiệt độ. Ký tự chỉ
thang nhiệt độ là c hoặc C cho biết đó là nhiệt độ Celsius. Nếu ký tự chỉ thang
nhiệt độ là f hoặc F cho biết đó là nhiệt độ Fahrenheit.
Hãy nhận dạng thang nhiệt độ và đưa ra nhiệt độ tương ứng ở thang kia với độ
chính xác 2 chữ số sau dấu chấm thập phân.
Ví dụ:
INPUT OUTPUT
100c 212F
INPUT OUTPUT
98.60F 37.00C

V.01 – Vị trí lẻ
Nhập danh sách s.
Đưa ra trên một dòng các phần tử ở vị trí lẻ của danh sách.
Dữ liệu: Nhập danh sách s vào từ thiết bị vào chuẩn của hệ thống.
Ví dụ:
INPUT OUTPUT
1 one 2 two 3 three 4 four 5 five one two three four five
V.02 – Giá trị chẵn
Nhập vào mảng số nguyên a.

Đưa ra trên một dòng các phần tử có giá trị chẵn của a.
Dữ liệu: Nhập mảng số a vào từ thiết bị vào chuẩn của hệ thống.
Ví dụ:
INPUT OUTPUT
5 3 8 4 1 2 6 4 5 9 12 8 4 2 6 4 12
V.03 – Lớn hơn phần tử trước

Đưa ra trên một dòng các phần tử có giá trị lớn hơn phần tử đứng ngay trước nó
trong a.
Ví dụ:
INPUT OUTPUT
5 3 8 4 1 2 6 4 5 9 12 15 8 2 6 5 9 12 15

V.04 – Cùng dấu

Xét các cặp phần tử đứng liên tiếp nhau trong mảng, các phần tử trong cặp khác
0. Đưa ra trên một dòng cặp phần tử gặp đầu tiên có trong a.
Nếu không tồn tại cặp giá trị cần tìm thì đưa ra 2 số 0.
Ví dụ:
INPUT OUTPUT
5 -3 0 4 -1 2 -6 -4 -5 9 -12 15 -6 -4
V.05 – Cực đại địa phương

Đếm và đưa ra màn hình số lượng các phần tử lớn hơn phần tử đứng trước và
phần tử đứng sau nó.
Ví dụ:
INPUT OUTPUT
5 -3 0 4 -1 2 -6 -4 -5 9 -12 15 4
V.06 – Phần tử max

Đưa ra giá trị phần tử lớn nhất của mảng và chỉ số của nó.
Nếu tồn tại nhiều phần tử cùng giá trị max thì đưa ra vị trí của phần tử max có chỉ
số nhỏ nhất.

Ví dụ:
INPUT OUTPUT
5 -3 0 4 -1 2 -6 -4 -5 9 -12 15 15 11
V.07 – Vị trí doanh nghiệp
Một doanh nghiệp càng đóng thuế nhiều bao nhiêu vào ngân sách nhà nước thì
doanh nghiệp đó càng qua trọng trên quan điểm kinh tế thuần túy. Số tiền thuế
đóng năm vừa qua của các doanh nghiệp được ghi nhận trong danh sách, sắp xếp
theo thứ tự không tăng.
Một doanh nghiệp mới thành lập, dự kiến sẽ mang lại x đồng/năm tiền thuế cho
ngân sách. Cần bổ sung tên doanh nghiệp này vào danh sách đã lập sao cho vẫn
đảm bảo thứ tự không tăng theo thuế đóng góp. Nếu đã có nhiều doanh nghiệp có
cùng số đóng góp là x thì doanh nghiệp mới được ghi vào vị trí sau các doanh
nghiệp này.
Đưa ra vị trí của doanh nghiệp mới. Các vị trí trong danh sách được đánh số bắt
đầu từ 0.
Dữ liệu: Nhập từ thiết bị vào chuẩn của hệ thống:
Dòng đầu tiên chứa danh sách số tiền thuế theo thứ tự giảm dần của các doanh
nghiệp hiện có,
Dòng thứ 2 chứa một số nguyên – tiền đóng thuế của doanh nghiệp mới.
Kết quả: Đưa ra thiết bị ra chuẩn của hệ thống vị trí cần bổ sung doanh nghiệp
mới vào danh sách.
Ví dụ:
INPUT OUTPUT
512 128 126 100 100 100 98 90 6
100
V.08 – Số phần tử khác nhau
Cho mảng chứa các số nguyên đã sắp xếp theo thứ tự không giảm hoặc không
tăng.
Hãy xác định mảng chứa bao nhiêu phần tử có giá trị khác nhau từng đôi một.

Ví dụ:
INPUT OUTPUT
512 128 128 100 100 100 98 90 5
V.09 – Đổi chổ cặp phần tử
Cho mảng a chứa các phần tử nguyên. Hãy đổi chổ các cặp phần tử a0 với a1, a2
với a3, . . . Nếu kích thước a là lẻ thì phần tử cuối cùng vẫn giữ nguyên vị trí.
Hãy đưa ra trên một dòng các phần tử của mảng sau khi đổi chổ.
Ví dụ:
INPUT OUTPUT
1 2 3 4 5 6 7 8 9 2 1 4 3 6 5 8 7 9
V.10 – Đổi chổ Min – Max
Cho mảng a chứa các phần tử nguyên khác nhau từng đôi một. Hãy đổi chổ vị trí
của phần tử giá trị nhỏ nhất và phần tử giá trị lớn nhất trong mảng.
Hãy đưa ra trên một dòng các phần tử của mảng sau khi đổi chổ.
Ví dụ:
INPUT OUTPUT
6 1 3 2 8 7 9 4 5 6 9 3 2 8 7 1 4 5
V.11 – Xóa phần tử
Cho mảng số nguyên a và số nguyên k (0 ≤ k < len(a) ).

Hãy thu gọn mảng a bằng cách xóa phần tử ở vị trí k. Trong quá trình xử lý không
được sử dụng mảng trung gian.
Đưa ra trên một dòng các phần tử của mảng sau khi thu gọn.

Dữ liệu: Nhập vào từ thiết bị vào chuẩn của hệ thống, dòng đầu tiên chứa các
phần tử của mảng a, dòng thứ 2 chứa số nguyên k.
Ví dụ:
INPUT OUTPUT
6 1 3 2 8 7 9 4 5 6 1 3 2 8 9 4 5
5
V.12 – Chèn phần tử
Cho mảng số nguyên a,các số nguyên k và val (0 ≤ k ≤ len(a) ).

Hãy đẩy các phần tử ai, i = k ÷ len(a)-1 sang phải một vị trí và gán val cho
ak. Trong quá trình xử lý không được sử dụng mảng trung gian.
Đưa ra trên một dòng các phần tử của mảng sau khi chèn thêm phần tử mới.
Dữ liệu: Nhập vào từ thiết bị vào chuẩn của hệ thống, dòng đầu tiên chứa các
phần tử của mảng a, dòng thứ 2 chứa 2 số nguyên k và val.
Ví dụ:
INPUT OUTPUT
6 1 3 2 8 7 9 4 5 6 1 3 2 8 16 7 9 4 5
5 16
V.13 – Cặp phần tử trùng nhau
Cho mảng số nguyên a. Hãy xác định có bao nhiêu cặp phần tử trùng nhau trong
dãy.
Ví dụ:
INPUT OUTPUT
2 4 2 5 3 5 2 5 6

V.14 – Độ đa dạng
Camera đặt cạnh đường cao tốc ghi nhận nhiều thông tin, trong đó có mảng số
nhận dạng loại ô tô đi qua. Mỗi loại ô tô được mã hóa thành một số nguyên.
Cho mảng số nhận dạng loại ô tô. Hãy xác định đã có bao nhiêu loại xe khác nhau
được nhận dạng
Dữ liệu: Nhập dữ liệu vào từ thiết bị vào chuẩn của hệ thống.
Ví dụ:
INPUT OUTPUT
2 4 2 5 4 5 2 5 4 5 5 3
V.15 – Các phần tử đơn độc
Cho mảng số nguyên a.

Hãy đưa ra trên một dòng các phần tử chỉ xuất hiện một lần trong a. Các phần tử
đưa ra theo trình tự gặp trong a và cách nhau một dấu cách.
Ví dụ:
INPUT OUTPUT
2 1 2 3 4 2 4 5 2 1 3 5
V.16 – Bowling
Bowling là trò chơi ném bóng làm đổ các con ki (chai gỗ - quille) được xếp thành
một hàng ngang.
Các con ki được đánh số từ 1 đến n từ trái sang phải.
Một người ném bóng n lượt, lượt thứ i làm đổ các con ki từ
lfi đến rti, kể cả lfi và rti, 1 ≤ lfi ≤ rti ≤ n, i = 1 ÷
k.
Hãy đưa ra n ký tự liên tiếp nhau trên một dòng, ký tự thứ i
là ‘I’ nếu con ki thứ i chưa bị đổ và là ‘.’ Trong trường hợp ngược lại.

Dữ liệu: Nhập dữ liệu vào từ thiết bị vào chuẩn của hệ thống, dòng thứ i chứa 2
số nguyên lfi và rti, i = 1, 2, . . .
Ví dụ:
INPUT OUTPUT
10 3 ..II....II
5 7
1 2
6 8
Cho danh sách các số nguyên.

Hãy thay thế các phần tử âm bằng -1, phần tử dương bằng 1, giữ nguyên các phần
tử giá trị 0.
Đưa ra danh sách nhận được.
Ví dụ:
INPUT OUTPUT
-5 0 6 8 -3 -4 -2 0 4 6 -1 0 1 1 -1 -1 -1 0 1 1
Khởi tạo dãy n số nguyên, mỗi số là một số ngẫu nhiên nằm trong đoạn [a, b].
Đưa ra dãy số đã khởi tạo
Đếm và đưa ra số lượng số lẻ âm, số lượng số chẵn âm, số lượng số lẻ dương và
số lượng số chẵn dương.
Dữ liệu vào từ thiết bị vào chuẩn của hệ thống:
Dòng đầu tiên chứa số nguyên dương n,
Dòng thứ 2 chứa 2 số a và b.
Kết quả: Đưa ra thiết bị ra chuẩn của hệ thống kết quả nhận được theo quy cách
nêu trong ví dụ.

Ví dụ: Một khả năng có thể của Output
INPUT OUTPUT
10 a, b: -10 10
-10 10 -3 2 -6 5 5 -10 0 4 -4 10
Negative odd: 1 Negative even: 3
Positive odd: 2 Positive even: 3
Xét dãy số nguyên A = (a1, a2, . . . , an).

Hãy tạo dãy B chứa ở phần đầu tất cả các phần tử ai < 0 theo đúng trình tự xuất
hiện trước sau trong A, sau đó là các phần tử 0 và cuối cùng là tất cả các phần tử
ai > 0 theo đúng trình tự xuất hiện trước sau trong A.
Dòng đầu tiên chứa số nguyên n,
Một số dòng sau chứa các số nguyên ai theo trình tự a1, a2, . . ., an. Trên
mỗi dòng các số cách nhau ít nhất một dấu cách
Kết quả đưa ra thiết bị ra chuẩn của hệ thống:
Các dòng sau đưa ra mảng B, 10 số trên một dòng, trừ dòng cuối cùng có
thể ít hơn, các số trên một dòng cách nhau một dấu cách.
Ví dụ:
INPUT OUTPUT
12 -2 -10 -4 -5 0 0 0 0 8 6
8 -2 0 0 5 5
6 5
-10 -4 0
5 0 -5
Cho mảng a chứa các giá trị nguyên. Mảng b gọi là đại diện cho a nếu các phần
tử giống nhau trong a chỉ được lưu một lần trong b và mọi phần tử của a đều có
một phần tử bằng nó trong b.

Hãy tính tổng chênh lệch giá trị của các cặp số khác nhau trong mảng đại diện.
Các cặp (bi, bj) và (bj, bi) được coi là giống nhau.
Ví dụ:
INPUT OUTPUT
9 -1 4 5 4 -1 31
Cho danh sách n phần tử.

Hãy tìm phần tử có số lần gặp nhiều nhất trong danh sách.
Dữ liệu: Vào từ thiết bị vào chuẩn:
Mỗi dòng trong n dòng sau chứa một phần tử của danh sách.
Đưa ra thiết bị ra chuẩn:
Dòng đầu tiên chứa 2 số nguyên m và k, trong đó m – số lần gặp nhiều nhất
của phần tử trong danh sách, k – số các phần tử khác nhau trong danh sách
có cùng số lần gặp m,
Dòng thứ 2 – danh sách k phần tử khác nhau có cùng số lần gặp m. Các
phần tử ghi cách nhau một dấu cách.
Ví dụ:
INPUT OUTPUT
10 3 2
1.28 1.28 abcd
5
abcd
1.28
abcd
62.3
abcd
1.28
-46
5

Các bài tập về hàm luôn đòi hỏi phải có kèm chương trình chính gọi nó để minh
họa về hoạt động cũng như cách sử dụng hàm.
Một số hàm đã hoặc sẽ được bổ sung vào hệ thống lập trình cho Python. Việc tự
xây dựng các hàm đó không đơn thuật có ý nghĩa học thuật. Các hàm tự xây dựng
có thể dễ dàng sửa đổi, thích nghi với các tình huống cụ thể để cho sơ đồ xử lý
hiệu quả.
VI.01 – Độ dài đoạn thẳng
Cho 2 điểm trên mặt phẳng, điểm A có tọa độ (xa, ya), điểm B có tọa độ (xb,
yb). Các tọa độ nhận giá trị thực.
Khoảng cách Euclide dA,B được tính theo công thức:
dA,B = √(𝑥𝑎 − 𝑥𝑏)2 + (𝑦𝑎 − 𝑦𝑏)2
Xây dựng hàm tính khoảng cách dA,B.
Nhập tọa độ 3 điểm A, B, C trên mặt phẳng. Sử dụng hàm nói trên để tìm và đưa
ra độ dài cạnh ngắn nhất của ABC (ABC có thể suy biến).
Kết quả đưa ra với độ chính xác 6 chữ số sau dấu
chấm thập phân. Oy B
Ví dụ:
INPUT OUTPUT A Ox
-2 -1 4.609772
3.5 2
2.5 -2.5 C
VI.02 – Tính nhanh lũy thừa theo mô đun
Hãy xây dựng hàm fpower(a,n,p) tính nhanh giá trị an theo mô đun p với
a, n, p là các số nguyên dương.
Nhập các số nguyên dương x, y, và z. Sử dụng hàm đã xây dựng để đưa ra giá
trị xy theo mô đun z.

Ví dụ:
INPUT OUTPUT
2 10 100 24
VI.03 – Tính nhanh tích 2 số nguyên theo mô đun p
Hãy xây dựng hàm fmult(x,y,p) tính nhanh giá trị x*y theo mô đun p với
x, y, p là các số nguyên dương.
Nhập các số nguyên dương a, b, và c. Sử dụng hàm đã xây dựng để đưa ra giá
trị a*b theo mô đun c.
Ví dụ:
INPUT OUTPUT
95 11 100 45
VI.04 – Lower_bound và Upper_bound
Xây dựng các hàm lower_bound và upper_bound với tham số là danh sách
đã sắp xếp không giảm và giá trị val, hàm lower_bound trả về vị trí của phần
tử lớn nhất trong a không nhỏ hơn val, hàm upper_bound trả về vị trí của
phần tử nhỏ nhất trong a lớn hơn val.
Trong trường hợp không tồn tại vị trí cần tìm, hàm lower_bound trả về vị trí
-1, hàm upper_bound trả về vị trí len(a).
Viết chương trình nhập b = (b1, b2, . . ., bn) và giá trị v, gọi các hàm nói trên,
đưa ra vị trí và giá trị phần tử b tương ứng.
Dòng dầu tiên chứa số nguyên n,
Dòng thứ 2 chứa n số nguyên b1, b2, . . ., bn, bi ≤ bi+1, i = 1 ÷ n-1,
Dòng thứ 3 chứa số nguyên v.
Kết quả: Đưa ra thiết bị ra chuẩn của hệ thống 2 dòng, mỗi dòng chứa 2 số nguyên
– chỉ số và giá trị phần tử b tương ứng.

Các hàm lower_bound và upper_bound hoạt động tương tự như
bisect_left và bisect_right trong thư viện bisect.
Ví dụ:
INPUT OUTPUT
10 Lower bound: 7 18
1 3 8 12 12 15 18 25 30 45 Upper bound: 8 25
19
VI.05 – Giá trị đa thức
Xây dựng hàm polynomial tính giá trị đa thức

P(x) = a0xn + a1xn-1+ . . . + an-1x + an
Với các tham số vào:
Mảng nguyên a = (a0, a1. . . ., an)
Số nguyên n,
Số thực x.
Trả về: Giá trị thực P(x).
Lập trình nhập một mảng a và giá trị x, sử dụng hàm đã xây dựng để đưa ra giá
trị P(x).
Ví dụ:
INPUT OUTPUT
3 84.0
1 -2 3 -6
5
VI.06 – Dãy số khác nhau
Xây dựng hàm kiểm tra các số trong mảng số nguyên a khác nhau từng đôi một
hay không, trả về kết quả 1 nếu các số khác nhau từng đôi một và 0 trong trường
hợp ngược lại.

Lập trình tạo mảng chứa n số nguyên, các số được khởi tạo ngẫu nhiên trong đoạn
[a, b], gọi hàm đã xây dựng kiểm tra các số trong mảng khác nhau từng đôi
một hay không và đưa ra thông báo Yes hoặc No tương ứng.
Ví dụ:
INPUT OUTPUT
15 Yes
0 1000

VII.01 – Số lớn nhất trong bảng
Cho n, m và bảng a kích thước n×m (n dòng, m cột), mỗi phần tử của bảng là một
số nguyên. Hãy chỉ ra tọa độ dòng và cột của phần tử lớn nhất trong bảng. Nếu
có nhiều phần tử cùng đạt max thì đưa ra tọa độ của phần tử ở dòng có chỉ số nhỏ
nhất. Nếu trong dòng này có nhiều phần tử cùng đạt max thì đưa ra tọa độ phần
tử có cột nhỏ nhất.
Ví dụ:
INPUT OUTPUT
3 4 1 2
4 2 3 5
1 5 6 2
0 5 3 4
VII.02 – Bông tuyết
Cho n là một số nguyên dương lẻ, vẽ hình bông tuyết kích thước n×n bằng cách
tạo bảng a kích thước n×n, mỗi phần tử là một ký tự ‘.’, sau đó thay các ký tự
trên đường chéo chính, đường chéo phụ, trên cột giữa và hàng giữa của bảng bằng
ký tự ‘*’.
Đưa ra bảng a nhận được.
Ví dụ:
INPUT OUTPUT
5 * . * . *
. * * * .
* * * * *
. * * * .
* . * . *

VII.03 – Các đường chéo

Tạo bảng a kích thước n×n theo quy tắc sau:
Những phần tử trên đường chéo chính nhận giá trị 0,
Những phần tử trên các đường chéo kề với đường chéo chính nhận giá trị
1,
Những phần tử trên các đường chéo kề với đường chéo giá trị 1 nhận giá trị
2,
.......
Đưa ra bảng nhận được sau các phép xử lý trên.
Ví dụ:
INPUT OUTPUT
6 0 1 2 3 4 5
1 0 1 2 3 4
2 1 0 1 2 3
3 2 1 0 1 2
4 3 2 1 0 1
5 4 3 2 1 0
VII.04 – Đường chéo phụ

Tạo bảng a kích thước n×n theo quy tắc sau:
Những phần tử trên đường chéo phụ nhận giá trị 1,
Những phần tử bên trái đường chéo phụ nhận giá trị 0,
Những phần tử bên phải đường chéo phụ nhận giá trị 2.
Đưa ra bảng nhận được sau các phép xử lý trên.

Ví dụ:
INPUT OUTPUT
6 0 0 0 0 0 1
0 0 0 0 1 2
0 0 0 1 2 2
0 0 1 2 2 2
0 1 2 2 2 2
1 2 2 2 2 2
VII.05 – Đổi chổ cột
Xét mảng a kích thước n×m, trong đó n – số hàng, m – số cột, ai,j nhận giá trị
nguyên.
Cho 2 số nguyên p và q (0 ≤ p, q < m, p ≠ q).
Hãy xây dựng hàm đổi chổ 2 cột u và v của a và gọi hàm để đổi chổ 2 cột p, q
của a. Đưa ra mảng a sau biến đổi.
Dữ liệu: vào từ thiết bị vào chuẩn:
Dòng đầu tiên chứa 2 số nguyên dương n và m,
Mỗi dòng trong n dòng sau chứa m số nguyên xác định một dòng của a,
các số trên một dòng cách nhau một dấu cách,
Dòng cuối cùng chứa 2 số nguyên p và q (0 ≤ p, q < m, p ≠ q).
Kết quả: Đưa ra thiết bị ra chuẩn mảng nhận được sau biến đổi.
Ví dụ:
INPUT OUTPUT
5 6 0 0 0 0 0 1
0 0 0 0 0 1 0 1 0 0 0 2
0 0 0 0 1 2 0 2 0 1 0 2
0 0 0 1 2 2 0 2 1 2 0 2
0 0 1 2 2 2 0 2 2 2 1 2
0 1 2 2 2 2
1 4
Lập trình tạo ma trận b kích thước m×n (m hàng, n cột), mỗi phần tử là một số
ngẫu nhiên trong phạm vi từ x đến y.

Với số nguyên k cho trước hãy xác định k gặp bao mhiêu lần trong b và tại các
vị trí nào.
Dòng thứ nhất chứa 2 số nguyên m và n,
Dòng thứ 2 chứa 2 số nguyên dương x, y (1 ≤ x < y),
Dòng thứ 3 chứa số nguyên k.
Kết quả: Đưa ra thiết bị ra chuẩn
Đưa ra số lượng phần tử của b nhận giá trị bằng k,
Các dòng tiếp theo, mỗi dòng chứa cặp số nguyên xác định tọa độ phần tử
bằng k, các dòng và cột của b được đánh số bắt đầu từ 1.
Lưu ý: Với mục đích hiệu chỉnh, chương trình có thể đưa ra ma trận b.
Ví dụ: Một khả năng có thể của kết quả ra
INPUT OUTPUT
5 6 28 18 17 8 18 7
5 30 14 16 24 8 11 8
10 8 24 30 16 22 22
20 20 23 28 16 27
23 16 16 27 18 11
Total: 0
Xét mảng 2 chiều Am×n ( m hàng và n cột), mỗi phần tử của mảng là một số
nguyên. Hãy xác định cột có tổng giá trị các phần trên cột là lớn nhất, hàng có
tổng giá trị các phần trên hàng là lớn nhất. Tính và đưa ra tổng các phần tử trên
hàng và cột tìm được.
Dòng đầu tiên chứa 2 số nguyên m và n,
Mỗi dòng trong m dòng sau chứa n số nguyên xác định một hàng của bảng,
các số ghi cách nhau ít nhất một dấu cách,
Kết quả: Đưa ra thiết bị ra chuẩn một số nguyên – tổng tìm được.

Ví dụ:
INPUT OUTPUT
4 5 21
1 -2 6 0 2
3 4 4 1 -3
1 -1 1 -2 -3
2 1 5 1 0

VIII.01 – Số phần tử khác nhau
Xét danh sách a chứa các phần tử có thể cùng hoặc khác kiểu dữ liệu.
Hãy đưa ra số lượng phần tử khác nhau của a.
Ví dụ:
INPUT OUTPUT
5 -12.6 5 swan 5 swan 12.6 4
VIII.02 – Số phần tử chung
Xét các phần tử ở 2 danh sách và đưa số lượng phần tử đồng thời có mặt ở cả hai
danh sách đã cho.
Ví dụ:
INPUT OUTPUT
5 -12.6 5 swan 5 swan 12.6 2
duck swan 12.6 duck duck 12.6
VIII.03 – Danh sách phần tử chung
Xét các phần tử ở 2 danh sách và đưa các phần tử đồng thời có mặt ở cả hai danh
sách đã cho theo thứ tự sắp xếp tăng dần.
Ví dụ:
INPUT OUTPUT
5 -12.6 5 swan 5 swan 12.6 12.6 swan
duck swan 12.6 duck duck 12.6

VIII.04 – Số mới
Đọc lần lượt từ đầu đến cuối các số của một dãy số nguyên, với mỗi số đưa ra
thông báo NEW nếu đó là số mới, chưa gặp lần nào trong quá trình đọc hoặc OLD
trong trường hợp ngược lại.
Ví dụ:
INPUT OUTPUT
5 8 1 5 2 8 2 6 NEW NEW NEW OLD NEW OLD OLD NEW
VIII.05 – Bảo tàng gen
Ở Oslo Na Uy và NewYork Mỹ đề có Viện bảo tàng gen, lưu trữ gen thực động
vật đã có trên thế giới. Các gen được mã hóa theo quy tắc chung, mỗi loại gen
được đặt tương ứng với một số nguyên trong phạm vi từ 1 đến 108.
Trong một dự án khoa học hai Viện hợp tác, trao đổi và phối hợp với nhau cùng
phát hiện và bảo vệ các gen quý.
Việc đầu tiên cần làm là xác định những gen nào cùng có ở cả 2 Viện, những gen
chỉ có ở Viện Oslo và những gen chỉ có ở Viện NewYork.
Hãy xác định số lượng và chỉ ra cụ thể các gen trong mỗi tập đã nêu.
Dòng đầu tiên chứa 2 số nguyên n và m – số lượng gen có Viện Oslo và ở
Viện NewYork,
n số tiếp theo, mỗi số trên một dòng xác định các gen lưu Viện Oslo,
m số tiếp theo, mỗi số trên một dòng xác định các gen lưu Viện NewYork.
Dòng thứ nhất chứa số nguyên xác định số lượng gen có ở cả hai Viện,
Dòng thứ 2: ghi các gen có chung,
Dòng thứ 3: chứa số nguyên xác định số lượng gen chỉ có ở Oslo,
Dòng thứ 4: ghi các gen chỉ có ở Oslo,
Dòng thứ 5: chứa số nguyên xác định số lượng gen chỉ có ở NewYork,
Dòng thứ 6: ghi các gen chỉ có ở NewYork.

Các gen ở mỗi tập được đưa ra theo thứ tự tăng dần.
Ví dụ: Một khả năng có thể của kết quả ra
INPUT OUTPUT
5 8 4
2 6 5 4 9 4 5 6 9
1 10 6 4 5 7 8 9 1
2
4
1 7 8 10
VIII.06 – Số lượng từ
Xét một số xâu, mỗi xâu chứa các từ. Từ là dãy ký tự liên tiếp không chứa dấu
cách. Các từ trong xâu cách nhau một hoặc nhiều dấu cách. Trước từ đầu tiên và
sau từ cuối cùng có thể không có dấu cách.
Thông tin về văn bản bắt đầu bằng dòng chứa một số nguyên xác định số dòng
trong văn bản, các dòng tiếp theo chứa xâu trong văn bản.
Hãy xác định văn bản chứa bao nhiêu từ.
Ví dụ:
INPUT OUTPUT
3 13
12 345 6 7 890
a bc def gh
dxy ljm lkmnb gtr
VIII.07 – Đoán số
Trong thời gian bị cách ly vì COVID các bạn trẻ có rất nhiều thời gian rãnh và
thường tổ chức các trò chơi qua mạng.
Alice báo cho Bob là mình nghĩ một số nguyên dương không vượt quá n trong
đầu và đề xuất Bob tìm ra số đó bằng cách nêu một tập số, Alice sẽ trả lời Yes
nếu tập đó chứa số cần đoán và No trong trường hợp ngược lại.
Với chiến lược đúng Bob có thể tìm được câu trả lời sau không quá logn lần đoán.
Đáng tiếc, Bob say mê đủ mọi thứ, trừ tin học. Sau một số lần đoán, Bob xin chịu

thua, đưa ra thông báo Help. Alice sẽ chỉ ra cho Bob biết các lần đoán đã thu
nhỏ tập cần tìm và chỉ ra tập đó.
Dựa vào biên bản cuộc chơi: dòng đầu tiên chứa số n, các cặp dòng tiếp theo chứa
danh sách các số Bob đoán và câu trả lời của Alice, dòng cuối cùng chứa thông
báo Help hãy đưa ra tập các số còn lại cần tìm.
Ví dụ:
INPUT OUTPUT
10 6 7
1 2 3 4
No
6 7 8 9
Yes
4 5 6 7
Yes
8 9
No
Help
VIII.08 – Ngoại ngữ

Trường đại học ngoại ngữ có n sinh viên, mỗi sinh viên biết một số ngoại ngữ.
Hãy xác định:
Số lượng và các ngoại ngữ mọi sinh viên đều biết,
Số lượng và các ngoại ngữ có ít nhất một sinh viên biết.
Các dòng tiếp theo chia thành n nhóm, nhóm thứ i có quy cách:
Dòng đầu tiên chứa số nguyên ki – số ngoại ngữ sinh viên thứ i biết,
Mỗi dòng trong số ki dòng tiếp theo chứa tên một ngoại ngữ sinh
viên thứ i biết
Dòng đầu tiên chứa số nguyên p – số lượng các ngoại ngữ mọi sinh viên
đều biết,
p dòng sau mỗi dòng chứa tên một ngoại ngữ mọi người đều biết,

Dòng tiếp theo chứa số nguyên q – số lượng các ngoại ngữ có ít nhất một
người biết,
q dòng sau mỗi dòng chứa tên một ngoại ngữ có ít nhấtmột người biết,
Tên các ngoại ngữ được đưa ra theo thứ tự từ điển tăng dần.
Ví dụ:
INPUT OUTPUT
5 1
3 English
French 7
Rusian Arab
English Chiness
2 Deuch
English English
Rusian French
3 Latin
English Rusian
Arab
Latin
2
Chiness
English
3
Deuch
French
English
Russian
VIII.09 – Bãi công

Ở một nước có k đảng chính trị hoạt động. Để phản đối một chính sách mới của
chính phủ các đảng tổ chức phản đối trong vòng n ngày bằng cách lần lượt kêu
gọi đình công theo lịch, đảng thứ i lên kế hoạch cứ mỗi bi ngày đình công một
ngày bắt đầu từ ngày ai, tức là đình công sẽ diễn ra ở các ngày ai, ai+bi,
ai+2*bi, . . . Có thể sẽ có những ngày đình công diễn ra theo lời kêu gọi của
nhiều đảng phái.
Một tuần có 7 ngày đánh số từ 1 đến 7, trong đó 2 ngày cuối tuần (ngày thứ 6 và
thứ 7) là ngày nghỉ. Các ngày còn lại là ngày làm việc. Những cuộc đình công
xẩy ra trong ngày làm việc sẽ gây tổn hại lớn cho nền kinh tế. Ngày đầu tiên trong
đợt n ngày này là ngày 1 trong tuần.
Hãy xác định có bao nhiêu ngày làm việc rơi vào trạng thái đình công.

Dòng đầu tiên chứa 2 số nguyên dương n và k,
Dòng thứ i trong k dòng tiếp theo chứa 2 số nguyên dương ai và bi.
Kết quả đưa ra thiết bị ra chuẩn của hệ thống một số nguyên – số ngày làm việc
rơi vào trạng thái đình công.
Ví dụ:
INPUT OUTPUT
50 3 17
5 5
4 8
2 9
Nhập dãy số nguyên, các số của dãy ghi trên một dòng, cách nhau ít nhất một dấu
cách.
Tìm và đưa ra số xuất hiện nhiều nhất trong dãy số cùng số lần xuất hiện.
Nếu tồn tại nhiều số khác nhau cùng xuất hiện nhiếu lần như nhau – đưa ra số có
giá trị nhỏ nhất.
Ví dụ:
INPUT OUTPUT
4 4 3 4 2 3 4 2 3 6 2 3 2 3 2 8 2 5

Sàng Eratosthenes là giải thuật tìm các số nguyên tố trong khoảng [1, n].
Nguyên lý làm việc của sàng khá đơn giản: lập bảng b đánh dấu từ 0 đến n:
0 nếu i là hợp số,

bi =
1 nếu i là số nguyên tố.
Ban đầu b0 = b1 = 0, bi = 1, i = 2 ÷ n.
Xuất phát từ q = 1:
B1 – Tìm p nhỏ nhất thỏa mãn các điều kiện:
p > q và p < n,
bp = 1,
B2 – Cho bj = 0 với mọi j > p và chia hết cho p,
B3 – Gán q = p.
Lặp lại các bước trên cho đến khi không tìm được p.
i sẽ là nguyên tố nếu bi = 1.
Cho m số nguyên dương n1, n2, . . ., nm, mỗi số không vượt quá 107.
Với mỗi số ni đã cho hãy xác định số lượng số nguyên tố không vượt quá ni vừa
đưa ra các số nguyên tố đó.
Dữ liệu: vào từ file văn bản INPUT.TXT:
Dòng đầu tiên chứa số nguyên m (1 ≤ m ≤ 100),
Dòng thứ i trong m dòng sau chứa số nguyên ni (1 <ni ≤ 107).
Kết quả: đưa ra file văn bản OUTPUT.TXT, với mỗi số ni (i = 1 ÷ m) đưa ra 2
dòng:
 Dòng đầu tiên chứa 2 số nguyên ni và k – số lượng số nguyên tố không
vượt quá ni,
 Dòng thứ 2 chứa k số nguyên: danh sách các số nguyên tố tìm được ứng
với ni,
 Sau mỗi nhóm 2 dòng (trừ nhóm cuối cùng ) là một dòng trống.
Các số trên một dòng ghi cách nhau một dấu cách.

Ví dụ:
INPUT.TXT OUTPUT.TXT
3 10 4
10 2 3 5 7
30
100 30 10
2 3 5 7 11 13 17 19 23 29
100 25
2 3 5 7 11 13 17 19 23 29 31 37 41 43
47 53 59 61 67 71 73 79 83 89 97
Ngoài việc tìm ước số chung lớn nhất (gcd) của 2 số a và b, nhiều khi ta còn phải
biết các hệ số thể hiện gcd qua a và b, tức là phải tìm x và y thỏa mãn
a×x + b×y = gcd(a,b)
Với a và b đã cho, hãy tìm một cặp số nguyên x và y thỏa mãn điều kiện nêu
trên.
Dữ liệu: vào từ file văn bản INPUT.TXT gồm một dòng chứa 2 số nguyên a và
b.
Kết quả: đưa ra file văn bản OUTPUT.TXT các số x, y và gcd(a,b) trên một
dòng.
Các số ghi trên một dòng cách nhau một dấu cách.
Ví dụ:
25 15 -1 2 5

Với số nguyên dương m cho trước, tập các số nguyên 0, 1, 2, . . ., m-1 được gọi là
vành tạo bởi mô đun m.
Số nguyên b được gọi là nghịch đảo của số nguyên a theo mô đun m nếu
a×b ≡ 1 (mod m)
b còn thường được ký hiệu là a-1.
Ví dụ, với a = 15, m = 8 thì b = (7: 15×7)%8 = 105%8 = 1
Cho a và m, hãy tìm b.
Dữ liệu: vào từ file văn bản INPUT.TXT gồm một dòng chứa 2 số nguyên a và
m, các số ghi cách nhau một dấu cách.
Kết quả: đưa ra file văn bản OUTPUT.TXT giá trị b tìm dược.
Ví dụ:
15 8 7
Cho số nguyên tố m. Hãy tìm nghịch đảo theo mô đun m của mỗi số trong đoạn
[1..m-1].
Dữ liệu: vào từ file văn bản INPUT.TXT gồm một dòng chứa số nguyên m.
Kết quả: đưa ra file văn bản OUTPUT.TXT m-1 số nguyên – các nghịch đảo tìm
được, các số ghi cách nhau một dấu cách.
Ví dụ:
11 1 6 4 3 9 2 8 7 5 10
Cho 3 số nguyên dương a, b và m, trong đó a và m – nguyên tố cùng nhau. Hãy

tìm số nguyên x thỏa mãn điều kiện
ax = b (mod m).

Dữ liệu: Vào từ file văn bản INPUT.TXT gồm một dòng chứa 3 số nguyên dương
a, b và m (1 ≤ a , b, m ≤ 109).
Kết quả: Đưa ra file văn bản OUTPUT.TXT một số nguyên – kết quả tìm được.
Nếu không tồn tại x thì đưa ra số -1.
Ví dụ:
3 43 100 5
Cho phương trình tuyến tính 2 ẩn số

a×x + b×y = c,
trong đó a, b, c – các số nguyên.
Các yêu cầu thực hiện có thể là:
Một cặp số nguyên (x, y) là nghiệm của phương trình trên,
Tìm tất cả các nghiệm thuộc miền cho trước,
Tính số lượng nghiệm thuộc miền cho trước,
Tìm nghiệm có tổng các ẩn số là nhỏ nhất thuộc miền cho trước.
Trong trường hợp bài toán vô nghiệm – đưa ra số -1.
Hãy lập các chương trình độc lập, mỗi chương trình xử lý một yêu cầu.
Dữ liệu: Vào từ file văn bản INPUT.TXT gồm một dòng chứa 3 số nguyên dương
a, b và c.Với các yêu cầu 2, 3 và 4: dòng thứ 2 chứa 4 số nguyên minx, maxx,
miny và maxy.
Kết quả: Đưa ra file văn bản OUTPUT.TXT kết quả tìm được. Nếu không tồn tại
x thì đưa ra số -1.
Ví dụ: Tìm một nghiệm
4 10 12 -12 6
Ví dụ: Đưa ra tất cả các nghiệm và nghiệm có tổng nhỏ nhất

2 -3 4 5
-5 15 0 15 14 8
11 6
8 4
5 2
2 0
Solution with min sum: 2 0
Cho các số nguyên a, b, n (n > 0). Hãy tìm các số nguyên x trong đoạn [0, n-1]
thỏa mãn điều kiện a×x = b (mod n).
Dữ liệu: Vào từ file văn bản INPUT.TXT gồm một dòng chứa 3 số nguyên a, b và
n (0 ≤ a, b ≤ 109, 0 < n ≤ 2×109 ).
Kết quả: Đưa ra file văn bản OUTPUT.TXT:
Dòng đầu tiên chứa số nguyên k – số lượng số tìm được,
Nếu k > 0: Dòng thứ 2 chứa k số thỏa mãn điều kiện bài toán.
Ví dụ:
5 9 13 1
7
Cho các số nguyên dương n và k. Hãy tìm số nguyên x lớn nhất thỏa mãn điều
kiện n! chia hết cho kx.
Dữ liệu: Vào từ file văn bản INPUT.TXT gồm một dòng chứa 2 số nguyên n và
k (1 ≤ n ≤ 109, 1 < k ≤ 1015).
Kết quả: Đưa ra file văn bản OUTPUT.TXT số nguyên x tìm được.
Ví dụ:
6 3 2

Dữ liệu: Vào từ file văn bản INPUT.TXT gồm một dòng chứa 2 số nguyên n và
p (1 ≤ n ≤ 109, 1 < k ≤ 1015).
Kết quả: Đưa ra file văn bản OUTPUT.TXT một số nguyên – kết quả tìm được.
Ví dụ:
10 5 2
Ví dụ, với n = 10 thì g = 3: Các số nguyên tố cùng nhau với n là 3, 7 và 9.

Ta có: 31 = 3 (mod 10)
33 = 7 (mod 10)
32 = 9 (mod 10)
Yêu cầu: Cho số nguyên n. Hãy tìm g.
Dữ liệu: Vào từ file văn bản INPUT.TXT gồm một dòng chứa số nguyên n.
Kết quả: Đưa ra file văn bản OUTPUT.TXT số nguyên g.
Ví dụ:
10 3

Dữ liệu:
Kết quả:
Ví dụ:
6 3 7 3
3 5 6
Thủy triều đỏ là một thuật ngữ thông dụng được dùng để chỉ một trong một loạt
các hiện tượng tự nhiên được gọi là tảo nở hoa gây hại hay HABs (viết tắt của
cụm từ tiếng anh Harmful Algal Blooms). Thuật ngữ Thủy triều đỏ được sử dụng
đặc biệt để đề cập đến sự nở hoa của một loài tảo có tên là Karenia brevis. Thủy
triều đỏ gây tác hại lớn cho môi trường vì nó dẫn đến cái chết hàng loạt của nhiều
loại sinh vật biển.
Cứ mỗi chu kỳ sinh sản mỗi cá thể tảo phát triển thành a cá thể. Phụ thuộc vào
nhiệt độ và nồng độ các chất hữu cơ hòa tan trong nước, tảo Karenia brevis có
thể phát triển nhanh hay chậm, vì vậy hệ số phát triển a không cố định mà thay
đổi theo từng chu kỳ phát triển.
Ở m vùng biển có hiện tượng thủy triều đỏ các nhà khoa học lấy mẫu nước và ước
lượng số cá thể tảo độc trong một đơn vị thể tích của từng mẫu, mẫu nước thứ i
có bi cá thể, i = 1 ÷ m. Ở mức vô hại, ban đầu trong mỗi đơn vị thể tích nước chỉ
có thể có một cá thể. Người ta muốn biết nhiều nhất có bao nhiêu chu kỳ sinh sản
đã xẩy ra, từ đó liên hệ với các yếu tố môi trường để tìm ra nguyên nhân chính
gây ra thảm họa môi trường.

Ví dụ, với b1 = 20, nhiều nhất có 3 chu kỳ phát triển với các hệ số phát triển là 2,
2 và 5: 20 = 1×2×2×5.
Với mỗi mẫu nước hãy đưa ra số chu kỳ phát triển nhiều nhất có thể và hệ số phát
của từng chu kỳ, các hệ số đưa ra theo thứ tự không giảm.
Dữ liệu: Vào từ file văn bản INPUT.TXT:
Dòng đầu tiên chứa một số nguyên m (1 ≤ m ≤ 1000),
Dòng thứ 2 chứa m số nguyên b1, b2, . . ., bm (1 < bi ≤ 2×109, i = 1 ÷ m).
Kết quả: Đưa ra file văn bản OUTPUT.TXT, thông tin về mỗi mẫu nước đưa ra
trên 2 dòng, dòng đầu tiên là một số nguyên k – số chu kỳ phát triển nhiều nhất
có thể, dòng thứ 2 chứa k số nguyên (theo thứ tự không giảm) xác định hệ số phát
triển của tảo trong từng chu kỳ.
Ví dụ:
4 3
20 108 896045556 231 2 2 5
5
2 2 3 3 3
7
2 2 3 7 7 163 9349
3
3 7 11
Xét dãy số Fibonacci:

 F0 = F1 =1,
 Fn = Fn-1 + Fn-2, n ≥ 2.
Với số nguyên a và b cho trước, hãy tính s = ∑𝑏𝑖=𝑎 𝐹𝑖 và đưa ra theo mô đun 109.
Dữ liệu: Vào từ file INPUT.TXT một số dòng, mỗi dòng chứa 2 số nguyên a và
b (0 ≤ a ≤ b ≤ 109).
Kết quả: Đưa ra file OUTPUT.TXTcác kết quả tính được dưới dạng số nguyên,
mỗi số trên một dòng.

Ví dụ:
INPUT OUTPUT
1 1 1
3 5 16
10 1000 496035733
Xét xâu chỉ chứa các ký tự ngoặc tròn ( và ). Xâu tạo thành một biểu thức ngoặc
đúng nếu thỏa mãn điều kiện định nghĩa biểu thức ngoặc đúng:
Xâu rỗng là một biểu thức ngoặc đúng,
Nếu A là biểu thức ngoặc đúng thì (A) cũng là một biểu thức ngoặc đúng,
Nếu A và B là các biểu thức ngoặc đúng thì AB cũng là một biểu thức ngoặc
đúng.
Xét biểu thức ngoặc đúng độ dài 2×n. Biểu thức sẽ chứa n ngoặc mở và n ngoặc
đóng. Mỗi ngoặc mở sẽ tương ứng với đúng một ngoặc đóng mà xâu con các ký
tự giữa 2 ngoặc này là một biểu thức ngoặc đúng, 2 ngoặc này tạo thành cặp ngoặc
liên hợp. Số ký tự nằm giữa 2 ngoặc của một cặp ngoặc liên hợp được gọi là
khoảng cách của cặp ngoặc đó.
Cho số nguyên n và khoảng cách của các cặp ngoặc liên hợp trong biểu thức
ngoặc.
Nếu có thể xác định biểu thức ngoặc đúng có khoảng cách các cặp ngoặc liên hợp
thỏa mãn dữ liệu đã cho thì đưa ra thông báo Yes và ở dòng tiếp theo – một biểu
thức ngoặc đúng tùy chọn thỏa mãn điều kiện đã nêu.
Nếu không tồn tại biểu thức ngoặc đúng thỏa mãn điều kiện đã nêu – đưa ra
thông báo No.
Dữ liệu: Vào từ thiết bị vào input chuẩn của hệ thống:
Dòng đầu tiên chứa một số nguyên n (1 ≤ n ≤ 20),
Dòng tứ 2 chứa n số nguyên a1, a2, . . ., an – khoảng cách của các cặp
ngoặc liên hợp (0 ≤ ai ≤ 2×n, i = 1 ÷ n).
Kết quả: Đưa ra thiết bị ra chuẩn của hệ thống các thông tin xác định được theo
quy cách đã nêu.

Ví dụ:
INPUT OUTPUT
5 Yes
0 0 0 2 6 ()((())())
Cho tam giác ABC với đỉnh là các điểm có tọa độ nguyên (xa, ya), (xb, yb) và
(xc, yc). Hãy tính và đưa ra diện tích của tam giác đã cho.
Dữ liệu: vào từ file INPUT.TXT gồm 3 dòng, mỗi dòng chứa 2 số nguyên xác
định tọa độ của một đỉnh. Các số trên một dòng ghi cách nhau một dấu cách.
Kết quả: đưa ra file OUTPUT.TXT diện tích tính được.
Ví dụ:
1 5 1000.0
31 45
61 5
Cho hình chữ nhật được xác định bởi tọa độ 2 đỉnh đối (xa, ya) và (xc, yc). Các
tọa độ có giá trị nguyên.
Hãy xác định bán kính đường tròn ngoại tiếp hình chữ nhật đã cho.
Dữ liệu: vào từ file INPUT.TXT, dòng thứ nhất chứa 2 số nguyên xa, ya, dòng
thứ hai chứa 2 số nguyên xc, yc. Các số trên một dòng ghi cách nhau một dấu
cách.
Kết quả: đưa ra file OUTPUT.TXT độ dài bán kính xác định được.
Ví dụ:
INPUT OUTPUT
0 30 25.0
40 0

Cho tam giác được xác định bởi tọa độ3 đỉnh (xa, ya), (xb, yb) và (xc, yc). Các tọa
độ có giá trị nguyên.
Hãy xác định tọa độ tâm và bán kính đường tròn ngoại tiếp tam giác đã cho.
Dữ liệu: Vào từ file INPUT.TXT:
Dòng thứ nhất chứa 2 số nguyên xa, ya,
Dòng thứ hai chứa 2 số nguyên xb, yb,
Dòng thứ ba chứa 2 số nguyên xc, yc.
Kết quả: đưa ra file OUTPUT.TXT:
Dòng thứ nhất chứa 2 số xác định tọa độ tâm của đường tròn ngoại tiếp
tam giác,
Dòng thứ 2 chứa số xác định độ dài bán kính của đường tròn ngoại tiếp.
Ví dụ:
INPUT OUTPUT
0 0 20.0
0 30 15.0
40 0 25.0
Cho n đoạn thẳng trên đường thẳng, đoạn thứ i có tọa độ các điểm đầu và cuối
là ai, bi. Hãy tính độ dài của hợp các đoạn đã cho.
Dòng đầu tiên chứa một số nguyên n (1 ≤ n ≤ 105),
Dòng thứ i trong n dòng sau chứa 2 số nguyên ai và bi (-109 ≤ ai ≤ bi ≤
109).
Kết quả: Đưa ra file văn bản OUTPUT.TXT một số nguyên – độ dài tính được.

Ví dụ:
4 17
1 5
3 8
14 16
10 20
Xét đa giác n đỉnh diện tích khác 0, cạnh không tự cắt và trong mặt phẳng với hệ
tọa độ Đề các tọa độ các đỉnh đa giác đều nguyên, đỉnh thứ i có tọa độ (xi, yi),
i = 1 ÷ n.
Hãy xác định k và m, trong đó k là số lượng điểm có tọa độ nguyên nằm trên cạnh
của đa giác (có thể là đỉnh) và m – số lượng điểm có tọa độ nguyên nằm trong đa
giác.
Dữ liệu vào từ file văn bản INPUT.TXT, dòng đầu tiên chứa số nguyên n, dòng
thứ i chứa 2 số nguyên xi, yi ghi cách nhau một dấu cách, xác định tọa độ đỉnh
i của đa giác. Các đỉnh được liệt kê theo một chiều nào đó.
Kết quá đưa ra file văn bản OUTPUT.TXT trên một dòng 2 số nguyên k và m,
các số ghi cách nhau một dấu cách.
Ví dụ:
INPUT.INP OUTPUT.OUT
6 12 15
2 1
0 3
3 6
6 5
8 1
4 3

Cho n đoạn thẳng trên đường thẳng, đoạn thứ i có tọa độ các điểm đầu và cuối
là ai, bi. Hãy xác định số lượng ít nhất các điểm cần chọn để mỗi đoạn thẳng đã
cho chứa ít nhất một điểm trong số đã chọn.
Dòng đầu tiên chứa một số nguyên n (1 < n ≤ 105),
Dòng thứ i trong n dòng sau chứa 2 số nguyên ai và bi(-109 ≤ ai ≤ bi ≤
109).
Kết quả: Đưa ra file văn bản OUTPUT.TXT một số nguyên – số điểm ít nhất cần
chọn.
Ví dụ:
7 4
1 5
3 8
30 32
25 35
33 33
10 20
14 16
Đây là mô hình toán học của một dạng bài toán lập lịch.
Để tạo không khí học tập sôi động, thầy giáo yêu cầu mỗi người trong lớp viết
một biểu thức số học trong Python với các toán hạng là các hằng, các biến nguyên
a, b, c. Biểu thức có thể chứa các cặp ngoặc tròn (, ).
Khi chấm, một bộ 3 giá trị các biến sẽ được tạo ngẫu nhiên trong phạm vi [-10,
10] với a, [-5, 5] với b và [0, 10] với c và được dùng để tính cho mọi
biểu thức đã nộp và từ đó – tính trung bình các giá trị nhận được.
Ai có biểu thức với giá trị không lệch quá giá trị trung bình 20% sẽ được miễn
kiểm tra một tiết sắp tới.

Dĩ nhiên cả lớp rất hào hứng với trò chơi may rủi này. Các biểu thức được ghi
vào file văn bản INPUT.TXT:
Dòng đầu tiên chứa số nguyên n – số biểu thức đã nộp,
Dòng thứ i trong n dòng sau chứa biểu thức của người i (i = 1, 2, . . ., n).
Hãy viết chương trình chấm, đưa ra file văn bản OUTPUT.TXT các kết quả:
Dòng đầu tiên là giá trị 3 biến a, b, c được khởi tạo lúc chấm,
Dòng thứ 2 chứa giá trị trung bình của các biểu thức với độ chính xác 6
chữ số sau dấu chấm thập phân,
Dòng thứ 3 nêu số lượng người có giá trị biểu thức không lệch quá giá trị
trung bình 20%,
Nếu số lượng nêu trên khác 0: dòng thứ tư đưa ra số thứ tự của những người
được miễn kiểm tra.
Cụ thể hơn về quy cách đưa ra: Xem ví dụ dưới đây.
Ví dụ:
INPUT.TXT
6
a**2 + b**2 + c*c
(a+b)*(a+c)- a*b*c
(a+b+c)/(a*a+b*b+c*c+1)
15*a - int(4/b) +6*c
a*b + a*c + b*c
a/(b*b+c*c+1) + b/(a*a+c*c+1) + c/(b*b+a*a+1)
OUTPUT.TXT
a,b,c: -1 3 6
Average: 17.295479
Total results in range: 1
Winners: 4

Alice đi xem xiếc và được mời lên sân khấu tham gia một tiết mục ảo thuật. Ảo
thuật gia đề nghị Alice viết và giữ riêng cho mình một hoán vị a1, a2, . . ., an các
số tự nhiên từ 1 đến n, với mỗi i từ 1 đến n Alice xét bộ 3 {ai, ai+1, ai+2}, an+1
= a1, an+2 = a2, viết ra mẩu giấy con 3 số này theo trình tự tùy ý. Tất cả n mẩu
giấy con này được xáo trộn và đưa cho ảo thuật gia.
Sau một thời gian chăm chú xem các mẩu giấy nhận được, ảo thuật gia ghi lên
bảng hoán vị mà Alice đã viết, bắt đầu từ 1.
Hãy xác định hoán vị mà ảo thuật gia tìm được.
Dòng đầu tiên chứa số nguyên n (3 ≤ n ≤ 2×105),
Mỗi dòng trong n dòng sau chứa 3 số nguyên đã ghi trên một mẩu giấy.
Dữ liệu đảm bảo hợp lý với hoán vị đã nghĩ của Alice.
Kết quả: Đưa ra file văn bản OUTPUT.TXT trên một dòng hoán vị được ghi trên
bảng.
Ví dụ:
6 1 3 4 2 5 6
3 4 1
5 1 6
5 4 2
2 4 3
2 5 6
6 1 3
Để theo dõi tình hình thời tiết ngoài khơi người thả n phao nổi chứa các thiết bị
đo đạc. Ban đầu các phao này được thả và neo dọc theo một đường thẳng.
Sau một thời gian, dưới tác động của gió và sóng, một số neo có thể bị chuyển
dịch làm cho các phao có khả năng không còn nằm trên một đường thẳng nữa.
Số liệu tự động gửi về cho thấy phao thứ i đang ở tọa độ (xi, yi), i = 1 ÷ n.

Hãy xác định có hay không việc chuyển dịch làm các phao không còn nằm trên
một đường thẳng nữa và nếu có – chỉ ra 3 phao không ở trên cùng một đường
thẳng.
Dòng đầu tiên chứa số nguyên n (3 ≤ n ≤ 105),
Dòng thứ i trong n dòng sau chứa 2 số nguyên xi và yi xác định tọa độ
của phao i (|xi|, |yi| ≤ 109).
Không có 2 phao nào ở cùng một điểm trên mặt phẳng.
Kết quả: Đưa ra file văn bản OUTPUT.TXT đưa ra thông báo Yes nếu có sự
dịch chuyển làm các phao không thẳng hàng hoặc No trong trường hợp ngược lại.
Nếu có sự chuyển dịch làm các phao không còn thẳng hàng thì ở dòng tiếp theo
đưa ra 3 số nguyên xác định theo tùy chọn 3 phao không thẳng hàng.
Ví dụ:
5 Yes
1 2 3 2 5
0 0
3 6
4 8
4 4
Bob được lớp cử đi mua hoa tặng Alice nhân ngày sinh nhật.
Quầy bán hoa trưng bày n loại hoa. Tại quầy loại thứ i có ai bông, i = 1 ÷ n.
Bob biết Alice thích số lẻ hơn số chẵn vì vậy quyết định mua một bó hoa gồm số
lẻ loại hoa và mỗi loại – có số lẻ bông.
Hãy xác định bó hoa Bob sẽ có số lượng tối đa bao nhiêu bông.
Dòng thứ 2 chứa n số nguyên a1, a2, . . ., an (1 ≤ ai ≤ 103, i = 1 ÷ n).
Kết quả: Đưa ra file văn bản OUTPUT.TXT một số nguyên – số lượng tối đa các
bông hoa được mua.
Ví dụ:

3 17
3 5 10
Các số nguyên không âm theo cơ số B (B >1) tạo thành một nhóm có các tính
chất tương tự nhau không phụ thuộc vào cơ số B. Vì vậy, nếu một vấn đề đã giải
quyết được với cơ số B1 thì cũng có thể dễ dàng giả quyết ở cơ số B2. Việc bảo
toàn các tính chất đó được gọi là bất biến đại số.
Trong Tin học tính bất biến hỗ trợ rất nhiều trong việc xác định giải thuật. Một
bài toán đã giải quyết được ở cơ số 3 thì có thể dễ dàng triển khai để giải với cơ
số B > 1 bất kỳ.
Để chứng minh cho điều đó bài tập về nhà cho cả lớp là
cho 2 số nguyên dương x và y ở cơ số B, x ≤ y và mỗi
số có không quá 5×105 chữ số. Yêu cầu thực hiện các
phép biến đổi:
1. Tính tích các số nguyên từ a đến b, kể cả a và b,
2. Tính tổng các chữ số trong kết quả nhận được,
3. Nếu tổng không nhỏ hơn B thì thực hiện lại bước
2, trong trường hợp ngược lại – đưa ra chữ số
nhận được.
Hãy xác định chữ số cần đưa ra.
Mỗi người trong lớp nhận được một cơ số B khác nhau
và 2 số x, y ở cơ số tương ứng.
Alice nhận được cơ số B là 16 – cơ số Hexa. Các chữ
số của cơ số Hexa được nêu ở bảng bên.
Hãy xác định chữ số Alice cần đưa ra. Nếu chữ số nhận
được lớn hơn 9 thì đưa ra dưới dạng chữ cái hoa.
Dữ liệu: Vào từ file INPUT.TXT, dòng thứ nhất chứa số nguyên x, dòng thứ 2
chứa số nguyên y (x ≤ y), mỗi số có không quá 5×105 chữ số, trong một số các
chữ số lớn hơn 9 có thể ghi dưới dạng cả ký tự hoa lẫn ký tự hoa thường, ví dụ
1bA hoặc 1BA hay 1Ba.

Kết quả: Đưa ra file OUTPUT.TXT chữ số nhận được. Nếu chữ số nhận được
lớn hơn 9 – đưa ra dưới dạng ký tự hoa.
Ví dụ:
1bA F
1Bd
Bob làm nhiệm vụ lên kế hoạch giao hàng ở một công ty bán hàng qua mạng.
Việc lên kế hoạch sẽ dễ dàng hơn nhiều nếu tìm thấy một kế hoạch như thế trước
đó.
Hôm nay cần chuyển n gói hàng cho khách. Bob xếp các gói hàng thành một dãy
dài và ghi trên nhãn mỗi gói một chữ cái từ a đến z tùy thuộc vào tính chất của
hàng, từ đó nhận được xâu đặc trưng s độ dài n. Với trí nhớ tốt, Bob có cảm giác
đã có một kế hoạch tương tự như vậy với xâu đặc trưng t cũng có độ dài n. Nếu
quả thật như thế thì từ s có thể nhận được t bằng cách thực hiện một lần hai phép
biến đổi sau:
Mang k gói hàng ở đầu dãy đặt xuống cuối dãy (0 ≤ k < n), giữ nguyên
trình tự trong các gói hàng mang xuống cuối,
Áp dụng cách mã hóa Ceasar với các ký tự ghi trên nhãn hàng, tức là thay
vòng tròn mỗi ký tự bằng ký tự đứng trước nó d vị trí (0 ≤ d <26), ví dụ,
với d = 4 thì e chuyển thành a, c chuyển thành y.
Thà mất công kiểm tra một chút còn hơn đi xây dựng kế hoạch mới, Bob quyết
định thực hiện biến đổi từ s sang t.
Hãy xác định từ s Bob có nhận được xâu t hay không và nếu được thì cần thực
hiện biến đổi với k nhỏ nhất và d là bao nhiêu.
Dòng đầu tiên chứa số nguyên n (1 ≤ n ≤ 2×105),
Dòng thứ 2 chứa xâu s từ các ký tự la tinh thường độ dài n,
Dòng thứ 2 chứa xâu t từ các ký tự la tinh thường độ dài n.
Kết quả: Đưa ra file văn bản OUTPUT.TXT thông báo “Impossible” nếu
không thể đưa s về t theo cách đã nêu và thông báo “Succes” nếu biến đổi
được. Trong trường hợp biến đổi được – dòng thứ 2 đưa ra các giá trị k và d.

Ví dụ:
5 Succes
abcde 3 0
cdeab
Procon là cuộc thi trang bị trí tuệ nhân tạo đơn giản cho robot. Với các nhiệm vụ
đặt ra các đội phải lập trình, trang bị cho robot để nó có thể thực hiện các nhiệm
vụ một cách độc lập, không có sự can thiệp tiếp theo của con người.
Một trong số các bài thi năm nay là lắp ráp số nguyên. Mỗi robot được giao n
khối lập phương. Trên mỗi mặt của khối lập phương có in một chữ số trong phạm
vi từ 0 đến 9. Như vậy mỗi khối lập phương chứa 6 chữ số. Các chữ số này có thể
giống nhau.
Robot phải lấy các khối lập phương, xoay và đặt cạnh nhau sao cho mặt trên của
chúng thể hiện một số nguyên không bắt đầu bằng chữ số 0. Các số cần tạo ra lần
lượt là 1, 2, 3, . . . Mỗi khối lập phương có thể tham gia vào việc tạo các số khác
nhau. Quá trình tạo số sẽ dừng lại khi gặp số nguyên đầu tiên không thể lắp ráp
từ các khối đã cho.
Hãy xác định số nguyên làm dừng quá trình tạo số.
Dòng thứ i trong n dòng chứa xâu 6 ký tự số trong tập các chữ số hệ 10
xác định các chữ số ghi trên khối lập phương thứ i.
Kết quả: Đưa ra file văn bản OUTPUT.TXT số nguyên tìm được.
Ví dụ:
3 90
123456
789012
345678

Ferma năm 1637 đã viết bên lề một cuốn sách: “Phương trình an+bn=cn không
có nghiệm nguyên dương a, b, c với n ≥ 3, nhưng ở đây không đủ chổ để trình
bày chứng minh”.
Mãi đến năm 1995 nhà toán học Anh W. Andrew mới chứng minh được điều
này và với công trình đó ông đã được tặng Giải thưởng toán học Abel năm 2016.
Trước đó người ta đã dùng máy tính để so sánh các giá trị an+bn và cn với a, b,
c, n nguyên dương đủ lớn, n ≥ 3..
Để tránh trùng lặp cũng như bỏ sót các trường hợp cần kiểm tra, người ta xét bộ
số (a, b, c, n) theo thứ tự tăng dần của max(a,b,c,n), với các bộ số có max giống
nhau – xét theo thứ tự từ điển tăng dần. Ví dụ, sau (1, 1, 1, 3) là (1, 1, 2, 3), sau
(3, 3, 3, 3) là (1, 1, 1, 4). Bộ số có thứ tự từ điển nhỏ nhất là (1, 1, 1, 3) và được
đánh số là 1.
Với mỗi số nguyên k hãy đưa ra bộ số (a, b, c, n) có thứ tự từ điển là k.
Dòng đầu tiên chứa số nguyên n – số bộ dữ liệu cần tìm (1 ≤ n ≤ 105),
Mỗi dòng trong n dòng sau chứa một số nguyên k (1 ≤ k ≤ 1015),
Kết quả: Đưa ra file văn bản OUTPUT.TXT các bộ số tìm được, mỗi bộ số trên
một dòng.
Ví dụ:
4 1 2 3 4
35 1 2 1 3
4 1 1 1 4
28 14 14 1 10
32768

I.01_S – Ba số
Chương trình
Nhập số nguyên
a = int(input('a = ')) Mỗi số trên một

b = int(input('b = ')) dòng Ngầm định xuống
c = int(input('c = '))
dòng sau print
dòng
print('Tổng 3 số:', a + b + c)
print('Tông bình phương:', a*a + b**2 + c*c)
I.02_S – Tam giác vuông

Chương trình
Nạp thư viện
các hàm toán
import math
b = int(input('b = '))
print('Diện tích tam giác: ',b*c/2)
print('Độ dài cạnh huyền: ',math.sqrt(b*b+c*c))
Gọi hàm sqrt trong thư

viện hàm toán học
I.03_S – Chia mận

Chương trình
n = int(input('n = ')) Lưu ý: chia nguyên
k = int(input('k = '))
print('Results: ',k//n,k%n)

I.04_S – Đồng hồ điện tử
Chương trình giải thuật I
n = int(input('n = '))
# Số phút trong một ngày
p = 24*60
# Giảm số nguyên ngày
n = n%p
print(n//60,n%60)
Chương trình giải thuật II

# Số giờ đã qua
Số giờ từ đầu ngày
h = n//60
cuối cùng
m = n%60
print(h%24,m)
I.05_S – m Trước và sau

n có thể có số lượng
Chương trình chữ số tùy ý
print('Số đứng trước: ', n-1)
print('Số đứng sau: ', n+1)
I.06_S – Số bàn học

Chương trình
a = int(input('a = '))
Cách làm tròn lên
print((a+1)//2+(b+1)//2+(c+1)//2)
I.07_S – Tổng các số lẻ

Giải thuật
Tổng các số lẻ từ 1 đến 2×k-1 bằng k2.
Ví dụ: 1 + 3 + 5 = 9 = 32
1 + 3 + 5 + 7 + 9 = 25 = 52.
Gọi f(k) là tổng k số lẻ đầu tiên.
ka = số thứ tự của số lẻ a,

kb = số thứ tự của số lẻ b,
f(kb)
f(ka-1) a b
ka-1 ka kb
f(kb)-f(ka-1)
Chương trình
a = int(input('Số lẻ thứ I : '))
b = int(input('Số lẻ thứ II: '))
p = a//2
q = (b+1)//2
print('Sum = ',q*q-p*p)
Độ phức tạp giải thuật: O(1)
I.08_S – An ninh lương thực

Chương trình a,b có thể lớn
tùy ý
print('Result = ',a*b,'kg')
I.09_S – Gặp nhau

Chương trình Thời gian gặp nhau:
Nhập số thực 𝑑
d = float(input('d = ')) t =𝑣1+𝑣2
v1 = float(input('v1 = '))
v2 = float(input('v2 = '))
print('Hai tàu gặp nhau sau ',d/(v1+v2),'giờ.')
I.10_S – Khoảng cách

Chương trình
m = float(input('m = '))
# Số giây trong một năm
t = 365*24*60*60
# Một tỷ
p = 1000000000
# Tốc độ ánh sáng km/s
v = 299792458
# Khoảng cách km
r = int(v*t*m)
print('Khoảng cách: ',(r+p-1)//p,'tỷ km.')

I.11_S – Đuổi kịp
Chương trình
h = int(input('h = '))
m = int(input('m = '))
va = float(input('va = '))
vb = float(input('vb = ')) Thời gian đuổi kịp:
#Thời gian đuổi kịp tính theo phút 𝑑
t =𝑣𝑏−𝑣𝑎
#t = (k*va/60)/(vb-va)/60
t = round(k*va/(vb-va))
t1 = h*60+m Quy ra phút
t2 = t1+t+k
print('Thời điểm đuổi kịp:',t2//60,' giờ',t2%60,' phút.')
I.12_S – Phương trình bậc 3
Chương trình
x2 = int(input('x2 = '))
x3 = int(input('x3 = '))
b = -(x1+x2+x3)
c = x1*x2+x1*x3+x2*x3
d = -x1*x2*x3
print('b =',b,' c =',c,' d =',d)
I.13_S – Lát sân
Giải thuật:
Không phụ thuộc vào tính chẵn lẻ của n, cứ 2 hàng phải chặt đôi một viên.
Nếu m là lẻ thì n phải chẵn (từ điều kiện đầu bài), Để lát hàng cuối cùng: không
cần chặt gạch.
Chương trình
print('Result:',m*n//2,m//2)
I.14_S – Du lịch Phanxipan

Chương trình

u = int(input('u = '))
v = int(input('v = '))
x = int(input('x = '))
y = int(input('y = '))
x -= y
print('Tổng số tiền vé:',(a+u)*x+(b+v)*y,' ngàn đồng.')
I.15_S – Xuất khẩu gạo

Chương trình
t = int(input('t = '))
print('Tổng thu nhập:',(t*v*n+999999)//1000000,'triệu USD.')
I.16_S – Chữ số hàng đơn vị

Tổng các số nguyên thuộc [p, q] bằng tổng các số nguyên từ 1 tới q trừ tổng các
số nguyên từ 1 tới p-1.
fq
fp
p-1 p fq -fp
q
Công thức tính tổng các số nguyên từ 1 đến k:
𝑘 × (𝑘 + 1)
2
Chương trình
s = input('s = ').split()
p, q = [int(s[0]), int(s[1])]
fq = q*(q+1)//2
fp = p*(p-1)//2
r = fq - fp
print('Last digit:',r%10)
I.17_S – Chữ số lẻ đầu tiên

Nhân số x với 10, chữ số lẻ đầu tiên sẽ trở thành chữ số hàng đơn vị của phần
nguyên.
Chương trình

x = float(input('x = '))
n = int(x*10)
print('Result =',n%10)
I.18_S – Chữ số lẻ thứ k

Nhân số x với 10k, chữ số lẻ thứ k sẽ trở thành chữ số hàng đơn vị của phần
nguyên.
Trong Python tồn tại phép nâng lên lũy thừa.
Chương trình
a = float(input('a = '))
b = float(input('b = '))
# print('*** ',a/b)
n = int(a*(10**k)/b)
print('Result =',n%10)
I>19_S – Bữa tối

Chương trình
Cách làm tròn lên
d = int(input('d = '))
print('Result:',(d+m-1)//m)
I.20_S – Hamburger
Chương trình
a,b,n = [int(s[0]),int(s[1]),int(s[2])]
x = a*n + b*n//100
y = b*n%100
print('Result: ',x,'.',y,'usd')
I.21_S – Tôm sú
Chương trình
r = n%100
print('Result:',r//10,r%10)
I.22_S – Thời gian

Giải thuật

Sau 12 giờ kim giờ đi được một vòng tròn, tức là có góc quay 3600. Như vậy mỗi
giờ kim giờ quay một góc 300 so với trước. Một giờ có 60*60 = 3600 giây. Vậy
thời gian để kim giờ dịch chuyển 10 là 3600/30 = 120 giây.
Từ góc a đã cho có thể tính được số giờ theo giây, từ đó dễ dàng đổi sang cách
tính giờ, phút, giây.
Chương trình
r = int(a*120)
h = r//3600
r -=h*3600 Thời gian tính
m = r//60 theo giây
s = r-m*60
print(h,'h',m,'m',s,'s')
I.23_S – Gửi tiết kiệm

Chương trình
a = int(input('Tiền gửi:'))
p = int(input('Lãi suất:'))
print('Số tiền sau 2 năm:',int((a*(1+p/100))*(1+p/100)))
I.24_S – Số chữ số
Chương trình
import sys, time
fi = open("input.txt")
Thay thế bàn phím và
fo = open("output.txt","w")
màn hình bằng files
sys.stdin = fi
sys.stdout = fo
tb = time.time()
a = int(input())
b = int(input()) Đưa ra thời
Chương trình
c = str(abs(a+b)) gian thực hiện
xử lý
chương trình
print(len(c))
print("Time: {:.4f}".format(time.time()-tb))
fo.close()
Biến đổi số thành xâu và

bỏ dấu

Giải thuật:
𝑛!
Số cần tìm là 𝐶𝑛𝑚 =
𝑚!(𝑛−𝑚)!
Python cho phép thực hiện các phép tính số học với số nguyên có số lượng chữ
số bất kỳ. Với sự hỗ trợ của hàm factorial trong thư viện math ta có thể xác định
được giá trị các giai thừa cần thiết và từ đó – dẫn xuất trực tiếp giá trị cần tính.
Chương trình
import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time()
from math import factorial
s = input().split()
m,n = int(s[0]), int(s[1])
res = factorial(n)//factorial(m)//factorial(n-m)
print(res)
fo.close()

II.01_S – Số lớn nhất
Chương trình:
Trường hợp cho 3 số nguyên, mỗi số trên một dòng:
maxnum = a
if b > maxnum: maxnum = b
if c > maxnum: maxnum = c
print('Max =',maxnum)
Trường hợp cho 3 số nguyên trên cùng một dòng: Một cách nhập 3 số
s = input('s =').split() nguyên trên một dòng
a,b,c = int(s[0]),int(s[1]),int(s[2])
maxnum = a
if b > maxnum: maxnum = b
if c > maxnum: maxnum = c
print('Max =',maxnum)
II.02_S – Dấu của tổng

Chương trình 1:
Sử dụng cấu trúc if . . . elif . . .
s = a + b
if s > 0: ptrint('Positive')
elif s < 0: print('Negative')
else: print('Zero')
Chương trình 2
Sử dụng cấu trúc if . . . else . . .
s = a + b
if s > 0: print ('Positive')
else:
if a+b < 0: print('Negative')

else: print('Zero')
II.03_S – Bàn cờ
Giải thuật: m = 4, n = 6 (6, 4)
4
Xét ô trắng có tọa độ (i, j). 3 Ô trắng
i và j phải cùng chẵn hay cùng lẻ, 2
(5, 3)
điều này tương đương với điều kiện 1
i%2+j%2 là số chẵn. 1 2 3 4 5 6
Chương trình:
board = input('Size: ').split()
m, n = int(board[0]),int(board[1])
cell = input('Cell: ').split()
p, q = int(cell[0]),int(cell[1])
if (p % 2 + q % 2) % 2 == 0: print('W')
else: print('B')
II.04_S – Năm nhuận

Chương trình:
if n % 3328 == 0: print('Multiple leap')
elif n % 400 == 0 or (n % 4 == 0 and n % 100 !=0): print('Leap')
else: print('No')
II.05_S – Tích lớn nhất

Chương trình:
b = float(input('b = '))
c = float(input('c = '))
MaxPr = a*b
if a*c > MaxPr: MaxPr = a*c
if b*c > MaxPr: MaxPr = b*c
print('Result =', MaxPr)
II06_S – Giống nhau

Giải thuật:
Dùng 3 biến r1, r2, r3 để đánh dấu .
Ban đầu các biến nhận giá trị 0 (chưa biết có cặp bánh nào có giá giống nhau).

Nếu cặp bánh i và j có giá giống nhau : gán 1 cho ri và rj.
Số lượng bánh có giá giống nhau sẽ là r1+r2+r3.
Vì chỉ có 3 bánh nên không cần dùng biến có chỉ số.
Chương trình:
p1 = int(input('p1 = '))
r1,r2,r3 =0, 0, 0 Gán danh sách giá trị
if p1 == p2: r1, r2 = 1, 1 cho danh sách biến
if p1 == p3: r1, r3 = 1, 1
if p2 == p3: r2, r3 = 1, 1
print('Result:',r1+r2+r3)
II.07_S – Quân hậu

Giải thuật:
m = 4, n = 6
Quân hậu ở ô (qi, qj) sẽ kiểm soát các ô (i, j) thỏa 4
mãn một trong số các điều kiện: 3
2
Cùng hàng: i = qi,
Cùng cột: j = qj, 1
Ở trên đường chéo chính đi qua ô (qi, qj): i – 1 2 3 4 5 6
qi = j – qj,
Ở trên đường chéo phụ đi qua ô (qi, qj): i – qi = qj – j.
Dùng một biến lô gic để tổng hợp kết quả kiểm tra 4 điều kiện trên.
Chương trình:
sq = input('sq = ').split()
qi,qj = int(sq[0]), int(sq[1]) Một cách nhập 2 số
sa = input('sa = ').split() nguyên trên một dòng
ai,aj = int(sa[0]), int(sa[1])
flag = (ai == qi) | (aj == qj)
flag |= (ai-qi == aj-qj) | (ai-qi+aj-qj == 0)
if flag: print('YES')
else: print('NO')

II.08_S – Sô cô la
Giải thuật:
Có thể bẻ được khi và chỉ khi k chia hết cho m hoặc cho n.
Chương trình:
sz = input('sz = ').split()
m, n = [int(sz[0]), int(sz[1])]
if (k%m == 0) | (k%n == 0): print('YES')
else: print('NO')
II.09_S – Bể bơi
Giải thuật:
Chuẩn hóa dữ liệu để n là cạnh dài của bể bơi,
Từ x tìm khoảng cách gần nhất tới cạnh dài của bể bơi,
Từ y tìm khoảng cách gần nhất tới cạnh ngắn của bể bơi,
n
y
m
x
Xác định min giữa 2 giá trị tính được.
Chương trình:
sz = input('sz = ').split()
m, n = int(sz[0]), int(sz[1])

if m >n : m, n = n, m
x = int(input('x = '))
y = int(input('y = '))
if x > m-x: x = m-x
if y > n-y: y = n-y
print(min(x,y))
II.10_S – Đường vành đai

Chương trình:
m = int(input('m = ')) d C
A d
m-d
t = int(input('t = '))
d = input('d = ')
s = v * t
r = s % m
if d == 'C': r = m - r
print('Result =',r%m)
II.11_S – Hết tiết học

Chuyển cách tính thời gian theo số phút đã qua tính từ 0 giờ 0 phút. 7 giờ 00 ứng
với phút thứ 60*7 = 420.
Thời gian 2 tiết học lẻ và chẵn liên tiếp là 45 + 5 + 45 +15 = 110 phút.
Nếu k là số chẵn thì thời gian học là chẵn số nhóm 2 (tức là k//2) nhưng từ
bớt 15 nghỉ giải lao cuối.
Nếu k lẻ:thời gian học sẽ là thời gian các nhóm 2 tiết cộng với thời gian học tiết
cuối (45 phút).
Từ thời điểm kết thúc tính theo phút dễ dàng chuyển sang cách tính giờ - phút.
Chương trình:
if (k&1) == 0: t = 420 + 110 * k//2 -15
else: t = 420 + 110 * (k-1)//2 + 45
print('Giờ kết thúc:',t//60,'giờ',t%60,'phút')
II.12_S – Hiệu quả

Chuyển sang cách tính thời gian theo giây tính từ đầu ngày.
Chương trình:
s = input('Bắt đầu lúc ').split()
a,b,c = [int(s[0]),int(s[1]),int(s[2])]

t0 = (a*60+b)*60+c
s = input('Kết thúc lúc ').split()
a,b,c = [int(s[0]),int(s[1]),int(s[2])]
t1 = (a*60+b)*60+c
t = t1 - t0
if t < 0: t += 86400
print('Thời gian thực hiện chương trình:',t)
II.13_S – Ốc sên
Chương trình:
s = input('h,a,b: ').split()
h,a,b = int(s[0]),int(s[1]),int(s[2])
if h <= a: res =1
else: res = (h-b-1)//(a-b)+1
print('Result:',res)
II.14_S – Kim giờ

Quảng đường kim giờ đi được:
Trong 1 giờ là 360/12 = 300,
Trong một phút là 30/60 = 0.50.
Trong một giây là 30/3600 = 1/120
Chương trình:
d = input('h,m,s: ').split()
h,m,s = [int(d[0]),int(d[1]),int(d[2])]
if h==12 & m==0 & s ==0: res = 0
else:
res = h*30 + m/2 + s/120
print('Angle:',res)
II.15_S – Cấp số
Giải thuật:
Ba số a, b, c tạo thành cấp số cộng khi và chỉ khi
b – a = c - b
Công bội d của cấp số cộng đã cho sẽ là d = c – b.

Ba số a, b, c tạo thành cấp số nhân khi và chỉ khi

b / a = c / b
Công sai d của cấp số nhân đã cho sẽ là q = c / b.
Đoạn chương trình định hướng

Chương trình: lại các files vào/ra chuẩn, thay
import sys, time bàn phím bằng file fi, thay màn
fi = open("input.txt") hình bằng file fo
sys.stdin = fi
sys.stdout = fo
tb = time.time()
s = input().split()
a,b,c = int(s[0]),int(s[1]),int(s[2])
if b-a == c-b: Đưa ra thời gian thực hiện
d = c-b chương trình
print('AP',b+d, b+2*d)
elif b/a == c/b:
q = c/b
print('GM',c*q,c*q*q)
else: print('NP')
fo.close()
Bắt buộc phải có câu lệnh đóng

file output

III.01_S – Dãy số
Chương trình: Các số cách nhau

Để tính cả b một dấu cách
for i in range(a, b+1):
if (i%2 == 0) | (i%3 == 1): print(i, end=' ')
III.02_S – Dãy bình phương giảm dần
Chương trình: Lùi từ b về a

if a > b: a, b = b, a
for i in range(b,a-1,-1): print(i*i,end=' ')
III.03_S – Số chính phương

Chương trình:
Khai báo thư viện
import math
Gọi hàm
for i in range(a,b+1):
k = int(math.sqrt(i))
if k*k == i: print(i,end=' ')
Các số cách nhau

một dấu cách
III.04_S - Tổng dãy số
Chương trình:
sum = 0
for i in range(n):
sum += int(input())
print('Sum =',sum)

III.05_S – Tổng lập phương
Giải thuật với độ phức tạp O(1):

Nhận xét:
13 = 1
13+23 = 9 = 32
13+23 + 33 = 36 = 62
. . . . . . . . . .
𝑘×(𝑘−1) 2
13+23 + 33 + . . . + k3 = ( )
2
Dễ dàng tính:
fb = 13 +23 + . . . + (a-1)3 + a3 + . . . + b3
fa = 13 +23 + . . . + (a-1)3
Kết quả cần tìm là fb – fa.
Chương trình:
fb = b * (b+1) // 2
fa = a * (a-1) // 2
print('Result =',fb*fb-fa*fa)
Giải thuật độ phức tạp O(n):

sum = 0
sum += i**3
print('Result =',sum)
III.06_S – Giai thừa
Chương trình:
ft = 1
for i in range(2,n+1):
ft *= i
print('Result:',ft)

III.07_S – Tổng giai thừa
Chương trình: Khai báo thư viện
import math
b = int(input('b = ')) Gọi hàm
f = math.factorial(a-1)
sum = 0
f *=i
sum += f
print('Result:',sum)
III.08_S – Số bị thiếu
Nếu đầy đủ các số từ 1 đến n thì tổng của chúng bằng n×(n+1)/2.
Từ tổng các số có mặt (được nhập vào) ta dễ dàng xác định được số bị thiếu.
Chương trình:
x = n*(n+1)//2
for i in range(n-1):
x -= int(input())
print('Số bị thiếu:',x)
III.09_S – Danh sách bình phương
Chương trình:
print(i*i, end=' ')
III.10_S – Ước nhỏ nhất
Chương trình:
if n % i == 0:
print(i)
break

III.11_S – Lũy thừa 2
Tìm vị trí bit 1 trái nhất trong dạng biểu diễn nhị phân của n.
Chương trình:
m = n
k = -1
while m > 0:
k +=1
m >>=1
print(k, 1<<k)
III.12_S – Khởi động
Chương trình:
x = float(input())
y = float(input())
k = 0
while x < y:
k +=1
x *=1.1
print(k)
III.13_S – Kích thước mảng
Chương trình:
size = 0
while int(input())> 0: size +=1
print(size)
III.14_S – Tổng các phần tử
Chương trình:
sum = 0
e = int(input())
while e != 0:
sum += e
e =int(input())
print('sum =',sum)

III.15_S – Giá trị trung bình
Chương trình:
sum = 0
size = 0
e = int(input())
while e != 0:
sum += e
size += 1
e =int(input()) Chú ý: Giá trị thực
print('Average = ',sum/size)
III.16_S – Phần tử lớn nhất

Chương trình:
Max_e = -1
e = int(input())
while e != 0:
Max_e = max(Max_e,e)
e =int(input())
print('Max = ',Max_e)
III.17_S – Chỉ số phần tử lớn nhất

Chương trình:
idx = 0
e = int(input())
Max_e = e
k = 0
while e != 0:
if Max_e < e: Max_e,idx = e, k
e =int(input())
k +=1
print('Index Max Element:',idx)
III.18_S – Số lượng phần tử chẵn
Chương trình:
even =0

e = int(input())
while e != 0:
if (e&1) == 0: even += 1
e =int(input())
print('Even:',even)
III.19_S – Số phần tử lớn hơn phần tử đứng trước
Chương trình:
prev = int(input())
res = 0
while prev != 0:
next = int(input())
if next != 0 and prev < next: res += 1
prev = next
print('Result =', res)
III.20_S – Huy chương bạc
Giải thuật:
Tìm giá trị max thứ 2.
Tạo phòng đệm chứa số lớn nhất và lớn thứ nhì.
Nếu số mới lớn hơn số thứ 2:
Thay thế số tứ 2 bằng số mới,
Cập nhật vị trí các phần tử trong phòng đệm.
Chương trình:
n = int(input())
gold = int(input())
silver = int(input())
if gold < silver: gold, silver = silver, gold
for i in range(2, n):
eval = int(input())
if eval > silver:
silver = eval
if gold < silver: gold, silver = silver, gold
print('Silver:',silver)

III.21_S – Số phần tử đạt max
Chương trình:
n = int(input())
mx = int(input())
m = 1
for i in range(1, n):
t = int(input())
if t > mx: mx,m = t, 1
elif t == mx: m +=1
print('Summary:',m)
Ghi chú: Có thể viết chương trình ngắn gọn hơn bằng các hàm max và count,
nhưng sẽ tốn thời gian thực hiện hơn.
III.22_S – Liên tiếp bằng

Chương trình:
n = int(input())
mx_len = 0
cur_len = 1
x = int(input()) Xử lý liên tiếp
for i in range(1,n): bằng nhau
y = int(input())
if y == x:
cur_len += 1 Sang đoạn mới
else:
if cur_len > 0:
if cur_len > mx_len:
mx_len = cur_len Cập nhật độ dài đoạn
cur_len = 1 bằng nhau liên tiếp
x = y
print('Max length:',mx_len)
III.23_S – Kiểm tra nguyên tố

Chương trình:
Thay thế các thiết bị
import sys, time chuẩn bằng files
sys.stdin = fi
sys.stdout = fo
tb = time.time()
1 – Không nguyên tố
2, 3 – Nguyên tố
n = int(input())
ans = 'Yes'
if n == 1:
ans='No'
elif n > 3: Kiểm tra tồn tại ước
i = 1 ≠ 1 và n
while i*i <= n:
i +=1
if n%i == 0:
ans = 'No'
break
print(ans)
fo.close()
Bắt buộc có
III.24_S – Số nguyên tố
Chương trình:
import sys, time
sys.stdin = fi
sys.stdout = fo Khởi tạo mảng n+1 phần tử
tb = time.time() và gán giá trị đầu bằng 1
n = int(input()) 0 và 1 – không
a =[1]*(n+1) nguyên tố
a[0],a[1]=0,0
Loại bỏ các số
d , p = 2, 2
chia hết d
res = 1
while p < n:
for i in range(p,n+1,d):a[i]=0
d =n+1
for i in range(p,n+1):
if a[i]> 0: Tìm d mới
d = i
break
p = d
if p<=n: res += 1
Xử lý kết thúc
print(res)

fo.close()
import sys, time

sys.stdin = fi
sys.stdout = fo
tb = time.time()
n = int(input())
c_old = 1
for i in range(1,n):
c_new = 2*(2*i+1)*c_old//(i+2)
c_old = c_new
print(c_new)
fo.close()
import sys, time


sys.stdin = fi
sys.stdout = fo
tb = time.time()
from math import factorial
n = int(input())
t = factorial(n)
res = factorial(2*n)//t//t//(n+1)
print(res)
fo.close()

Với biến kiểu xâu: Không được phép thay đổi nội dung của biến. Khi cần thay
đổi: phải tạo biến mới.
IV.01_S – Các lát cắt

Chương trình:
s = input('s = ')
print(s[2])
print(s[-2])
print(s[:5])
print(s[:-2])
print(s[::2])
print(s[1::2])
print(s[::-1])
print(s[::-2])
print(len(s))
IV.02_S – Số lượng từ
Chương trình:
print(input().count(' ')+1)
IV.03_S – Xâu mới

Chương trình:
s = input()
print(s[(len(s)+1)//2:]+s[:(len(s)+1)//2])
IV.04_S – Vị trí ký tự
Chương trình:
s = input()
c = input()
if s.count(c) == 1:print(s.find(c))
elif s.count(c) > 1:
print(s.find(c),s.rfind(c))
else: print('-1')

IV.05_S – Lần thứ 2
Chương trình:
s = input()
c = input()
t = s.count(c)
if t == 0: print('-2')
elif t ==1:print('-1')
else: print(s.find(c, s.find(c) + 1))
IV.06_S – Xóa xâu con

Chương trình:
s = input()
c = input()
t = s.count(c)
if t > 1: s = s[:s.find(c)] + s[s.rfind(c) + 1:]
print(s)
IV.07_S – Đảo ngược xâu con

Chương trình:
s = input()
c = input()
a = s[:s.find(c)]
b = s[s.find(c):s.rfind(c)+1]
d = s[s.rfind(c)+1:]
s = a + b[::-1] + d
print(s)
IV.08_S – Thay thế

Chương trình:
s = input()
w =s.replace('1','one')
print(w)
IV.09_S – Xóa ký tự
Chương trình:
c = input()
w = s.replace(c,'')
print(w)

IV.10_S – Thay thế ký tự
Chương trình:
s = input()
c = input()
cnew =input()
a = s[:s.find(c)+1]
b = s[s.find(c) + 1:s.rfind(c)]
d = s[s.rfind(c):]
s = a + b.replace(c,cnew) + d
print(s)
IV.11_S – Rút ngắn xâu

Chương trình:
s = input()
r = ''
for i in range(len(s)):
if i%3 != 0: r+= s[i]
print(r)
Hàm randint(a,b) tạo

Chương trình: số nguyên ngẫu nhiên trong
import sys, time đoạn [a,b]
from random import randint
sys.stdin = fi
sys.stdout = fo
tb = time.time()
t = input()
w_old = input()
w_new = input()
lwo = len(w_old)
p = t.find(w_old)
while p >= 0:
t = t[:p] + w_new + t[p+lwo:]

p = t.find(w_old)
print(t)
print("\nTime: {:.4f}".format(time.time()-tb))
fo.close()
Hàm random() tạo số

Chương trình: thực ngẫu nhiên trong
đoạn [0,-1]
import sys, time
from random import random
fo = open("output.txt","w") Tạo số thực ngẫu nhiên không
sys.stdin = fi quá 106 và có 6 chữ số lẻ
sys.stdout = fo
tb = time.time()
a = round(random()*1000000, 6)
b = round(random()*1000000, 6)
c = a*b
print('a,b,c:',a,b,c) Đổi số thành xâu
strnum = str(c)
maxdg = 0
for i in strnum:
if i == '.': continue Duyệt tìm chữ số
elif maxdg < int(i): lớn nhất
maxdg = int(i)
print('Maxdigit:',maxdg)
fo.close()
Chương trình:
import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time() Danh sách từ
lx = 0
sx =''
for s in input().split():
if len(s) >lx: lx, sx = len(s), s

print(sx, lx)
fo.close()
Chương trình:
import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time()
flag = True Duyệt nửa xâu

s = input()
ls =len(s)
for i in range(ls//2):
if s[i]!= s[ls-i-1]:
flag = False
break
if flag: print('Yes')
else: print('No')
fo.close()
Chương trình:
import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time()
n = int(input())
b = int(input())
pat ='0123456789ABCDEF'
x = ''
while n > 0: Giải thuật đổi cơ số
i = n % b
x += pat[i]
n //=b

res = x[::-1]
print(res) Đảo ngược xâu
fo.close()
Chương trình:
import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time()
x = input()
y = x[::-1] Xâu đảo ngược
t = int(x)+int(y)
z = str(t)
while z != z[::-1]:
z = z[::-1]
t = t + int(z)
z = str(t)
print(z)
fo.close()
Chương trình:
import sys, string
sys.stdin = fi
sys.stdout = fo
s = input()
t = s[-1]
t = t.upper()
res = float(s[0:-1])
if t == 'C':
res = res*1.8+32

t = 'F'
else:
res = (res-32)/1.8
t = 'C'
print('{:.2f}{:1}'.format(res,t))
fo.close()

Việc xử lý danh sách thường đòi hỏi nhập lượng lớn dữ liệu. Việc hiệu chỉnh cũng
như thực hiện chương trình sẽ hiệu quả hơn nệu dữ liệu được nhập vào từ thiết bị
vào chuẩn và kết quả - đưa ra thiết bị ra chuẩn của hệ thống.
Để đơn giản ta chỉ định hướng lại thiết bị vào – ra chuẩn sang file văn bản.
Việc định hướng lại được thực hiện theo mẫu:
import sys
sys.stdin = fi
Phần chương trình xử lý:
sys.stdout = fo Không thay đổi
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
fo.close()
Phải có
V.01_S – Vị trí lẻ
Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo Bước thay đổi
tham số
s = input().split()
for i in range(1, len(s),2):
print(s[i],end=' ')
fo.close() Các phần tử trên một dòng,

cách nhau một dấu cách.

V.02_S – Giá trị chẵn
Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo Một cách nhập
danh sách
s = input().split()
a = [int(i) for i in s]
for i in range(len(s)):
if a[i]&1 == 0: print(a[i],end=' ')
fo.close()
V.03_S – Lớn hơn phần tử trước

Chương trình:
import sys
sys.stdin = fi Một cách khác
sys.stdout = fo nhập danh sách
a = [int(i) for i in input().split()]

for i in range(1,len(a)):
if a[i] > a[i-1] : print(a[i],end=' ')
fo.close()
V.04_S – Cùng dấu

Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo

x, y = 0, 0
if a[i] * a[i-1] > 0 :
x, y = a[i-1], a[i]
break
print(x, y)
fo.close()
V.05_S – Cực đại địa phương
Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo Lưu ý các biên

cnt = 0
for i in range(1,len(a)-1):
if a[i-1] < a[i] > a[i+1] : cnt += 1
print(cnt) Python cho phép
fo.close()
V.06_S – Phần tử max

Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo

mx, idx = a[0], 0
if a[i] > mx : mx, idx = a[i], i
print(mx, idx)
Bắt đầu từ 1
fo.close()

V.07_S – Vị trí doanh nghiệp
Giải thuật I: Tìm kiếm trực tiếp.

Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo

x = int(input())
n = len(a)
if x > a[0]: p = 0
elif x <= a[n-1]: p = n
else:
for i in range(n-1,0,-1):
if a[i-1] >= x > a[i]:
p= i
break
print(p)
fo.close()
Giải thuật II: Tìm kiếm nhị phân. Độ phức tạp phần xử lý tìm vị trí: O(logn).
Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo

x = int(input())
n = len(a)
if x > a[0]: p = 0
elif x <= a[n-1]: p = n
else:
l = 0
r = n-1
while r-l > 1:
mid = (l+r)//2

if a[mid] <= x: l = mid
else: r = mid
p = r
print(p)
fo.close()
Giải thuật III: Sử dụng công cụ tìm kiếm nhị phân của hệ thống. Độ phức tạp
phần xử lý tìm vị trí: O(logn).
Python 3.0 trở lên cung cấp thư viện bisect chứa các hàm phục vụ tìm kiếm
nhị phân trên danh sách đã sắp xếp tăng dần (không giảm), trong đó có hàm
bisect_left(a,x) tìm vị trí p lớn nhất thỏa mãn các điều kiện:
ai ≤ x với mọi i ≤ p,
aj > x với mọi j > p.
Hàm bisect_left còn cho phép tìm trong khoảng cho trước trong a.
Để sử dụng bisect_left cần:
Nạp mô đun bisect_left từ thư viện bisect,
Đảo ngược dãy a để có dãy không giảm.
Vị trí cần tìm sẽ được tính từ vị trí do hàm tìm kiếm cung cấp.
Chương trình:
import sys
fo = open("output.txt","w") Kết nạp hàm vào
sys.stdin = fi chương trình
sys.stdout = fo
from bisect import bisect_left

x = int(input())
n = len(a)
Phân lập trường
if x > a[0]: p = 0 hợp đặc biệt
elif x <= a[n-1]: p = n
else: Tìm kiếm nhị phân

a.reverse()
p = bisect_left(a,x)
p = n-p

print(p)
fo.close()
V.08_S – Số phần tử khác nhau
Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo

cnt = 1
if a[i] != a[i-1]: cnt +=1
Bắt đầu từ 1
print(cnt)
fo.close()
V.09_S – Đổi chổ cặp phần tử

Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo
for i in range(0,len(a)-1,2):
a[i], a[i+1] = a[i+1], a[i]
#print(' '.join([str(i) for i in a]))

for i in a: print(i,end=' ')
fo.close()
V.10_S – Đổi chổ Min – Max

Chương trình:

import sys
sys.stdin = fi
sys.stdout = fo

p_min, p_max = 0, 0
for i in range(len(a)):
if a[i] > a[p_max]: p_max = i
Một cách khác đưa ra các
if a[i] < a[p_min]: p_min = i
phần tử cách nhau một dấu
cách trên cùng dòng
a[p_min], a[p_max] = a[p_max], a[p_min]
print(' '.join([str(i) for i in a]))
fo.close()
V.11_S – Xóa phần tử

Chương trình:
import sys
sys.stdin = fi Một cách nhập
sys.stdout = fo danh sách

k = int(input())
for i in range(k,len(a)-1):
a[i] = a[i+1]
a.pop()
fo.close()
V.12_S – Chèn phần tử

Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo

k, val = [int(i) for i in input().split()]
a.append(0)
for i in range(len(a) - 1, k, -1):
a[i] = a[i-1]
a[k] = val
fo.close()
V.13_S – Cặp phần tử trùng nhau
Giải thuật I: Tìm kiếm trực tiếp, độ phức tạp O(n2).
Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo

cnt = 0
for i in range(len(a) - 1):

for j in range(i+1,len(a)):
if a[i] == a[j]: cnt += 1
print(cnt)
fo.close()
Giải thuật II: Sử dụng tập hợp để lọc dữ liệu, độ phức tạp O(nlog n).
Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo

s = set()
res = 0
for i in a:

if i in s: continue
k = a.count(i)
res += k*(k-1)//2
s.add(i)
print(res)
fo.close()
V.14_S – Độ đa dạng
Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo

cnt = len(set(a))
print(cnt)
fo.close()
V.15_S – Các phần tử đơn độc

Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo

for i in range(len(a)):
if a.count(a[i]) == 1: print(a[i],end=' ')
fo.close()
V.16_S – Bowling
Chương trình:

import sys
sys.stdin = fi
sys.stdout = fo
n, k = [int(s) for s in input().split()]

b = ['I'] * n
for i in range(k):
lf, rt = [int(s) for s in input().split()]
for j in range(lf - 1, rt):
b[j] = '.'
print(''.join(b))
fo.close()
V.17_S – Cập nhật danh sách

Chương trình:
import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time()
res = [int(i) for i in input().split()]

for i in range(len(res)):
if res[i]>0: res[i] = 1
elif res[i] < 0: res[i] = -1
for i in res: print(i,end = ' ')
fo.close()
Chương trình:
import sys, time
sys.stdin = fi

sys.stdout = fo
tb = time.time()
n = int(input())
a,b = [int(i) for i in input().split()]
print('a,b:',a,b)
lst = [0]*n
for i in range(n):
lst[i]=randint(a,b)
for i in lst: print(i,end=' ')
odd_neg,ev_neg,odd_pos,ev_pos = 0,0,0,0
for i in lst:
if i < 0:
if (i&1) == 0: ev_neg +=1
else: odd_neg += 1
if i > 0:
if (i&1) == 0: ev_pos +=1
else: odd_pos += 1
print('\nNegative odd:',odd_neg,'Negative even:',ev_neg)

print('Positive odd:',odd_pos,'Positive even:',ev_pos)
fo.close()
Chương trình:
import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time()
n = int(input())
# Tạo danh sách rỗng chứa kết quả nhập
A = []
t = n
# Nhập từng phần của A và kết nối vào cuối kết quả đã có
while t > 0:
c = [int(i) for i in input().split()]
p = len(c)
A += c
t -= p

# Tạo các danh sách rỗng chứa dãy số âm và dãy số dương
c = []
d = []
# Tách các dãy số thánh 2 phần âm và dương

for i in A:
if i < 0: c.append(i)
elif i > 0: d.append(i)
# Tạo danh sách chứa các phần tử 0

z =[0]*(n - len(c) - len(d))
# Tổng hợp kết quả

B = c + z + d
# Đưa ra theo yêu cầu 10 số/dòng

for i in range(n):
print(B[i],end= ' ')
if (i+1)%10 == 0: print('')
fo.close()
Nhận xét:
Độ phức tạp giải thuật: O(n),
Có thể viết chương trình gọn hơn dựa trên cơ sở Stable Sort, nhưng độ phức
tạp của giải thuật sẽ là O(n2).
Giải thuật:
Với mỗi i (i = 0, 1, 2, . . ., n-2) cần tính
sumi = ∑𝑛−1
𝑗=𝑖+1 |𝑏𝑖 − 𝑏𝑗 |
Để tránh phải làm việc với giá trị tuyệt đối: sắp xếp b theo thứ tự tăng dần.
Khi đó tổng sumi cần tính có dạng:
sumi = ∑𝑛−1
𝑗=𝑖+1(𝑏𝑗 − 𝑏𝑖 )
sumi = ∑𝑛−1
𝑗=𝑖+1 𝑏𝑗 − (𝑛 − 𝑖 − 1) × 𝑏𝑖 )
sumi = ∑𝑛−1
𝑗=𝑖 𝑏𝑗 − (𝑛 − 𝑖) × 𝑏𝑖 )
Gọi fi là tổng tiền tố của b từ đầu tới vị trí i: fi = b0 + b1 + . . . + bi .

Ký hiệu n = len(b) – 1.
Dễ dàng thấy rằng sumi = f(n) – (n-i)×bi .
Kết quả cần tìm là tổng các sumi với mọi i.
Việc tính tổng tiền tố có độ phức tạp O(n).
Độ phức tạp tính sumi là O(1).
Do có lọc dữ liệu để xác định đại diện và sắp xếp mảng b nên độ phức tạp chung
của lời giải sẽ là O(mlogm), trong đó m – kích thước của mảng dữ liệu vào.
Chương trình:
import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time()

b = list(set(a))
b.sort()
Tạo mảng đại diện Tính tổng tiền tố
lb =len(b) của mảng đại diện
f = [0]*lb
f[0] = b[0]
for i in range(1,lb): f[i] = f[i-1]+b[i]
res, n = 0, lb-1
for i in range(n):
res += f[n] - f[i]- b[i]*(n-i)
print(res) Tích lũy kết quả

fo.close()
Giải thuật:
Cấu trúc dữ liệu dict thích hợp với phần lớn các bài toán liên quan tới tần số.
Tuy vậy, ở đây ta sẽ vòng tránh việc sử dụng cấu trúc dict.

Vấn đề tương đối phức tạp khi sử dụng các ngôn ngữ lập trình khác là danh sách
đã cho có thể chứa các phần tử thuộc những kiểu dữ liệu khác nhau. Với Python,
đây không phải là trở ngại cần lưu ý!
Việc tạo danh sách chứa dữ liệu vào được thực hiện như bình thừng, không cần
lưu ý kiểu dữ liệu:
n = int(input())
a = []
for i in range(n):
a.append(input())
Sử dụng công cụ lọc loại bỏ phần tử lặp có thể dễ dàng tìm tần suất xuất hiện lớn
nhất của các phần tử khác nhau:
fr = 0;
for x in set(a):
t = a.count(x)
if t > fr: fr = t;
Vấn đề còn lại chỉ là tìm tất cả các phần tử có cùng tần suất lớn nhất đã xác định:
b = []
for x in set(a):
if a.count(x) == fr:
b.append(x)
Các kết quả cần đưa ra có thể dễ dàng dẫn xuất từ danh sách b:
print(fr, len(b))
for x in b:
print(x,end=' ')
Nhận xét:
Chương trình ngắn gọn và đơn giản nhưng độ phức tạp có thể cao, bậc
O(n2) vì hàm count có thể có độ phức tạp O(n),
Việc sử dụng cấu trúc dữ liệu dict sẽ cho chương trình hiệu quả hơn.
Chương trình:
import sys, time
sys.stdin = fi
sys.stdout = fo

tb = time.time()
n = int(input())
a = []
for i in range(n):
a.append(input())
fr = 0;
for x in set(a):
t = a.count(x)
if t > fr: fr = t;
b = []
for x in set(a):
if a.count(x) == fr:
b.append(x)
print(fr, len(b))
for x in b:
print(x,end=' ')
fo.close()

VI.01_S – Độ dài đoạn thẳng
Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo
from math import sqrt
def distance(xa, ya, xb, yb):

return sqrt((xa-xb)**2+(ya-yb)**2)
xa, ya = [float(s) for s in input().split()]

xb, yb = [float(s) for s in input().split()]
xc, yc = [float(s) for s in input().split()]
res = distance(xa,ya, xb, yb)

r = distance(xa,ya, xc, yc)
if res > r: res = r
r = distance(xb,yb, xc, yc)
if res > r: res = r
print("{:.6f}".format(res))
fo.close()
VI.02_S – Tính nhanh lũy thừa theo mô đun

Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo
def fpower(a,n,p):
r, t = 1, a
while n > 0:
if (n&1) > 0: r = r*t%p
t = t*t%p
n >>= 1

return r
x,y,z = [int(i) for i in input().split()]

print(fpower(x,y,z))
fo.close()
VI.03_S – Tính nhanh tích 2 số nguyên theo mô đun p

Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo
def fmult(x,y,p):
r, t = 0, x
while y > 0:
if (y&1) > 0: r = (r+t)%p
t = (t<<1)%p
y >>= 1
return r
a,b,c = [int(i) for i in input().split()]

print(fmult(a,b,c))
fo.close()
Chương trình:
import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time()
def lower_bound(a,val):
la = len(a);
lf, rt = -1, la
while rt-lf>1:
mid = (lf+rt)//2
if a[mid]<=val: lf=mid

else: rt = mid
return lf
def upper_bound(a,val):
la = len(a);
lf, rt = -1, la
while rt-lf>1:
mid = (rt+lf)//2
if a[mid]<= val: lf=mid
else: rt=mid
return rt
n = int(input())
b = [int(i) for i in input().split()]
v = int(input())
p = lower_bound(b,v)
print("Lower bound:",p+1,b[p])
q = upper_bound(b,v)
print('Upper bound:',q+1,b[q])
fo.close()
Chương trình:
fo = open("output.txt","w") Tính giá trị đa thức
sys.stdin = fi
theo sơ đồ Horner
sys.stdout = fo
tb = time.time()
def polynomial(a,n,x):
p = 0.0
for i in range(n+1):
p = p*x + a[i]
return p
n = int(input())
x = float(input())
print(polynomial(a,n,x))
fo.close()

Chương trình:
import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time()
def check_same(z):
if len(z) != len(set(z)): return 0
else: return 1
n = int(input())
a, b = [int(i) for i in input().split()]
c =[0]*n
for i in range(n):
c[i] = randint(a,b)
if check_same(c) == 1: print('Yes')
else: print('No')
#print(c)
fo.close(

VII.01_S – Số lớn nhất trong bảng
Chương trình:
import sys
sys.stdin = fi Một cách nhập
sys.stdout = fo mảng 2 chiều
n, m = [int(i) for i in input().split()]

a = [[int(j) for j in input().split()] for i in range(n)]
i_x, j_x = 0, 0
max_val = a[0][0]
for i in range(n): Truy nhập phần tử
for j in range(m): mảng 2 chiều
if max_val < a[i][j]:
max_val, i_x, j_x = a[i][j], i, j
print(i_x, j_x)
fo.close()
VII.02_S – Bông tuyết
Chương trình:
import sys
sys.stdin = fi Khởi tạo giá trị đầu
sys.stdout = fo mảng 2 chiều
n = int(input())
a = [['.']*n for i in range(n)]
for i in range(n):
a[i][i] = '*'
a[n//2][i] = '*'
a[i][n//2] = '*' Đưa ra từng dòng
a[i][n-i-1] = '*'
for row in a:
print(' '.join(row))

fo.close()
VII.03_S – Các đường chéo

Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo
n = int(input())
a = [[abs(i - j) for j in range(n)] for i in range(n)]
for row in a:
print(' '.join([str(i) for i in row]))
fo.close() Đưa ra các số của

một dòng
VII.04_S – Đường chéo phụ
Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo
n = int(input())
a = [[0] * n for i in range(n)]
for i in range(n):
a[i][n - i - 1] = 1
for i in range(n):
for j in range(n - i, n):
a[i][j] = 2 Cách khác đưa ra
for row in a: các số của một dòng
for e in row:
print(e, end=' ')
print()
fo.close()

VII.05_S – Đổi chổ cột
Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo
def swap_columns(a, u, v):

for k in range(len(a)):
a[k][u], a[k][v] = a[k][v], a[k][u]

a = [[int(j) for j in input().split()] for i in range(n)]
p, q = [int(i) for i in input().split()]
swap_columns(a, p, q)
print('\n'.join([' '.join([str(i) for i in row]) for row in a]))
fo.close() Cách thứ 3 đưa ra

mảng 2 chiều
Chương trình:
import sys, time
fo = open("output.txt","w") Nạp mô đun tạo số
sys.stdin = fi nguyên ngẫu nhiên
sys.stdout = fo
tb = time.time()
m,n =[int(i) for i in input().split()]

x,y =[int(i) for i in input().split()]
k = int(input()) Tạo số nguyên ngẫu nhiên
p = 0 thuộc đoạn [x, y]
b = []
for i in range(m):
row = []
for j in range(n): row.append(randint(x,y))
b.append(row)
for i in range(m):
for j in range(n): print(b[i][j],end=' ')
for i in range(m):
for j in range(n):

if b[i][j] == k: p += 1
print("Total:",p)
for i in range(m):
for j in range(n):
if b[i][j] == k: print(i+1,j+1)
fo.close()
Chương trình:
import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time()
m,n = [int(i) for i in input().split()]

a = []
#r = [0]*n
mx_r =-1e9
for i in range(m):
r = [int(j) for j in input().split()]
a.append(r)
t = sum(r)
if mx_r < t: mx_r, i_x = t,i
mx_c = -1e9
for j in range(n):
t =0
for i in range(m): t+=a[i][j]
if mx_c < t : mx_c, j_x = t, j
res = mx_r+mx_c - a[i_x][j_x]
print(res)
fo.close()

VIII.01_S – Số phần tử khác nhau
Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo
print(len(set(input().split())))
fo.close()
VIII.02_S – Số phần tử chung

Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo
print(len(set(input().split()) & set(input().split())))

fo.close()
VIII.03_S – Danh sách phần tử chung
Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo
print(*sorted(set(input().split()) & set(input().split())))

fo.close()
VIII.04_S – Số mới
Chương trình:
import sys

sys.stdin = fi
sys.stdout = fo
a = [int(s) for s in input().split()]

num = set()
for i in a:
if i in num: print('OLD',end= ' ')
else:
print('NEW',end=' ')
num.add(i)
fo.close()
VIII.05_S – Bảo tàng gen

Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo
def print_set(s):
print(len(s))
print(*[str(elem) for elem in sorted(s)])

O_s, N_s = set(), set()
t = [int(i) for i in input().split()]

for i in range(n):
O_s.add(t[i])

for i in range(m):
N_s.add(t[i])
print_set(O_s & N_s)

print_set(O_s - N_s)
print_set(N_s - O_s)
fo.close()

VIII.06_S – Số lượng từ
Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo
n = int(input())
w = set()
for i in range(n):
w.update(input().split())
print(len(w))
fo.close()
VIII.07_S – Đoán số
Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo
n = int(input())
s_a = set(range(1,n+1))
s_p = s_a
while True:
guess = input()
if guess == 'Help': break
guess = {int(k) for k in guess.split()}
answer = input()
if answer == 'Yes':
s_p &= guess
else:
s_p &= s_a - guess
print(' '.join([str(x) for x in sorted(s_p)]))

fo.close()

VIII.08_S – Ngoại ngữ
Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo
st = [{input() for j in range(int(input()))}

for i in range(int(input()))]
known_all, known_1 = set.intersection(*st),set.union(*st)
print(len(known_all), *sorted(known_all), sep='\n')

print(len(known_1), *sorted(known_1), sep='\n')
fo.close()
VIII.09_S – Bãi công
Chương trình:
import sys
sys.stdin = fi
sys.stdout = fo
n, k = [int(s) for s in input().split()]

w_d = set([d for d in range(1, n + 1) if d % 7 not in (6, 0)])
no_strikes = set(w_d)
for p in range(k):
a, b =[int(i) for i in input().split()]
mx_strk = (n-a)//b+1
no_strikes -= {a + b*i for i in range(mx_strk)}
print(len(w_d)-len(no_strikes))
fo.close()
Chương trình:
import sys, time

sys.stdin = fi
sys.stdout = fo
tb = time.time()

a_set = set(a)
res = 0
for i in a_set:
j = a.count(i)
if res < j: res, v = j, i
print(v,res)
fo.close()

Giải thuật I: Lọc số theo sơ đồ đã nêu.
Chương trình
import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time()
def sieve_1(n):
prime =[1]*(n+1)
prime[0], prime[1] = 0, 0
if prime[i] == 1:
if i*i <= n:
for j in range(i*i,n+1,i): prime[j] = 0
res = []
if prime[i] == 1:
res.append(i)
return res
n = int(input())
for i in range(n):
m = int(input())
ans = sieve_1(m)
print(m,len(ans))
for j in ans: print(j, end=' ')
print('\n')
Giải thuật II: Lọc theo khối.

Để tập trung vào tư tưởng lọc dữ liệu theo khối chương trình sau không đưa ra
dãy các số nguyên tố tìm được!
Bằng phương pháp lọc đơn giản đã nêu tìm và đánh dấu các số nguyên tố trong
phạm vi từ 1 đến √𝑛, lưu kết quả vào bảng số nguyên tố cơ sở.
Toàn bộ dữ liệu được lọc theo khối, ở mỗi thời điểm chỉ giữ và xử lý một khối.

Gọi s là kích thước khối. Ta có số lượng khối là (n+s-1)/s. Khối thứ k chứa
các số trong đoạn [k×s, k×s+s-1], k = 0, 1, 2, . . ., n/s. Với mỗi khối dùng
bảng nguyên tố cơ sở để lọc tương tự như trong giải thuật đơn giản đã nêu.
Cần đặc biệt lưu ý việc xử lý khối đầu tiên và khối cuối cùng:
Khối đầu tiên:
 Các số 0 và 1 không được đánh dấu là nguyên tố,
 Không được loại bỏ các số nguyên tố trong bảng nguyên tố cơ sở,
Khối cuối cùng: Có thể không chứa đủ s số.
Lựa chọn s:
Nếu s quá nhỏ hiệu quả giải thuật sẽ thấp vì có nhiều khối phải xử lý và
với mỗi khối – phải một lần làm việc với bảng nguyên tố cơ sở,
Nếu s quá lớn – tốn bộ nhớ,
Các kết quả thực nghiệm cho thấy nên lựa chọn s trong khoảng 104 – 105.
Chương trình
import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time()
def sieve_2(n,m):
nprime = [False]*(m+1)
prime = []
nsqrt = int(sqrt(n))
for i in range(2,nsqrt+1):
if not nprime[i]:
prime.append(i)
if i*i <= nsqrt:
for j in range(i*i,nsqrt+1, i):
nprime[j] = True
res = 0
maxk = n//m
for k in range(maxk+1):
bl = [False]*(m+1)
start = k*m
cnt = len(prime)
for i in range(cnt):
start_idx = (start+prime[i]-1)//prime[i]
j = max(start_idx,2)*prime[i]-start
for l in range(j,m,prime[i]): bl[l] = True
if k == 0:

bl[0], bl[1] = True, True
i = 0
while (i < m) & ((start+i) <= n):
if not bl[i]: res += 1
i += 1
return res
s = input().split()
n, m = int(s[0]), int(s[1])
print(n, sieve_2(n,m))
fo.close()
Giải thuật
Việc tính các hệ số này không phức tạp, chỉ cần dẫn xuất công thức biến đổi từ
cặp (a, b) sang (b%a, a).
Giả thiết ta đã biết nghiệm (x1, y1) đối với cặp (b%a, a):
(b%a)×x1 + a×y1 = g
Và muốn tìm cặp (x, y) đối với (a, b).
Ta có b%a = b – (a/b)×a.
Thế vào phương trình trên, có:
g = b%a)×x1 + a×y1
= (b-a/b)×x1 + a×y1
= b×x1 + a×(y1 – (a/b)×x1)
Từ đây suy ra:
x = y1 – (a/b)×x1,
y = x1.
Chương trình
import sys, time
sys.stdin = fi

sys.stdout = fo
tb = time.time()
def gcd_ex(a,b,res):
if a == 0:
res = [0, 1, b]
return res
res = gcd_ex(b%a,a,res)
t = res[1]
res[1] = res[0]
res[0] = t-(b//a)*res[0]
return res
s = input().split()
a, b = int(s[0]), int(s[1])
res = [0,0,0]
res = gcd_ex(a,b,res)
print(res[0],res[1],res[2])
fo.close()
Giải thuật
Dễ dàng thấy rằng số 0 không có nghịch đảo. Với m cho trước mỗi số nguyên
khác 0 có thể có hoặc không có nghịch đảo. Nghịch đảo chỉ tồn tại với các số
nguyên a nguyên tố cùng nhau với m.
Xét phương trình
a×x + m×y = 1
Đây là phương trình Diophantine tuyến tính bậc 2. Phương trình này có nghiệm
khi và chỉ khi gcd(a, m) = 1.
Lấy mô đun m cả 2 vế phương trình trên, ta có:
a×x = 1 (mod m)
Bằng giải thuật Euclid mở rộng dễ dàng tìm được x.
Chương trình
import sys, time
sys.stdin = fi

sys.stdout = fo
tb = time.time()
if a == 0:
res = [0, 1, b]
return res
t = res[1]
res[1] = res[0]
res[0] = t-(b//a)*res[0]
return res
s = input().split()
a, m = int(s[0]), int(s[1])
res = [0,0,0]
ans = gcd_ex(a,m,res)
if ans[2] != 1: print('No Solution')
else:
res = (ans[0]%m+m)%m
print(res)
fo.close()
Giải thuật
Theo các giải thuật đã nêu, bài toán có thể được giải quyết với độ phức tạp
O(mlogm).
Có một phương pháp tiếp cận khác cho phép giải với độ phức tạp O(m).
Ký hiệu r[i] là nghịch đảo của i theo mô đun m. Ta có:
 r[1] = 1,
 r[i] = -(m/i)×r[m%i]%m với i > 1.
Chứng minh:
m % i = m – (m/i)×i
Lấy mô đun m cả 2 vế, ta có
m % i = -(m/i)×i (mod m)
Nhân cả 2 vế với nghịch đảo của i và của (m%i) ta có
r[i] = -(m/i)×r[m%i] (mod m).

Đó là điều phải chứng minh.
Chương trình xử lý hết sức ngắn gọn.
Chương trình
import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time()
m = int(input())
r =[1]*m
for i in range(2,m):
r[i] = (m-(m//i)*r[m%i]%m)%m
for i in range(1,m): print(r[i],end = ' ')
fo.close()
Giải thuật
Giải thuật cho bài toán trên có tên thường gọi là Meet-in-the-Midle (Gặp nhau ở
giữa) do Shanks đề xuất năm 1971. Bản thân Shanks gọi nó là “Giải thuật bước
nhỏ – bước lớn” (Baby-step-giant-step Algorithm).
Ta có phương trình cần giải
ax = b (mod m)
trong đó a và m nguyên tố cùng nhau.
Đặt x = n×p-q với n là một hằng nguyên dương chọn trước.
Khi đó phương trình cần giải có dạng:
an×p-q = b (mod m)
an×p = b×aq (mod m)
f1(p) = f2(q) (mod m)

trong đó p và q là các số cần tìm. p được gọi là bước lớn vì khi p thay đổi một
đơn vị x sẽ thay đổi n đơn vị, còn q – bước nhỏ.
Dễ dàng thấy rằng chỉ cần tìm x trong khoảng [0, m).
Khi n được chọn, ta có p  [1, (m+n-1)/n], q  [0, n].
Bằng phương pháp nâng nhanh lũy thừa, các hàm f1(p) và f2(q) có thể tính
với độ phức tạp O(logm).
Giải thuật bao gồm 2 bước:
Bước 1: Tính tất cả các giá trị của f1(p) trong miền xác định và sắp xếp kết
quả,
Bước 2: Với mỗi giá trị của q trong miền xác định tính giá trị f2(q) và kiểm tra
sự có mặt của nó trong tập giá trị đã tính ở bước 1.
𝑚
Đặt k =   = (m+n-1)/n.
𝑛
Độ phức tạp của bước 1 là O(klogm),

Độ phức tạp của bước 2 bao gồm tính giá trị hàm và tìm kiếm nhị phân: O(nlogm).
Độ phức tạp của toàn giải thuật sẽ thấp nhất khi n  m/n, tức là n  √𝑚.
Trên thực tế để tính f1(p) ta chỉ cần dùng sơ đồ nâng nhanh lũy thừa một lần
khi tính an = an, các giá trị còn lại nhận được bằng cách nhân tiếp với an. Do n
không quá lớn, độ phức tạp của giải thuật sẽ giảm không đáng kể ngay cả khi
không dùng sơ đồ tính nhanh lũy thừa.
Với f2(q), xuất phát từ b, lần lượt nhân với a ta sẽ được tất cả các giá trị cần
kiểm tra.
Thay vì việc dùng mảng lưu giá trị ở bước 1 và sau đó sắp xếp ta có thể dùng cấu
trúc map (Cây Đỏ - Đen) để lưu trữ. Điều này sẽ làm cho việc lập trình ở bước 2
trở nên đơn giản hơn.
Chương trình
import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time()
s = input().split()

a,b,m = int(s[0]),int(s[1]),int(s[2])
flag = False
n = int(sqrt(m))
an = 1
ta = a%m
tn = n
while tn > 0:
if (tn & 1) > 0: an = (an*ta)%m
ta = (ta*ta)%m
tn >>=1
cur = an
vals = {}
if cur not in vals: vals[cur] = i
cur = (cur*an)%m
cur = b
if cur in vals:
ans = vals[cur]*n-i
if ans < m:
flag = True
break
cur = (cur*a)%m
if flag: print(ans)
else: print('-1')
fo.close()
Giải thuật
Đầu tiên xét trường hợp a và b không âm.
Giải thuật Euclid mở rộng cho phép tính được g, xg và yg, trong đó g – ước số
chung lớn nhất của a, b và a×xg + b×yg = g.
Vế trái của phương trình ban đầu chia hết cho g, vì vậy vế phải, tức là c cũng
phải chia hết cho g và việc dẫn xuất tiếp theo dưới đây cho thấy bài toán có
nghiệm. Nếu c không chia hết cho g – bài toán vô nghiệm.

Nhân cả 2 vế của biểu thức đánh dấu ở trên với c/g, ta có:
a×xg×(c/g) + b×yg×(c/g) = c
Nghiệm của phương trình sẽ là:
x0 = xg×(c/g),
y0 = yg×(c/g).
Trường hợp có hệ số âm, ta tìm x0, y0 với giá trị tuyệt đối của hệ số, sau đó đổi
dấu nghiệm nếu hệ số tương ứng nhỏ hơn 0.
Chương trình
import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time()
if a == 0:
res = [0, 1, b]
return res
t = res[1]
res[1] = res[0]
res[0] = t-(b//a)*res[0]
return res
s = input().split()
a, b, c = int(s[0]),int(s[1]),int(s[2])
flag = True
res = [0,0,0]
ans = gcd_ex(abs(a),abs(b),res)
if c % ans[2] != 0:
print('-1')
else:
t = c//ans[2]
x0 = ans[0]*t
y0 = ans[1]*t
if a < 0: x0 = -x0
if b < 0: y0 = -y0
print(x0,y0)
fo.close()

Cho hai đoạn [minx, maxx] và [miny, maxy]. Cần xác định số lượng nghiệm nằm
trong đoạn đã cho và dẫn xuất chính các nghiệm đó.
Nếu một trong 2 hệ số a hoặc b bằng 0 phương trình đã cho sẽ có không quá một
nghiệm và do đó dưới đây ta sẽ không xét trường hợp này.
Đầu tiên ta tìm x nhỏ nhất nằm trong khoảng đã cho, tức là x ≥ minx. Gọi phần
tử đó là lx1. lx1 dễ dàng xác định được với chi phí O(1) theo công thức dẫn
xuất nghiệm đã nêu và ta có kl1 – hệ số k tương ứng với lx1.
Tương tự như vậy có thể tìm được x = rx1 ≤ maxx – x lớn nhất thuộc khoảng
đã cho và kr1 – hệ số k tương ứng với rx1.
Hoán đổi kl1 và kr1 nếu kl1 > kr1. Như vậy ta có đoạn [kl1, kr1] giá trị k
đảm bảo x nằm trong khoảng đã cho.
Bây giờ ta bắt đầu xét đến ràng buộc đối với y. Trước hết tìm y nhỏ nhất lớn hơn
hoặc bằng miny. Ký hiệu kl2 là k tương ứng với y tìm được. Tiếp sau – tìm y
lớn nhất thỏa mãn điều kiện y ≤ maxy và ký hiệu kr2 là k tương ứng với y tìm
được.
Hoán đổi kl2 và kr2 nếu kl2 > kr2. Như vậy ta có đoạn [kl2, kr2] giá trị k
đảm bảo y nằm trong khoảng đã cho.
Giao của 2 đoạn [kl1, kr1] và [kl2, kr2] là tập các giá trị k cho nghiệm trong
đoạn đã cho.
Nếu giao là rỗng – không có nghiệm nào thỏa mãn yêu cầu. Trường hợp giao
khác rỗng – ta có đoạn chung là [kl, kr]. Số lượng nghiệm thỏa mãn sẽ là kr-
kl+1.
Việc dẫn xuất nghiệm không phải là vấn đề lớn: lần lượt cho k nhận các giá trị
trong đoạn [kl, kr] và tính nghiệm theo công thức đã tìm được ở phần trước.
Giải thuật tìm giao của 2 đoạn thẳng:
kl = max(kl1,kl2);
kr = min(kr1,kr2);
if(kl>kr) /* vô nghiệm */; else /* xử lý trường hợp có
nghiệm*/;

Hàm get_segment tính đoạn [v1, v2] chứa các giá trị v thỏa mãn điều kiện
lf ≤ z ≤ rh, trong đó z = v0 + v×h với h ≠ 0,
Hàm này phục vụ tính các đoạn [kl1, kr1] và [kl2, kr2] đã nêu ở trên.
Với h < 0: biến đổi dữ liệu vào, đưa về trường hợp h > 0.
Phép chia nguyên x/h được thực hiện theo trình tự chia các giá trị tuyệt đối, sau
đó mới gán dấu tương ứng vào kết quả, vì vậy cần lưu ý kiểm tra và chỉnh lý kết
quả khi x < 0.
def get_segment(v0, lf, rh, h):

global v1, v2, ans, kl, kr
lf -= v0
rh -= v0 Đưa về trường hợp h > 0
if h < 0:
h = -h
lf = -lf
rh = -rh
lf, rh = rh, lf
v1 = (lf + h - 1)//h
v2 = rh//h
if (lf < 0) and (h*(v1-1) >= lf): v1 -= 1
if (rh < 0) and (h*v2 >rh): v2 -= 1
if v1 > v2:
v1, v2 = v2, v1
return Chỉnh lý kết quả khi
trái dấu
Hàm đưa ra tất cả các nghiệm:

def sol_segment():
g = ans[2]
get_segment(x0,minx,maxx,b//g)
klx, krx = v1, v2
get_segment(y0,miny,maxy,-a//g)
kly, kry = v1, v2
kl = max(klx, kly)
kr = min(krx, kry)
if kl > kr: print('-1')
else:
ta = b//g
tb = -a//g
print(kr-kl+1)
for i in range(kl,kr+1):

print(x0+i*ta,y0+i*tb)
return
Chương trình gọi hàm này sẽ được nêu ở phần sau.
Cho hai đoạn [minx, maxx] và [miny, maxy]. Cần xác định nghiệm nằm trong
đoạn đã cho có tổng x+y là nhỏ nhất.
Theo giải thuật ở phần trên ta có thể tìm đoạn [kl, kr] để dẫn xuất các nghiệm
nằm trong các đoạn đã cho.
Giả thiết (x, y) là một nghiệm của phương trình đang xét. Với một k cụ thể nào
đó ta có nghiệm mới (xn, yn):
 xn = x + k×(b/g),
 yn = y – k×(a/g).
Từ đây có:
xn + yn = x + y +k×(b – a)/g
Như vậy, để xn + yn là nhỏ nhất cần chọn k nhỏ nhất có thể khi b ≥ a và k lớn
nhất khi b < a.
import sys, time

sys.stdin = fi
sys.stdout = fo
tb = time.time()
if a == 0:
res = [0, 1, b]
return res
t = res[1]
res[1] = res[0]
res[0] = t-(b//a)*res[0]
return res
def get_segment(v0, lf, rh, h):


lf -= v0
rh -= v0
if h < 0:
h = -h
lf = -lf
rh = -rh
lf, rh = rh, lf
v1 = (lf + h - 1)//h
v2 = rh//h
if (lf < 0) and (h*(v1-1) >= lf): v1 -= 1
if (rh < 0) and (h*v2 >rh): v2 -= 1
if v1 > v2:
v1, v2 = v2, v1
return
def sol_segment():
g = ans[2]
get_segment(x0,minx,maxx,b//g)
klx, krx = v1, v2
get_segment(y0,miny,maxy,-a//g)
kly, kry = v1, v2
kl = max(klx, kly)
kr = min(krx, kry)
if kl > kr: print('-1')
else:
ta = b//g
tb = -a//g
print(kr-kl+1)
for i in range(kl,kr+1):
print(x0+i*ta,y0+i*tb)
return
def sol_min_sum():
g = ans[2]
ta = b//g
tb = -a//g
if a < b: k = kl
else: k = kr
print('Solution with min sum:',x0+k*ta,y0+k*tb)
return
s = input().split()
a, b, c = int(s[0]),int(s[1]),int(s[2])
s = input().split()
v1, v2 = 0, 0
minx,maxx,miny,maxy = int(s[0]),int(s[1]),int(s[2]),int(s[3])
res = [0,0,0]

ans = gcd_ex(abs(a),abs(b),res)
flag = True
if c % ans[2] != 0:
print('-1')
flag = False
else:
t = c//ans[2]
x0 = ans[0]*t
y0 = ans[1]*t
if a < 0: x0 = -x0
if b < 0: y0 = -y0
sol_segment()
sol_min_sum()
fo.close()
Đầu tiên xét trường hợp a và n nguyên tố cùng nhau. Khi đó có thể tìm phần tử
a-1 nghịch đảo với a theo mô đun n. Nhân cả 2 vế phương trình với phần tử
nghịch đảo này, ta nhận được nghiệm của phương trình và là nghiệm duy nhất:
x = b×a-1 (mod n)
Xét trường hợp a và n không nguyên tố cùng nhau. Phương trình đã cho có thể
vô nghiệm, ví dụ 2×x = 1 (mod 4).
Ký hiệu g = gcd(a,n). Vế trái của phương trình luôn luôn chia hết cho g, vì
vậy nếu b không chia hết cho g – bài toán vô nghiệm.
Chia a, b và n cho g, ta có phương trình
a’×x = b’ (mod n’)
a’ và n’ nguyên tố cùng nhau và theo cách đã xét, ta tìm được nghiện x’ duy
nhất. Dễ dàng thấy rằng nó cũng là nghiệm của phương trình ban đầu, nhưng
không phải là nghiệm duy nhất.
Trong đoạn cần xét, phương trình ban đầu có đúng g nghiệm và có dạng:
xi = x’ + i×n’, i = 0, 1, . . ., g-1
Như vậy, trong mọi trường hợp, phương trình ban đầu hoặc vô nghiệm hoặc có
đúng g = gcd(a,n) nghiệm trong đoạn [0, n-1].

import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time()
from math import gcd
if a == 0:
res = [0, 1, b]
return res
res = gcd_ex(b%a,a,res)s
t = res[1]
res[1] = res[0]
res[0] = t-(b//a)*res[0]
return res
s = input().split()
a, b, n = int(s[0]), int(s[1]), int(s[2])
res = [0,0,0]
g = gcd(a,n)
if b%g != 0:
print('0')
else:
a //=g
b //=g
n //= g
ans = gcd_ex(a,n,res)
print(res)
x = (ans[0]%n+n)%n
x = (x*b)%n
print(g)
for i in range(g): print(x+i*n, end = ' ')
fo.close()
Biểu thức tính giai thừa: n! = 1×2×3×. . . ×(n-1)×n.

Trong tích trên các thừa số ở vị trí (bắt đầu từ 1) là bội của k chia hết cho k, mỗi
thừa số đó sẽ làm tăng số mũ cần tìm lên 1 và có tất cả n/k thừa số như vậy.
Mỗi thừa số ở vị trí là bội của k2 sẽ làm tăng số mũ cần tìm lên 1 (vì đã tính một
lần ở bước trước). Số lượng thừa số loại này là n/k2.

Tương tự như vậy, mỗi thừa số ở vị trí là bội của ki sẽ làm tăng số mũ cần tìm
lên 1 (vì đã tính i-1 một lần ở các bước trước). Số lượng thừa số loại này là n/ki.
Như số cần tìm là n/k + n/k2 + . . . + n/ki + . . . Số lượng số hạng trong tổng
là O(logkn) và độ phức tạp của giải thuật cũng sẽ là như vậy.
Chương trình tính x trường hợp k là nguyên tố:
import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time()
def fac_pow(n,k):
res = 0
while n > 0:
n //=k
res +=n
return res
s = input().split()
n, k = int(s[0]), int(s[1])
ans = fac_pow(n, k)
print(ans)
fo.close()
Phân tích k ra thừa số nguyên tố. Giả thiết ki là thừa số thứ i với số mũ pi. Áp
dụng giải thuật đã xét với ki ta có số mũ là ansi với độ phức tạp tính toán
O(logn).
Số mũ cần tìm sẽ là min{ansi/pi} với mọi i.
Tồn tại các phương pháp phân tích nhanh ra thừa số nguyên tố (sẽ xét sau). Ở đây
ta xét phương pháp đơn giản trong lập trình và có độ phức tạp O(√𝑘).
Giải thuật:
Nhận xét:
Do có yêu cầu đưa ra số lượng số nguyên tố khác nhau trong phép phân rã
k ra tích các thừa số nguyên tố nên cần lưu trữ các giá trị ai, bi nhận được
trong quá trình phân tích,

Vì m không biết trước, để tiện xử lý ai được tổ chức lưu giữ trong
vector<int64_t> a, bi – lưu giữ trong vector<int> b.
Xử lý: Giải thuật xử lý với mỗi số nguyên k = x:
import sys, time

sys.stdin = fi
sys.stdout = fo
tb = time.time()
def calc_p(x):
global a, b, m
m, t = 0, 2
while t*t <= x:
if x%t == 0:
tg = 0
while x%t == 0:
x //= t
tg += 1
a.append(x)
b.append(tg)
m += 1
t += 1
if x > 1:

a.append(x)
b.append(1)
m += 1
def calc_x(x):
global res
res = 0
t = n
while t > 0:
t //= x
res += t
s = input().split()
n, k = int(s[0]), int(s[1])
a = []
b = []
ans = int(1e20)
calc_p(k)
for i in range(m):
calc_x(a[i])
if ans > res//b[i]: ans = res//b[i]
print(ans)
fo.close()

import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time()
def facmod(n, p):

res = 1
while n > 1:
if (n//p)%2 > 0: t = p - 1
else: t = 1
res = (res * t) % p

for i in range(2,n%p+1):
res = res*i%p
n//= p
return res%p
s = input().split()
n, p = int(s[0]), int(s[1])
ans = facmod(n,p)
print(ans)
fo.close()

Φ(𝑛)
𝑔 𝑝𝑖
(mod n),
Nếu với một nào đó mọi giá trị tính được đều khác 1 thì là số cần tìm.
import sys, time

sys.stdin = fi
sys.stdout = fo
tb = time.time()

def binpow(a, b, p):

ans = 1
a %= p
while b > 0:
if b & 1 == 1: ans = ans* a % p
a = a*a%p
b >>= 1
return ans
def f_phi(n):
res = n
i = 2
while i*i <= n:
if n%i == 0:
while n%i == 0: n //= i
res -= res//i
i += 1
if n > 1: res -= res//n
return res
def generator(p):
phi = f_phi(p)
m = phi
fact = []
i = 2
while i*i <= m:
if m % i == 0:
fact.append(i)
while m%i == 0: m //= i
i += 1
if m > 1: fact.append(m)
for r in range(2,p+1):
ok = True
if gcd(r,p) != 1: continue
i = 0
while (i < len(fact)) and ok:
ok &= binpow(r,phi//fact[i],p) != 1
i += 1
if ok: return r
return -1
n = int(input())
ans = generator(n)
print(ans)

fo.close()

import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time()
from math import sqrt,gcd
from bisect import bisect_left
def binpow(a, b, p):

ans = 1
a %= p
while b > 0:
if b & 1 == 1: ans = ans* a % p
a = a*a%p
b >>= 1
return ans
def generator(p):
phi = p-1
m = phi
fact = []
i = 2
while i*i <= m:
if m % i == 0:
fact.append(i)
while m%i == 0: m //= i
i += 1
if m > 1: fact.append(m)
for r in range(2,p+1):
ok = True
if gcd(r,p) != 1: continue
i = 0
while (i < len(fact)) and ok:
ok &= binpow(r,phi//fact[i],p) != 1
i += 1
if ok: return r
return -1

s = input().split()
a, k, n = int(s[0]), int(s[1]), int(s[2])
if a == 0:
print('1\n0')
fo.close()
quit()
g = generator(n)
sq = int(sqrt(n))+1
dec =[[]]
for i in range(1,sq+1):
dec.append([binpow(g,i*sq*k%(n-1),n),i])
dec.sort()
any_ans = -1
for i in range(sq):
my = binpow(g,i*k%(n-1),n)*a%n
it = bisect_left(dec,[my,0],0,len(dec))
if it !=len(dec) and dec[it][0] == my:
any_ans = dec[it][1]*sq-i
break
if any_ans == -1:
print('-1')
fo.close()
quit()
delta = (n-1)//gcd(k,n-1)
ans = []
for cur in range(any_ans%delta,n-1,delta):
ans.append(binpow(g,cur,n))
ans.sort()
print(len(ans))
for i in ans: print(i,end = ' ')
fo.close()
Giải thuật: Ứng dụng giải thuật Leman.

Độ phức tạp của giải thuật: bậc O(mlnn1/3).
import sys, time

sys.stdin = fi
sys.stdout = fo

tb = time.time()
from math import sqrt,gcd,ceil
def Leman(n):
sqrt3_n_up = ceil(pow(n,1.0/3))+2
m = 2
divisors = []
while (m*m <= n) and (m < sqrt3_n_up):
while n%m == 0:
divisors.append(m)
n //= m
m += 1
if m*m > n:
if n != 1: divisors.append(n)
return divisors
sqrt6_n = pow(n,1.0/6)
sqrt_n = sqrt(n)
for k in range(1,sqrt3_n_up):
sqrt_k = sqrt(float(k))
sqrt_4nk = ceil(2*sqrt_k*sqrt_n) + 2
diff = sqrt_4nk**2- 4*k*n
while diff >= 2*sqrt_4nk-1:
diff +=-2*sqrt_4nk+1
sqrt_4nk -= 1
max_d = ceil(sqrt6_n/(4*sqrt_k)) + 3
for d in range(max_d):
a = sqrt_4nk + d
b = round(sqrt(diff))
if b*b == diff:
d1 = gcd(a+b,n)
d2 = gcd(a-b,n)
if (1 < d1 < n) or (1 < d2 < n):
if 1 < d1 < n: p = d1
else: p = d2
divisors.append(p)
divisors.append(n//p)
return divisors
diff += 2*a+1
divisors.append(n)
return divisors
m = int(input())
s = input().split()
for i in range(m):
n = int(s[i])
res = Leman(n)
print(len(res))
for j in res: print(j,end = ' ')
print('\n',end ='')

fo.close()
Tính nhanh lũy thừa.

Với mọi n ta có
Việc tính Fn và Fn+1 có thể dễ dàng thực hiện theo sơ đồ tính nhanh lũy thừa.
Xuất từ ma trận ban đầu
x = 1 1
1 0
Ta sẽ tính x2, x4, x8, . . . và tích lũy kết quả vào ma trận z kích thước 2×2
Để tăng tốc độ xử lý các ma trận x và z được lưu trữ dưới dạng một chiều:
x0 x1 z0 z1
x = x2 x3 z = z2 z3
Xét s = Fa + Fa+1 + . . . + Fb-1 + Fb

Với b-a+1 chẵn: nhóm từng cặp 2 số hàng từ cuối về đầu, ta được:
s = Fa + Fa+1 + . . . + Fb-3 + Fb-2 + Fb-1 + Fb

Fa+2 Fb-1 Fb+1
Cộng thêm vào 2 vế đẳng thức giá trị Fa+1, ta có:
S + Fa+1 = Fa + Fa+1 + . . . + Fb-3 + Fb-2 + Fb-1 + Fb

Fa+1 Fa+2 Fb-1 Fb+1
+ Fb-2
. . . Fb Fb+2
Fa+3

s = Fb+2 – Fa+1
Như vậy:
Dễ dàng chứng minh công thức này đúng với cả trường hợp b-a+1 là lẻ.
Tuy công thức vẫn đúng trong trường hợp a = b, nhưng để giảm thời gian tính
toán nên phân biệt riêng trường hợp này.
Cần lưu ý tổ chức sơ đồ dẫn xuất kết quả không phụ thuộc vào dấu của Fb+2–
Fa+1 (vì giá trị của mỗi toán hạng được tính theo mô đun 109).
Quá trình xử lý kết thúc khi file input rỗng. Với hệ thống lập trình C++, nếu sau
dòng dữ liệu cuối cùng có dấu xuống dòng, chương trình sẽ đọc tiếp một dòng
nữa và không làm thay đổi giá trị các biến ở lần đọc trước! Do đó, cần tổ chức
nhận dạng trường hợp gặp dòng rỗng.
Độ phức tạp của giải thuật:

Với mỗi cặp dữ liệu độ phức tạp xử lý là O(logb),
Gọi q – số lượng các cặp dữ liệu cầ xử lý, m = max các giá trị b,
Độ phức tạp toàn chương trình: O(qlogm).
import sys,time
fi=open("Input.txt")
fo=open("Output.txt","w")
sys.stdin=fi
sys.stdout=fo
tb=time.time()
def mul(u, v):

global p
t = [0]*4
t[0] = (u[0]*v[0]%p+u[1]*v[2]%p)%p
t[1] = (u[0]*v[1]%p+u[1]*v[3]%p)%p
t[2] = (u[2]*v[0]%p+u[3]*v[2]%p)%p
t[3] = (u[2]*v[1]%p+u[3]*v[3]%p)%p
return t
def get_fib(k):
z = [1, 0, 0, 1]
x = [1, 1, 1, 0]
while k > 0:
if (k & 1) == 1: z = mul(x, z)

x = mul(x, x)
k >>= 1
return z[0]
p = int(1e9)
for s in fi:
s = s.split()
a, b = int(s[0]), int(s[1])
if a == b:
if a == 0: ans = 1
else: ans = get_fib(a)
else:
ans = (get_fib(b+2) + p - get_fib(a+1))%p
print(ans)
print("\nTime: %.4f sec" %(time.time()-tb))

fo.close()
Tổ chức dữ liệu, duyệt tổ hợp.

Nhận xét:
Mỗi cặp ngoặc liên hợp sẽ tạo ra một biểu thức ngoặc đúng ,
Biết khoảng cách của cặp ngoặc liên hợp ta có thể dễ dàng tính số cặp
ngoặc tham gia vào biểu thức đúng tương ứng với cặp ngoặc đó,
Số cặp ngoặc tham gia vào biểu thức đúng tương ứng với một cặp ngoặc
liên hợp được gọi là độ dài biểu thức,
Biểu thức ngoặc đúng độ dài lớn hơn 1 phải chứa ít nhất một biểu thức
ngoặc đúng độ dài 1,
Khoảng cách của một cặp ngoặc liên hợp phải là một số chẵn, trong trường
hợp ngược lại – bài toán vô nghiệm.
Từ dữ liệu đã cho ta có thể tính số lượng biểu thức độ dài i, i = 1 ÷ n.
Gọi ai – số lượng biểu thức độ dài i, i = 1 ÷ n.
a1 biểu thức ngoặc đúng độ dài 1 là cơ sở xuất phát để xác định biểu thức cần
tìm, mỗi biểu thức cơ sở có dạng ().
Lần lượt duyệt ai với i = 2 ÷n.
Với mỗi ai > 0 :
 Tìm ai tập con không giao nhau từng đôi một từ cơ sở hiện có, mỗi tập con
cho tổng độ dài các phần tử bằng i-1,

 Gọi s – tổng các biểu thức xác định bởi một tập con, kết nạp biểu thức
‘(‘+s+’)’ độ dài i vào cơ sở,
 Xóa các biểu thức đã sử dụng trong cơ sở.
Nếu với một ai > 0 nào đó không tìm được đủ ai biểu thức ngoặc đúng độ dài i
– bài toán vô nghiệm.
Trong trường hợp có nghiệm: Biểu thức cần tìm là tổng các biểu thức trong cơ sở
cuối cùng.
Tìm tập con cho tổng độ dài các phần tử là k từ cơ sở có m phần tử: duyệt các tổ
hợp chập 1, chập 2, . . ., chập m các phần tử của cơ sở. Số lượng tổ hợp cần kiểm
tra không vượt quá 2m.
import sys,time
fi=open("Input.txt")
fo=open("Output.txt","w")
sys.stdin=fi
sys.stdout=fo
tb=time.time()
def calc_sum(y):
global nb,b0,b_sum
r = 0
p = nb+1
b_sum = ''
b0 = [0]*21
for i in range(nb):
q = nb-i
if (y &(1<<i))> 0:
r += b[q]
b_sum +=sb[q]
b0[q] = 1
return r
def get_base(x):
global nb,flag,b,b0,b_sum,a
a[x+1] -= 1
for i in range(1, 1<<nb):
t = calc_sum(i)
flag = (t == x)
if flag: break
if not flag: return

for i in range(1,nb+1):
if b0[i] > 0: b[i] = 0

nb += 1
b[nb] = x+1
sb[nb] = '('+ b_sum + ')'
k = 0
if b[i] == 0: continue
k += 1
b[k] = b[i]
sb[k] = sb[i]
nb = k
return
n = int(input())
a = [0]*22
b = [0]*22
sb = ['']*22
ans = ''
flag = False
for i in range(n):
k = (t[i]+2)//2
if ((t[i]&1) == 1) or (k > n):
print('No')
fo.close()
quit()
a[k] += 1
nb = a[1]
b[i] = 1
sb[i] = '()'
if a[i] == 0: continue
while a[i] > 0:get_base(i-1)
if not flag:
print('No')
fo.close()
quit()
print('Yes')
if nb == 1: ans = sb[1]
else:
for i in range(1,nb+1): ans += sb[i]
print(ans)
print("\nTime: %.4f sec" %(time.time()-tb))

fo.close()

Tính diện tích theo công thức hình thang.
S =|xa*yb - xb*ya + xb*yc – xc*yb + xc*ya – ya*xc|/2
Chương trình:
import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time()
# Tinh dien tich theo cong thuc hinh thang

s = input().split()
xa, ya = int(s[0]), int(s[1])
s = input().split()
xb, yb = int(s[0]), int(s[1])
s = input().split()
xc, yc = int(s[0]), int(s[1])
dt = xa*yb - ya*xb + xb*yc - xc*yb + xc*ya - xa*yc

dt = abs(dt)/2
print("Area =",dt)
fo.close()
Tính diện tích theo công thức Heron.
S = √𝒑 × (𝒑 − 𝒂) × (𝒑 − 𝒃) × (𝒑 − 𝒄)
Trong đó:
a, b, c – độ dài các cạnh tam giác,
p = (a+b+c)/2

Chương trình:
import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time()
# Tinh dien tich dua theo cong thuc Heron

s = input().split()
xa, ya = float(s[0]), int(s[1])
s = input().split()
xb, yb = float(s[0]), int(s[1])
s = input().split()
xc, yc = float(s[0]), int(s[1])
a = sqrt((xb-xc)**2+(yb-yc)**2)
b = sqrt((xa-xc)**2+(ya-yc)**2)
c = sqrt((xb-xa)**2+(yb-ya)**2)
p = (a+b+c)/2
dt = sqrt(p*(p-a)*(p-b)*(p-c))
print("Area =",dt)
fo.close()
Tính diện tích theo công thức S = a×ha/2,

a – độ dài cạnh đáy,
ha – độ dài đường cao hạ xuống cạnh đáy.
Chương trình
import sys, time

sys.stdin = fi
sys.stdout = fo
tb = time.time()

# Tinh dien tich dua theo S = a×ha/2
s = input().split()
s = input().split()
s = input().split()
a = sqrt((xb-xc)**2+(yb-yc)**2)
p = yc-yb
q = -(xc-xb)
r = yb*(xc-xb)- xb*(yc-yb)
h = (p*xa+q*ya+r)/sqrt(p*p+q*q)
dt = a*h/2
print("Area =",dt)
fo.close()
Giải thuật
Đường tròn ngoại tiếp hình chữ nhật nhận đường chéo hình chữ nhật làm đường
kính. Vì vậy bán kính cần tìm bằng một nửa độ dài đường chéo hình chữ nhật.
import sys, time

sys.stdin = fi
sys.stdout = fo
tb = time.time()

# Tinh ban kinh duong tron ngoai tiep hinh chu nhat
s = input().split()
s = input().split()
r = sqrt((xa-xc)**2+(ya-yc)**2)/2
print(r)
fo.close()
Tâm đường tròn ngoại tiếp ABC là giao của các đương trung trực.
Gọi M1 là điểm giữa của cạnh BC, M2 – điểm giữa cạnh AB, O – tâm đường tròn
ngoại tiếp tam giác.
A(xa,ya)
M2(xm2,ym2)
B(xb,yb)
M1(xm1,ym1) C(xc,yc)
Phương trình đường thẳng đi qua 2 điểm B và M1:

𝑥 − 𝑥𝑚1 𝑦 − 𝑦𝑚1
=
𝑥𝑏 − 𝑥𝑚1 𝑦𝑏 − 𝑦𝑚1
Từ đây suy ra phương trình đường thẳng đi qua điểm M1 vàvuông góc với BM1:
𝑥 − 𝑥𝑚1 𝑦 − 𝑦𝑚1
=
−(𝑦𝑏 − 𝑦𝑚1) 𝑥𝑏 − 𝑥𝑚1

Ta có:
(xb–xm1)x + (yb-ym1)y = xm1(xb-xm1) + ym1(yb-ym1)
a1×x + b1×y = c1
Lập luận tương tự với đường trung trực đi qua điểm M2, ta có:
(xb–xm2)x + (yb-ym2)y = xm2(xb-xm2) + ym2(yb-ym2)
a2×x + b2×y = c2
Tọa độ tâm đường tròn ngoại tiếp là nghiệm của hệ phương trình:
a1×x + b1×y = c1
a2×x + b2×y = c2
Ký hiệu
𝑎1 𝑏1
d = = a1×b2-a2×b1
𝑎2 𝑏2
𝑐1 𝑏1
dx = = c1×b2-c2×b1
𝑐2 𝑏2
𝑎1 𝑐1
dy = = a1×c2-a2×c1
𝑎2 𝑐2
Tọa độ tâm đường tròn sẽ là (dx/d, dy/d).
Biết tọa độ tâm dễ dàng tính được độ dài bán kính
import sys, time

sys.stdin = fi
sys.stdout = fo

tb = time.time()
# Tinh ban kinh duong tron ngoai tiep tam giac

s = input().split()
s = input().split()
s = input().split()
xm1 = (xb+xc)/2
ym1 = (yb+yc)/2
xm2 = (xb+xa)/2
ym2 = (yb+ya)/2
c1 = ym1*(yb-ym1)+xm1*(xb-xm1)
c2 = ym2*(yb-ym2)+xm2*(xb-xm2)
a1 = xb-xm1
b1 = yb-ym1
a2 = xb-xm2
b2 = yb-ym2
d = a1*b2-a2*b1
xr = (c1*b2-b1*c2)/d
yr = (a1*c2-c1*a2)/d
r = sqrt((xa-xr)**2+(ya-yr)**2)
print("Center:",xr,yr)
print("Radius =",r)
fo.close()
Giải thuật giải bài toán đã nêu được Klee công bố năm 1977 với độ phức tạp
O(nlogn) và là giải thuật nhanh nhất hiện nay.
Lưu tất cả các tọa độ vào mảng x,
Với mỗi phần tử của x: đánh dấu là điểm đầu hay điểm cuối của đoạn thẳng,

Sắp xếp x theo thứ tự tăng dần, với các điểm cùng tọa độ – ưu tiên điểm đầu,
Sử dụng bộ đếm c thống kê số lượng đoạn thẳng giao nhau,
Duyệt mảng x, nếu c ≠ 0: cộng thêm vào kết quả hiệu xi – xi-1, nếu gặp điểm
đầu – tăng c lên 1, gặp điểm cuối – giảm c.
10 20
3 8
14 16
1 5
Kết quả
import sys, time

sys.stdin = fi
sys.stdout = fo
tb = time.time()
n = int(input())
x = [[0,0]]*(2*n)
for i in range(n):
s =input().split()
a,b = int(s[0]),int(s[1])
x[2*i] = [a, 0]
x[2*i+1] = [b,1]
x.sort()
c, ans = 1, 0
for i in range(1,2*n):
if c > 0: ans += x[i][0]-x[i-1][0]
if x[i][1] > 0: c-= 1
else: c +=1
print(ans)
fo.close()

Gọi S là diện tích của đa giác, B – số điểm có tọa độ nguyên nằm trên cạnh của
đa giác, I – số điểm trong có tọa độ nguyên. Khi đó tồn tại quan hệ
Định này do nhà toán học Áo G. A. Pick phát biểu và chứng minh năm 1899.
Dựa vào định lý này, nếu biết B và I ta có thể tính diện tích đa giác mà không
cần quan tâm đến tọa độ cụ thể của các đỉnh.
Ví dụ, với đa giác của hình dưới đây ta có :
I = 15, B = 12 → S = 15 + 12/2.0 - 1 = 20.0
Định lý đúng với trường hợp hình vuông đơn vị,

Nếu đa giác là hình chữ nhật cạnh độ dài a, b song song với trục tọa độ, số điểm
trong là I = (a-1)×(b-1), số điểm trên cạnh là B = 2×(a+b). Dễ dàng thấy
được là diện tích S = a×b = I + B/2.0 – 1.
Trường hợp đa giác là tam giác vuông có các cạnh góc vuông song song với trục
tọa độ: đa giác là một nửa hình chữ nhật nếu ta cắt hình chữ nhật theo đường
chéo. Gọi c là số điểm có tọa độ nguyên trên đường chéo này. Dễ dàng chứng

minh diện tích hình chữ nhật (và từ đó – diện tích tam giác vuông) không phụ
thuộc vào c.
Trường hợp tam giác bất kỳ: bằng cách ghép thêm tối đa 3 tam giác vuông có các
cạnh góc vuông song song với trục tọa độ ta đưa tam giác về hình chữ nhật cạnh
song song với trục tọa độ. Lưu ý là diện tích các tam giác bổ sung không phụ
thuộc vào số điểm nguyên trên cạnh huyền ta có điều cần chứng minh.
Với đa giác bất kỳ: chia thành các tam giác.
Lưu ý: Định lý Pick không áp dụng với trường hợp 3 hay nhiều chiều.
import sys, time

sys.stdin = fi
sys.stdout = fo
tb = time.time()
n = int(input())
x =[0]*(n+1)
y = [0]*(n+1)
for i in range(n):
s = input().split()
x[i], y[i] = int(s[0]), int(s[1])
x[n], y[n] = x[0], y[0]
s, b = 0, 0
for i in range(n):
s += x[i]*y[i+1] - x[i+1]*y[i]
u = abs(x[i]-x[i+1])
v = abs(y[i]-y[i+1])
if u == 0 or v == 0: b += u+v
else: b += gcd(u,v)
s = abs(s)

I = (s-b+1)//2
print(I, b)
fo.close()
Dữ liệu được lưu trữ vào vector x, mỗi tọa độ được lưu dưới dạng nhóm 3 số
(tọa độ, dấu hiệu cuối đoạn, số thứ tự của đoạn)
ai hoặc bi True nếu tọa độ là bi i
Dùng mảng flg[] để đánh dấu, flg[i] = true nếu đã có điểm đại diện và
bằng false trong trường hợp ngược lại,
Sắp xếp x theo thứ tự tăng dần,
Duyệt x từ đầu đến cuối:
 Gặp điểm đầu: nạp số thứ tự vào vector v,
 Gặp điểm cuối: kiểm tra flg tương ứng, nếu đoạn tương ứng chưa có đại
diện thì tăng số lượng đại diện lên 1, đánh dấu có đại diện cho tất cả các
đoạn có số thứ tự lưu trữ trong v và xóa v.
Độ phức tạp của giải thuật: O(nlogn).
import sys, time

sys.stdin = fi
sys.stdout = fo
tb = time.time()
n = int(input())
x = [[0,False,0]]*(2*n)
flag = [False]*n
for i in range(n):
s = input().split()
a, b = int(s[0]), int(s[1])

x[2*i] = [a,False,i]
x[2*i+1] = [b,True,i]
x.sort()
v = [0]*n
ans, pv = 0, 0
for i in range(2*n):
if not x[i][1]:
v[pv] = x[i][2]
pv += 1
if x[i][1] and not flag[x[i][2]]:
for j in range(pv): flag[v[j]] = True
flag[x[i][2]] = True
ans += 1
pv = 0
print(ans)
fo.close()
Gợi ý:
Việc tính biểu thức s được thực hiện bằng câu lệnh v = eval(s).
import sys, time

sys.stdin = fi
sys.stdout = fo
tb = time.time()
a = randint(-10, 10)
b = randint(-5, 5)
c = randint(0, 10)
n = int(input())
v =[0]*n Tính giá trị
sum = 0 biểu thức
res = []
for i in range(n):
v[i] = eval(input())
sum += v[i]

average = sum/n
a1 = average*0.8
a2 = average*1.2
ans = 0
for i in range(n):
if a1 <= v[i] <= a2:
ans += 1
res.append(i)
Một cách viết điều kiện
print('a,b,c:',a,b,c)
print(("Average: {:0.6f} \nTotal results in range: {:d}")
.format(average,ans))
if ans > 0:
print('Winners: ',end = '')
for i in res: print(i+1, end = ' ')
fo.close()
Kỹ thuật tổ chức dữ liệu.

Mỗi cặp số đứng liên tiếp nhau trong hoán vị cần tìm sẽ xuất hiện 2 lần trong các
bộ 3 đã cho.
1 3 4 2 5 6 1 3 4 2 5 6 1 3 4 2 5 6
Xét một bộ 3 số trong dữ liệu vào.
Để tiện lưu trữ và tìm kiếm: Sắp xếp các số trong bộ 3 theo thứ tự tăng dần.
Gọi kết quả sắp xếp là (a, b, c).
Có 3 cách tách nhóm 3 này thành một một cặp 2 số và số tiếp theo:
((a,b),c)
((a,c),b)
((b,c),a)
Khi cố định một cặp 2 số thì số thứ 3 đứng kề sẽ trở nên tiền định, đồng thời cũng
xác định cặp số tiếp theo chứa số thứ 3.
Với mỗi cách tách đã nêu, tìm các số tiếp theo. Nếu kết quả tìm kiếm cho dãy n
số thì đó là nghiệm bài toán. Vấn đề còn lại chỉ là xoay dãy số, đưa 1 về vị trí
đầu.

Trường hợp riêng: Với n ≤ 4 – mọi hoán vị đều phù hợp!
Tổ chức dữ liệu:
 Danh sách inp = [[0,0,0]]*n – Lưu dữ liệu vào,
 Từ điển ds = {} – Lưu quan hệ cặp số và số thứ 3,
 Danh sách cur = [] – Lưu kết quả cần tìm.
Xử lý:
Lưu quan hệ cặp số và số thứ 3:
for i in range(n):
inp[i] = [int(j) for j in input().split()]
inp[i][0] -=1
inp[i][1] -=1
inp[i][2] -=1
Nạp vào từ điển
inp[i].sort()
if (inp[i][0], inp[i][1]) in ds:

ds[(inp[i][0], inp[i][1])].append(inp[i][2])
else: ds[(inp[i][0], inp[i][1])] = [inp[i][2]]


Khóa phải nêu dưới Giá trị: Có dạng kiểu

dạng kiểu tuple list

Duyệt cặp số:
Xác định số
for st in range(3):
đứng kề
cur = []
for i in range(3): Xác định các
cur.append(inp[0][(st+i)%3]) số tiếp theo
while len(cur)< n:
l = len(cur)-1
a = cur[l]
b = cur[l-1]
ok = False
for x in ds[(min(a,b), max(a,b))]:
if x != cur[l-2]:
Gặp lại số đã xét cur.append(x)
ok = True
break
if not ok: break
# . . . . . Đưa ra kết quả
Đưa ra kết quả:
Tìm vị trí số 0
trong dãy
if len(cur) == n: Đưa số 0 về đầu
it = cur.index(0)
cur2 = cur[it:]+cur[:it]
for elem in cur2: print(elem+1, end = ' ')
fo.close()
quit()
Độ phức tạp của giải thuật: O(n).
import sys, time

sys.stdin = fi

sys.stdout = fo
tb = time.time()
n = int(input())
if n <= 4:
for i in range(1,n+1): print(i,end = ' ')
fo.close()
inp = [[0,0,0]]*n
ds = {}
for i in range(n):
inp[i] = [int(j) for j in input().split()]
inp[i][0] -=1
inp[i][1] -=1
inp[i][2] -=1
inp[i].sort()


for st in range(3):
cur = []
for i in range(3):
cur.append(inp[0][(st+i)%3])
while len(cur)< n:
l = len(cur)-1
a = cur[l]
b = cur[l-1]
ok = False
for x in ds[(min(a,b), max(a,b))]:
if x != cur[l-2]:
cur.append(x)
ok = True
break
if not ok: break
if len(cur) == n:
it = cur.index(0)
cur = cur[it:]+cur[:it]
for elem in cur: print(elem+1, end = ' ')
fo.close()

quit()

Cơ sở lập trình .
Gọi Pi là điểm tương ứng với vị trí của phao thứ i.

Xét các tam giác P1P2Pi, i = 3 ÷ n. Nếu các điểm
nằm thẳng hàng thì các tam giác này đều có diện
tích bằng 0 với mọi i.
Nếu tồn tại i để tam giác P1P2Pi có diện tích khác
0 thì 3 điểm P1, P2 và Pi không thẳng hàng.
Công thức tính 2 lần diện tích (có dấu) của tam
giác P1P2Pi :
x1y2-y1x2+x2yi-y2xi+xiy1-yix1
Xác định phương trình đường thẳng f(x,y) = ax+by+c đi qua 2 điểm P1 và
P2, trong đó:
a = y2-y1
b = -(x2-x1)
c = y1(x2-x1)-x1(y2-y1)
Tính f(xi,yi), i = 3 ÷ n, nếu f(xi,yi) ≠ 0 → 3 điểm P1, P2 và Pi không
thẳng hàng.
import sys, time

sys.stdin = fi
sys.stdout = fo
tb = time.time()
n = int(input())

ir = 0
s = input().split()
s = input().split()
area = xa*yb - xb*ya
s = input().split()
if area + xb*yc - xc*yb + xc*ya - xa*yc != 0:
ir = i
break
if ir > 0:
print('Yes\n1 2',ir)
else: print('No')
fo.close()
import sys, time

sys.stdin = fi
sys.stdout = fo
tb = time.time()
n = int(input())
ir = 0
s = input().split()
s = input().split()
a = yb-ya
b = xa-xb
c = ya*(xb-xa) - xa*(yb-ya)
s = input().split()
if a*xc + b*yc + c != 0:
ir = i
break
if ir > 0:

print('Yes\n1 2',ir)
else: print('No')
fo.close()
Cơ sở lập trình.
Số loại hoa sẽ mua là n nếu n lẻ và bằng n-1 trong trường hợp ngược lại,
Nếu n chẵn – không mua loại hoa có số lượng nhỏ nhất,
Với loại hoa i được mua: số lượng bông sẽ mua là ai nếu ai lẻ và là ai-1 trong
trường hợp ngược lại.
# WA 46 A17
import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time()
n = int(input())
ans ,fmn = 0, 1001
if(n&1) == 1:
for i in range(n): ans += a[i] - (1-(a[i]&1))
else:
for i in range(n): fmn = min(fmn,a[i])
for i in range(n):
ans += a[i] - (1-(a[i]&1))
fmn -=1 -(fmn&1)
ans -= fmn
print(ans)
fo.close()
Nhận dạng tình huống lô gic .

Xét số x chỉ có một chữ số khác 0 trong cơ số B: x = d×Bk, k ≥ 0, 1 ≤ d <B.
Dễ dàng thấy rằng:
X mod(B-1)nếu x mod (B-1)> 0,

d =
B-1 nếu x mod (B-1)= 0,
Từ đây suy ra việc lấy tổng các chữ số của số x bất kỳ và lập lại cho đến khi còn
một chữ số sẽ cho kết quả bằng tổng các chữ số của x theo mô đun B-1 và thay
nó bằng B-1 nếu kết quả tính mô đun bằng 0.
Gọi fB(x) – hàm tính tổng các chữ số của x (theo cơ số B) theo quy tắc nêu trên
Không phụ thuộc vào cơ số, ta có:
fB(x×y) = fB(fB(x)×fB(y))
Ví dụ, với x = 11, y = 11
x×y fB(x) fB(y) fB(fB(x)×fB(y))

y)
Cơ số 2 : 1001 1 1 1
Cơ số 10: 121 2 2 4
Cơ số 16: 121 2 2 4
Với 2 số x và y (x ≤ y) với y = x+k (k ≥ 0), gọi ans là kết quả cần tìm.
Ta có:
ans = fB(x×(x+1)×(x+2)× . . . ×(x+k))
= fB(fB(x)×(fB(x)+1)×(fB(x)+2)× . . . ×(fB(x)+k))
Nếu k ≥ B-1 hoặc fB(x) > fB(fB(x)+k) thì một trong số các fB(fB(x)+i)
sẽ bằng B-1và ans sẽ bằng B-1.
Như vậy trong trường hợp xấu nhất, để dẫn xuất kết quả cần tính
fB(fB(x)×(fB(x)+1)×(fB(x)+2)× . . . ×(fB(x)+m)),
trong đó 0 ≤ m < B-1.
 Hai xâu a,b – lưu trữ dữ liệu vào,
 Xâu pat = ‘0123456789ABCDEF’ – Phục vụ chuẩn hóa dữ liệu và xác
định giá trị của các chữ số Hexa.

Xử lý:
Chuẩn hóa dữ liệu vào:
sa = input()
sb = input()
na = len(sa)
nb = len(sb)
ta, tb = 0, 0
pat='0123456789ABCDEF'
a = sa.upper()
b = sb.upper()
Tính f16(a) và f16(b):
for c in a:
k = pat.find(c)
ta += k
ta %= 15
for c in b:
k = pat.find(c)
tb += k
tb %= 15
Nhận dạng các trường hợp có fB(fB(x)+i) bằng 15:
if na<nb or tb<ta or ta==0 or tb==0:

print('F')
fo.close()
quit()
tg = 15 - ta Tính a+=tg
res_a = ''
for i in range(na-1,-1,-1):
k = pat.find(a[i])
t = k+tg
tg = t//16
res_a += pat[t%16]
if tg > 0 or res_a <= b:

print('F')
fo.close()
quit() fB(fB(x)+i)=15

Trường hợp chưa biết chắc chắn có fB(fB(x)+i)=15 :
Không quá
14 số
tg = 1
for i in range(ta,tb+1): tg *= i
ans = 0
while tg > 0:
ans += tg&15
tg >>= 4
ans %= 15
if ans == 0: ans = 15
print(pat[ans])
Tính hàm fB()
Độ phức tạp của giải thuật: O(n), trong đó n = max(len(a), len(b)).
# WA 41 A17
import sys, time
sys.stdin = fi
sys.stdout = fo
tbb = time.time()
sa = input()
sb = input()
na = len(sa)
nb = len(sb)
ta, tb = 0, 0
pat='0123456789ABCDEF'
a = sa.upper()
b = sb.upper()
for c in a:
k = pat.find(c)
ta += k
ta %= 15
for c in b:
k = pat.find(c)

tb += k
tb %= 15
if na<nb or tb<ta or ta==0 or tb==0:

print('F')
fo.close()
quit()
tg = 15 - ta
res_a = ''
for i in range(na-1,-1,-1):
k = pat.find(a[i])
t = k+tg
tg = t//16
res_a += pat[t%16]
if tg > 0 or res_a <= b:

print('F')
fo.close()
quit()
tg = 1
for i in range(ta,tb+1): tg *= i
ans = 0
while tg > 0:
ans += tg&15
tg >>= 4
ans %= 15
if ans == 0: ans = 15
print(pat[ans])
print("\nTime: {:.4f}".format(time.time()-tbb))
fo.close()
Xử lý dữ liệu vòng tròn và nhận dạng .

Để dễ dàng thực hiện việc đẩy vòng các ký tự sang trái cần tạo xâu mẫu p:
p=”abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwx”
yz

Ký tự la tinh thường s[i] khi đẩy vòng sang trái một vị trí sẽ có giá trị mới là
p[s[i]-97+25] .
Tạo xâu s2 bằng cách gấp đôi xâu s: s2 = s + s.
Kiểm tra 26 lần sự tồn tại của t trong s2 với các ký tự trong s2 lần lượt được
đẩy vòng sang trái một vị trí.
Nếu t không xuất hiện lần nào trong số các s2 nhận được thì đưa ra thông báo
“Impossible”.
Nếu tồn tại cách đẩy vòng: Độ dài đoạn cần mang lên đầu là khoảng cách từ đầu
s2 tới t.
# WA 42 A17
import sys, time
sys.stdin = fi
sys.stdout = fo
tbb = time.time()
n = int(input())
s = input()
t = input()
s2 = s + s
d = -1
p='abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz'
for i in range(26):
k = s2.find(t)
if k >= 0:
d =i;
break
s3 = ''
for j in range(2*n):
s3 += p[ord[s2[j]]-72]
s2 = s3
if d < 0:
k = s2.find(t)
if k != -1: d = 25
if k > 0: k = n-k

if d >= 0:
print('Succes\n',k,d)
else:
print('Impossible')
fo.close()
Kỹ thuật tổ chức dữ liệu, Bảng phương án.

Số nguyên tiếp theo nhỏ nhất không thể xây dựng phụ thuộc vào tần số xuất hiện
các chữ số.
Nếu các chữ số từ 1 đến 9 xuất hiện k lần, chữ số 0 xuất hiện k-1 lần và tồn tại
bộ các khối lập phương khác nhau chứa chúng, ta có thể xây dựng mọi số có k
chữ số (tức là từ 1 đến 10k-1).
Gọi d là chữ số nhỏ nhất khác 0 có tần số xuất hiện nhỏ nhất và k – tần số xuất
hiện của nó ở các khối khác nhau.
Nếu tần số xuất hiện chữ số 0 là k-1 thì số nhỏ nhất cần tìm sẽ là 10k-1 (Trường
hợp a).
Trường hợp tần số xuất hiện chữ số 0 lớn hơn hoặc bằng k:
Nếu bộ các khối lập phương chứa d và 0 trùng nhau thì số nhỏ nhất cần
tìm sẽ là d×10k-1 (Trường hợp b).
Trong trường hợp ngược lại – số cần tìm sẽ có dạng
dddddd...dd (Trường hợp c).

k+1 chữ số
 Mảng vector<int> cnt(10) – ctn[i] lưu số khối lập phương chữ số
i,
 Mảng hai chiều vector<vector<int>> cubes(10) – Lưu số của các
khối lập phương chứa mỗi chữ số.

Xử lý: Xử lý các khối lập phương:
for i in range(n):
k = int(input())
Ghi nhận chữ số
s = str(k)
cur = []
for c in s: cur.append(ord(c)-48)
for d in set(cur): Xét các chữ

Ghi nhận cnt[d] += 1 số khác nhau
tần số cubes[d].append(i)
Ghi nhận khối
lập phương
Dẫn xuất kết quả:
Xác định tần số

min
k = min(cnt[0] + 1, min(cnt[1:]))
if cnt[0] == k-1:
ans = '1'+'0'*(k-1) Trường hợp a
else:
for i in range(1,10):
if cnt[i] == k:
c = chr(i+48)
if cubes[0] == cubes[i]: ans = c + '0'*k
else:ans = c*(k+1)
break
Trường hợp b
print(ans) Trường hợp c
# WA 45 A17
import sys, time
sys.stdin = fi
sys.stdout = fo
tbb = time.time()

n = int(input())
cnt =[0]*10
cubes =[[0]]*10
for i in range(n):
k = int(input())
s = str(k)
cur = []
for d in set(cur):
cnt[d] += 1
cubes[d].append(i)
k = min(cnt[0] + 1, min(cnt[1:]))
if cnt[0] == k-1:
ans = '1'+'0'*(k-1)
else:
if cnt[i] == k:
c = chr(i+48)
else:ans = c*(k+1)
break
print(ans)
fo.close()
Thứ tự từ điển và tính nhanh lũy thừa .

Các bộ 4 số (a, b, c, n) có thể phân nhóm theo giá trị lớn nhất của các số trong
nhóm.
Nhóm đầu tiên có giá trị max là 3, nhóm thứ 2 có giá trị max là 4, . . .
Gọi số lớn nhất là đại diện của nhóm.
Các bộ cùng nhóm đứng liên tiếp nhau trong dãy đã sắp xếp theo quy tắc nêu
trong đầu bài.
Các vấn đề cần giải quyết:
Tìm số đại diện của nhóm đầu tiên trong khoảng cần xử lý,
Xác định nhóm đầu tiên cần xử lý,

a) Tìm số đại diện của nhóm đầu tiên trong khoảng cần xử lý:
Gọi m là số đại diện cần tìm.
Xác định số phần tử trong nhóm:
Tạm gác sự tồn tại bắt buộc của phần tử đại diện:
 Có m khả năng lựa chọn a (từ 1 đến m),
 Tương tự như vậy, có m khả năng lựa chọn b và m khả năng lựa chọn c,
 Với n: m-2 khả năng lựa chọn: từ 3 đến m.
Tổng cộng số lượng nhóm sẽ là m×m×m×(m-2).
Trong số nhóm nói trên, có những nhóm không chứa phần tử đại diện:
 Có m-1 cách chọn a nhỏ hơn m,
 Tương tự, có m-1 cách chọn b và m-1 cách chọn c không nhận giá trị m,
 Có m-3 khả năng chọn n ≠ m.
Tổng cộng có (m-1)×(m-1)×(m-1)×(m-3).
Như vậy số phần tử trong nhóm nhận m là đại diện sẽ là
Pm = m×m×m×(m-2) - (m-1)×(m-1)×(m-1)×(m-3)
Lần lượt trừ lf cho Pm, m = 3, 4, 5, . . .chừng nào lf còn lớn hơn Pm ta sẽ xác
định được số đại diện m của nhóm đầu tiên cần xử lý.
Mảng int x[4] – Lưu các giá trị a, b, c, n.
Xử lý:
a) Tìm đại diện của nhóm đầu tiên:
m = 3
m4 = m*m*m*(m-2) - (m-1)*(m-1)*(m-1)*(m-3)
while k > m4:
k -= m4 Số phần tử trong nhóm
m += 1
Thu hẹp m4 = m*m*m*(m-2) - (m-1)*(m-1)*(m-1)*(m-3)
khoảng cách

b) Xác định bộ số đầu tiên cần xử lý:
Để thuận tiện xử lý, thứ tự các bộ số trong nhóm được tính bắt đầu từ 0.
Việc xác định bộ số được thực hiện theo nguyên tắc cục bộ hóa dần phạm vi tìm
kiếm, đầu tiên theo a, sau đó – theo b và cuối cùng – theo c. Giá trị n được tự
động xác định dựa theo kết quả quá trình cục bộ hóa.
Mỗi số a cố định trong bộ (a, b, c, n) sẽ gắn với mọi khả năng có thể của bộ 3
số (b, c, n).
Dễ dàng thấy được trong nhóm cùng đại diện m, bộ 4 số (a, b, c, n) với a cố định
xuất hiện m×m×(m-2)-(m-1)×(m-1)×(m-3) lần.
m×m×(m-2)-(m-1)×(m-1)×(m-3)
a b c n
1 b,c,n 1 b,c,n 1 b,c,n . . . 1 b,c,n 2 b,c,n . . . 2 b,c,n 3 b,c,n . . .

Nhóm con 0 Nhóm con 1 Nhóm con 2
m×m×(m-2)-(m-1)×(m-1)×(m-3)
Ký hiệu m4= m×m×(m-2)-(m-1)×(m-1)×(m-3) , lf – thứ tự từ điển của

bộ số cần tìm.
Ta có: a = u = min(m,lf/m4+1)
Gọi mỗi bộ 4 số (a, b, c, n) là một phần tử. Phần tử đầu tiên của nhóm con (u,
b, c, n) có thứ tự từ điển là p=lf-(u-1)×m4).
Gọi kb là kích thước của nhóm các phần tử có a = u .
Trong số các b, c, n còn lại

phải có đại lượng bằng m
m×(m-2)-(m-1)×(m-3) nếu u < m,

kb =
m×(m-2) nếu u = m.

Lập luận tương tự như trên ta có:
b = v = min(m,p/kb+1)
Phần tử đầu tiên của nhóm con (u, v, c, n) có thứ tự từ điển là q = p-(v-
1)×kb).
Kích thước kc của nhóm các phần tử có a = u và b = v sẽ là:
1 nếu u = m hoặc v = m ,
kc =
m-2 trong trường hợp ngược lại.
Trong hai số c, n còn lại

phải có đại lượng bằng m
c nhận giá trị w = min(m,q/kc+1)

Khoảng cách còn lại tới phần tử cần tìm là r = q-(v-1)×kc).
Giá trị n được xác định theo công thức:
r+3 nếu u = m hoặc v = m hoặc v = m,

n =
m trong trường hợp ngược lại.
Lưu ý: Khi lập trình, giá trị lf sẽ được thu lùi dần về các mốc địa chỉ đã nêu ở
trên.

Xử lý: Xử lý các khối lập phương:
for i in range(n):
k = int(input())
Ghi nhận chữ số
s = str(k)
cur = []
for d in set(cur): Xét các chữ

Ghi nhận cnt[d] += 1 số khác nhau
tần số cubes[d].append(i)
Ghi nhận khối
lập phương
Dẫn xuất kết quả:
Xác định tần số

min
k = min(cnt[0] + 1, min(cnt[1:]))
if cnt[0] == k-1:
ans = '1'+'0'*(k-1) Trường hợp a
else:
if cnt[i] == k:
c = chr(i+48)
else:ans = c*(k+1)
break
Trường hợp b
print(ans) Trường hợp c

import sys, time
sys.stdin = fi
sys.stdout = fo
tb = time.time()
def get_first():
global m, k, m4
m4 = m*m*(m-2) - (m-1)*(m-1)*(m-3)
t = 0
a = k//m4+1
if a > m:
t = a-m
a = m
k = k%m4 + t*m4
if a == m:
m4 = m*(m-2)
else: m4 = m*(m-2) - (m-1)*(m-3)
t = 0
b = k//m4+1
if b > m: t, b = b-m, m
k = k%m4 + t*m4
if a == m or b == m: m4 = m-2
else: m4 = 1
t = 0
c = k//m4+1
if c > m: t, c = c-m, m
k = k%m4 + t*m4
d = 3 + k
if a<m and b<m and c<m: d = m
print(a, b, c, d)
n = int(input())
for i in range(n):
k = int(input())
m = 3
m4 = m*m*m*(m-2) - (m-1)*(m-1)*(m-1)*(m-3)
while k > m4:
k -= m4
m += 1
m4 = m*m*m*(m-2) - (m-1)*(m-1)*(m-1)*(m-3)
k -= 1
get_first()
fo.close()

Athena 19 All

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Athena 19 All

Uploaded by

Copyright:

Available Formats

.................................................................................................

ATHENA XV Page 1 of 219 Nguyễn Thanh Tùng

ATHENA XV Page 2 of 219 Nguyễn Thanh Tùng

ATHENA XV Page 3 of 219 Nguyễn Thanh Tùng

ATHENA XV Page 4 of 219 Nguyễn Thanh Tùng

ATHENA XV Page 5 of 219 Nguyễn Thanh Tùng

ATHENA XV Page 6 of 219 Nguyễn Thanh Tùng

ATHENA XV Page 7 of 219 Nguyễn Thanh Tùng

ATHENA XV Page 8 of 219 Nguyễn Thanh Tùng

ATHENA XV Page 9 of 219 Nguyễn Thanh Tùng

ATHENA XV Page 10 of 219 Nguyễn Thanh Tùng

I.02 – Tam giác vuông

I.03 – Chia mận

ATHENA XV Page 11 of 219 Nguyễn Thanh Tùng

I.04 – Đồng hồ điện tử

I.05 – Trước và sau

ATHENA XV Page 12 of 219 Nguyễn Thanh Tùng

I.06 – Số bàn học

I.07 – Tổng các số lẻ

ATHENA XV Page 13 of 219 Nguyễn Thanh Tùng

I.09 – Gặp nhau

I.10 – Khoảng cách

ATHENA XV Page 14 of 219 Nguyễn Thanh Tùng

I.11 – Đuổi kịp

I.12 – Phương trình bậc 3

ATHENA XV Page 15 of 219 Nguyễn Thanh Tùng

I.13 – Lát sân

ATHENA XV Page 16 of 219 Nguyễn Thanh Tùng

I.15 – Xuất khẩu gạo

ATHENA XV Page 17 of 219 Nguyễn Thanh Tùng

I.17 – Chữ số lẻ đầu tiên

I.18 – Chữ số lẻ thứ k

ATHENA XV Page 18 of 219 Nguyễn Thanh Tùng

ATHENA XV Page 19 of 219 Nguyễn Thanh Tùng

I.22 – Thời gian

I.23 – Gửi tiết kiệm

ATHENA XV Page 20 of 219 Nguyễn Thanh Tùng

ATHENA XV Page 21 of 219 Nguyễn Thanh Tùng

II.02 – Dấu của tổng

ATHENA XV Page 22 of 219 Nguyễn Thanh Tùng

của bàn cờ được tô một trong hai màu W (Trắng) hoặc B 1

II.04 – Năm nhuận

ATHENA XV Page 23 of 219 Nguyễn Thanh Tùng

II.05 – Tích lớn nhất

II.06 – Giống nhau

ATHENA XV Page 24 of 219 Nguyễn Thanh Tùng

II.07 – Quân hậu

ATHENA XV Page 25 of 219 Nguyễn Thanh Tùng

ATHENA XV Page 26 of 219 Nguyễn Thanh Tùng

II.10 – Đường vành đai

ATHENA XV Page 27 of 219 Nguyễn Thanh Tùng

II.12 – Hiệu quả

ATHENA XV Page 28 of 219 Nguyễn Thanh Tùng

II.14 – Kim giờ

ATHENA XV Page 29 of 219 Nguyễn Thanh Tùng

ATHENA XV Page 30 of 219 Nguyễn Thanh Tùng

III.02 – Dãy bình phương giảm dần

ATHENA XV Page 31 of 219 Nguyễn Thanh Tùng

III.04 – Tổng dãy số

III.05 – Tổng lập phương

ATHENA XV Page 32 of 219 Nguyễn Thanh Tùng

III.06 – Giai thừa

III.07 – Tổng giai thừa