Đề lý thuyết số 2 (Năm 2023-2024)

Câu 1.

Cho một chương trình như sau:

#include <iostream>
using namespace std;
int main()
{
    cout << 8.0/5 - 7%2 << ",";
    cout << (int)-3.5 * (14/3) + (float)8/5;
    return 0;
}

Sau khi thực hiện chương trình, kết quả in ra màn hình là gì?

Lời giải:

Sau khi thực hiện xong chương trình, kết quả in ra màn hình là: 0.6,-10.4

Giải thích:

Biểu thức 1: 8.0/5 - 7%2

8.0/5 = 1.6 (Phép chia số thực)
7%2 = 1 (Phép chia lấy dư)

Kết quả: $1.6 - 1 = 0.6$

Biểu thức 2: (int)-3.5 * (14/3) + (float)8/5

(int)-3.5 = -3 (Ép kiểu số nguyên, làm tròn về 0)
(14/3) = 4 (Chia số nguyên: 14 chia 3 được 4 dư 2)
(float)8/5 = 1.6 (Ép kiểu số thực cho số 8 trước khi chia)

Kết quả: $(-3 * 4) + 1.6 = -12 + 1.6 = -10.4$

Câu 2:

Cho một chương trình như sau:

#include <iostream>
using namespace std;
int main()
{
    int a=2, b=7;
    cout << (a==2 && (a>5 || b<=7)) << ",";
    cout << (a>b ? -a : 2*b) << ",";
    cout << (12>10>5) << ",";
    cout << (1!=2 && !3);
    return 0;
}

Sau khi thực hiện chương trình, kết quả in ra màn hình là gì?

Lời giải:

Sau khi thực hiện xong chương trình, kết quả in ra màn hình là: 1,14,0,0

Giải thích:

Biểu thức 1: (a==2 && (a>5 || b<=7))

a==2 là đúng (1).
(a>5 || b<=7) tương đương (2>5 || 7<=7) là (0 || 1), kết quả là đúng (1).
1 && 1 $\rightarrow$ 1

Biểu thức 2: (a>b ? -a : 2*b)

So sánh 2 > 7 là sai.
Thực hiện vế sau dấu : là 2*b = 2*7 = 14.

Biểu thức 3: (12>10>5)

Tính từ trái sang phải: 12 > 10 là đúng (1).
Biểu thức trở thành 1 > 5 là sai (0).

Biểu thức 4: (1!=2 && !3)

1!=2 là đúng (1).
!3 (phủ định của một số khác 0) là sai (0).
1 && 0 $\rightarrow$ 0

Câu 3.

Cho một chương trình như sau:

#include <iostream>
using namespace std;
int main()
{
    int x, y;
    cin >> x;
    y = x;
    switch (x)
    {
        case 1:
        case 3:
            y += y * x;
        case 4:
            y++;
        case 5:
            y = x + 10; break;
        case 6:
            y = y / 3; break;
        default:
            y--;
    }
    cout << y;
    return 0;
}

Nếu nhập giá trị của biến x là 2 thì kết quả in ra màn hình là gì? Nếu nhập giá trị của biến x là 3 thì kết quả in ra màn hình là gì?

Lời giải:

Nếu nhập giá trị của biến x là 2 thì kết quả in ra màn hình là: 1
Nếu nhập giá trị của biến x là 3 thì kết quả in ra màn hình là: 13

Giải thích:

Trường hợp x = 2

Gán y = x = 2.
Vào switch (x): Do không có case 2, chương trình nhảy vào lệnh default.
Thực hiện y-- $\rightarrow$ y = 1. Kết quả: cout << y in ra 1.

Trường hợp x = 3

Gán y = x = 3.
Vào switch (x): Nhảy vào case 3.
Thực hiện y += y * x $\rightarrow$ y = 3 + (3 * 3) = 12.
Vì không có lệnh break, chương trình tiếp tục "rơi" xuống các case tiếp theo (fall-through):
- Tại case 4: y++ $\rightarrow$ y = 13.
- Tại case 5: y = x + 10 $\rightarrow$ y = 3 + 10 = 13.
Gặp lệnh break, thoát khỏi cấu trúc switch. Kết quả: cout << y in ra 13.

