├── Factorization.cpp
├── Greatest_common_divisor.cpp
├── Least_common_multiple_code.cpp
├── Modular Exponentiation (Fast power).cpp
├── Modular_Arithmetic.cpp
├── README.md
├── Sieve_and_linear_Sieve.cpp
├── extended euclidian algorithm.cpp
├── modinverse.cpp
├── number_theroy.cpp
└── prime_factorization.cpp


/Factorization.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
 3 | #define dpp(arr,val) memset(arr,val,sizeof(arr))
 4 | #define ll long long
 5 | #define ull unsigned long long
 6 | #define dd double
 7 | #define ld long double
 8 | #define PQ priority_queue
 9 | #define pii pair<int,int>
10 | #define pll pair<ll,ll>
11 | #define S second
12 | #define F first
13 | #define MP make_pair
14 | #define endl "\n"
15 | #define PI 3.14159265
16 | using namespace std;
17 | ll M=1e9+7;
18 | const int sz=1e5+10;
19 | const int OO=0x3f3f3f3f;
20 | int main()
21 | {
22 | 
23 | 
24 |     IOS;
25 |     int n;
26 |     cin>>n;
27 |     for (int i=1;i*i<=n;i++)
28 |     {
29 |         if (n%i==0)
30 |         {
31 |             cout<<i<<" ";
32 |             if (i*i!=n)
33 |             {
34 |                 cout<<n/i;
35 |             }
36 |             cout<<endl;
37 |         }
38 |     }
39 |     return 0;
40 | }
41 | 


--------------------------------------------------------------------------------
/Greatest_common_divisor.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
 3 | #define dpp(arr,val) memset(arr,val,sizeof(arr))
 4 | #define ll long long
 5 | #define ull unsigned long long
 6 | #define dd double
 7 | #define ld long double
 8 | #define PQ priority_queue
 9 | #define pii pair<int,int>
10 | #define pll pair<ll,ll>
11 | #define S second
12 | #define F first
13 | #define MP make_pair
14 | #define endl "\n"
15 | #define PI 3.14159265
16 | using namespace std;
17 | const int sz=1e3+10;
18 | const int OO=0x3f3f3f3f;
19 | ll gcd(ll a,ll b)
20 | {
21 |     while(b!=0)
22 |     {
23 |         ll a2=a;
24 |         a=b;
25 |         b=a2%b;
26 |     }
27 |     return a;
28 | }
29 | 
30 | int main()
31 | {
32 |     //myf.open("file.txt");
33 |     //freopen("task.in", "r", stdin);
34 |     //freopen("output.txt", "w", stdout);
35 |     ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
36 |     cout<<gcd(12,6)<<" "<<gcd(24,8)<<endl;
37 |     return 0;
38 | }
39 | 


--------------------------------------------------------------------------------
/Least_common_multiple_code.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
 3 | #define dpp(arr,val) memset(arr,val,sizeof(arr))
 4 | #define ll long long
 5 | #define ull unsigned long long
 6 | #define dd double
 7 | #define ld long double
 8 | #define PQ priority_queue
 9 | #define pii pair<int,int>
10 | #define pll pair<ll,ll>
11 | #define S second
12 | #define F first
13 | #define MP make_pair
14 | #define endl "\n"
15 | #define PI 3.14159265
16 | using namespace std;
17 | const int sz=1e3+10;
18 | const int OO=0x3f3f3f3f;
19 | ll gcd(ll a,ll b)
20 | {
21 |     while(b!=0)
22 |     {
23 |         ll a2=a;
24 |         a=b;
25 |         b=a2%b;
26 |     }
27 |     return a;
28 | }
29 | ll lcm(ll a,ll b)
30 | {
31 |     return a/gcd(a,b)*b;
32 | }
33 | 
34 | int main()
35 | {
36 |     //myf.open("file.txt");
37 |     //freopen("task.in", "r", stdin);
38 |     //freopen("output.txt", "w", stdout);
39 |     ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
40 |     cout<<lcm(7,3)<<" "<<lcm(3,8);
41 |     return 0;
42 | }
43 | 


--------------------------------------------------------------------------------
/Modular Exponentiation (Fast power).cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
 3 | #define dpp(arr,val) memset(arr,val,sizeof(arr))
 4 | #define ll long long
 5 | #define ull unsigned long long
 6 | #define dd double
 7 | #define ld long double
 8 | #define PQ priority_queue
 9 | #define pii pair<int,int>
