Trong hướng dẫn này, chúng tôi sẽ thảo luận về cách chúng tôi có thể có được yếu tố chính của số đã cho bằng chương trình Python. Tất cả chúng ta quen thuộc với các số nguyên tố, nếu không thì các số nguyên tố là số có thể được chia cho một hoặc chính nó. Ví dụ - 1, 2, 3, 5, 7, 11, 13,
Tìm tất cả các yếu tố chính của một số
Nếu người dùng nhập số là 12, thì đầu ra phải là '2, 2, 3 và nếu đầu vào là 315; Đầu ra phải là "3 3 5 7". Chương trình phải trả về tất cả các yếu tố chính của số đã cho. Các yếu tố chính của 330 là 2, 3, 5 và 11. Do đó, 11 là yếu tố chính đáng kể nhất là 330.
Ví dụ: 330 = 2 × 3 × 5 × 11.
Trước khi viết chương trình Python, hãy hiểu những phỏng đoán sau đây.
- Phán đề 1 - Có thể có một yếu tố chính ở mức độ chính sẽ nhỏ hơn √n trong trường hợp N không phải là số nguyên tố. - There can be at-least one prime factor that would be less than √n in case of n is not a prime number.
Bằng chứng -Có hai số sqrt [n] lớn hơn, thì sản phẩm của họ cũng sẽ phân chia n nhưng sẽ vượt quá N, mâu thuẫn với giả định của chúng tôi. Vì vậy, không thể có nhiều hơn một yếu tố chính của N lớn hơn SQRT [N].There are two greater sqrt[n] numbers, then their product should also divide n but which will exceed n, which contradicts our assumption. So there can NOT be more than one prime factor of n greater than sqrt[n].
Hãy xem bước sau đây để thực hiện một hoạt động như vậy.
- Phục giả thứ 2 - Có thể có hệ số 1 chính của N lớn hơn SQRT [N]. There can be AT-MOST 1 prime factor of n greater than sqrt[n].
Bằng chứng - Giả sử có hai số sqrt [n] lớn hơn thì sản phẩm của họ cũng sẽ phân chia n nhưng sẽ vượt quá n, mâu thuẫn với giả định của chúng tôi. Vì vậy, không thể có nhiều hơn 1 hệ số nguyên tố N lớn hơn SQRT [N]. Suppose there are two greater sqrt[n] number then their product should also divide n but which will exceed n, which contradicts our assumption. So there can NOT be more than 1 prime factor of n greater than sqrt[n].
Hãy xem bước sau đây để thực hiện thao tác như vậy.
Ví dụ - Chương trình Python để in các yếu tố chính
Output:
Giải trình -
Trong mã trên, chúng tôi đã nhập mô -đun toán học. Hàm Prime_factor [] chịu trách nhiệm in số tổng hợp. Đầu tiên, chúng tôi nhận được những con số chẵn; Sau này, tất cả các yếu tố chính còn lại phải là lẻ. Trong vòng lặp, num phải kỳ lạ, vì vậy chúng tôi tăng lên hai. A for Loop sẽ chạy căn bậc hai của n lần.prime_factor[] function is responsible for printing the composite number. First, we get the even numbers; after this, all remaining prime factors must be odd. In for loop, the num must be odd, so we incremented i by two. A for loop will run the square root of n times.
Hãy hiểu thuộc tính sau của số tổng hợp.
Mỗi số tổng hợp có ít nhất một yếu tố nguyên tố nhỏ hơn hoặc bằng căn bậc hai.
Chương trình sẽ hoạt động như sau.
- Trong bước đầu tiên, tìm yếu tố chính nhất i.
- Sự xuất hiện của tôi sẽ được loại bỏ khỏi N bằng cách chia liên tục n cho i.
- Lặp lại các bước trên để chia n và i = i + 2. Cả hai bước sẽ lặp đi lặp lại cho đến khi n trở thành 1 hoặc số nguyên tố.
Hãy hiểu một ví dụ khác nơi chúng ta tìm thấy yếu tố chính lớn nhất của một số nhất định.
Ví dụ - 2 Chương trình Python để tìm hệ số chính lớn nhất của một số nhất định.
Output:
Cho một số N, viết một chức năng hiệu quả để in tất cả các yếu tố chính của n. Ví dụ: nếu số đầu vào là 12, thì đầu ra phải là 2 2 2 3. Và nếu số đầu vào là 315, thì đầu ra phải là 3 3 5 7 7.n, write an efficient function to print all prime factors of n. For example, if the input number is 12, then the output should be “2 2 3”. And if the input number is 315, then the output should be “3 3 5 7”.
Cách tiếp cận đầu tiên:
Sau đây là các bước để tìm tất cả các yếu tố chính. & Nbsp; 1] trong khi n chia hết cho 2, in 2 và chia n cho 2. & nbsp; 2] Sau bước 1, n phải là lẻ. Bây giờ bắt đầu một vòng từ I = 3 đến căn bậc hai của n. Trong khi tôi chia n, in i và chia n cho i. Sau khi tôi không chia n, tăng i cho 2 và tiếp tục. & Nbsp; 3] Nếu n là số nguyên tố và lớn hơn 2, thì n sẽ không trở thành 1 trong hai bước trên. Vì vậy, in n nếu nó lớn hơn 2. & nbsp;
1]
While n is divisible by 2, print 2 and divide n by 2.
2] After step 1, n must be odd. Now start a loop from i = 3 to the square root of n. While i divides n, print i, and divide n by i. After i fails to divide n, increment i by 2 and continue.
3] If n is a prime number and is greater than 2, then n will not become 1 by the above two steps. So print n if it is greater than 2.
C++
#include
using
namespace
std;
void
primeFactors[
int
n]
{
#include
0____11 #include
2
#include
0{
#include
5#include
6#include
7#include
8
#include
5using
0
#include
0using
2
____10using
4 using
5int
using
7using
8using
9
#include
0{
#include
5#include
1 namespace
4
#include
5{
namespace
7namespace
8#include
7#include
8
namespace
7std;
2
#include
5using
2
#include
0using
2
#include
0std;
8 std;
9
#include
5void
1#include
7#include
8
using
2
int
void
6
{
#include
0__ primeFactors[
0
#include
0primeFactors[
2
#include
0primeFactors[
4 primeFactors[
5
using
2
C
primeFactors[
7
primeFactors[
8
void
primeFactors[
int
n]
{
#include
0____11 #include
2
#include
0{
#include
5n]
0using
5n]
2n]
3
#include
5using
0
#include
0using
2
____10using
4 using
5int
using
7using
8using
9
#include
0{
#include
5#include
1 namespace
4
#include
5{
namespace
7n]
0using
5n]
2#include
06
namespace
7std;
2
#include
5using
2
#include
0using
2
#include
0std;
8 std;
9
int
void
6
using
2
int
void
6
{
#include
0__ primeFactors[
0
#include
0primeFactors[
2
#include
0primeFactors[
4 primeFactors[
5
using
2
C
#include
0____11 int
6
____10using
4 using
5int
using
7using
8{
4
#include
5#include
1 {
9
{
#include
5n]
0 using
5n]
2#include
20
#include
0{
Java
#include
5{
#include
34 #include
35
namespace
7#include
66#include
53#include
8
#include
5using
2
#include
34 #include
37
#include
38 #include
39
#include
0#include
42 #include
43 void
primeFactors[
int
n]
namespace
7{
#include
89#include
90#include
7#include
64
#include
89#include
94
namespace
7using
2
#include
5using
2
Is
namespace
7using
05
#include
0using
2
namespace
7#include
60#include
53 #include
62#include
7#include
64
#include
0{
#include
5using
4 using
5int
#include
75#include
76#include
777#include
53#include
56
#include
5primeFactors[
2
#include
0using
2
using
2
#include
5{
namespace
7#include
1 #include
84#include
55#include
56
#include
5std;
8 using
01#include
53#include
56
#include
0#include
42 #include
43 void
using
12
#include
5int
using
17using
18#include
8
Python
#include
34 using
26
using
27 using
28
namespace
7using
39 using
74
namespace
7using
31using
34 using
31using
46 using
67
____10std;
8 using
83#include
53using
37
#include
5using
39 using
88
using
31using
34 using
18
using
92
C#
using
using
94
namespace
using
96
{
#include
42 #include
38 #include
39
namespace
01
#include
0#include
42 #include
43 void
primeFactors[
int
n]
#include
0{
#include
5#include
1 #include
2
#include
5{
namespace
7namespace
17#include
7#include
64
namespace
7namespace
21
#include
5using
2
#include
5using
4 using
5int
namespace
28
#include
5{
namespace
7#include
1 namespace
4
namespace
7{
#include
89namespace
37#include
7#include
64
#include
89#include
94
namespace
7using
2
#include
5using
2
#include
5std;
8 std;
9
namespace
7namespace
50
#include
0using
2
____10#include
42 #include
43 void
namespace
57
#include
0{
#include
5int
primeFactors[
0
#include
5primeFactors[
2
#include
0using
2
using
2
using
2
PHP
namespace
69
namespace
70 primeFactors[
namespace
72#include
56
{
____10#include
1using
5namespace
72 namespace
79
#include
0{
#include
5namespace
83 namespace
84#include
7#include
8
#include
5namespace
72 namespace
89namespace
72 namespace
91
#include
0using
2
#include
0using
4 using
5namespace
97
std;
03namespace
97 namespace
89namespace
97 std;
07
#include
0{
#include
5#include
1 using
5namespace
72 std;
14namespace
97 std;
16
#include
5{
namespace
7namespace
83 namespace
97using
41#include
7#include
8
namespace
7namespace
72 namespace
89namespace
72 std;
29namespace
97#include
8
#include
5using
2
#include
0using
2
____10std;
8 using
5namespace
72 std;
40
#include
5namespace
83 namespace
72using
41#include
7#include
8
using
2
#include
0namespace
72 std;
50
#include
0primeFactors[
namespace
72#include
64
std;
55
JavaScript
std;
56
namespace
70 using
92
{
#include
0____11 #include
2
#include
0{
#include
5std;
66#include
7#include
64
#include
5std;
70
#include
0using
2
#include
0using
4std;
75
namespace
7std;
77
namespace
7std;
79
#include
0{
#include
5#include
1 namespace
4
#include
5{
namespace
7std;
88#include
7#include
64
namespace
7std;
92
#include
5using
2
#include
0using
2
#include
0std;
8 std;
9
#include
5void
01#include
7#include
64
using
2
void
05
primeFactors[
2
void
07
Output:
3 3 5 7
Độ phức tạp về thời gian: O [SQRT [N]]O[sqrt[n]]
Trong trường hợp xấu nhất [khi n hoặc sqrt [n] là số nguyên tố, ví dụ: lấy n = 11 hoặc n = 121 cho cả hai trường hợp cho vòng lặp chạy sqrt [n] lần] lần. Càng nhiều lần vòng lặp trong khi lặp lại trên một số mà nó làm giảm n ban đầu, điều này cũng làm giảm giá trị của sqrt [n]. Mặc dù độ phức tạp thời gian trường hợp tốt nhất là O [log [n]], khi các yếu tố chính của n chỉ là 2 và 3 hoặc n có dạng [2^x*[3^y] trong đó x> = 0 và y> = 0.
Không gian phụ trợ: O [1] O[1]
Điều này hoạt động như thế nào? & NBSP; Các bước 1 và 2 chăm sóc các số tổng hợp và bước 3 chăm sóc các số nguyên tố. Để chứng minh rằng thuật toán hoàn chỉnh hoạt động, chúng ta cần chứng minh rằng các bước 1 và 2 thực sự chăm sóc các số tổng hợp. Điều này rõ ràng là Bước 1 chăm sóc các số chẵn. Và sau bước 1, tất cả các yếu tố chính còn lại phải là lẻ [chênh lệch hai yếu tố chính phải ít nhất là 2], điều này giải thích lý do tại sao tôi được tăng lên bởi 2. & nbsp;
The steps 1 and 2 take care of composite numbers and step 3 takes care of prime numbers. To prove that the complete algorithm works, we need to prove that steps 1 and 2 actually take care of composite numbers. This is clear that step 1 takes care of even numbers. And after
step 1, all remaining prime factors must be odd [difference of two prime factors must be at least 2], this explains why i is incremented by 2.
Bây giờ phần chính là, vòng lặp chạy cho đến căn bậc hai của N cho đến khi n. Để chứng minh rằng tối ưu hóa này hoạt động, chúng ta hãy xem xét thuộc tính sau của số tổng hợp. & NBSP;
Mỗi số tổng hợp có ít nhất một yếu tố nguyên tố nhỏ hơn hoặc bằng với căn bậc hai của chính nó. & Nbsp; thuộc tính này có thể được chứng minh bằng cách sử dụng một câu lệnh truy cập. Đặt a và b là hai yếu tố của n sao cho a*b = n. Nếu cả hai đều lớn hơn √n, thì a.b> √n, * √n, điều này mâu thuẫn với biểu thức là A * b = n, & nbsp;
This property can be proved using
a counter statement. Let a and b be two factors of n such that a*b = n. If both are greater than √n, then a.b > √n, * √n, which contradicts the expression “a * b = n”.
Trong bước 2 của thuật toán trên, chúng tôi chạy một vòng lặp và thực hiện các mục sau trong vòng lặp & nbsp; a] Tìm yếu tố chính nhất i [phải nhỏ hơn √n,] & nbsp; b] loại bỏ tất cả các lần xuất hiện i khỏi bởi i. & nbsp; c] lặp lại các bước a và b cho chia n và i = i + 2. Các bước a và b được lặp lại cho đến khi n trở thành 1 hoặc số nguyên tố.
a] Find the least prime factor i [must be less than √n,]
b] Remove all occurrences i from n by repeatedly dividing n by i.
c] Repeat steps a and b for divided n and i = i + 2. The steps a and b are repeated till n
becomes either 1 or a prime number.
Cách tiếp cận thứ hai: Cách tiếp cận này tương tự như sàng của Eratosthenes.
Chúng ta có thể đạt được O [log n] cho tất cả các số tổng hợp bằng cách chia số liên tiếp của số đã cho bằng một số nguyên bắt đầu từ 2 đại diện cho hệ số hiện tại của số đó. Cách tiếp cận này hoạt động trên thực tế là tất cả các số tổng hợp đều có các yếu tố theo cặp không phải là 1 hoặc số như 6 = 3 x 2 và 9 = 3 x 3 trong khi đối với các số nguyên tố không có cặp nào khác ngoài 1 hoặc số.
Do đó, nếu chúng ta bắt đầu chia số cho số nguyên tố nhỏ nhất có thể [2] thì tất cả các bội số hoặc số tổng hợp của nó sẽ tự động được xóa trước khi chúng ta thực sự đạt đến số đó.
Ví dụ: Chúng ta có thể chia 12 cho 2 hai lần và loại bỏ các yếu tố đó từ 12 để nhận 3 do đó đảm bảo rằng tổng hợp số 4 [bội số 2] không xảy ra tại bất kỳ thời điểm nào sau này.
Tương tự, nếu chúng ta có một số lượng lớn không chia hết cho bất kỳ giá trị nào của C = 2 đến N-1 có nghĩa là nó là số nguyên tố như 13 [không chia hết từ 2 đến 12].
C++14
#include
using
namespace
std;
void
primeFactors[
int
n]
{
#include
0__ void
19
#include
0#include
1void
22
#include
0{
#include
5std;
8void
27
#include
5void
29#include
7#include
8
#include
5void
33
#include
5using
2
#include
5void
37 void
38
#include
0using
2
using
2
int
void
6
{
#include
0__ primeFactors[
0
#include
0primeFactors[
2
#include
0primeFactors[
4 primeFactors[
5
using
2
C
void
54
void
primeFactors[
int
n]
{
#include
0__ void
19
#include
5void
37 void
38
int
void
6
void
69n]
0using
5n]
2void
73
void
69void
75
#include
0using
2
#include
0void
37
void
69void
38
#include
0__ primeFactors[
0
using
2
int
void
6
{
#include
0__ primeFactors[
0
void
60primeFactors[
2
#include
0primeFactors[
4 primeFactors[
5
using
2
C
void
60int
void
62
void
60#include
1 void
65
#include
0std;
8 void
68
#include
0{
void
60using
2
void
60int
primeFactors[
0
void
60primeFactors[
4 primeFactors[
5
Java
#include
89void
75
namespace
7using
2
namespace
7void
37
#include
89void
38
#include
5using
2
#include
0using
2
#include
34 void
98
#include
0{
#include
38 primeFactors[
00
#include
5primeFactors[
2
#include
0using
2
using
2
C#
#include
0#include
42 #include
43 void
primeFactors[
int
n]
void
60#include
1 void
65
#include
0std;
8 void
68
#include
0{
void
60using
2
void
60int
primeFactors[
0
void
60primeFactors[
4 primeFactors[
5
#include
89primeFactors[
80#include
7#include
64
#include
89void
75
namespace
7using
2
namespace
7void
37
#include
89void
38
#include
5using
2
#include
0using
2
Java
#include
0{
#include
34 void
98
#include
5primeFactors[
2
#include
38 primeFactors[
00
#include
0using
2
using
2
Python3
#include
0#include
42 #include
43 void
primeFactors[
int
n]
#include
5int
primeFactors[
12#include
53#include
8
#include
0#include
1using
01using
59using
62
#include
5#include
1 using
01using
59primeFactors[
19
namespace
7using
39int
35using
34#include
7#include
56
namespace
7std;
8 primeFactors[
222#include
55primeFactors[
19
#include
5void
37using
37
#include
89primeFactors[
26#include
7#include
64
____10#include
42 #include
43 void
primeFactors[
45
using
92
#include
5int
using
17using
18#include
8
std;
56
using
using
94
{
#include
0int
63
#include
0#include
1int
66
#include
0{
#include
5std;
8int
71
namespace
7int
73#include
7#include
64
namespace
7void
75
#include
5using
2
#include
5void
37 void
38
#include
0using
2
using
2
void
05
primeFactors[
2
void
07
int
void
6This Approach is best for all composite numbers and achieves
O[log n] but is O[n] otherwise.
#include
0__ primeFactors[
0 O[1]
#include
0primeFactors[
4 primeFactors[
5
Prime Factorization using Sieve O[log n] for multiple queries
Thanks to Vishwas Garg for suggesting the above algorithm. Please write comments if you find anything incorrect, or you want to share more information about the topic
discussed above