Câu 4.

Cho một chương trình như sau:

#include <iostream>
using namespace std;
int main()
{
    int sum, num;
    cin >> sum;
    do
    {
        cin >> num;
        if (num % 10 != 0) continue;
        sum += num;
    }
    while (sum < 110);
    cout << "sum=" << sum;
    return 0;
}

Giả sử user muốn nhập lần lượt các số sau: 21 55 42 30 9 10 15 -10 50 7 -30 50 8 20 (có thể không thể nhập hết được dãy số này).
Sau khi thực hiện chương trình, kết quả in ra màn hình là gì?

Lời giải:

Sau khi thực hiện xong chương trình, kết quả in ra màn hình là: sum=121

Giải thích:

Nguyên tắc hoạt động: sum chỉ được cộng dồn khi số num nhập vào chia hết cho 10 (num % 10 == 0).Vòng lặp do-while sẽ tiếp tục chạy cho đến khi sum >= 110.
Quá trình thực hiện: Ban đầu nhập sum = 21. Vào vòng lặp do-while:

num = 55: Không chia hết cho 10 $\rightarrow$ continue (bỏ qua).
num = 42: Không chia hết cho 10 $\rightarrow$ continue.
num = 30: Chia hết cho 10 $\rightarrow$ sum = 21 + 30 = 51.
num = 9: Không chia hết cho 10 $\rightarrow$ continue.
num = 10: Chia hết cho 10 $\rightarrow$ sum = 51 + 10 = 61.
num = 15: Không chia hết cho 10 $\rightarrow$ continue.
num = -10: Chia hết cho 10 $\rightarrow$ sum = 61 + (-10) = 51.
num = 50: Chia hết cho 10 $\rightarrow$ sum = 51 + 50 = 101.
num = 7: Không chia hết cho 10 $\rightarrow$ continue.
num = -30: Chia hết cho 10 $\rightarrow$ sum = 101 + (-30) = 71.
num = 50: Chia hết cho 10 $\rightarrow$ sum = 71 + 50 = 121.

Lúc này sum = 121 (đã lớn hơn 110), điều kiện while (sum < 110) sai $\rightarrow$ Thoát vòng lặp.

Câu 5.

Cho một chương trình như sau:

#include <iostream>
using namespace std;
int main () {
    int n=732, S=0;
    for (int i=n; i>0; i=i/10)
        S += i;
    cout << S;
    return 0;
}

Sau khi thực hiện chương trình, kết quả in ra màn hình là gì?

Lời giải:

Sau khi thực hiện xong chương trình, kết quả in ra màn hình là: 812

Giải thích:

Vòng lặp này thực chất đang tính tổng của các số được tạo ra bằng cách loại bỏ dần các chữ số từ phải sang trái của số ban đầu thông qua phép chia nguyên cho 10 (i = i/10).

Các bước chạy của vòng lặp:

Lần 1: $i = 732$ (thỏa mãn $i > 0$ ). Thực hiện: $S = 0 + 732 = 732$ .
Lần 2: $i = 732 / 10 = 73$ (thỏa mãn $i > 0$ ). Thực hiện: $S = 732 + 73 = 805$ .
Lần 3: $i = 73 / 10 = 7$ (thỏa mãn $i > 0$ ). Thực hiện: $S = 805 + 7 = 812$ .
Lần 4: $i = 7 / 10 = 0$ (không thỏa mãn $i > 0$ ). Dừng vòng lặp.

Kết quả: $S = 732 + 73 + 7 = 812$

Câu 6.

Cho một chương trình như sau:

#include <iostream>
using namespace std;

void fun(int &a, int &b, int c)
{
    a += b * c;
    b = 2 * c;
    c = 1;
}