10 | #define pll pair<ll,ll>
11 | #define S second
12 | #define F first
13 | #define MP make_pair
14 | #define endl "\n"
15 | #define PI 3.14159265
16 | using namespace std;
17 | ll M=1e9+7;
18 | const int sz=1e5+10;
19 | const int OO=0x3f3f3f3f;
20 | ll mul(ll a,ll b,ll m)
21 | {
22 |   return ((a%m)*(b%m))%m;
23 | }
24 | int binaryExponentiation(int x,int n)
25 | {
26 |     int result=1;
27 |     while(n>0)
28 |     {
29 |         if(n%2==1){result=result*x;}
30 |         x=x*x;
31 |         n=n/2;
32 |     }
33 |     return result;
34 | }
35 | int modularExponentiation(int x,int n,int m)
36 | {
37 |     int result=1;
38 |     while(n>0)
39 |     {
40 |         if(n%2==1){result=(result*x)%m;}
41 |         x=(x*x)%m;
42 |         n=n/2;
43 |     }
44 |     return result;
45 | }
46 | ll modularExponentiation_lastmodified(ll x,ll n,ll m)
47 | {
48 |     ll result=1;
49 |     while(n>0)
50 |     {
51 |         if(n%2==1){result=mul(result,x,m);}
52 |         x=mul(x,x,m);
53 |         n=n/2;
54 |     }
55 |     return result;
56 | }
57 | 
58 | int main()
59 | {
60 | 
61 | 
62 |     IOS;
63 |     cout<<binaryExponentiation(2,6)<<endl;
64 |     cout<<modularExponentiation(2,6,M)<<endl;
65 |     cout<<modularExponentiation_lastmodified(2,6,M)<<endl;
66 |     return 0;
67 | }
68 | 


--------------------------------------------------------------------------------
/Modular_Arithmetic.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
 3 | #define dpp(arr,val) memset(arr,val,sizeof(arr))
 4 | #define ll long long
 5 | #define ull unsigned long long
 6 | #define dd double
 7 | #define ld long double
 8 | #define PQ priority_queue
 9 | #define pii pair<int,int>
10 | #define pll pair<ll,ll>
11 | #define S second
12 | #define F first
13 | #define MP make_pair
14 | #define endl "\n"
15 | using namespace std;
16 | const int sz=1e6+1;
17 | int arr[sz];
18 | ll add(ll a,ll b,ll m)
19 | {
20 |     return ((a%m)+(b%m))%m;
21 | }
22 | ll mul(ll a,ll b,ll m)
23 | {
24 |     return ((a%m)*(b%m))%m;
25 | }
26 | ll sub(ll a,ll b,ll m)
27 | {
28 |     return ((a%m)-(b%m)+m)%m;
29 | }
30 | int main()
31 | {
32 | 
33 |     IOS;
34 |     int n;
35 |     cin>>n;
36 |     int m;
37 |     cin>>m;
38 |     for(int i=0;i<n;i++)
39 |     {
40 |         cout<<i<<"------->"<<i%m<<endl;
41 |     }
42 |     return 0;
43 | 
44 | 
45 | 
46 | 
47 | }
48 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Number_theroy


--------------------------------------------------------------------------------
/Sieve_and_linear_Sieve.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
 3 | #define dpp(arr,val) memset(arr,val,sizeof(arr))
 4 | #define ll long long
 5 | #define ull unsigned long long
 6 | #define dd double
 7 | #define ld long double
 8 | #define PQ priority_queue
 9 | #define pii pair<int,int>
