What is output ?

Đề bài yêu cầu xác định kết quả in ra màn hình của đoạn code C++.

Đoạn code thực hiện một vòng lặp `for` với biến `i` chạy từ 0 đến 3 (không bao gồm 3). Bên trong vòng lặp, giá trị của `i` được in ra màn hình. Như vậy, các giá trị được in ra sẽ là 0, 1, và 2, mỗi giá trị trên một dòng mới do có `endl`.

Vậy, đáp án đúng là C. 0 1 2

Đoạn code trên có hai vòng lặp `for` lồng nhau. Vòng lặp bên ngoài (biến `i`) chạy từ 0 đến 4 (tổng cộng 5 lần). Vòng lặp bên trong (biến `j`) chạy từ 0 đến 5 (tổng cộng 6 lần). Trong mỗi lần lặp của vòng lặp bên trong, giá trị của `i` và `j` được in ra. Do đó, đáp án đúng là in `i` từ 0 đến 4 và `j` từ 0 đến 5.

Đề bài yêu cầu xác định kết quả in ra màn hình của đoạn code C++ được cung cấp. Đoạn code thực hiện các thao tác sau:

1. Khai báo và khởi tạo mảng `arr`: Một mảng số nguyên `arr` gồm 5 phần tử được khởi tạo với các giá trị {2, 6, 10, 14, 18}.
2. Duyệt và thay đổi giá trị mảng: Một vòng lặp `for` duyệt qua các phần tử của mảng `arr` từ chỉ số 0 đến 3 (tức là 4 phần tử đầu tiên).
3. Phép gán: Bên trong vòng lặp, mỗi phần tử `arr[i]` được gán bằng tổng của chính nó cộng với 4 (`arr[i] += 4`).
4. In giá trị mảng: Sau vòng lặp, code in ra hai phần tử `arr[3]` và `arr[4]` (lưu ý dấu phẩy giữa hai phần tử).

Phân tích chi tiết:

* Ban đầu: `arr` = {2, 6, 10, 14, 18}
* Vòng lặp:
* `i` = 0: `arr[0]` = 2 + 4 = 6. `arr` = {6, 6, 10, 14, 18}
* `i` = 1: `arr[1]` = 6 + 4 = 10. `arr` = {6, 10, 10, 14, 18}
* `i` = 2: `arr[2]` = 10 + 4 = 14. `arr` = {6, 10, 14, 14, 18}
* `i` = 3: `arr[3]` = 14 + 4 = 18. `arr` = {6, 10, 14, 18, 18}
* In ra: `arr[3]` (18) và `arr[4]` (18). Vậy kết quả in ra là 18, 18.

Tuy nhiên, không có đáp án nào trùng khớp với kết quả này. Có thể có lỗi trong đề bài hoặc các phương án trả lời.

Đoạn code kiểm tra xem `num` có lớn hơn 10 không. Vì `num` được gán giá trị là 15, điều kiện `num > 10` là đúng (True). Do đó, output sẽ là True.

Đề bài yêu cầu xác định output của đoạn code C++ cho trước. Đoạn code này sử dụng con trỏ và cấp phát bộ nhớ động.

Phân tích code:

- `int *p = new int[3];` cấp phát một mảng 3 số nguyên và gán địa chỉ cho con trỏ `p`.
- `p[0] = 10; p[1] = 20; p[2] = 30;` gán giá trị cho các phần tử của mảng.
- `int *q = p;` gán địa chỉ của `p` cho `q`. Lúc này, `p` và `q` cùng trỏ đến cùng một vùng nhớ.
- `p = new int[5];` cấp phát một mảng 5 số nguyên *mới* và gán địa chỉ cho `p`. Vùng nhớ mà `p` trỏ đến trước đó (mảng 3 phần tử) bây giờ không còn được trỏ tới bởi `p` nữa, nhưng `q` vẫn trỏ đến vùng nhớ đó.
- `p[0] = 1; p[1] = 2; p[2] = 3; p[3] = 4; p[4] = 5;` gán giá trị cho các phần tử của mảng *mới* mà `p` trỏ tới.
- `cout << q[0] << q[1] << q[2];` in ra giá trị của các phần tử đầu tiên của mảng mà `q` trỏ tới. Vì `q` vẫn trỏ đến mảng ban đầu (3 phần tử), nên các giá trị được in ra là 10, 20 và 30.

Vì vậy, output của chương trình là `102030`, tương ứng với đáp án C.