Bài toán yêu cầu chúng ta viết một hàm để giải phương trình bậc nhất có dạng \( ax + b = 0 \) (với \( a \) khác 0), sau đó sử dụng hàm này để tìm nghiệm và in ra màn hình với 2 chữ số thập phân.

1. Phân tích bài toán

Phương trình bậc nhất có dạng tổng quát là \( ax + b = 0 \).

Mục tiêu của chúng ta là tìm giá trị của \( x \).

Từ phương trình, chúng ta có thể biến đổi như sau:

\[ ax = -b \]

Và vì đề bài cho biết \( a \neq 0 \), nên chúng ta có thể chia cả hai vế cho \( a \):

\[ x = \frac{-b}{a} \]

Công thức này sẽ là nền tảng để chúng ta viết hàm.

Chúng ta cần một “hàm” (function) để thực hiện việc này. Hàm sẽ nhận vào hai số nguyên \( a \) và \( b \) (là các hệ số của phương trình) và trả về giá trị \( x \) là nghiệm của phương trình. Vì \( x \) có thể là số thập phân, nên kiểu dữ liệu trả về của hàm sẽ là số thực (ví dụ: \(double\)).

Sau khi có kết quả, chúng ta cần in ra màn hình và làm tròn tới 2 chữ số thập phân.

2. Hướng dẫn giải chi tiết từng bước

Bước 1: Khai báo các thư viện cần thiết
Chúng ta cần thư viện \(iostream\) để thực hiện các thao tác nhập và xuất dữ liệu (đọc \(a, b\) từ bàn phím và in nghiệm ra màn hình).

Ngoài ra, để định dạng số thập phân thành 2 chữ số, chúng ta cần thư viện \(iomanip\).

#include <iostream> // Để sử dụng cin, cout
#include <iomanip>  // Để sử dụng setprecision và fixed

Bước 2: Định nghĩa hàm giải phương trình bậc nhất
Hàm này sẽ có tên là \(giaiPhuongTrinhBacNhat\) (tên tự đặt, có ý nghĩa là được).

– Tham số đầu vào: Hàm cần nhận vào hai số nguyên \(a\) và \(b\). Kiểu dữ liệu là \(int\).
– Kiểu dữ liệu trả về: Nghiệm \(x\) có thể là số thập phân, nên chúng ta sẽ trả về kiểu \(double\) (kiểu số thực với độ chính xác cao).
– Thân hàm: Chứa công thức tính nghiệm \( x = \frac{-b}{a} \).

double giaiPhuongTrinhBacNhat(int a, int b) {
    // Tính nghiệm theo công thức x = -b / a
    // Chú ý: để phép chia ra kết quả số thực,
    // chúng ta cần ép kiểu một trong hai toán hạng về double.
    // Nếu không, (-b)/a sẽ là phép chia số nguyên và có thể bị mất phần thập phân.
    return (double)-b / a;
}

Giải thích thêm về \((double)-b / a;\):
Nếu chúng ta viết \(return -b / a;\) thì máy tính sẽ thực hiện phép chia hai số nguyên (\(int\) chia \(int\)). Ví dụ, nếu \(b = 5\), \(a = 2\), thì \(-5 / 2\) sẽ cho kết quả là \(-2\) (phép chia số nguyên bỏ đi phần dư), trong khi nghiệm đúng phải là \(-2.5\).

Để đảm bảo phép chia cho ra kết quả số thực, chúng ta ép kiểu một trong hai toán hạng (ở đây là \(-b\)) thành \(double\) bằng cách viết \((double)-b\). Khi đó, phép chia sẽ là \(double\) chia \(int\), và kết quả sẽ là \(double\), giữ lại phần thập phân.

Bước 3: Viết hàm main() – chương trình chính
Trong hàm \(main()\), chúng ta sẽ:

– Khai báo hai biến số nguyên \(a\) và \(b\).
– Đọc giá trị của \(a\) và \(b\) từ bàn phím.
– Gọi hàm \(giaiPhuongTrinhBacNhat\) với \(a\) và \(b\) đã nhập, sau đó lưu kết quả vào một biến kiểu \(double\).
– In kết quả ra màn hình với định dạng 2 chữ số thập phân.

int main() {
    // Khai báo biến a và b để lưu hệ số của phương trình
    int a, b;

    // Đọc giá trị của a và b từ bàn phím
    // (a đã đảm bảo khác 0 theo đề bài)
    std::cin >> a >> b;

    // Gọi hàm giaiPhuongTrinhBacNhat để tìm nghiệm
    // và lưu kết quả vào biến 'nghiem'
    double nghiem = giaiPhuongTrinhBacNhat(a, b);

    // In nghiệm ra màn hình với 2 chữ số phần thập phân
    // std::fixed: Đảm bảo in ra số thập phân theo kiểu cố định (không dùng ký hiệu khoa học)
    // std::setprecision(2): Đặt độ chính xác là 2 chữ số sau dấu phẩy
    std::cout << std::fixed << std::setprecision(2) << nghiem << std::endl;

    // Trả về 0 để báo hiệu chương trình kết thúc thành công
    return 0;
}

3. Mã nguồn hoàn chỉnh

Đây là toàn bộ mã nguồn của chương trình:

#include <iostream> // Thư viện cho nhập/xuất dữ liệu (cin, cout)
#include <iomanip>  // Thư viện để định dạng đầu ra số thực (setprecision, fixed)

// Hàm giải phương trình bậc nhất ax + b = 0
// Nhận vào hai số nguyên a, b
// Trả về nghiệm của phương trình (kiểu double để giữ phần thập phân)
double giaiPhuongTrinhBacNhat(int a, int b) {
    // Công thức tính nghiệm: x = -b / a
    // Chúng ta ép kiểu (-b) thành double để đảm bảo phép chia là phép chia số thực,
    // giữ lại được phần thập phân.
    return (double)-b / a;
}

int main() {
    // Khai báo hai biến số nguyên a và b để lưu hệ số
    int a, b;

    // Đọc hai số nguyên a và b từ bàn phím
    // Giả định a khác 0 theo yêu cầu đề bài
    std::cin >> a >> b;

    // Gọi hàm giaiPhuongTrinhBacNhat để tính nghiệm
    // và lưu kết quả vào biến 'nghiem' kiểu double
    double nghiem = giaiPhuongTrinhBacNhat(a, b);

    // In nghiệm ra màn hình với định dạng 2 chữ số thập phân
    // std::fixed: Buộc cout in ra số thập phân với một số lượng chữ số cố định
    // std::setprecision(2): Đặt số lượng chữ số sau dấu phẩy là 2
    std::cout << std::fixed << std::setprecision(2) << nghiem << std::endl;

    // Hàm main trả về 0 báo hiệu chương trình chạy thành công
    return 0;
}

4. Ví dụ chạy chương trình

Giả sử người dùng nhập:

Input

2 5

Chương trình sẽ làm như sau:

1. Đọc \(a = 2\), \(b = 5\).
2. Gọi hàm \(giaiPhuongTrinhBacNhat(2, 5)\).
3. Trong hàm, tính \((double)-5 / 2 = -2.5\).
4. Hàm trả về \(-2.5\). Biến \(nghiem\) trong \(main\) sẽ có giá trị \(-2.5\).
5. In \(nghiem\) ra màn hình với 2 chữ số thập phân.

Output

-2.50

Chúc các em học tốt môn Tin học và luôn tự tin giải quyết các bài toán lập trình nhé! Nếu có bất kỳ thắc mắc nào, đừng ngần ngại hỏi thầy cô nhé!