10 | #define pll pair<ll,ll>
11 | #define S second
12 | #define F first
13 | #define MP make_pair
14 | #define endl "\n"
15 | #define PI 3.14159265
16 | using namespace std;
17 | const int sz=1e6+10;
18 | const int OO=0x3f3f3f3f;
19 | bool composite[sz+1];
20 | vector<int>prime;
21 | void sieve()
22 | {
23 |     composite[0]=composite[1]=1;
24 |     for (int i=2;i*i<=sz;i++)
25 |     {
26 |          if (!composite[i])
27 |          {
28 |              for (int j=i*i;j<=sz;j+=i)
29 |              {
30 |                  composite[j]=1;
31 |              }
32 |          }
33 |     }
34 | }
35 | void linear_sieve()
36 | {
37 |     composite[0]=composite[1]=1;
38 |     for (int i=2; i<=sz; ++i)
39 |     {
40 |         if (!composite[i])
41 |         {
42 |             prime.push_back(i);
43 |         }
44 |         for (int j=0; j<(int)prime.size()&&i*prime[j]<=sz; ++j)
45 |         {
46 |             composite[i * prime[j]] = 1;
47 |             if (i%prime[j]==0) break;
48 | 
49 |         }
50 |     }
51 | }
52 | int main()
53 | {
54 |     //myf.open("file.txt");
55 |     //freopen("task.in", "r", stdin);
56 |     //freopen("output.txt", "w", stdout);
57 |     ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
58 | 
59 |     sieve();
60 |     for (int i=0;i<100;i++)
61 |     {
62 |         if (!composite[i]){cout<<i<<endl;}
63 |     }
64 | 
65 | 
66 | 
67 | 
68 |     return 0;
69 | }
70 | 


--------------------------------------------------------------------------------
/extended euclidian algorithm.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
 3 | #define dpp(arr,val) memset(arr,val,sizeof(arr))
 4 | #define ll long long
 5 | #define ull unsigned long long
 6 | #define dd double
 7 | #define ld long double
 8 | #define PQ priority_queue
 9 | #define pii pair<int,int>
10 | #define pll pair<ll,ll>
11 | #define S second
12 | #define F first
13 | #define MP make_pair
14 | #define endl "\n"
15 | #define PI 3.14159265
16 | using namespace std;
17 | const int sz=1e6+10;
18 | const int OO=0x3f3f3f3f;
19 | 
20 | int extendedEuclid_recursive(int a, int b, int& x, int& y) {
21 |     if (b==0) {
22 |         x=1;
23 |         y=0;
24 |         return a;
25 |     }
26 |     int x1,y1;
27 |     int d=extendedEuclid_recursive(b,a%b,x1,y1);
28 |     x=y1;
29 |     y=x1-y1*(a/b);
30 |     return d;
31 | }
32 | 
33 | int extendedEuclid_iterative(int a, int b, int& x_prev, int& y_prev)
34 | {
35 |     x_prev=1,y_prev=0;
36 |     int x=0,y=1;
37 |     while (b) {
38 |         int q=a/b;
39 |         tie(x,x_prev)=make_tuple(x_prev-q*x,x);
40 |         tie(y,y_prev)=make_tuple(y_prev-q*y,y);
41 |         tie(a,b)=make_tuple(b,a%b);
42 | 
43 |     }
44 | 
45 |     return a;
46 | }
47 | 
48 | int main()
49 | {
50 |     //myf.open("file.txt");
51 |     //freopen("task.in", "r", stdin);
52 |     //freopen("output.txt", "w", stdout);
53 |     ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
54 |     int a,b;
55 |     cin>>a>>b;
56 |     int x,y;
57 |     cout<<extendedEuclid_recursive(a,b,x,y)<<" ";
58 |     cout<<x<<" "<<y<<endl;
59 | 
60 |     cout<<extendedEuclid_iterative(a,b,x,y)<<" ";
61 |     cout<<x<<" "<<y<<endl;
62 | 
63 |     return 0;
64 | 
65 | }
66 | 


--------------------------------------------------------------------------------
/modinverse.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | #define ll  long long
 4 | #define dd double
 5 | const int sz=1e6+10;
 6 | const int OO=0x3f3f3f3f;
 7 | bool composite[sz+1];
 8 | vector<int>prime;
 9 | ll M=1e9+7;
