Font size
WorksheetsÔn Tập CS 11 - Trắc Nghiệm
Total questions: 101
Worksheet time: 51mins
Điều kiện vòng while để dịch phải trong insertion sort:
i == j
j >= 0 và A[j] > key
i < n và A[i] < key
A[j] == key
Tạo bản sao ĐỘC LẬP của list a (shallow copy) là:
b = a
b = list; b(a)
copy(a) (không đối số)
b = a[:]
Số lần dịch phải trong insertion sort phụ thuộc:
không phụ thuộc dữ liệu
chỉ độ dài danh sách
số phần tử bên trái lớn hơn key
chỉ phụ thuộc n^2
Thiết kế mô đun tốt hướng tới:
tên biến rất ngắn
1 hàm thật dài
nhiều biến toàn cục
mỗi mô đun giải 1 nhiệm vụ rõ ràng (cohesion cao)
Câu 5: Đoạn mã tính tổng các phần tử nào và IN kết quả?
Hàng 0
Cột 0
Đường chéo chính
Đường chéo phụ
Câu 6: Gọi n là số nguyên dương. Số lần lặp xấp xỉ bằng:
n^2
n
⌊log2(n)⌋ + 1
1
"Làm mịn dần" (stepwise refinement) là:
gộp nhiều nhiệm vụ vào 1 hàm
chia bài toán lớn thành các bước/tiểu bài toán cụ thể dần
tối ưu tốc độ ở bước cuối
bỏ mã giả/sơ đồ
Hoán đổi HAI HÀNG i và k trong A bằng 1 câu lệnh:
A[i]==A[k]
swap(A[i],A[k])
for j: A[i][j]=A[k][j]
A[i], A[k] = A[k], A[i]
Chọn phát biểu KHÔNG đúng về danh sách Python (list):
Có thể chứa phần tử khác kiểu trong cùng 1 list
Duyệt list bằng for rất phổ biến
Chỉ số bắt đầu từ 0
Các phần tử luôn phải liền kề trong bộ nhớ
Phát biểu đúng về 'slicing' a[L:R] của list:
lấy phần tử từ L đến R-1
luôn tạo bản sao sâu
lấy phần tử từ L đến R
gây lỗi nếu R > len(a)
Đoạn mã trên tính tổng các phần tử của:
Đường chéo chính
Cột 0
Hàng 0
Đường chéo phụ
Giả sử a đã sắp xếp. Độ phức tạp thời gian (theo n) là:
O(n^2)
O(n)
O(log n)
O(1)
Khởi tạo ma trận 3×3 toàn 0, mỗi hàng độc lập là:
[0]*9
[[0]*3 for _ in range(3)]
[[0]*3]*3
(0)*9
Tính giá trị trung bình của dãy số nguyên a = [1,2,3]:
mean(a) không cần import
sum(a)/len(a)
a/len(a)
sum(a)/(len(a)-1)
Insertion sort: 'nhấc' phần tử cần chèn tại vị trí i là lệnh:
j -= 1
key = A[i]
A[j+1] = A[j]
A[j] > key
Trong ma trận vuông n×n, 'đường chéo phụ' gồm các phần tử có chỉ số:
i == j
i == 0
j == n-1
i + j == n - 1
Với a như trên, chương trình IN ra giá trị nào?
15
14
13
'31415'
Gọi n = len(a) ≥ 1. Độ phức tạp thời gian của đoạn mã sau là:
O(log n)
O(n^2)
O(n)
O(1)
Lỗi thường gặp khi dùng [[0]*m]*n để tạo ma trận:
sai kiểu
Python không hỗ trợ 2D
thiếu bộ nhớ
các hàng cùng tham chiếu 1 danh sách con
Sau vòng while, lệnh chèn đúng:
key = A[j]
A[i] = key
swap(A[j],key)
A[j+1] = key
Tìm phần tử lớn nhất trong list a (không sắp xếp lại a) nên:
dùng toán tử in
duyệt toàn bộ và cập nhật biến max
sắp xếp rồi lấy phần tử cuối
tạo bản sao rồi tìm
Phân biệt 'shallow copy' và 'deep copy' của list:
không có khác biệt
shallow copy sao chép tham chiếu phần tử; deep copy sao chép đệ quy
deep copy chỉ sao chép lớp ngoài
shallow copy luôn nhanh hơn và đúng
Giả sử b tham chiếu cùng danh sách với a; chương trình IN ra:
[9, 1, 2, 3, 4, 5]
Lỗi IndexError
[1, 2, 3, 4, 5]
[9, 2, 3, 4, 5]
Gọi n và m là hai kích thước độc lập. Độ phức tạp thời gian là:
O(n+m)
O(1)
O(max(n,m))
O(n·m)
Cho a = [1, 2]; lệnh nào thêm phần tử 3 vào CUỐI danh sách?
a.append(3)
a.insert_first(3)
a.add(3)
push(a,3)
Trong ma trận vuông, 'đường chéo chính' gồm các phần tử có chỉ số:
i == j
i == 0
j == 0
i + j == n - 1
Khởi tạo ma trận n×m mọi giá trị đều v (hàng độc lập):
[[v]*m for _ in range(n)]
[[v]*n for _ in range(m)]
[v]*n*m
(v)*n*m
Mảng 1 chiều (list số) và ma trận (list lồng nhau) khác nhau chủ yếu ở:
khả năng sắp xếp
khả năng lặp
số chiều truy cập phần tử
kiểu số trong phần tử
Giá trị được IN ra từ phần tử hàng 1, cột 0 của A là: 1. A = [[1,2,3],[4,5,6]] 2. print(A[1][0])
1
6
4
2
Gọi n là số phần tử cần duyệt. Độ phức tạp thời gian là:
O(log n)
O(n)
O(1)
O(n^2)
Dãy gần tăng sẵn nên chọn:
selection sort
insertion sort
bubble sort
heap sort
Với A = [[1,2,3],[4,5,6]], phần tử hàng 1 (thứ hai), cột 0 là:
6
1
4
2
In các phần tử đường chéo chính của ma trận vuông n×n:
for i in range(n): print(A[i][i])
for j: print(A[0][j])
for i: print(A[i][n-1-i])
print(A[0][n-1])
Với danh sách a = [2, 4, 6, 8], chỉ số đầu tiên hợp lệ trong Python là:
0
Tuỳ phiên bản
1
-1
Vì khởi tạo bằng 'for _ in range(3)', các hàng ĐỘC LẬP; chương trình IN:
1. A = [[0]*3 for _ in range(3)]
2. A[0][1] = 5
3. print(A)
[[5, 5, 5],[5, 5, 5],[5, 5, 5]]
[[0, 5, 0], [0, 0, 0], [0, 0, 0]]
Lỗi
[[0, 5, 0], [0, 5, 0], [0, 5, 0]]
Độ phức tạp thời gian theo n là:
O(n^3)
O(n)
O(n^2)
O(n·log n)
Với a = [2, 4, 6, 8], biểu thức a[-1] trả về:
4
Lỗi vì chỉ số âm
6
8
Insertion sort được xem là 'ổn định' (stable) vì:
giữ nguyên thứ tự tương đối của các phần tử bằng nhau
không dùng bộ nhớ phụ
luôn chạy O(n log n)
chỉ cần 1 lần quét
Với a = [1,2,3,4,5], lát cắt a[1:4] (trái‑kín phải‑mở) cho:
[2,3,4]
[2,4]
[1,4]
[1,2,3]
Nếu a có n phần tử, phép truy cập a[i] (0 ≤ i < n) có thời gian gần đúng:
O(1)
O(log n)
O(n)
Phụ thuộc kiểu phần tử
Xét 1 lượt chèn với i=1 trong insertion sort; mảng IN ra là:
[2, 4, 5, 6]
[4, 5, 2, 6]
[5, 2, 4, 6]
[2, 5, 4, 6]
Gọi n là số nguyên dương. Số lần tăng k xấp xỉ bằng:
1
n^2
n/2 (bậc O(n))
log2(n)
Trường hợp tốt nhất (best case) của insertion sort là khi dãy:
ngẫu nhiên
giảm sẵn
toàn phần tử bằng nhau
đã tăng sẵn
Viết mã giả/sơ đồ khối trước khi code giúp:
kiểm tra cú pháp
làm rõ ý tưởng & cấu trúc
tự sinh giao diện
đo thời gian chạy
'Làm mịn dần' (stepwise refinement) dùng để:
đánh giá tốc độ chương trình
biến chương trình thành 1 hàm duy nhất
chuyển bài toán lớn thành các bước nhỏ dễ cài đặt
tự sinh mã nguồn từ sơ đồ khối
Tổng cột j (0 ≤ j < m) của A có n hàng:
A[0][j] + A[j][0]
sum(A[j][i] for i in range(m))
sum(A[i] for i trong range(n))
sum(A[i][j] for i in range(n))
Chọn đúng **1 dòng** cần điền để tính tổng mọi phần tử của a.
s += x
s = s * x
x += s
s = 0
Gọi n = len(a). Số phép cộng được thực hiện xấp xỉ bằng:
n
n^2
n(n-1)/2
log2(n)
Khi lập trình ma trận bằng list lồng nhau, lỗi do [[0]*m]*n là:
mọi hàng cùng trỏ 1 list con
không thể truy cập A[i][j]
A[i]==A[k] luôn False
tự động deep copy
Trong Python, 'list' là cấu trúc dữ liệu có tính chất:
không có thứ tự, bất biến
bất biến và có thứ tự
có thứ tự, thay đổi được (mutable)
tập hợp không lặp
Lấy giá trị lớn nhất của toàn ma trận A:
A.max()
sorted(A)[-1]
max(A)
max(max(row) for row in A)
Ưu tiên khi chuyển thuật toán sang mã nguồn:
nhiều vòng lặp lồng
bỏ chú thích
ít dòng nhất
đúng đắn trước, tối ưu sau
Điền **1 dòng** để hoàn tất bước CHÈN của insertion sort:
A[i] = key
swap(A[j], key)
A[j+1] = key
key = A[j]
Gọi n là kích thước. Độ phức tạp thời gian là:
O(log n)
O(n)
O(1)
O(n^2)
Biểu thức 3 in [1,3,5,7] trả về:
False
Lỗi cú pháp
True
3
Thiết kế từ trên xuống (top‑down) là:
bắt đầu từ chi tiết thấp
tối ưu câu lệnh nhỏ
viết mã từ dòng đầu
từ ý tưởng tổng quát đến chi tiết hoá dần
Trung bình từng cột của A kích thước n×m:
[sum(A[i][j] for i in range(n))/n for j in range(m)]
[sum(row)/m for row in A]
sum(A)/m
[sum(A[j][i] for j in range(m))/m for i in range(n)]
Ma trận A kích thước n×m là:
danh sách 1 chiều
tập hợp không thứ tự
bảng chữ nhật gồm n hàng, m cột
cây nhị phân cân bằng
Đoạn mã tính tổng các phần tử nào và IN kết quả?
Đường chéo chính
Đường chéo phụ
Cột 0
Hàng 0
Gọi n là kích thước. Số lần tăng k xấp xỉ bằng:
n^2+n
n
n(n-1)/2
2n
Điều kiện vòng while để dịch phải trong insertion sort:
A[j] == key
j >= 0 và A[j] > key
i < n và A[i] < key
i == j
Tạo bản sao ĐỘC LẬP của list a (shallow copy) là:
b = list; b(a)
b = a
b = a[:]
copy(a) (không đối số)
Số lần dịch phải trong insertion sort phụ thuộc:
không phụ thuộc dữ liệu
chỉ độ dài danh sách
chỉ phụ thuộc n^2
số phần tử bên trái lớn hơn key
Thiết kế mô đun tốt hướng tới:
mỗi mô đun giải 1 nhiệm vụ rõ ràng (cohesion cao)
1 hàm thật dài
nhiều biến toàn cục
tên biến rất ngắn
Gọi n = len(a), m = len(b). Độ phức tạp thời gian là:
O(n + m)
O(n·m)
O(max(n,m))
O(1)
"Làm mịn dần" (stepwise refinement) là:
tối ưu tốc độ ở bước cuối
chia bài toán lớn thành các bước/tiểu bài toán cụ thể dần
bỏ mã giả/sơ đồ
gộp nhiều nhiệm vụ vào 1 hàm
Hoán đổi HAI HÀNG i và k trong A bằng 1 câu lệnh:
A[i], A[k] = A[k], A[i]
swap(A[i],A[k])
for j: A[i][j]=A[k][j]
A[i]==A[k]
Chọn phát biểu KHÔNG đúng về danh sách Python (list):
Chỉ số bắt đầu từ 0
Có thể chứa phần tử khác kiểu trong cùng 1 list
Duyệt list bằng for rất phổ biến
Các phần tử luôn phải liền kề trong bộ nhớ
Phát biểu đúng về 'slicing' a[L:R] của list:
lấy phần tử từ L đến R
gây lỗi nếu R > len(a)
luôn tạo bản sao sâu
lấy phần tử từ L đến R-1
Với a như trên, chương trình IN ra giá trị nào?
15
13
'31415'
14
Gọi n là số nguyên dương. Số lần lặp xấp xỉ bằng:
n^2
1
n
⌊log2(n)⌋ + 1
Khởi tạo ma trận 3×3 toàn 0, mỗi hàng độc lập là:
[[0]*3]*3
[0]*9
[[0]*3 for _ in range(3)]
(0)*9
Tính giá trị trung bình của dãy số nguyên a = [1,2,3]:
sum(a)/(len(a)-1)
mean(a) không cần import
sum(a)/len(a)
a/len(a)
Insertion sort: 'nhấc' phần tử cần chèn tại vị trí i là lệnh:
key = A[i]
A[j+1] = A[j]
j -= 1
A[j] > key
Trong ma trận vuông n×n, 'đường chéo phụ' gồm các phần tử có chỉ số:
j == n-1
i == 0
i + j == n - 1
i == j
Giả sử b tham chiếu cùng danh sách với a; chương trình IN ra:
[1, 2, 3, 4, 5]
[9, 1, 2, 3, 4, 5]
[9, 2, 3, 4, 5]
Lỗi IndexError
Giả sử a đã sắp xếp. Độ phức tạp thời gian (theo n) là:
O(log n)
O(n^2)
O(1)
O(n)
Lỗi thường gặp khi dùng [[0]*m]*n để tạo ma trận:
Python không hỗ trợ 2D
sai kiểu
thiếu bộ nhớ
các hàng cùng tham chiếu 1 danh sách con
Sau vòng while, lệnh chèn đúng:
key = A[j]
A[j+1] = key
A[i] = key
swap(A[j],key)
Tìm phần tử lớn nhất trong list a (không sắp xếp lại a) nên:
dùng toán tử in
duyệt toàn bộ và cập nhật biến max
tạo bản sao rồi tìm
sắp xếp rồi lấy phần tử cuối
Phân biệt 'shallow copy' và 'deep copy' của list:
không có khác biệt
deep copy chỉ sao chép lớp ngoài
shallow copy sao chép tham chiếu phần tử; deep copy sao chép đệ quy
shallow copy luôn nhanh hơn và đúng
Giá trị được IN ra từ phần tử hàng 1, cột 0 của A là:
2
4
1
6
Gọi n = len(a) ≥ 1. Độ phức tạp thời gian của đoạn mã sau là:
1. x = a[0]
O(1)
O(log n)
O(n)
O(n^2)
Cho a = [1, 2]; lệnh nào thêm phần tử 3 vào CUỐI danh sách?
a.insert_first(3)
a.append(3)
a.add(3)
push(a,3)
Trong ma trận vuông, 'đường chéo chính' gồm các phần tử có chỉ số:
i == j
i == 0
j == 0
i + j == n - 1
Khởi tạo ma trận n×m mọi giá trị đều v (hàng độc lập):
[[v]*m for _ in range(n)]
(v)*n*m
[v]*n*m
[[v]*n for _ in range(m)]
Mảng 1 chiều (list số) và ma trận (list lồng nhau) khác nhau chủ yếu ở:
khả năng lặp
kiểu số trong phần tử
số chiều truy cập phần tử
khả năng sắp xếp
Vì khởi tạo bằng 'for _ in range(3)', các hàng ĐỘC LẬP; chương trình IN:
[[0, 5, 0], [0, 0, 0], [0, 0, 0]]
Lỗi
[[5, 5, 5],[5, 5, 5],[5, 5, 5]]
[[0, 5, 0], [0, 5, 0], [0, 5, 0]]
Gọi n và m là hai kích thước độc lập. Độ phức tạp thời gian là:
O(n+m)
O(1)
O(n·m)
O(max(n,m))
Dãy gần tăng sẵn nên chọn:
bubble sort
heap sort
selection sort
insertion sort
Với A = [[1,2,3],[4,5,6]], phần tử hàng 1 (thứ hai), cột 0 là:
2
4
6
1
In các phần tử đường chéo chính của ma trận vuông n×n:
for i: print(A[i][n-1-i])
for i in range(n): print(A[i][i])
print(A[0][n-1])
for j: print(A[0][j])
Với danh sách a = [2, 4, 6, 8], chỉ số đầu tiên hợp lệ trong Python là:
1
Tuỳ phiên bản
0
-1
Xét 1 lượt chèn với i=1 trong insertion sort; mảng IN ra là:
[4, 5, 2, 6]
[2,5,4,6]
[2,4,5,6]
[5,2,4,6]
Với a = [2, 4, 6, 8], biểu thức a[-1] trả về:
Lỗi vì chỉ số âm
4
6
8
Chọn đúng **1 dòng** cần điền để tính tổng mọi phần tử của a.
s = s * x
s += x
s = 0
x += s
Điền **1 dòng** để hoàn tất bước CHÈN của insertion sort:
key = A[j]
A[j+1] = key
swap(A[j], key)
A[i] = key
Đoạn mã tính tổng các phần tử nào và IN kết quả?
Đường chéo chính
Hàng 0
Cột 0
Đường chéo phụ
Đoạn mã trên tính tổng các phần tử của:
Cột 0
Hàng 0
Đường chéo phụ
Đường chéo chính
Câu 65: Đoạn mã trên tính tổng các phân tử của:
Hàng 0
Đường chéo chính
Cột 0
Đường chéo phụ
Đoạn mã trên tính tổng các phần tử của:
Hàng 0
Đường chéo chính
Cột 0
Đường chéo phụ