int main()
{
    int x=1, y=5, z=4;
    fun(z, x, y);
    cout << x << y << z;
    return 0;
}

Sau khi thực hiện chương trình, kết quả in ra màn hình là gì?

Lời giải:

Sau khi thực hiện xong chương trình, kết quả in ra màn hình là: 1059

Giải thích:

Xét lời gọi hàm fun(z, x, y) với các tham số tương ứng trong định nghĩa hàm fun(int &a, int &b, int c):

a tham chiếu đến z (thay đổi a là thay đổi z).
b tham chiếu đến x (thay đổi b là thay đổi x).
c nhận tham trị từ y (giá trị c = 5, thay đổi c không ảnh hưởng đến y).

Các bước tính toán trong hàm fun:

a += b * c $\rightarrow$ z = z + (x * y) = $4 + (1 * 5) = 9$ .
b = 2 * c $\rightarrow$ x = 2 * 5 = 10.
c = 1 $\rightarrow$ Chỉ thay đổi biến cục bộ c, không ảnh hưởng đến y.

Giá trị các biến sau khi thoát hàm:

x = 10
y = 5 (không đổi)
z = 9

Kết quả in ra (cout << x << y << z): 1059

Câu 7.

Cho một chương trình như sau:

#include <iostream>
using namespace std;

int test(int a)
{
    a = a * 2;
    return a;
}

int main()
{
    int a = 3;
    int &b = a;
    cout << test(a) << ",";
    b = 10;
    a = b - a;
    b++;
    cout << a << "," << b;
    return 0;
}

Sau khi thực hiện chương trình, kết quả in ra màn hình là gì?

Lời giải:

Sau khi thực hiện xong chương trình, kết quả in ra màn hình là: 6,1,1

Giải thích:

Lời gọi hàm test(a):

Biến a trong hàm main (giá trị là 3) được truyền tham trị vào hàm test.
Trong hàm test, biến cục bộ a = 3 * 2 = 6. Hàm trả về 6.
Lệnh cout << test(a) << "," in ra 6,. Lưu ý: Giá trị a ở hàm main vẫn là 3.

Thao tác với tham chiếu &b = a:

b là tên gọi khác (tham chiếu) của a. Mọi thay đổi trên b đều tác động trực tiếp lên a và ngược lại vì chúng dùng chung một ô nhớ.
b = 10; $\rightarrow$ Lúc này cả a và b đều bằng 10.
a = b - a; $\rightarrow$ a = 10 - 10 = 0. Lúc này cả a và b đều bằng 0.
b++; $\rightarrow$ b = 0 + 1 = 1. Vì b là tham chiếu của a nên a cũng bằng 1. Kết quả in ra:
Lệnh cout << a << "," << b; in ra 1,1.

Kết quả cuối cùng: 6,1,1

Câu 8.

Cho một chương trình như sau:

#include <iostream>
using namespace std;

int fun(int x)
{
    if (x < 2) return 1;
    return (x - 1) * fun(x - 1);
}

int main() 
{
    cout << fun(3) + fun(4);
    return 0;
}

Sau khi thực hiện chương trình, kết quả in ra màn hình là gì?

Lời giải:

Sau khi thực hiện xong chương trình, kết quả in ra màn hình là: 8

Giải thích:

Hàm fun(x) là một hàm đệ quy. Chúng ta sẽ tính toán giá trị của từng lời gọi hàm:

Tính fun(1): Do $1 < 2$ , hàm trả về 1.
Tính fun(2):
- fun(2) = (2 - 1) * fun(1) = 1 * 1 = 1.
Tính fun(3):
- fun(3) = (3 - 1) * fun(2) = 2 * 1 = 2.
Tính fun(4):
- fun(4) = (4 - 1) * fun(3) = 3 * 2 = 6.

Kết quả trong hàm main: cout << fun(3) + fun(4) tương đương với $2 + 6 = 8$ .

Câu 9.

Cho một chương trình như sau:

#include <iostream>
using namespace std;

bool KiemTra (int *a, int n){
    for (int i=0; i<n-1; i++)
        if (a[i] > a[i+1]) return false;
    return true;
}

int main()
{
    int n, a[100];
    cin >> n;
    for(int i=0; i<n; i++)
        cin >> a[i];
    cout << KiemTra(a, n);
}

Với các trường hợp nhập dữ liệu đầu vào như ở cột Input dưới đây, hãy điền kết quả in ra màn hình ở cột Output.

Input	Output
1 3	........
2 3 3	........
5 3 3 4 4 5	........
10 3 3 4 4 5 5 1 1 6 6	........

Lời giải: 1 1 1 0

Giải thích:

Nhìn vào hàm KiemTra, ta dễ thấy: Hàm này dùng để kiểm tra xem mảng có được sắp xếp theo thứ tự không giảm (phần tử đứng trước không được lớn hơn phần tử đứng sau) hay không.

Nếu tồn tại bất kỳ cặp a[i] > a[i+1] nào: Hàm trả về false (in ra 0).
Nếu duyệt hết mảng mà không vi phạm: Hàm trả về true (in ra 1).

Phân tích từng trường hợp:

n=1, mảng 3: Vòng lặp for không chạy (do i < 0 là sai). Trả về true $\rightarrow$ 1.
n=2, mảng 3: 3 > 3 là sai. Trả về true $\rightarrow$ 1.
n=5, mảng 5: Các phần tử đứng trước luôn $\le$ phần tử đứng sau. Trả về true $\rightarrow$ 1.
n=10, mảng 6: Xuất hiện cặp 5 > 1 (tại vị trí a[5] và a[6]). Trả về false $\rightarrow$ 0.

Câu 10.

Hãy hoàn thành chương trình bên dưới để thực hiện việc đếm số lượng ký tự in hoa trong một chuỗi.

#include<iostream>    
using namespace std;    
int count_UpperCase(char *s)      
{        

    int i = 0, dem = 0;     
    while ( ______________________)      
    {      

        if ( _____________________)      
        {   
          dem++;
        }
        _____________________
    }
    _____________________
}

int main()    
{

    char str[35];
    cin.getline(str, 30);
    cout << count_UpperCase(str);
    return 0;
}

Hướng dẫn

#include <iostream>
using namespace std;

int count_UpperCase(char *s)
{
    int i = 0, dem = 0;
    while ( s[i] != '\0' ) // Điều kiện lặp: chưa gặp ký tự kết thúc chuỗi
    {
        if ( s[i] >= 'A' && s[i] <= 'Z' ) // Kiểm tra ký tự in hoa
        {
            dem++;
        }
        i++; // Tăng biến chỉ số để kiểm tra ký tự tiếp theo
    }
    return dem; // Trả về kết quả đếm được
}

int main()
{
    char str[35];
    cin.getline(str, 30);
    cout << count_UpperCase(str);
    return 0;
}

Giải thích:

Chỗ trống tại while(...): Điền s[i] != '\0' (để vòng lặp chạy xuyên suốt chuỗi cho đến khi gặp ký tự kết thúc NULL).
Chỗ trống tại if(...): Điền s[i] >= 'A' && s[i] <= 'Z' (điều kiện để xác định một ký tự nằm trong khoảng từ 'A' đến 'Z' trong bảng mã ASCII).
Chỗ trống dưới dem++;: Điền i++; (cần tăng biến đếm i sau mỗi lần kiểm tra để không bị lặp vô tận).
Chỗ trống tại return...: Điền return dem; (trả về giá trị cuối cùng của biến đếm cho hàm main).

Câu 11.

Cho một chương trình như sau:

#include <iostream>
using namespace std;