10 | ll add(ll a,ll b,ll m)
11 | {
12 |     return ((a%m)+(b%m))%m;
13 | }
14 | ll mul(ll a,ll b,ll m)
15 | {
16 |   return ((a%m)*(b%m))%m;
17 | }
18 | 
19 | int extendedEuclid_recursive(int a, int b, int& x, int& y) {
20 |     if (b==0) {
21 |         x=1;
22 |         y=0;
23 |         return a;
24 |     }
25 |     int x1,y1;
26 |     int d=extendedEuclid_recursive(b,a%b,x1,y1);
27 |     x=y1;
28 |     y=x1-y1*(a/b);
29 |     return d;
30 | }
31 | 
32 | int extendedEuclid_iterative(int a, int b, int& x_prev, int& y_prev)
33 | {
34 |     x_prev=1,y_prev=0;
35 |     int x=0,y=1;
36 |     while (b) {
37 |         int q=a/b;
38 |         tie(x,x_prev)=make_tuple(x_prev-q*x,x);
39 |         tie(y,y_prev)=make_tuple(y_prev-q*y,y);
40 |         tie(a,b)=make_tuple(b,a%b);
41 | 
42 |     }
43 | 
44 |     return a;
45 | }
46 | int modinverse (int a,int m)
47 | {
48 |     a=a%m;
49 |     for (int i = 1; i < m; ++i) {
50 |         if((a*i)%m==1)
51 |             return i;
52 |     }
53 | }
54 | int x;
55 | int modinverse_bezouts_therom (int a,int m)
56 | {
57 |     int x, y;
58 |     int g = extendedEuclid_iterative(a, m, x, y);
59 |     if (g != 1) {
60 |         cout << "No solution!";
61 |     }
62 |     else {
63 |         x = (x % m + m) % m;
64 |         cout << x << endl;
65 |     }
66 | }
67 | int modinverse_fermat (int a,int m)
68 | {
69 |     return modularExponentiation(a,m-2,m);
70 | }
71 | 
72 | 
73 | 


