Friendship is commutative.

Đoạn code khai báo hai biến `i` và `j` kiểu `int`, sau đó gán giá trị 10 cho cả hai. `ptr` và `ptr1` là hai con trỏ kiểu `int*`, lần lượt trỏ đến địa chỉ của `i` và `j`.

Phép so sánh `ptr == ptr1` so sánh địa chỉ mà hai con trỏ này đang giữ, chứ không so sánh giá trị của `i` và `j`. Vì `i` và `j` là hai biến riêng biệt, chúng sẽ có địa chỉ khác nhau trong bộ nhớ. Do đó, `ptr` và `ptr1` sẽ trỏ đến hai địa chỉ khác nhau, và kết quả của phép so sánh `ptr == ptr1` sẽ là `False`.

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

Chương trình này có một lỗi biên dịch. Hàm `func` được khai báo là `extern int func(float);` trong hàm `main`, nhưng định nghĩa thực tế của hàm `func` lại nằm sau hàm `main`. Khi trình biên dịch gặp lời gọi `func(3.14)` trong `main`, nó chỉ biết rằng `func` là một hàm trả về `int` và nhận một `float`. Tuy nhiên, khi biên dịch đến định nghĩa của `func`, trình biên dịch có thể phát hiện ra sự không nhất quán (ví dụ: nếu có nhiều định nghĩa cho `func` với các kiểu tham số khác nhau). Trong trường hợp này, dù không có nhiều định nghĩa, việc khai báo `extern` mà không có định nghĩa trước khiến một số trình biên dịch báo lỗi hoặc cảnh báo, đặc biệt khi có sự khác biệt về kiểu dữ liệu hoặc cách thức biên dịch giữa khai báo và định nghĩa. Tuy nhiên, trong trường hợp này, vấn đề chính là thứ tự khai báo và định nghĩa, khiến trình biên dịch không thể xác định chính xác hàm `func` trước khi nó được sử dụng trong `main`. Do đó, chương trình sẽ báo lỗi biên dịch.

Trong đoạn chương trình C này, vòng lặp `for` có một điều kiện lặp đặc biệt. Điều kiện lặp không phải là một biểu thức so sánh trực tiếp (ví dụ, `i < 10`), mà là một lệnh gán có kèm theo hàm `scanf`. Hàm `scanf("%d", &i)` cố gắng đọc một số nguyên từ đầu vào chuẩn (thường là bàn phím) và gán giá trị đó cho biến `i`.

Điều quan trọng là `scanf` trả về số lượng mục nhập mà nó đã đọc thành công. Nếu `scanf` đọc thành công một số nguyên, nó sẽ trả về 1. Nếu nó không đọc được gì cả (ví dụ: người dùng nhập một chuỗi không phải là số), nó sẽ trả về một giá trị khác 1, thường là `EOF` (End-of-File), một giá trị âm. Do đó, vòng lặp `for` sẽ tiếp tục thực thi miễn là `scanf` trả về 1, tức là đọc thành công một số nguyên. Khi `scanf` không đọc được số nguyên (ví dụ, người dùng nhập chữ hoặc kết thúc luồng nhập), nó sẽ trả về một giá trị khác 1, và vòng lặp sẽ kết thúc.

Trong thân vòng lặp, `printf("%d", i)` in giá trị hiện tại của `i` ra màn hình. Vì vậy, vòng lặp sẽ tiếp tục cho đến khi `scanf` không thể đọc được một số nguyên từ đầu vào. Điều này có nghĩa là vòng lặp có thể chạy nhiều lần, phụ thuộc vào đầu vào của người dùng.

Vì vậy, đáp án chính xác là: D. Vòng lặp for sẽ được thực thi vô số lần, cho đến khi người dùng nhập vào một giá trị không phải số nguyên, hoặc kết thúc luồng nhập.

Trong biểu thức `z = x + y * z / 4 % 2 – 1;`, thứ tự ưu tiên của các toán tử trong C (và nhiều ngôn ngữ lập trình khác) là:

1. `*`, `/`, `%`: Nhân, chia, và chia lấy dư. Các toán tử này có cùng độ ưu tiên và được thực hiện từ trái sang phải.
2. `+`, `–`: Cộng và trừ. Các toán tử này cũng có cùng độ ưu tiên và được thực hiện từ trái sang phải.
3. `=`: Gán. Toán tử gán có độ ưu tiên thấp nhất và được thực hiện cuối cùng.

Dựa trên thứ tự này, biểu thức được đánh giá như sau:

1. `y * z`
2. `(y * z) / 4`
3. `((y * z) / 4) % 2`
4. `x + ((y * z) / 4) % 2`
5. `(x + ((y * z) / 4) % 2) – 1`
6. `z = (x + ((y * z) / 4) % 2) – 1`

Vậy thứ tự đúng của các toán tử là `* / % + – =`.