[C]. Ước Chung Lớn Nhất – Bội Chung Nhỏ Nhất

ucln bcnn

1. Thuật Toán Ngây Thơ

Bạn đang xem: [C]. Ước Chung Lớn Nhất – Bội Chung Nhỏ Nhất

Ước Chung Lớn Nhất (UCLN) của 2 số a, b là số lớn nhất mà 2 số a và b cùng chia hết

Thuật toán tự nhiên mà bạn dùng để tìm UCLN đó là duyệt từ số nhỏ hơn trong 2 số về tới 1, số nào mà cả a và b chia hết đầu tiên sẽ là UCLN

Chú ý rằng UCLN(a, 0) = a

Code :

#include “stdio.h” #include “math.h” int ucln(int a, int b){ if(a == 0 || b == 0){ return a + b; } int min = a = 1; i-){ if(a % i == 0 && b % i == 0){ return i; } } return 1; } int main(){ printf(“%d”, ucln(28, 20)); return 0; }

Bội Chung Nhỏ Nhất (BCNN) của 2 số a, b là số nhỏ nhất mà chia hết đồng thời cho cả a và b

Thuật toán tự nhiên mà bạn dùng để tìm BCNN đó là duyệt từ số lớn hơn trong 2 số và tăng dần cho tới khi gặp số đầu tiên chia hết cho cả a và b.

Code :

#include “stdio.h” #include “math.h” int bcnn(int a, int b){ int max = a > b ? a : b; int kq = max; while(1){ if(max % a == 0 && max % b == 0){ kq = max; break; } ++max; } return kq; } int main(){ printf(“%d”, bcnn(28, 20)); return 0; }

2. Thuật Toán Euclid

Thuật toán Euclid phát biểu như sau : UCLN của hai số nguyên không thay đổi khi thay số lớn hơn bằng hiệu của nó với số nhỏ hơn

Quá trình thay thế này được lặp đi lặp lại cho tới khi 2 số bằng nhau, khi đó UCLN chính là 1 trong 2 số.

Ví dụ

UCLN(20, 15) = UCLN (15, 5) = UCLN(5, 10) = UCLN(5, 5) => UCLN(20, 15) = 5

UCLN(16, 10) = UCLN(10, 6) = UCLN(6, 4) = UCLN(4, 2) = UCLN(2, 2) => UCLN(16, 10) = 2

Code :

#include “stdio.h” #include “math.h” int ucln(int a, int b){ //neu a hoac b = 0 thi ucln la so con lai if(a == 0 || b == 0){ return a + b; } while(a != b){ if(a > b){ a = a – b; //Thay thế số lớn hơn bằng hiệu 2 số } else{ b = b – a; //Thay thế số lớn hơn bằng hiệu 2 số } } return a; // b } int main(){ printf(“%d”, ucln(28, 20)); return 0; }

Output :

4

Giải thích :

1. a = 28, b = 20, a != b vòng lặp lặp lần 1 : vì a > b nên a = a – b = 28 – 20 = 8
2. a = 8, b = 20, a != b vòng lặp lặp lần 2 : vì b > a nên b = b – a = 20 – 8 = 12
3. a = 8, b = 12, a != b vòng lặp lặp lần 3 : vì b > a nên b = b – a = 12 – 8 = 4
4. a = 8, b = 4, a != b vòng lặp lặp lần 3 : vì a > b nên a = a – b = 8 – 4 = 4
5. a = 4, b = 4, a == b => Vòng lặp kết thúc và hàm trả về 4

Để tìm BCNN bạn có thể dựa vào kiến thức : BCNN(a, b) = a * b / UCLN(a, b).

Ví dụ BCNN(28, 20) = 28 * 20 / UCLN(28, 20) = 560 / 4 = 140

Code :

#include “stdio.h” #include “math.h” int ucln(int a, int b){ //neu a hoac b = 0 thi ucln la so con lai if(a == 0 || b == 0){ return a + b; } while(a != b){ if(a > b){ a = a – b; //Thay thế số lớn hơn bằng hiệu 2 số } else{ b = b – a; //Thay thế số lớn hơn bằng hiệu 2 số } } return a; // b } int bcnn(int a, int b){ return a * b / ucln(a, b); // a / ucln(a, b) * b } int main(){ printf(“%d”, bcnn(28, 20)); return 0; }

Output :

140

3. Cải Tiến Thuật Toán Euclid

Xem thêm : 10 điều cần biết khi tắm cho trẻ sơ sinh

Trong mục 2 khi a và b cách xa nhau thì thuật toán Euclid hoạt động không hiệu quả, ví dụ bạn tìm ULCN(1000000000, 1) thì thuật toán cần lặp 999999999 lần.

Ta cải tiến thuật toán Euclid bằng nhận xét sau : UCLN của hai số nguyên không thay đổi khi thay 1 trong 2 số thành số dư của nó với số còn lại. Có nghĩa là UCLN(a, b) = UCLN(b, a % b)

Quá trình thay thế này được lặp đi lặp lại cho tới khi 1 trong 2 số bằng 0, khi đó UCLN chính là số còn lại

Ví dụ

UCLN(20, 15) = UCLN(15, 20 % 15) = UCLN(15, 5) = UCLN(5, 15 % 5) = UCLN(5, 0) => UCLN(20, 15) = 5

UCLN(16, 28) = UCLN(28, 16 % 28) = UCLN(28, 16) = UCLN(16, 28 % 16) = UCLN(16, 12) = UCLN(12, 16 % 12) = UCLN(12, 4) = UCLN(4, 12 % 4) = UCLN(4, 0) => UCLN(16, 28) = 4

UCLN(1000000000, 1) = UCLN(1, 1000000000 % 1) = UCLN(1, 0) = 1 => UCLN(1000000000, 1) = 1 (Bạn chỉ cần 1 vòng lặp thay vì 999999999)

Code :

#include “stdio.h” #include “math.h” int ucln(int a, int b){ while(b != 0){ int r = a % b; a = b; b = r; } return a; } int main(){ printf(“%d”, ucln(28, 20)); return 0; }

Giải thích :

1. a = 28, b = 20, b != 0 nên vòng lặp lặp lần 1 : r = a % b = 8, a = b = 20, b = r = 8
2. a = 20, b = 8, b != 0 nên vòng lặp lặp lần 2 : r = a % b = 4, a = b = 8, b = r = 4
3. a = 8, b = 4, b != 0 nên vòng lặp lặp lần 3 : r = a % b = 0, a = b = 4, b = r = 0
4. a = 4, b = 0, b == 0 nên vòng lặp dừng, hàm trả về a = 4

Cải tiến này giúp bạn có thể code hàm tìm UCLN nhanh hơn rất nhiều so với thuật toán Euclid ban đầu từ đó thuật toán tìm BCNN cũng hiệu quả hơn.

Nó giúp code của bạn chỉ tốn số bước nhiều nhất là năm lần số chữ số của số nhỏ hơn, điều này được Gabriel Lamé chứng minh vào năm 1844.

Bổ sung kiến thức : 2 số đồng nguyên tố hay nguyên tố cùng nhau là 2 số có UCLN là 1, vì dụ (5, 12) là nguyên tố cùng nhau

Xem thêm bài giảng của mình về UCLN, BCNN :

aw0c4kJpoEU

Nguồn: https://luatduonggia.edu.vn
Danh mục: Tổng hợp