Thứ Tư, 28 Tháng Chín 2022
Trang chủLập trìnhLập trình C/C++Cộng trừ nhân chia hai phân số trong lập trình C sử...

Cộng trừ nhân chia hai phân số trong lập trình C sử dụng Struct 

Bài toán cộng trừ nhân chia 2 phân số trong lập trình là một bài tập khá cơ bản, tuy nhiên độ hiệu quả mà nó mang lại là rất cao cho những bạn mới bắt đầu làm quen với lập trình. Khi làm bài tập này sẽ giúp các bạn có thể nắm rõ hơn về các hoạt động logic của lập trình, cũng như tăng một chút khả năng tư duy thuật toán. Khi bạn có thể tự hoàn thành bài toán này mà không cần bất kì sự trợ giúp nào, hay đọc lại code của người khác để code lại nữa thì kiến thức cơ bản lập trình bạn đã tương đối ổn rồi đó.

Và trong bài viết này mình sẽ cùng các bạn một lần nữa làm bài toán này với Struct trong C nhé. Đối với bài viết này chúng ta vừa có thể ôn và củng cố kiến thức cơ bản nhất cũng như củng cố và ôn lại phần struct, cùng bắt đầu nào.

Phân số trong C với Struct

Định nghĩa struct phân số

Ta sẽ định nghĩa struct cho phân số như sau.

typedef struct PhanSo{
	int tu; //Tử số
	int mau;  //Mẫu số
};

Một phân số sẽ gồm 2 phần là tử số và mẫu số, khi định nghĩa struct Phân số cũng sẽ gồm 2 biến tử và mẫu số.

Như vậy ta đã đã hoàn thành bước định nghĩa phân số, bây giờ chúng ta sẽ viết hàm nhập xuất phân số.

Viết hàm nhập xuất phân số

Viết hàm nhập

void nhap(PhanSo &A){
	printf("Nhap tu: ");
	scanf("%d",  &A.tu); //A.tu để gọi tử
	printf("Nhap mau: ");
	scanf("%d",  &A.mau); //A.mau để gọi mẫu
}

Với hai hàm nhập và xuất thì cũng tương đối đơn giản, ta truyền một biến, ở đây là biến A kiểu dữ liệu là PhanSo đã được định nghĩa bên trên. Để gọi tới tử hoặc mẫu số của PhanSo, ta sẽ sử dụng A.tu hoặc A.mau và thực hiện nhập xuất như bình thường.

Viết hàm xuất

Khi đã có hàm nhập rồi ta sẽ viết hàm xuất ra một phân số như sau.

void xuat(PhanSo A){
	printf("%d/%d",  A.tu,  A.mau);
}

Tại sao ở bên trên hàm nhập khi truyền dữ liệu vào hàm ta lại sử dụng &A, mà bên dưới hàm xuất mình chỉ truyền vào là A. Nếu bạn còn thắc mắc thì kiến thức cơ bản về tham chiếu, tham trị bạn chưa nắm vững. Cần thăm khảo ngay bài viết này nhé: Tham biến và Tham trị trong ngôn ngữ lập trình C.

Viết hàm rút gọn phân số

Rút gọn phân số là ta đưa phân số về mức tối giản nhất bằng cách chia cả tử và mẫu cho một số nào đó cho tới khi chúng không thể cùng chia cho một số khác 1. Đơn giản nhất là ta sẽ chia cho giá trị tuyệt đối của UCLN của tử và mẫu.

Ta có hàm tìm UCLN của 2 số là int __gcd(int a, int b) trong thư viện algorithm. Hoặc ta có thể tự viết lại hàm __gcd như sau.

//Đệ quy tìm UCLN
int __gcd(int a, int b){
    if(b==0) return a;
    return __gcd(b, a%b);
}

Mình có hản một bài viết riêng về tìm ƯCLN và BCNN, nếu bạn không hiểu hàm trên thì xem thêm nhé: Cách tìm UCLN và BCNN trong lập trình C/C++.

Và tương tự ta cũng viết, ta cũng có hàm int abs(int a, int b) trong algorithm để lấy giá tri tuyệt đối của một số. Và mình cũng hoàn toàn có thể viết lại hàm như sau.

int abs(int a){
    return a > 0 ? a : -a; // if(a>0) return a;else return -a;
}

