0

1

2

3

not

or

in

and

array

float

str

list

A.insert(m)

m.insert(A)

A.append(m)

m.append(A)

B.append( )

B.remove( )

B.insert( )

B.clear( )

append(A)

len(A)

str(A)

del(A)

arr.append( )

arr.remove( )

arr.insert( )

arr.clear()

A = (1, 3, 5)

A = {1, 3, 5}

A = [1, 3, 5]

A = [1; 3; 5]

arr[2]

arr[1]

arr[0]

arr[-1]

-1

0

1

không xác định

pop(A)

A.pop()

pop(len(A))

pop()

print(len(A) - 2)

print(A[len(A) – 2])

print(A[len(A) - 1])

print(A[len(A)])

3

7

9

2

colors[0]

colors[1]

colors[2]

colors[3]

numbers.add(6)

numbers.insert(6)

numbers.push(6)

numbers.append(6)

4

2

3

6

total(numbers)

add(numbers)

sum(numbers)

calculate(numbers)

largest(numbers)

max(numbers)

maximum(numbers)

find_max(numbers)

[7, 26, 48, 9, 35, 46, 5, 9, 83]

[7, 26, 48, 9, 22, 35, 5, 9, 82]

[7, 3, 26, 48, 9, 22, 46, 5, 9, 83]

[7, 26, 48, 9, 22, 35, 46, 9, 83]

print(A[len(A) - 1])

print(A[len(A)])

print(A[len(A) – 2])

print(len(A) - 1)

[5, 9, 7, 3, 4, 1]

[5, 7, 9, 3, 4, 1]

[5 ,7, 3, 4, 1, 2, 9]

[5, 7, 3, 4, 1, 2]

11

96

92

65

print(arr[:,-1])

print(arr[2])

print(arr[2, :])

print(arr[1])

A = [1, 2, 3, 4]

B = [“Hà”; “Quang”; “Lan”]

D = [[1,3,5], [2,5,9], [5,9,20]]

C = [1,3,5],[2,5,9],[5,9,20]

A.append( ): bổ sung phần tử vào cuối A

A.remove( ): xóa một phần tử trong A

A.remove( ): xóa toàn bộ phần tử trong A

A.clear( ): xóa toàn phần tử trong A

del(a[3])

del(a[0:3])

del(a[0:2])

del(a[1:3])

[7, 3, 1, 9]

[7, 3, 8, 9]

[7,8,1,9]

[7,3,8,1]

Xuất mảng theo hàng ngang, mỗi số cách nhau dấu cách: for m in B: print(m , end = " ")

Xuất mảng theo hàng dọc: for m in B: print(m, end = " ")

C = [1, 3, 5], [2, 5, 9], [5, 9, 20] là mảng hai chiều

Xuất mảng B theo chiều ngược lại: for m in B[: : 1]: print(m, end = " ")

pop(A)

A.remove(A[-1])

A.pop(A[len(A)])

pop(len(A))

Tìm kiếm tuần tự

Tìm kiếm nội suy

Tìm kiếm nhị phân

Tìm kiếm trong cây

Giá trị của phần tử đầu tiên.

Giá trị trung bình của mảng.

Giá trị nhỏ nhất của mảng.

Giá trị tại chỉ số trung tâm của mảng.

Tìm trên danh sách đã sắp xếp, bắt đầu từ đầu danh sách, chừng nào chưa tìm thấy hoặc chưa tìm hết thì còn tìm tiếp.

Tìm trên danh sách đã sắp xếp, bắt đầu từ giữa danh sách, chừng nào chưa tìm thấy hoặc chưa tìm hết thì còn tìm tiếp.

Tìm trên danh sách bất kì, bắt đầu từ giữa danh sách, chừng nào chưa tìm thấy hoặc chưa tìm hết thì còn tìm tiếp.

Tìm trên danh sách bất kì, bắt đầu từ đầu danh sách, chừng nào chưa tìm thấy hoặc chưa tìm hết thì còn tìm tiếp.

Tìm thấy vị trí i của phần tử K.

Đã duyệt hết các phần tử khi tìm thấy vị trí của K.

Tìm thấy vị trí i của phần tử K hoặc duyệt đến phần tử cuối cùng mà vẫn chưa thấy vị trí có giá trị bằng phần tử K.