int main()
{
    int a[5][5] = { {1, 0, 3, 2, 1},
                    {1, 8, 2, 0, 5},
                    {7, 2, 3, 1, 4},
                    {4, 3, 0, 1, 3},
                    {1, 2, 3, 4, 5} };
    int S = 0;
    for (int i = 0; i < 3; i++)
        for (int j = 2; j < 5; j++)
            if (i != j)
                S += a[i][j];
    cout << S;
    return 0;
}

Sau khi thực hiện chương trình, kết quả in ra màn hình là gì?

Lời giải:

Sau khi thực hiện xong chương trình, kết quả in ra màn hình là: 18

Giải thích:

Vòng lặp duyệt qua các phần tử của mảng hai chiều dựa trên chỉ số hàng i và chỉ số cột j:

Hàng (i): Chạy từ 0 đến 2 ( $i < 3$ ).
Cột (j): Chạy từ 2 đến 4 ( $j < 5$ ).
Điều kiện: Chỉ cộng vào S nếu chỉ số hàng khác chỉ số cột ( $i \neq j$ ).

Các bước tính toán chi tiết:

Với $i = 0$ :
- $j = 2: a[0][2] = 3$ (Thỏa mãn $0 \neq 2$ )
- $j = 3: a[0][3] = 2$ (Thỏa mãn $0 \neq 3$ )
- $j = 4: a[0][4] = 1$ (Thỏa mãn $0 \neq 4$ )
- => Tổng hàng 0: $3 + 2 + 1 = 6$
Với $i = 1$ :
- $j = 2: a[1][2] = 2$ (Thỏa mãn $1 \neq 2$ )
- $j = 3: a[1][3] = 0$ (Thỏa mãn $1 \neq 3$ )
- $j = 4: a[1][4] = 5$ (Thỏa mãn $1 \neq 4$ )
- => Tổng hàng 1: $2 + 0 + 5 = 7$
Với $i = 2$ :
- $j = 2: a[2][2] = 3$ (Loại vì $i = j = 2$ )
- $j = 3: a[2][3] = 1$ (Thỏa mãn $2 \neq 3$ )
- $j = 4: a[2][4] = 4$ (Thỏa mãn $2 \neq 4$ )
- => Tổng hàng 2: $1 + 4 = 5$

Tổng cộng: $S = 6 + 7 + 5 = 18$

Câu 12.

Cho một chương trình như sau:

#include <iostream>
using namespace std;

int fun(int arr[][6], int n)
{
    int i, j;
    for (i = 0; i < n; i++)
    {
        for (j = 0; j < n; j++)
            if (arr[i][j] != 0)
                break;
        if (j == n) return i;

        for (j = 0; j < n; j++)
            if (arr[i][j] != 1)
                break;
        if (j == n) return i;
    }
    return -1;
}

int main()
{
    int a[6][6] = { {0, 1, 1, 1, 1, 1},
                    {1, 0, 0, 0, 0, 0},
                    {1, 0, 1, 0, 0, 1},
                    {0, 1, 0, 1, 1, 0},
                    {1, 1, 1, 1, 1, 1},
                    {0, 0, 0, 0, 0, 0},
                  };
    cout << fun(a, 6);
    return 0;
}

Sau khi thực hiện chương trình, kết quả in ra màn hình là gì?

Lời giải:

Sau khi thực hiện xong chương trình, kết quả in ra màn hình là: 4

Giải thích:

Hàm fun thực hiện duyệt qua từng hàng của mảng hai chiều để tìm hàng nào thỏa mãn một trong hai điều kiện sau:

Toàn bộ các phần tử trong hàng đều là số 0.
Toàn bộ các phần tử trong hàng đều là số 1.
Nếu tìm thấy hàng đầu tiên thỏa mãn, hàm sẽ return ngay chỉ số (index) của hàng đó.

Phân tích các hàng trong mảng a:

Hàng 0: {0, 1, 1, 1, 1, 1} $\rightarrow$ Không phải toàn 0 cũng không phải toàn 1.
Hàng 1: {1, 0, 0, 0, 0, 0} $\rightarrow$ Không thỏa mãn.
Hàng 2: {1, 0, 1, 0, 0, 1} $\rightarrow$ Không thỏa mãn.
Hàng 3: {0, 1, 0, 1, 1, 0} $\rightarrow$ Không thỏa mãn.
Hàng 4: {1, 1, 1, 1, 1, 1} $\rightarrow$ Thỏa mãn điều kiện toàn số 1.

Vì hàm tìm thấy hàng có chỉ số i = 4 thỏa mãn trước, nó sẽ trả về giá trị 4 và kết thúc.

Lưu ý: Mặc dù hàng 5 cũng toàn số 0, nhưng chương trình đã dừng lại và thoát ra ngay khi gặp hàng 4.

Câu 13.

Cho một chương trình như sau. Hãy cho biết dòng lệnh nào sai (sai về cú pháp hoặc logic), và cho biết tại sao sai?

STT	Chương trình	Giải thích tại sao các dòng lệnh bị sai
1.	`#include <iostream>`
2.	`using namespace std;`
3.	`int main()`
4.	`{`
5.	`int a=5, b=6, c, *pa=NULL;`
6.	`float pb, pc;`
7.	`&a=0x6efelc;`
8.	`pb=&b;`
9.	`pa = &(b+2);`
10.	`int d[]={1,2,3,4,5};`
11.	`*(d+2)=10;`
12.	`d++;`
13.	`cout<<d;`
14.	`return 0;`
15.	`}`

Hướng dẫn

STT	Chương trình	Giải thích tại sao các dòng lệnh bị sai
1.	`#include <iostream>`
2.	`using namespace std;`
3.	`int main()`
4.	`{`
5.	`int a=5, b=6, c, *pa=NULL;`
6.	`float pb, pc;`
7.	`&a=0x6efelc;`	Sai: Không thể tự gán địa chỉ cho một biến. Địa chỉ do hệ điều hành cấp phát và là hằng số đối với biến đó.
8.	`pb=&b;`	Sai: Sai khác về kiểu dữ liệu. `pb` là con trỏ kiểu `float`, trong khi `b` là kiểu `int`. Không thể gán trực tiếp địa chỉ `int` cho `float*`.
9.	`pa = &(b+2);`	Sai: Không thể lấy địa chỉ của một biểu thức.
10.	`int d[]={1,2,3,4,5};`
11.	`*(d+2)=10;`
12.	`d++;`	Sai: Tên mảng (`d`) là một hằng con trỏ trỏ đến phần tử đầu tiên. Không thể thay đổi giá trị của hằng con trỏ bằng toán tử `++`.
13.	`cout<<d;`
14.	`return 0;`
15.	`}`

Câu 14.

Cho một đoạn chương trình như sau, hãy giải thích ý nghĩa của từng câu lệnh trong hàm main từ dòng số 5 đến dòng số 8 và cho biết kết quả in ra màn hình sau khi thực hiện xong chương trình.

Dòng	Chương trình	Giải thích ý nghĩa câu lệnh
1.	`#include <iostream>`
2.	`using namespace std;`
3.	`int main() {`
4.	`int a[5]={1,2,3,4,5};`
5.	`int *p=a;`	Dòng 5:___________________________________________________________________
6.	`p=&a[2];`	Dòng 6:___________________________________________________________________
7.	`p[-2]=4; //a[0]=4`	Dòng 7:___________________________________________________________________
8.	`p+=2;`	Dòng 8:___________________________________________________________________
9.	`*p=7; //a[4]=7`
10.	`p=new int(3);`
11.	`for (int i=0; i<5; i++)`
12.	`cout << a[i] << " ";`
13.	`return 0;`
14.	`}`

Sau khi thực hiện xong chương trình,kết quả in ra màn hình là:............

Hướng dẫn

