Hướng dẫn python program to find the prime factors of a number - chương trình python để tìm các thừa số nguyên tố của một số

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 5using0

#include 0using2

____10using4 using5int using7using8using9

#include 0{

#include 5#include 1 namespace4

#include 5{

namespace7namespace8#include 7#include 8

namespace7std;2

#include 5using2

#include 0using2

#include 0std;8 std;9

#include 5void1#include 7#include 8

using2

int void6

{

#include 0__ primeFactors(0

#include 0primeFactors(2

#include 0primeFactors(4 primeFactors(5

using2

C

primeFactors(7

primeFactors(8

void primeFactors(int n)

{

#include 0____11 #include 2

#include 0{

#include 5n)0using5n)2n)3

#include 5using0

#include 0using2

____10using4 using5int using7using8using9

#include 0{

#include 5#include 1 namespace4

#include 5{

namespace7n)0using5n)2#include 06

namespace7std;2

#include 5using2

#include 0using2

#include 0std;8 std;9

int void6

using2

int void6

{

#include 0__ primeFactors(0

#include 0primeFactors(2

#include 0primeFactors(4 primeFactors(5

using2

C

#include 0____11 int6

____10using4 using5int using7using8{4

#include 5#include 1 {9

{

#include 5n)0 using5n)2#include 20

#include 0{

Java

#include 5{

#include 34 #include 35

namespace7#include 66#include 53#include 8

#include 5using2

#include 34 #include 37

#include 38 #include 39

#include 0#include 42 #include 43 void primeFactors(int n)

namespace7{

#include 89#include 90#include 7#include 64

#include 89#include 94

namespace7using2

#include 5using2

Is

namespace7using05

#include 0using2

namespace7#include 60#include 53 #include 62#include 7#include 64

#include 0{

#include 5using4 using5int #include 75#include 76#include 777#include 53#include 56

#include 5primeFactors(2

#include 0using2

using2

#include 5{

namespace7#include 1 #include 84#include 55#include 56

#include 5std;8 using01#include 53#include 56

#include 0#include 42 #include 43 void using12

#include 5int using17using18#include 8

Python

#include 34 using26

using27 using28

namespace7using39 using74

namespace7using31using34 using31using46 using67

____10std;8 using83#include 53using37

#include 5using39 using88

using31using34 using18

using92

C#

using using94

namespace using96

{

#include 42 #include 38 #include 39

namespace01

#include 0#include 42 #include 43 void primeFactors(int n)

#include 0{

#include 5#include 1 #include 2

#include 5{

namespace7namespace17#include 7#include 64

namespace7namespace21

#include 5using2

#include 5using4 using5int namespace28

#include 5{

namespace7#include 1 namespace4

namespace7{

#include 89namespace37#include 7#include 64

#include 89#include 94

namespace7using2

#include 5using2

#include 5std;8 std;9

namespace7namespace50

#include 0using2

____10#include 42 #include 43 void namespace57

#include 0{

#include 5int primeFactors(0

#include 5primeFactors(2

#include 0using2

using2

using2

PHP

namespace69

namespace70 primeFactors(namespace72#include 56

{

____10#include 1using5namespace72 namespace79

#include 0{

#include 5namespace83 namespace84#include 7#include 8

#include 5namespace72 namespace89namespace72 namespace91

#include 0using2

#include 0using4 using5namespace97

std;03namespace97 namespace89namespace97 std;07

#include 0{

#include 5#include 1 using5namespace72 std;14namespace97 std;16

#include 5{

namespace7namespace83 namespace97using41#include 7#include 8

namespace7namespace72 namespace89namespace72 std;29namespace97#include 8

#include 5using2

#include 0using2

____10std;8 using5namespace72 std;40

#include 5namespace83 namespace72using41#include 7#include 8

using2

#include 0namespace72 std;50

#include 0primeFactors(namespace72#include 64

std;55

JavaScript

std;56

namespace70 using92

{

#include 0____11 #include 2

#include 0{

#include 5std;66#include 7#include 64

#include 5std;70

#include 0using2

#include 0using4std;75

namespace7std;77

namespace7std;79

#include 0{

#include 5#include 1 namespace4

#include 5{

namespace7std;88#include 7#include 64

namespace7std;92

#include 5using2

#include 0using2

#include 0std;8 std;9

#include 5void01#include 7#include 64

using2

void05

primeFactors(2

void07

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__ void19

#include 0#include 1void22

#include 0{

#include 5std;8void27

#include 5void29#include 7#include 8

#include 5void33

#include 5using2

#include 5void37 void38

#include 0using2

using2

int void6

{

#include 0__ primeFactors(0

#include 0primeFactors(2

#include 0primeFactors(4 primeFactors(5

using2

C

void54

void primeFactors(int n)

{

#include 0__ void19

#include 5void37 void38

int void6

void69n)0using5n)2void73

void69void75

#include 0using2

#include 0void37

void69void38

#include 0__ primeFactors(0

using2

int void6

{

#include 0__ primeFactors(0

void60primeFactors(2

#include 0primeFactors(4 primeFactors(5

using2

C

void60int void62

void60#include 1 void65

#include 0std;8 void68

#include 0{

void60using2

void60int primeFactors(0

void60primeFactors(4 primeFactors(5

Java

#include 89void75

namespace7using2

namespace7void37

#include 89void38

#include 5using2

#include 0using2

#include 34 void98

#include 0{

#include 38 primeFactors(00

#include 5primeFactors(2

#include 0using2

using2

C#

#include 0#include 42 #include 43 void primeFactors(int n)

void60#include 1 void65

#include 0std;8 void68

#include 0{

void60using2

void60int primeFactors(0

void60primeFactors(4 primeFactors(5

#include 89primeFactors(80#include 7#include 64

#include 89void75

namespace7using2

namespace7void37

#include 89void38

#include 5using2

#include 0using2

Java

#include 0{

#include 34 void98

#include 5primeFactors(2

#include 38 primeFactors(00

#include 0using2

using2

Python3

#include 0#include 42 #include 43 void primeFactors(int n)

#include 5int primeFactors(12#include 53#include 8

#include 0#include 1using01using59using62

#include 5#include 1 using01using59primeFactors(19

namespace7using39int35using34#include 7#include 56

namespace7std;8 primeFactors(222#include 55primeFactors(19

#include 5void37using37

#include 89primeFactors(26#include 7#include 64

____10#include 42 #include 43 void primeFactors(45

using92

#include 5int using17using18#include 8

std;56

using using94

{

#include 0int63

#include 0#include 1int66

#include 0{

#include 5std;8int71

namespace7int73#include 7#include 64

namespace7void75

#include 5using2

#include 5void37 void38

#include 0using2

using2

void05

primeFactors(2

void07

int void6This 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
 


Làm thế nào để bạn tìm thấy các yếu tố chính của một số trong Python?

Ví dụ - Chương trình Python để in các yếu tố chính..
Nhập toán ..
# Chức năng bên dưới sẽ in ..
# tất cả các yếu tố chính của số đã cho ..
def Prime_factors (num):.
# Sử dụng vòng lặp trong khi chúng tôi sẽ in số của hai người chia r ..
Trong khi Num % 2 == 0:.
print(2,).
num = num / 2 ..

Làm thế nào để bạn tìm thấy các yếu tố chính của một số?

Thực hiện theo các bước dưới đây để tìm các yếu tố chính của một số bằng phương pháp phân chia:..
Bước 1: Chia số đã cho cho số nguyên tố nhỏ nhất.....
Bước 2: Một lần nữa, chia chỉ số cho số nguyên tố nhỏ nhất ..
Bước 3: Lặp lại quá trình, cho đến khi thương số trở thành 1 ..
Bước 4: Cuối cùng, nhân tất cả các yếu tố chính ..

Làm thế nào để bạn tìm thấy yếu tố chính lớn nhất của một số trong Python?

Báo cáo vấn đề.Cho một số nguyên dương n.....
Approach..
Thí dụ.Nhập bản demo trực tiếp Math def MaxPrimeFactor (n): # Số phải thậm chí trong khi N % 2 == 0: MAX_PRIME = 2 N /= 1 # Số phải là lẻ cho I trong phạm vi (3, int (Math. ...
Đầu ra.....
Conclusion..