Duyệt lần lượt các phần tử từ đầu đến cuối dãy.

1.

2.

3.

4.

mid = (left + right) // 2.

mid = (left + right) % 2.

mid = (left + right) % 3.

mid = (left + right // 3.

2.

3.

4.

5.

9

10

11

8

Với K = 11, thuật toán tìm kiếm tuần tự sẽ thực hiện 5 bước chạy.

Với K = 8, thuật toán tìm kiếm tuần tự thì chỉ số của K trong mảng A là 3.

Với K = 12, thuật toán tìm kiếm nhị phân sẽ thực hiện 4 bước chạy.

Với K = 11, thuật toán nhị phân sau khi chạy xong bước 1 thì phạm vi tìm kiếm được giới hạn thành [11, 12, 18, 21].

3

4

5

6

9, 16, 12

13, 16, 14

15, 16, 15

16, 16, 16

9, 16, 12

13, 16, 14

15, 16, 15

0, 8, 16

Left = 0, Right = mid - 1.

Left = mid + 1, Right = mid - 1.

Left = mid + 1, Right = len(A) - 1.

Left = 0, Right = mid + 1.

Left = 0, Right = mid - 1.

Left = mid + 1, Right = mid - 1.

Left = mid + 1, Right = len(A) - 1.

Left = 0, Right = mid + 1.

Left = 0, Right = mid - 1.

Left = mid + 1, Right = mid - 1.

Left = mid + 1, Right = len(A) - 1.

Left = 0, Right = mid + 1.

Left = 0, Right = mid - 1.

Left = mid + 1, Right = mid - 1.

Left = mid + 1, Right = len(A) - 1.

Left = 0, Right = mid + 1.

3.

4.

5.

6.

5.

4.

3.

2.

Với K = 17, thuật toán tìm kiếm tuần tự sẽ thực hiện 5 bước chạy

Với K = 18, thuật toán tìm kiếm tuần tự thì chỉ số của K trong mảng A là 6

Với K = 12, thuật toán tìm kiếm nhị phân sẽ thực hiện 3 bước chạy

Với K = 11, thuật toán nhị phân sau khi chạy xong bước 1 thì phạm vi tìm kiếm được giới hạn thành [12, 17, 18, 21]

3.

4.

5.

14.

Sắp xếp chèn.

Sắp xếp lựa chọn.

Sắp xếp nổi bọt.

Sắp xếp nhanh.

f = open(, "r", encoding="UTF-8").

f = open(, "a", encoding="UTF-8").

f = open(, "w", encoding="UTF-8").

f.close().

f.readlines( ).

L = list(f).

f.lose( ).

f.readline( ).

L = line.split( ).

Ten.append(L[0]).

return Diem.

Không có đáp án.

0.

1.

2.

3.

Đổi chỗ.

So sánh và đổi chỗ.

So sánh.

Xóa và đổi chỗ.

Hoán đổi.

Thay thế.

Thay đổi.

Sửa đổi.

Vẫn còn cặp phần tử liền kề không đúng thứ tự mong muốn.

Dãy chưa được sắp xếp tăng dần.

Dãy chưa được sắp xếp giảm dần.

Cả A, B và C.

Hai lần.

Nhiều lần.

Một lần.

Mười lần.

3.

4.

5.

6.

[7, 9, 5, 4, 12]

[7, 5, 4, 9, 12]

[4, 5, 7, 9, 12]

[5, 4, 7, 9, 12]

[3, 4, 12, 15, 9]

[3, 12, 4, 15, 9]

[3, 4, 9, 15, 12]

[3, 4, 9, 12, 15]

g, c

q, g

a, c

q, h

[11, 35, 17, 23, 64]

[11, 17, 23, 35, 64]

[11, 17, 35, 23, 64]

[11, 23, 17, 35, 64]

[4, 5, 7, 9, 12]

[5, 7, 9, 12, 4]

[7, 9, 12, 5, 4]

[7, 9, 12, 4, 5]

[4, 5, 7, 9, 12]

[5, 7, 9, 12, 4]

[7, 9, 12, 5, 4]

[7, 9, 12, 5, 4]

1

2

3

4

Công cụ in biến trung gian

Công cụ thống kê dữ liệu

Công cụ sinh các bộ dữ liệu test

Công cụ điểm dừng trong phần mềm soạn thảo lập trình

Tìm ra lỗi, phòng ngừa, ngăn chặn.

Tìm ra lỗi, phòng ngừa, xử lí.

Phòng ngừa, ngăn chặn, xử lí lỗi.

Xử lí lỗi, phòng ngừa, ngăn chặn.

Kiểm thử sẽ giảm độ tin cậy của chương trình và chưa chứng minh được tính đúng của thuật toán và chương trình.

Kiểm thử sẽ tăng độ tin cậy của chương trình nhưng chưa chứng minh được tính đúng của thuật toán và chương trình.

Kiểm thử sẽ tăng độ tin cậy của chương trình và chứng minh được tính đúng của thuật toán và chương trình.

Kiểm thử sẽ giảm độ tin cậy của chương trình nhưng chưa chứng minh được tính đúng của thuật toán và chương trình.

Thuật toán.

Suy luận logic.

Bộ dữ liệu kiểm thử.

Lập luận toán học.

Độ phức tạp thời gian.

Độ phức tạp không gian.

Độ phức tạp tính toán.

Độ phức tạp của tập tin.

Thời gian thực hiện và không gian bộ nhớ.

Tính đúng và không gian bộ nhớ.

Thuật toán và lập luận bài toán.

Thời gian và tính tối ưu.

Không gian bộ nhớ được sử dụng bởi chương trình.

Thời gian mà chương trình mất để hoàn thành một nhiệm vụ, dựa trên kích thước của dữ liệu đầu vào.

Số lần thực hiện các phép toán cơ bản bởi chương trình.

Tất cả các phương án trên.

Không gian bộ nhớ được sử dụng bởi chương trình.

Thời gian mà chương trình mất để hoàn thành một nhiệm vụ, dựa trên kích thước của dữ liệu đầu vào.

Số lần thực hiện các phép toán cơ bản bởi chương trình.

Tất cả phương án trên.

Tốn ít thời gian nhưng nhiều bộ nhớ.

Tốn nhiều thời gian và nhiều bộ nhớ.

Tốn ít thời gian và ít bộ nhớ.

Tốn nhiều thời gian nhưng ít bộ nhớ.

Sau vòng 3 thì A = [5, 8, 0, 10, 4, 3] => điểm dừng j = 0

Sau vòng 3 thì A = [0, 5, 8, 10, 4, 3] => điểm dừng j = -1

Sau vòng 3 thì A = [0, 5, 8, 10, 4, 3] => điểm dừng j = 2

Sau vòng 3 thì A = [0, 4, 5, 8, 10, 3] => điểm dừng j = 0

B2, B1, B3, B4.

B1, B4, B3, B2.

B3, B1, B2, B4.

B2, B4, B3, B1.

Sai, sửa dòng 3 là k = 1.

Sai, sửa dòng 4 là k < n.

Sai, sửa dòng 3 là k = 1 và dòng 4 là k < n.

Đúng.

TKTT(A,9).

LinearSearch(A).

LinearSearch(A,9).

linearsearch(A,9).

matrix[i][j] đại diện cho phần tử nằm ở hàng i, cột j trong ma trận.

Cần dùng hai vòng lặp lồng nhau để duyệt toàn bộ phần tử trong ma trận.

Nếu ma trận có kích thước m x n, số lần lặp tối đa của thuật toán này là m + n.

Tổng của các phần tử trong mảng hai chiều được tính theo từng cột, rồi cộng các cột lại với nhau.

Thuật toán này chỉ hoạt động đúng nếu mảng đầu vào đã được sắp xếp.

Trong thuật toán này, số lần so sánh của thuật toán này là số phần tử của mảng A.

Nếu A[mid] > K, thì việc tìm kiếm sẽ tiếp tục trong nửa bên phải của mảng.

Dòng mid = (left + right) // 2 có ý nghĩa chia lấy phần nguyên của kết quả gán vào cho biến mid.

Thuật toán sắp xếp chọn lúc đầu chọn phần tử đầu tiên làm min.

Biến min_idx lưu vị trí phần tử lớn nhất trong dãy chưa sắp xếp.

Thuật toán này đưa lần lượt phần tử bé nhất về đúng vị trí đầu dãy.

Trong vòng lặp for j in range(i+1, n), j chạy từ 2 đến n - 1.

Biến max_val được dùng để lưu giá trị lớn nhất tìm thấy trong ma trận.

Thuật toán sử dụng hai vòng lặp lồng nhau để duyệt qua từng phần tử của ma trận.

Dòng lệnh t1 = perf_counter() và t2 = perf_counter() là thời gian kết thúc chương trình.

Dòng lệnh print (t2-t1) là in ra thời gian chạy của chương trình.

Hàm sum_even(lst) duyệt qua tất cả các phần tử trong danh sách để kiểm tra số chẵn.

Biến total được dùng để lưu tổng các số lẻ trong danh sách.

Toán tử % được dùng để kiểm tra số chia hết cho 2.

Nếu danh sách chỉ chứa số lẻ, hàm sẽ trả về giá trị None.

Hàm reverse_string (s) trả về chuỗi đảo ngược của s.

Biểu thức s [ : : - 1 ] là cú pháp dùng để duyệt chuỗi từ cuối lên đầu.

Hàm này chỉ hoạt động với chuỗi có độ dài chẵn.

Nếu s là một chuỗi rỗng, hàm vẫn hoạt động bình thường.

Hàm is_prime(n) trả về True nếu n là số nguyên tố, ngược lại trả về False.

Nếu n = 1, hàm sẽ trả về True.

Vòng lặp chạy từ 2 đến căn bậc hai của n để kiểm tra tính nguyên tố.

Hàm này có độ phức tạp thời gian là O(n).

Nếu s = "madam", hàm sẽ trả về True.

Nếu s = "hello", hàm sẽ trả về True.

Hàm sử dụng phép so sánh trực tiếp giữa chuỗi gốc và chuỗi đảo ngược để kiểm tra đối xứng.

Độ phức tạp của thuật toán là O(n), với n là độ dài chuỗi.

Nếu n = 5, kết quả trả về sẽ là 120.

Nếu n = 0, hàm sẽ trả về 0.

Hàm này sử dụng kỹ thuật đệ quy để tính giai thừa.

Độ phức tạp của thuật toán là O(n!).

Hàm count_letters(s) trả về số lượng chữ cái (a-z, A-Z) trong chuỗi s.

Phương thức .isalpha() kiểm tra xem một ký tự có phải là chữ cái không.

Nếu s = "Ver Python 3.10.2!", kết quả trả về là 8.

Hàm này không đếm khoảng trắng và các ký tự số trong chuỗi.

Nếu danh sách có phần tử trùng lặp, hàm trả về True.

Hàm set(lst) chuyển danh sách thành một tập hợp (loại bỏ các phần tử trùng lặp).

Nếu danh sách không có phần tử trùng, độ dài danh sách và tập hợp là bằng nhau.

Độ phức tạp của thuật toán là O(1).

Hàm count_elements(lst) trả về một từ điển chứa số lần xuất hiện của mỗi phần tử trong danh sách.

Phương thức .get(item, 0) được sử dụng để lấy giá trị của item, mặc định là 0 nếu item chưa tồn tại.

Nếu danh sách chứa n phần tử, số lượng khóa trong từ điển luôn bằng n.

Độ phức tạp của thuật toán này trung bình là O(n).

Hàm set(lst1) & set(lst2) tạo ra một tập hợp chứa các phần tử chung giữa hai danh sách.

Nếu lst1 = [1, 2, 3] và lst2 = [4, 5, 6], hàm sẽ trả về True.

Hàm trả về True nếu có ít nhất một phần tử chung giữa lst1 và lst2.

Độ phức tạp của thuật toán là O(n + m), với n, m là độ dài của lst1 và lst2.

Sau khi thực hiện lst.sort(), danh sách sẽ được sắp xếp tăng dần.

Phương thức .sort() trả về một danh sách mới, không làm thay đổi danh sách gốc.

.sort() sử dụng thuật toán Timsort với độ phức tạp trung bình là O(n log n).

.sort() có thể sắp xếp danh sách chứa cả số và chuỗi ký tự.

Hàm is_even(n) trả về True nếu n là số chẵn, ngược lại trả về False.

Toán tử % (chia lấy dư) được dùng để kiểm tra số chẵn bằng cách kiểm tra n % 2 == 0.

Nếu n = 7, kết quả trả về là True.

Nếu n = -4, hàm vẫn trả về True.