Dòng	Chương trình	Giải thích ý nghĩa câu lệnh
1.	`#include <iostream>`
2.	`using namespace std;`
3.	`int main() {`
4.	`int a[5]={1,2,3,4,5};`
5.	`int *p=a;`	Dòng 5: Tạo một con trỏ kiểu `int` gán địa chỉ của mảng `a`, lúc này `p` đang trỏ vào phần tử `a[0]`.
6.	`p=&a[2];`	Dòng 6: Gán địa chỉ của phần tử `a[2]` cho con trỏ `p`. `p` lưu địa chỉ của vùng nhớ của phần tử a[2] có giá trị là 3.
7.	`p[-2]=4; //a[0]=4`	Dòng 7: `p` đang trỏ vào `a[2]`, nên lùi 2 đơn vị (`-2`) chính là trỏ đến `a[0]` và gán giá trị 4 cho `a[0]`.
8.	`p+=2;`	Dòng 8: Vì `p` đang ở `a[2]` nên sau khi cộng thêm 2 đơn vị, `p` sẽ trỏ đến phần tử `a[4]`.
9.	`*p=7; //a[4]=7`
10.	`p=new int(3);`
11.	`for (int i=0; i<5; i++)`
12.	`cout << a[i] << " ";`
13.	`return 0;`
14.	`}`

Kết quả thực hiện chương trình:

Sau khi thực hiện các phép gán thông qua con trỏ:

a[0] thay đổi từ 1 thành 4.
a[4] thay đổi từ 5 thành 7.
Các phần tử a[1], a[2], a[3] giữ nguyên giá trị 4.

Kết quả in ra màn hình là: 4 2 3 4 7

Câu 15.

Điền vào các vị trí trống để hoàn chỉnh một chương trình cho phép nhập một đa giác (DAGIAC) có n điểm (DIEM), với $3 \le n \le 10$ . Chương trình yêu cầu người dùng nhập số điểm của đa giác, sau đó nhập tọa độ của từng điểm. Chú ý, không cần kiểm tra tính hợp lệ của đa giác và phải tận dụng được hàm nhập một điểm (NhapMotDiem) trong hàm nhập một đa giác (NhapMotDaGiac).

#include <`iostream`>   
using namespace std;    
struct DIEM {  
int x, y;  
};    
struct DAGIAC {   

    int n;
    DIEM *p;
};
 
void NhapMotDiem(______________________) {

    cin >> A.x >> A.y;
}
  
______________ NhapMotDaGiac(_____________) {

    //có gọi đến hàm NhapMotDiem   
    ___________________________________
    ___________________________________
    ___________________________________
    ___________________________________
    ___________________________________
    ___________________________________
    ___________________________________
    ___________________________________
}   

Lưu ý: Có hàm main

int main() {

    DAGIAC B;
    B = NhapMotDaGiac();
    return 0;
}

Hướng dẫn

#include <iostream>
using namespace std;

struct DIEM {
    int x, y;
};

struct DAGIAC {
    int n;
    DIEM *p;
};

// Hàm nhập tọa độ cho một điểm
void NhapMotDiem(DIEM &A) {
    cin >> A.x >> A.y;
}

// Hàm nhập thông tin cho một đa giác
DAGIAC NhapMotDaGiac() {
    DAGIAC dg;
    
    // Nhập số lượng điểm n
    cin >> dg.n;
    
    // Cấp phát động mảng các điểm dựa trên n
    dg.p = new DIEM[dg.n];
    
    // Duyệt qua từng điểm và gọi hàm NhapMotDiem
    for (int i = 0; i < dg.n; i++) {
        NhapMotDiem(dg.p[i]);
    }
    
    return dg;
}

int main() {
    DAGIAC B;
    B = NhapMotDaGiac();
    
    // Xử lý đa giác

    return 0;
}

Câu 16.

Cho một bài toán như sau:

Input: Một số nguyên dương $n$ với $1 \le n \le 1 \text{ tỷ}$ .