Như vậy bây giờ ta sẽ xây dựng code cho hàm Rút gọn phân số như sau.

	
void rutGon(PhanSo &A){
	int usc = abs(__gcd(A.tu, A.mau)); //Tìm giá trị tuyệt đối UCLN
	
	A.tu = A.tu/usc;  //tính tử bằng cách lấy tử chua UCLN
	A.mau = A.mau/usc;  //tính tử bằng cách lấy tử chua UCLN
}

Viết hàm Quy đồng hai phân số

Lý thuyết về quy đồng phân số thì chắc mình không cần nhắc lại. Vậy mình sẽ viết hàm quy đồng như sau:

void quyDong(PhanSo &A, PhanSo &B){
//Tử của phân số này tính bằng cách nhân tử với mẫu phân số kia
	A.tu = A.tu * B.mau;
	B.tu =  B.tu * A.mau;
	
//Lấy mẫu 2 phân số nhân với nhau sau đó  B.mau sẽ được gắn bằng kq đó, rồi A.mau được gắn  = B.mau
	A.mau = B.mau = B.mau * A.mau;
}

Viết hàm Cộng hai phân số

Với các hàm cộng trừ nhân chia phân số thì mình sẽ có kiểu dữ liệu hàm là PhanSo sau khi có kết quả mình sẽ return về kết quả cho hàm.

Để cộng hai phân số ta sẽ cần quy đồng 2 phân số để 2 phân số có cùng mẫu, sau đó lấy 2 tử số cộng với nhau và lấy mẫu số của 1 trong 2 phân số đó ta được kết quả.

PhanSo congPhanSo(PhanSo &A, PhanSo &B){
	quyDong(A,B); //Để công 2 phân số ta cần quy đồng 2 phân số về chung mẫu
	
	PhanSo tong; //Khai báo biến tong
	tong.tu = A.tu + B.tu; //Cộng tử vơi nhau
	tong.mau = A.mau; //Mẫu lấy 1 trong 2
	
	return tong; //Trả kq cho hàm tính tổng
}

Viết hàm Trừ hai phân số

Để cộng trừphân số ta sẽ cần quy đồng 2 phân số để 2 phân số có cùng mẫu, sau đó lấy tử số phân số thứ nhất trừ đi tử số phân số thứ 2, và lấy mẫu số của 1 trong 2 phân số đó ta được kết quả.

PhanSo truPhanSo(PhanSo &A, PhanSo &B){
	quyDong(A,B); /Để trừ 2 phân số ta cần quy đồng 2 phân số về chung mẫu
	
	PhanSo hieu;
	hieu.tu = A.tu - B.tu; //Trư tử số phân số thứ nhất cho phân số thứ 2
	hieu.mau = A.mau; //Mẫu số lấy  1 trong hai mẫu số
	
	return hieu; //Trả kq cho hàm 
}

Viết hàm Nhân hai phân số

Để nhân 2 phân số ta đơn giản nhân 2 tử số và 2 mẫu số với nhau ta sẽ được kết quả.

PhanSo nhanPhanSo(PhanSo &A, PhanSo &B){
	PhanSo tich;
	tich.tu = A.tu * B.tu; //Nhân tử số với nhau
	tich.mau = A.mau *  B.mau; //Nhân mẫu số với nhau
	
	return tich; //trả về kq cho hàm
}

Viết hàm Chia hai phân số

Để chia 2 phân số ta lấy phân số thứ nhất nhân nghịch đảo phân số thứ 2. Tức là lấy tử phân số thứ nhất nhân mẫu phân số thứ 2 được bao nhiêu thì là kết quả tử số, nhân mẫu số phân số thứ nhất nhân tử số phân số thứ hai ta được mẫu số của kết quả.

PhanSo chiaPhanSo(PhanSo &A, PhanSo &B){
	PhanSo thuong;
	thuong.tu = A.tu * B.mau; //Nhân tử với mẫu phân số  kia
	thuong.mau = A.mau *  B.tu;//Nhân mẫu với tử phân số kia
	
	return thuong; //Trả kq cho hàm
}

Chương trình minh họa hoàn chỉnh

Từ các ý trên mình có thể viết lại một chương trình minh họa hoàn chỉnh như bên dưới đây. Trước khi coppy chương trình này bạn hãy tự viết, nếu gặp lỗi chỗ nào thì mới nên thăm khảo chương trình mẫu này nhé.

Code mẫu

#include <stdio.h>
#include <algorithm>

//Định nghĩa struct phân số
typedef struct PhanSo{
	int tu;
	int mau; 
};

