Scribd
Upload
39 views15 pages

Number Theory

This document discusses several topics in number theory including primality testing algorithms like the brute force and square root methods. It also covers the Sieve of Eratosthenes algorithm for finding all primes below a limit in O(N log log N) time. Prime factorization methods like trial division are presented along with modular arithmetic operations like addition, subtraction and multiplication. Example code is provided for many of these algorithms.

Uploaded by

varun05772
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
39 views15 pages

Number Theory

This document discusses several topics in number theory including primality testing algorithms like the brute force and square root methods. It also covers the Sieve of Eratosthenes algorithm for finding all primes below a limit in O(N log log N) time. Prime factorization methods like trial division are presented along with modular arithmetic operations like addition, subtraction and multiplication. Example code is provided for many of these algorithms.

Uploaded by

varun05772
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 15

Number Theory

- Srivaths P
Goal:
To learn:
• Basic Primality Testing
• Sieve of Eratosthenes
• Prime Factorization
• Basic Modular Arithmetic
Primality Testing
A primality test is an algorithm for determining whether a number is
prime or composite.

There are many algorithms for primality testing such as:


• Brute-Force
• Square Root method
• Using Sieve (precomputation)
Primality Testing – Code
Brute-Force: Sqrt method:
bool is_prime(int n) { bool is_prime(int n) {
for (int i = 2; i < n; i++) for (int i = 2; i*i <= n; i++)
if (n % i == 0) if (n % i == 0)
return false; return false;

return n > 1; return n > 1;


} }
Square Root Method Proof
If the number 𝑁 given is not a prime, then it must be possible to factor
into two values 𝐴 and 𝐵 such that 𝐴𝐵 = 𝑁.

Here, it is impossible for both 𝐴 and 𝐵 to be greater than 𝑁, as in that


case the product will be greater than 𝑁.

Therefore, if the number is not a prime, it must have atleast one factor
less than or equal to the square root of the number.
Sieve of Eratosthenes
Sieve of Eratosthenes can find all the prime numbers upto a given limit
in 𝑂(𝑁 log log 𝑁) time complexity.

Any composite number 𝐶 must have a prime factor 𝑃 such that 𝑃 < 𝐶.

We will repeatedly find the first number that does not have any prime
factors, as that number must be prime. Then we will mark the multiples
of the number as composite.
Sieve of Eratosthenes – Code
void sieve(int n) {
bool primes[n+1];
fill(primes, primes+n+1, true);

primes[0] = primes[1] = false;


for (int i = 2; i*i <= n; i++) {
if (primes[i])
for (int j = i*i; j <= n; j += i)
primes[j] = false;
}
}
Sieve of Eratosthenes – Time Complexity
The Prime Harmonic Series is the infinite sum of the reciprocals of all
prime numbers. https://bit.ly/3uTfpr0

1 1 1 1
+ + + +⋯
2 3 5 7

The above sum comes out as log log 𝑁 when the primes are less than 𝑁.

The sieve takes approximately 2𝑁 iterations for 𝑁 = 107 .


Prime Factorization
Prime Factorization is finding all the prime factors of a given number.

There are multiple ways to factor primes, such as:


• Trial Division
• Wheel Factorization
• Sieve method (precomputation)
Prime Factorization – Trial Division
Trial division is the most basic method of prime factorization.

We will use the fact that the smallest divisor of any number 𝑁 is prime,
and it will be less than 𝑁.

𝑞 𝑞 𝑞 𝑞
𝑁 can be represented as 𝑝0 0 ∗ 𝑝1 1 ∗ 𝑝2 2 ∗ ⋯ ∗ 𝑝𝑘 𝑘 where 𝑝𝑖 is prime.
Let us assume that the prime array is sorted.

We will iterate through the range 2, 𝑁 to find 𝑝0 first, then 𝑝1 , etc.


Prime Factorization – Trial Division Code
vector<int> factor(int n) {
vector<int> facts;
for (long long d = 2; d * d <= n; d++) {
while (n % d == 0) {
facts.push_back(d);
n /= d;
}
}

if (n > 1)
facts.push_back(n);

return facts;
}
Modular Arithmetic
Modular Arithmetic is arithmetic operations involving taking the
modulo with some modulus. It is usually given in problem statements
so that the solution doesn’t overflow in case the answer is huge.

A few operations involving modulo are:


• Addition
• Subtraction
• Multiplication
• Division
Modular Arithmetic
Modular addition:
𝐴 + 𝐵 % 𝑀 = 𝐴 % 𝑀 + 𝐵 % 𝑀 % 𝑀.

Modular subtraction (be very careful when using C++):


𝐴 − 𝐵 % 𝑀 = 𝐴 % 𝑀 − 𝐵 % 𝑀 % 𝑀.
𝐴 − 𝐵 % 𝑀 = ((𝐴 % 𝑀 − 𝐵 % 𝑀 % 𝑀) + 𝑀) % 𝑀. (in C++)

Modular multiplication:
𝐴 ∗ 𝐵 % 𝑀 = (𝐴 % 𝑀) ∗ (𝐵 % 𝑀) % 𝑀.
Problems
• https://codeforces.com/problemset/problem/472/A
• https://codeforces.com/problemset/problem/1475/A
• https://codeforces.com/problemset/problem/1679/A
• https://codeforces.com/problemset/problem/1165/D
Resources
• https://en.wikipedia.org/wiki/Primality_test
• https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
• https://cp-algorithms.com/algebra/factorization.html (advanced)
• https://bit.ly/3cl0Vdj (modular arithmetic basics)

You might also like