Cho hàm Boole: f(a,b,c,d)=a.b+b.d+d.c. Dạng tối thiểu của hàm f là.

Thuật toán cần đảm bảo các đặc trưng sau:

* Nhập: Thuật toán có thể nhận dữ liệu đầu vào.
* Xuất: Thuật toán phải đưa ra kết quả.
* Tính xác định: Các bước của thuật toán phải rõ ràng, không mơ hồ.
* Tính hữu hạn: Thuật toán phải kết thúc sau một số hữu hạn bước.
* Tính hiệu quả: Thuật toán phải sử dụng tài nguyên (thời gian, bộ nhớ) một cách hợp lý.
* Tính đúng đắn: Thuật toán phải cho ra kết quả đúng với mọi đầu vào hợp lệ.

Phương án C (Nhập, xuất, tính xác định, tính hữu hạn, tính hiệu quả, tính tổng quát, tính đúng đắn) là đáp án chính xác nhất vì nó bao gồm tất cả các đặc trưng quan trọng của một thuật toán, mặc dù 'tính tổng quát' không phải lúc nào cũng bắt buộc nhưng nó thể hiện khả năng áp dụng của thuật toán cho nhiều trường hợp khác nhau.

Phương án A thiếu tính tổng quát. Phương án B thiếu tính hữu hạn. Phương án D thiếu dữ liệu nhập.

Số các chỉnh hợp không lặp chập k của n phần tử, ký hiệu là A(n, k), được tính bằng công thức: A(n, k) = n! / (n - k)! . Vậy đáp án đúng là C.

Đề bài yêu cầu xác định kết quả đúng của hàm đệ quy `Test(n)`. Hàm này tính giai thừa của n. Ta sẽ kiểm tra từng đáp án:

* A. Test(4) = 24:
* Test(4) = 4 * Test(3)
* Test(3) = 3 * Test(2)
* Test(2) = 2 * Test(1)
* Test(1) = 1 * Test(0)
* Test(0) = 1
* Suy ra: Test(1) = 1, Test(2) = 2, Test(3) = 6, Test(4) = 24. Vậy đáp án A đúng.

* B. Test(2) = 1: Như đã tính ở trên, Test(2) = 2, nên đáp án này sai.

* C. Test(3) = 9: Như đã tính ở trên, Test(3) = 6, nên đáp án này sai.

* D. Test(5) = 20:
* Test(5) = 5 * Test(4)
* Test(4) = 24 (đã tính ở trên)
* Suy ra: Test(5) = 5 * 24 = 120, nên đáp án này sai.

Vậy đáp án đúng là A.

Đề bài cho một thuật toán `Test` và một mảng `A`. Ta cần tìm kết quả đúng khi gọi thuật toán `Test` với các tham số khác nhau. Mảng A ban đầu là {5, 2, 9, 8, 6, 4, 7, 1}. Do các chỉ số mảng trong thuật toán bắt đầu từ 1, ta cần sắp xếp lại mảng A theo thứ tự tăng dần để dễ theo dõi. Mảng A sau khi sắp xếp là: A = {1, 2, 4, 5, 6, 7, 8, 9} và chỉ số tương ứng từ 1 đến 8.

* A. Test(3, 1, 8), vt = 0:
* x = 3, i = 1, j = 8.
* m = trunc((1 + 8) / 2) = 4.
* x = 3 != a[4] = 5. (Sai)
* x = 3 < a[4] = 5 và i = 1 < m = 4, gọi Test(3, 1, 3).
* m = trunc((1 + 3) / 2) = 2.
* x = 3 != a[2] = 2. (Sai)
* x = 3 > a[2] = 2 và j = 3 > m = 2, gọi Test(3, 3, 3).
* m = trunc((3 + 3) / 2) = 3.
* x = 3 != a[3] = 4. (Sai)
* x = 3 < a[3] = 4 và i = 3 < m = 3, gọi Test(3, 3, 2). Điều này không thể xảy ra vì i > j. Vì vậy, theo code, `vt` := 0.
* Kết quả vt = 0. Vậy A đúng.

* B. Test(4, 1, 8), vt = 5:
* x = 4, i = 1, j = 8.
* m = trunc((1 + 8) / 2) = 4.
* x = 4 != a[4] = 5. (Sai)
* x = 4 < a[4] = 5 và i = 1 < m = 4, gọi Test(4, 1, 3).
* m = trunc((1 + 3) / 2) = 2.
* x = 4 != a[2] = 2. (Sai)
* x = 4 > a[2] = 2 và j = 3 > m = 2, gọi Test(4, 3, 3).
* m = trunc((3 + 3) / 2) = 3.
* x = 4 != a[3] = 4. (Sai)
* Else If ( x

* Else If ( x> a[m] ) and (j>m) then Test(x,m+1,j)
* Else vt:=0;
* Kết quả vt = 3. Vậy B sai.

* C. Test(6, 1, 8), vt = 0:
* x = 6, i = 1, j = 8.
* m = trunc((1 + 8) / 2) = 4.
* x = 6 != a[4] = 5. (Sai)
* x = 6 > a[4] = 5 và j = 8 > m = 4, gọi Test(6, 5, 8).
* m = trunc((5 + 8) / 2) = 6.
* x = 6 = a[6] = 7. (Sai)
* Kết quả vt = 6. Vậy C sai.

* D. Test(7, 1, 8), vt = 8:
* x = 7, i = 1, j = 8.
* m = trunc((1 + 8) / 2) = 4.
* x = 7 != a[4] = 5. (Sai)
* x = 7 > a[4] = 5 và j = 8 > m = 4, gọi Test(7, 5, 8).
* m = trunc((5 + 8) / 2) = 6.
* x = 7 = a[6] = 7. vt := 6
* Kết quả vt = 6. Vậy D sai.

Vậy đáp án đúng là A.
Lưu ý: Có một lỗi nhỏ trong đoạn code gốc, cụ thể là `x= a[i] then vt:=m` nên sửa thành `x= a[m] then vt:=m`

Thuật toán đệ quy trên thực chất là một cách cài đặt của thuật toán Euclid để tìm ước chung lớn nhất (ƯCLN) của hai số nguyên dương a và b.

Giải thích:

* Trường hợp cơ sở: Nếu a = 0 hoặc b = 0, thì ƯCLN(a, b) = a + b (vì nếu một trong hai số bằng 0, thì số còn lại là ƯCLN).
* Bước đệ quy:
* Nếu a > b, thì ƯCLN(a, b) = ƯCLN(a - b, b).
* Nếu a < b, thì ƯCLN(a, b) = ƯCLN(a, b - a).
* Nếu a = b, thì ƯCLN(a, b) = a = b. Tuy nhiên, trường hợp này không được thể hiện trực tiếp trong code, nhưng nó được xử lý bởi một trong hai bước đệ quy trên khi a và b dần tiến về cùng một giá trị.

Ví dụ: Test(12, 8)

* 12 > 8, Test(12 - 8, 8) = Test(4, 8)
* 4 < 8, Test(4, 8 - 4) = Test(4, 4)
* 4 = 4 (trường hợp này được xử lý bởi một trong hai bước đệ quy: Test(4 - 4, 4) = Test(0,4) = 4+0 =4, hoặc Test(4, 4-4) = Test(4,0) = 4+0 = 4.)

Vậy, thuật toán trên tính ước chung lớn nhất của a và b.