//Hàm nhập 1 phân số
void nhap(PhanSo &A){
	printf("Nhap tu: ");
	scanf("%d",  &A.tu);
	printf("Nhap mau: ");
	scanf("%d",  &A.mau);
}


//Hàm xuất ra 1 phân số
void xuat(PhanSo A){
	printf("%d/%d",  A.tu,  A.mau);
}

//Hàm tinh UCLN của 2 số
int __gcd(int a, int b){
    if(b==0) return a;
    return __gcd(b, a%b);
}

//Hàm lấy giá trị tuyệt đối của một số
int abs(int a){
    return a > 0 ? a : -a;
}
	
//Hàm rút gọn phân số
PhanSo rutGon(PhanSo &A){
	int usc = abs(__gcd(A.tu, A.mau));
	
	A.tu = A.tu/usc;
	A.mau = A.mau/usc;
}

//Hàm quy đồng 2 phân số
void quyDong(PhanSo &A, PhanSo &B){
	rutGon(A);
	rutGon(B);
	
	A.tu = A.tu * B.mau;
	B.tu =  B.tu * A.mau;
	
	A.mau = B.mau = B.mau * A.mau;
}


//Hàm tính tổng 2 phân số
PhanSo congPhanSo(PhanSo &A, PhanSo &B){
	quyDong(A,B);
	
	PhanSo tong;
	tong.tu = A.tu + B.tu;
	tong.mau = A.mau;
	
	return tong;
}

//Hàm trừ 2 phân số
PhanSo truPhanSo(PhanSo &A, PhanSo &B){
	quyDong(A,B);
	
	PhanSo hieu;
	hieu.tu = A.tu - B.tu;
	hieu.mau = A.mau;
	
	return hieu;
}

//Hàm nhân 2 phân số
PhanSo nhanPhanSo(PhanSo &A, PhanSo &B){
	quyDong(A,B);
	
	PhanSo tich;
	tich.tu = A.tu * B.tu;
	tich.mau = A.mau *  B.mau;
	
	return tich;
}


//Hàm chia 2 phân số
PhanSo chiaPhanSo(PhanSo &A, PhanSo &B){
	quyDong(A,B);
	
	PhanSo thuong;
	thuong.tu = A.tu * B.mau;
	thuong.mau = A.mau *  B.tu;
	
	return thuong;
}

int main()
{
	PhanSo A;
	PhanSo B;
	
	printf("Nhap phan so A\n ");
	nhap(A);
	printf("Nhap phan so B\n");
	nhap(B);
	
	printf("\n-------------XUAT---------------\n");
	printf("Phan so A: ");
	xuat(A);
	printf("\nPhan so B: ");
	xuat(B);
	
	printf("\n\n-------------RUT GON---------------\n");
	printf("Phan so A: ");
	rutGon(A);
	xuat(A);
	
	printf("\nPhan so B: ");
	rutGon(B);
	xuat(B);
	
	printf("\n\n------------QUY DONG---------------\n");
	quyDong(A,B);
	
	printf("Phan so A: ");
	xuat(A);
	printf("\nPhan so B: ");
	xuat(B);
	
	printf("\n\n------------CONG TRU NHAN CHIA---------------\n");
	PhanSo tong = congPhanSo(A,B);
	PhanSo hieu = truPhanSo(A,B);
	PhanSo tich = nhanPhanSo(A,B);
	PhanSo thuong = chiaPhanSo(A,B);
	
	printf("\nTong A + B: "); xuat(tong);
	printf("\nTong A - B: "); xuat(hieu);
	printf("\nTong A * B: "); xuat(tich);
	printf("\nTong A / B: "); xuat(thuong);
	
	return 0;
}

Và đấy là kết quả khi chạy chương trình trên.

Kết quả thực thi chương trình

Cảm ơn bạn đã đọc hết bài viết! CHúc BạN họC tHật TốT nhÉ!!!

[ĐỌC TẤT CẢ BÀI VIẾT VỀ C/C++ TẠI ĐÂY]

0 0 Phiếu bình chọn
Xếp hạng bài viết
BÀI VIẾT LIÊN QUAN
Đăng ký nhận thông báo
Thông báo email khi
guest
0 Bình luận
Không thể gửi email
Phản hồi nội tuyến

NÊN ĐỌC THÊM

Bạn muốn tìm kiếm gì?


0
Giáo sư! có thể ném gạch bên dưới nhé!x
()
x