Functions cannot return more than one value at a time

Đoạn code cung cấp hai hàm `my_func` và `main`. Hàm `my_func` nhận một đối số kiểu `int` và trả về giá trị của đối số đó cộng với 5. Hàm `main` gọi hàm `my_func` với đối số là 10, sau đó in ra giá trị trả về (15). Vì vậy, đoạn code này sẽ hoạt động bình thường và không gây ra lỗi.

Đoạn code trên thực hiện một vòng lặp `while` với điều kiện `i >= 0`. Bên trong vòng lặp, giá trị của `i` được in ra, sau đó `i` giảm đi 1. Vòng lặp bắt đầu với `i = 5`, vì vậy các giá trị được in ra sẽ là 5, 4, 3, 2, 1, 0. Khi `i` trở thành -1, điều kiện `i >= 0` không còn đúng nữa và vòng lặp kết thúc.

Như vậy, đáp án đúng là A. 543210

Đoạn code trên thực hiện các phép toán với các biến có kiểu dữ liệu khác nhau, sau đó in ra kích thước của các biến `x`, `y`, và `z`.

* `x = a + b`: `a` là `char` (1 byte) và `b` là `float` (4 byte). Trong phép cộng, `a` sẽ được chuyển đổi thành `float` để phù hợp với kiểu dữ liệu của `b`. Kết quả của phép cộng sẽ là một số `float`, do đó `x` sẽ có kích thước của `float` là 4 byte.
* `y = a + d`: `a` là `char` (1 byte) và `d` là `double` (8 byte). Tương tự, `a` sẽ được chuyển đổi thành `double` để phù hợp với kiểu dữ liệu của `d`. Kết quả của phép cộng sẽ là một số `double`, do đó `y` sẽ có kích thước của `double` là 8 byte.
* `z = a + c`: `a` là `char` (1 byte) và `c` là `int` (4 byte). Trong phép cộng, `a` sẽ được chuyển đổi thành `int` để phù hợp với kiểu dữ liệu của `c`. Kết quả của phép cộng sẽ là một số `int`, do đó `z` sẽ có kích thước của `int` là 4 byte.

Như vậy, kết quả in ra sẽ là: 8 4 1

Đoạn code C cung cấp thực hiện một số phép toán bitwise.

* `a = 5;` Khởi tạo biến `a` bằng giá trị 5 (0101 trong hệ nhị phân).
* `b = a++;` Gán giá trị hiện tại của `a` cho `b` (tức là 5), sau đó tăng `a` lên 1. Vậy `b` = 5 và `a` = 6.
* `c = ++a;` Tăng `a` lên 1 (tức là 7), sau đó gán giá trị mới của `a` cho `c`. Vậy `c` = 7 và `a` = 7.
* `d = b + c;` Tính tổng của `b` (5) và `c` (7), gán kết quả cho `d`. Vậy `d` = 12.
* `e = d >> 2;` Dịch phải bit của `d` (12) đi 2 vị trí. 12 trong hệ nhị phân là 1100. Dịch phải 2 vị trí sẽ thành 0011, tương ứng với giá trị 3 trong hệ thập phân. Vậy `e` = 3.
* `f = e & a;` Thực hiện phép AND bitwise giữa `e` (3, tức là 0011) và `a` (7, tức là 0111). Kết quả là 0011, tương ứng với giá trị 3 trong hệ thập phân. Vậy `f` = 3.
* `g = f | 4;` Thực hiện phép OR bitwise giữa `f` (3, tức là 0011) và 4 (tức là 0100). Kết quả là 0111, tương ứng với giá trị 7 trong hệ thập phân. Vậy `g` = 7.

Hàm `printf` in giá trị của `g`, do đó kết quả in ra là 7.

Đoạn code trên sử dụng một mảng `arr` kiểu `int` và khởi tạo nó với các giá trị {1, 2, 3, 4, 5}. Sau đó, một con trỏ `ptr` kiểu `int*` được gán địa chỉ của phần tử thứ ba trong mảng (tức là `arr[2]` hoặc số 3).

Khi đó, `*ptr` sẽ trả về giá trị mà con trỏ `ptr` đang trỏ tới, tức là 3.

Biểu thức `*ptr++` có nghĩa là:

1. `*ptr`: Lấy giá trị mà `ptr` đang trỏ tới (là 3).
2. `ptr++`: Tăng con trỏ `ptr` lên một vị trí (sau khi đã lấy giá trị). Như vậy, sau biểu thức này, `ptr` sẽ trỏ tới `arr[3]` (tức là số 4).

Như vậy, `printf("%d", *ptr++)` sẽ in ra giá trị 3 (giá trị ban đầu mà `ptr` trỏ tới), và sau đó `ptr` sẽ trỏ đến phần tử tiếp theo trong mảng.

Tiếp theo, `printf("%d", *ptr)` in ra giá trị mà `ptr` hiện đang trỏ tới. Vì `ptr` đã được tăng lên ở bước trước, nên giờ nó trỏ tới `arr[3]`, có giá trị là 4. Do đó, nó sẽ in ra 4.

Kết quả cuối cùng in ra màn hình là 34. Vì không có đáp án nào trùng khớp với kết quả này nên đáp án đúng nhất là "Complier error" do đề bài thiếu dấu cách giữa 2 lệnh in.