--------------------------------------------------------------------------------
/number_theroy.cpp:
--------------------------------------------------------------------------------
  1 | #include<bits/stdc++.h>
  2 | using namespace std;
  3 | #define ll  long long
  4 | #define dd double
  5 | const int sz=1e6+10;
  6 | const int OO=0x3f3f3f3f;
  7 | bool composite[sz+1];
  8 | vector<int>prime;
  9 | ll M=1e9+7;
 10 | ll add(ll a,ll b,ll m)
 11 | {
 12 |     return ((a%m)+(b%m))%m;
 13 | }
 14 | ll mul(ll a,ll b,ll m)
 15 | {
 16 |   return ((a%m)*(b%m))%m;
 17 | }
 18 | int binaryExponentiation(int x,int n)
 19 | {
 20 |     int result=1;
 21 |     while(n>0)
 22 |     {
 23 |         if(n%2==1){result=result*x;}
 24 |         x=x*x;
 25 |         n=n/2;
 26 |     }
 27 |     return result;
 28 | }
 29 | int modularExponentiation(int x,int n,int m)
 30 | {
 31 |     int result=1;
 32 |     while(n>0)
 33 |     {
 34 |         if(n%2==1){result=(result*x)%m;}
 35 |         x=(x*x)%m;
 36 |         n=n/2;
 37 |     }
 38 |     return result;
 39 | }
 40 | ll modularExponentiation_lastmodified(ll x,ll n,ll m)
 41 | {
 42 |     ll result=1;
 43 |     while(n>0)
 44 |     {
 45 |         if(n%2==1){result=mul(result,x,m);}
 46 |         x=mul(x,x,m);
 47 |         n=n/2;
 48 |     }
 49 |     return result;
 50 | }
 51 | void factorization(int n){
 52 | 
 53 |     for (int i=1;i*i<=n;i++)
 54 |     {
 55 |         if (n%i==0)
 56 |         {
 57 |             cout<<i<<" ";
 58 |             if (i*i!=n)
 59 |             {
 60 |                 cout<<n/i;
 61 |             }
 62 |             cout<<endl;
 63 |         }
 64 |     }
 65 | }
 66 | void prime_factorization(int n){
 67 |     vector<int>v;
 68 | 
 69 |     for (int i=2;i*i<=n;i++)
 70 |     {
 71 |         while(n%i==0)
 72 |         {
 73 |             n/=i;
 74 |             v.push_back(i);
 75 |             cout<<n<<" ";
 76 |         }
 77 |     }
 78 |     if (n!=1)
 79 |     {
 80 |         v.push_back(n);
 81 |     }
 82 |     for (int i=0;i<v.size();i++)
 83 |     {
 84 |        // cout<<v[i]<<" ";
 85 |     }
 86 | }
 87 | ll gcd(ll a,ll b)
 88 | {
 89 |     while(b!=0)
 90 |     {
 91 |         ll a2=a;
 92 |         a=b;
 93 |         b=a2%b;
 94 |     }
 95 |     return a;
 96 | }
 97 | ll lcm(ll a,ll b)
 98 | {
 99 |     return a/gcd(a,b)*b;
100 | }
101 | 
102 | void sieve()
103 | {
104 |     composite[0]=composite[1]=1;
105 |     for (int i=2;i*i<=sz;i++)
106 |     {
107 |         if (!composite[i])
108 |         {
109 |             for (int j=i*i;j<=sz;j+=i)
110 |             {
111 |                 composite[j]=1;
112 |             }
113 |         }
114 |     }
115 | }
116 | void linear_sieve()
117 | {
118 |     composite[0]=composite[1]=1;
119 |     for (int i=2; i<=sz; ++i)
120 |     {
121 |         if (!composite[i])
122 |         {
123 |             prime.push_back(i);
124 |         }
125 |         for (int j=0; j<(int)prime.size()&&i*prime[j]<=sz; ++j)
126 |         {
127 |             composite[i * prime[j]] = 1;
128 |             if (i%prime[j]==0) break;
129 | 
130 |         }
131 |     }
132 | }
133 | int extendedEuclid_recursive(int a, int b, int& x, int& y) {
134 |     if (b==0) {
135 |         x=1;
136 |         y=0;
137 |         return a;
138 |     }
139 |     int x1,y1;
140 |     int d=extendedEuclid_recursive(b,a%b,x1,y1);
141 |     x=y1;
142 |     y=x1-y1*(a/b);
143 |     return d;
144 | }
145 | 
146 | int extendedEuclid_iterative(int a, int b, int& x_prev, int& y_prev)
147 | {
148 |     x_prev=1,y_prev=0;
149 |     int x=0,y=1;
150 |     while (b) {
151 |         int q=a/b;
152 |         tie(x,x_prev)=make_tuple(x_prev-q*x,x);
153 |         tie(y,y_prev)=make_tuple(y_prev-q*y,y);
154 |         tie(a,b)=make_tuple(b,a%b);
155 | 
156 |     }
157 | 
158 |     return a;
159 | }
160 | int modinverse (int a,int m)
161 | {
162 |     a=a%m;
163 |     for (int i = 1; i < m; ++i) {
164 |         if((a*i)%m==1)
165 |             return i;
166 |     }
167 | }
168 | int x;
169 | int modinverse_bezouts_therom (int a,int m)
170 | {
171 |    // extendedEuclid_iterative(a,m);
172 |     return (x%m+m)%m;
173 | }
174 | int modinverse_fermat (int a,int m)
175 | {
176 |     return modularExponentiation(a,m-2,m);
177 | }
178 | 
179 | 
180 | 


--------------------------------------------------------------------------------
/prime_factorization.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
 3 | #define dpp(arr,val) memset(arr,val,sizeof(arr))
 4 | #define ll long long
 5 | #define ull unsigned long long
 6 | #define dd double
 7 | #define ld long double
 8 | #define PQ priority_queue
 9 | #define pii pair<int,int>
10 | #define pll pair<ll,ll>
11 | #define S second
12 | #define F first
13 | #define MP make_pair
14 | #define endl "\n"
15 | #define PI 3.14159265
16 | using namespace std;
17 | const int sz=1e3+10;
18 | const int OO=0x3f3f3f3f;
19 | vector<int>v;
20 | int main()
21 | {
22 |     //myf.open("file.txt");
23 |     //freopen("task.in", "r", stdin);
24 |     //freopen("output.txt", "w", stdout);
25 |     ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
26 |     int n;
27 |     cin>>n;
28 |     for (int i=2;i*i<=n;i++)
29 |     {
30 |         while(n%i==0)
31 |         {
32 |             n/=i;
33 |             v.push_back(i);
34 |         }
35 |     }
36 |     if (n!=1)
37 |     {
38 |         v.push_back(n);
39 |     }
40 |     for (int i=0;i<v.size();i++)
41 |     {
42 |         cout<<v[i]<<" ";
43 |     }
44 |     return 0;
45 | }
46 | 


--------------------------------------------------------------------------------