Output: Số lượng hình chữ nhật có diện tích nhỏ hơn $n$ mà cả chiều dài, chiều rộng và đường chéo đều là số nguyên dương? (Một hình chữ nhật có thể xoay ngang hay dọc tùy ý, tức là hình chữ nhật với kích thước $4 \times 3$ cũng chính là hình chữ nhật với kích thước $3 \times 4$ , chúng ta chỉ đếm một hình).

a. Cho một ví dụ với bài toán trên.

Input:___________________________________
Output:__________________________________

Giải thích vì sao có kết quả như vậy? (Tức là cho biết chiều dài, chiều rộng, đường chéo và diện tích của các hình chữ nhật thỏa điều kiện)

b. Tìm một input mà có output là 3 và giải thích vì sao có kết quả như vậy?

Hướng dẫn

a. Cho một ví dụ với bài toán trên.

Input: $13$
Output: $1$

Giải thích vì sao có kết quả như vậy? (Tức là cho biết chiều dài, chiều rộng, đường chéo và diện tích của các hình chữ nhật thỏa điều kiện)

Bộ ba chiều dài, chiều rộng và đường chéo là (3, 4, 5). Cả 3 số này đều là số nguyên dương.

Diện tích $S = 3 \times 4 = 12 < 13$ .

b. Tìm một input mà có output là 3 và giải thích vì sao có kết quả như vậy?

Chọn Input $n = 61$

Giải thích: Vì với $n = 61$ , có đúng 3 hình chữ nhật có diện tích nhỏ hơn 61 và đường chéo là số nguyên (các bộ ba số Pitago) thỏa mãn:

Hình 1: Kích thước $3 \times 4$ (Diện tích $S = 12 < 61$ , đường chéo $5$ ).
Hình 2: Kích thước $6 \times 8$ (Diện tích $S = 48 < 61$ , đường chéo $10$ ).
Hình 3: Kích thước $5 \times 12$ (Diện tích $S = 60 < 61$ , đường chéo $13$ ).

Cả 3 hình này đều có chiều dài, chiều rộng, đường chéo là số nguyên dương và diện tích bé hơn 61.

Câu 1.​

Lời giải:​

Giải thích:​

Câu 2:​

Lời giải:​

Giải thích:​

Câu 3.​

Lời giải:​

Giải thích:​

Câu 4.​

Lời giải:​

Giải thích:​

Câu 5.​

Lời giải:​

Giải thích:​

Câu 6.​

Lời giải:​

Giải thích:​

Câu 7.​

Lời giải:​

Giải thích:​

Câu 8.​

Lời giải:​

Giải thích:​

Câu 9.​

Lời giải: 1 1 1 0​

Giải thích:​

Câu 10.​

Hướng dẫn​

Giải thích:​

Câu 11.​

Lời giải:​

Giải thích:​

Câu 12.​

Lời giải:​

Giải thích:​

Câu 13.​

Hướng dẫn​

Câu 14.​

Hướng dẫn​

Kết quả thực hiện chương trình:​

Câu 15.​

Hướng dẫn​

Câu 16.​

Hướng dẫn​

b. Tìm một input mà có output là 3 và giải thích vì sao có kết quả như vậy?​

Câu 1.

Lời giải:

Giải thích:

Câu 2:

Lời giải:

Giải thích:

Câu 3.

Lời giải:

Giải thích:

Câu 4.

Lời giải:

Giải thích:

Câu 5.

Lời giải:

Giải thích:

Câu 6.

Lời giải:

Giải thích:

Câu 7.

Lời giải:

Giải thích:

Câu 8.

Lời giải:

Giải thích:

Câu 9.

Lời giải: 1 1 1 0

Giải thích:

Câu 10.

Hướng dẫn

Giải thích:

Câu 11.

Lời giải:

Giải thích:

Câu 12.

Lời giải:

Giải thích:

Câu 13.

Hướng dẫn

Câu 14.

Hướng dẫn

Kết quả thực hiện chương trình:

Câu 15.

Hướng dẫn

Câu 16.

Hướng dẫn

b. Tìm một input mà có output là 3 và giải thích vì sao có kết quả như vậy?