Khi xây dựng một thuật toán cần chú ý đến các đặc trưng sau đây.

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.