├── .gitignore
├── Bit manipulation
    └── Brian-kerningam's-algorithm.cpp
├── Bitmasking
    ├── 1. Unique number I.txt
    ├── 10. Unique Number III.txt
    ├── 11. Fast Exponentiation.txt
    ├── 12. generate subsets.txt
    ├── 13. codechef problem.txt
    ├── 2. get ith bit.txt
    ├── 2. set ith bit.txt
    ├── 3. clear ith bit.txt
    ├── 4. update ith bit by value(0 or 1).txt
    ├── 5. clear last i bits of a number.txt
    ├── 6. clear bits from ith index to jth (from right to left).txt
    ├── 7. Replace bits in N by M.txt
    ├── 8. Convert Decimal to Binary.txt
    └── 9. Unique Number II.txt
├── Graph
    ├── Adjancency_List_Representation.cpp
    ├── BFS.cpp
    ├── DFS.cpp
    ├── Graph.py
    └── README.md
├── README.md
├── Tree
    ├── Sorted_to_BST.cpp
    ├── Tree_traversal.cpp
    └── tree_vertical_order_print
├── banker's algo
    └── banker_algo_implementation.txt
├── basic_algo
    ├── Bucket sort
    ├── Cycle Sort
    ├── bubble_sort.py
    ├── cycle_sort.cpp
    ├── heapSort.cpp
    ├── insertion_sort.py
    ├── mergeSort.cpp
    ├── mergesort.py
    ├── quickSort.cpp
    ├── radix-sort.cpp
    └── selection_sort.py
├── machine-learning
    ├── knn.py
    └── linear_regression.py
├── recursion
    ├── README.md
    ├── Sudoku.cpp
    └── factorial.py
└── searching
    ├── binary-search.py
    └── linear-search.py


/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store


--------------------------------------------------------------------------------
/Bit manipulation/Brian-kerningam's-algorithm.cpp:
--------------------------------------------------------------------------------
 1 | // program to calculate number of set bits in binary representation of a an unsigned int.
 2 | 
 3 | // time compexity : O(no. of set bits in binary representation of a number)
 4 | // auxilliary space : O(1)
 5 | 
 6 | #include<bits/stdc++.h>
 7 | using namespace std;
 8 | 
 9 | int countBits(unsigned int n)
10 | {
11 |     int res = 0;
12 |     while(n>0)
13 |     {
14 |         n = (n & (n-1));
15 |         res++;
16 |     }
17 |     return res;
18 | }
19 | 
20 | int main()
21 | {
22 |     unsigned int n;
23 |     cin >> n;
24 |     cout << countBits(n);
25 |     return 0;
26 | 
27 | }


--------------------------------------------------------------------------------
/Bitmasking/1. Unique number I.txt:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | /*
 5 | Every number occurs twice in the array except one number
 6 | find out that number
 7 | */
 8 | 
 9 | int uniqueNumber(int ar[], int n)
10 | {
11 | 	int ans = 0;
12 | 	for(int i=0; i<n; i++)
13 | 	{
14 | 		ans = ans ^ ar[i];
15 | 	}
16 | 	return ans;
17 | }
18 | 
19 | int main()
20 | {
21 | 	int arr[]= {1,5,3,5,8,9,8,1,3};
22 |     int n = sizeof(arr)/sizeof(int);
23 | 
24 | 	cout<<uniqueNumber(arr, n);
25 | 	return 0;
26 | }


--------------------------------------------------------------------------------
/Bitmasking/10. Unique Number III.txt:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | /*
 5 | Every number is occuring thrice in the given array except one. find the unique number
 6 | */
 7 | 
 8 | int main()
 9 | {
10 |   int count[64] = {0};
11 | 
12 |   int n;
13 |   cin>>n;
14 |   int no;
15 |   for(int i=0; i<n; i++)
16 |   {
17 |     cin>>no;
18 |     //we will keep adding the bits of upcoming numbers in the count array
19 | 
20 |     int j=0;
21 |     while(no>0)
22 |     {
23 |       count[j]+= (no&1);
24 |       j++;
25 |       no = no>>1;
26 |     }
27 |   }
28 | 
29 |   //now lets take mod with 3 of numbers present in the count array 
30 |   int ans = 0;
31 |   int p = 1;
32 |   for(int i=0; i<n; i++)
33 |   {
34 |     count[i] = count[i]%3;
35 |     ans+=count[i]*p;
36 |     p*=2;
37 |   }
38 |   cout<<ans;
39 | 
40 | 	return 0;
41 | }


--------------------------------------------------------------------------------
/Bitmasking/11. Fast Exponentiation.txt:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int fastExponentiation(int a, int n)
 5 | {
 6 |   int ans = 1;
 7 | 
 8 |   while(n>0)
 9 |   {
10 |     if((n&1)==1)
11 |     {
12 |       ans*=a;
13 |     }
14 |     n>>=1; 
15 |     a*=a;
16 |   }
17 |   return ans;
18 | }
19 | 
20 | int main()
21 | {
22 |   
23 |   int a,n;
24 |   cin>>a>>n;
25 |   cout<<fastExponentiation(a,n);
26 | 	return 0;
27 | }


--------------------------------------------------------------------------------
/Bitmasking/12. generate subsets.txt:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | void filterChars(char c[], int n)
 5 | {
 6 |   int j=0;
 7 |   while(n>0)
 8 |   {
 9 |     if(n&1)
10 |     {
11 |       cout<<c[j];
12 |     }
13 |     j++;
14 |     n>>=1;
15 |   }
16 |   cout<<endl;
17 | }
18 | 
19 | void printSubsequences(char c[])
20 | {
21 |   int n = strlen(c);
22 |   for(int i=0; i<(1<<n); i++)
23 |   {
24 |     filterChars(c,i);
25 |   }
26 | }
27 | 
28 | int main()
29 | {
30 |   char c[100];
31 |   cin>>c;
32 |   printSubsequences(c);
33 | 	return 0;
34 | }


--------------------------------------------------------------------------------
/Bitmasking/13. codechef problem.txt:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 |  
 4 | #define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
 5 | #define endl "\n"
 6 | #define int long long
 7 | 
 8 | /*
 9 | problem link:
10 | https://www.codechef.com/COOK128B/problems/OROFAND
11 | */
12 | 
13 | int32_t main()
14 | {
15 |   IOS;
16 |   int t;
17 |   cin>>t;
18 |   while(t--)
19 |   {
20 |     int n,q;
21 |     cin>>n>>q;
22 | 
23 |     int arr[n];
24 |     for(int i=0; i<n; i++)
25 |     {
26 |       cin>>arr[i];
27 |     }
28 | 
29 |     int bit[32] = {0};
30 |     for(int i=0; i<n; i++)
31 |     {
32 |       for(int j=0; j<32; j++)
33 |       {
34 |         if((1<<j)&arr[i]) bit[j]++;
35 |       }
36 |     }
37 | 
38 |     int ans = 0;
39 |     for(int i=0; i<32; i++)
40 |     {
41 |       if(bit[i]>0)
42 |       {
43 |         ans+=(1<<i);
44 |       }
45 |     }
46 | 
47 |     cout<<ans<<endl;
48 | 
49 |     while(q--)
50 |     {
51 |       int x,v;
52 |       cin>>x>>v;
53 |       x--;
54 | 
55 |       for(int i=0; i<32; i++)
56 |       {
57 |         if(((1<<i)&arr[x]))
58 |         bit[i]--;
59 |       }
60 | 
61 |       arr[x]=v;
62 | 
63 |       for(int i=0; i<32; i++)
64 |       {
65 |         if(((1<<i)&v)) bit[i]++;
66 |       }
67 | 
68 |       ans = 0;
69 |       for(int i=0; i<32; i++)
70 |       {
71 |         if(bit[i]>0)
72 |         {
73 |           ans+=(1<<i);
74 |         }
75 |       }
76 |       cout<<ans<<endl;
77 |     }
78 |   }
79 |   return 0;
80 | }
81 | 
82 | 


--------------------------------------------------------------------------------
/Bitmasking/2. get ith bit.txt:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | //task is to find ith bit (i starting from zero and from right side) in a number
 5 | 
 6 | int ithBit(int n, int i)
 7 | {
 8 | 	int mask = 1<<i;
 9 | 	int bit = (n & mask) > 0 ? 1 : 0;
10 | 
11 | 	return bit;
12 | }
13 | 
14 | int main()
15 | {
16 | 	int n,i;
17 | 	cin>>n>>i;
18 |     cout<<ithBit(n,i);
19 | 	return 0;
20 | }


--------------------------------------------------------------------------------
/Bitmasking/2. set ith bit.txt:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int setIthBit(int n, int i)
 5 | {
 6 | 	int mask = 1<<i;
 7 | 	n = n | mask;
 8 | 
 9 | 	return n;
10 | }
11 | 
12 | int main()
13 | {
14 | 	int n,i;
15 | 	cin>>n>>i;
16 |     cout<<setIthBit(n,i);
17 | 	return 0;
18 | }


--------------------------------------------------------------------------------
/Bitmasking/3. clear ith bit.txt:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int clearIthBit(int n, int i)
 5 | {
 6 | 	int mask = ~(1<<i);
 7 | 	n = n & mask;
 8 | 
 9 | 	return n;
10 | }
11 | 
12 | int main()
13 | {
14 | 	int n,i;
15 | 	cin>>n>>i;
16 |     cout<<clearIthBit(n,i);
17 | 	return 0;
18 | }


--------------------------------------------------------------------------------
/Bitmasking/4. update ith bit by value(0 or 1).txt:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int updateIthBitByValue(int n, int i, int v)
 5 | {
 6 |    //lets first cleat ith bit
 7 |    int mask = (~(1<<i));
 8 |    n = (n&mask);
 9 | 
10 |    int newmask = (v<<i);
11 |    n = (n|newmask);
12 | 
13 |    return n;
14 | }
15 | 
16 | int main()
17 | {
18 |   int n,i,v;
19 |   cin>>n>>i>>v;
20 | 
21 |   cout<<updateIthBitByValue(n,i,v);
22 | 	return 0;
23 | }


--------------------------------------------------------------------------------
/Bitmasking/5. clear last i bits of a number.txt:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int clearLastIBits(int n, int i)
 5 | {
 6 | 	//lets take mask with all ones
 7 | 	int mask = -1;
 8 | 
 9 | 	//lets clear last i bits of our mask
10 | 	mask = (mask<<i);
11 | 
12 | 	//take AND with of your number with mask
13 | 	n = n&mask;
14 | 
15 | 	return n;
16 | }
17 | 
18 | int main()
19 | {
20 | 	int n,i;
21 | 	cin>>n>>i;
22 | 	cout<<clearLastIBits(n,i);
23 | 	return 0;
24 | }


--------------------------------------------------------------------------------
/Bitmasking/6. clear bits from ith index to jth (from right to left).txt:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int clearBitsFromItoJ(int n, int i, int j)
 5 | {
 6 | 	//lets take one mask (a) as all ones with j+1 number of trailing zeros
 7 | 	int a = (~0)<<(j+1);
 8 | 
 9 | 	//lets take mask (b) as all zero with i number of trailing ones
10 | 	int b = (1<<i)-1;
11 | 
12 | 	//required mask will be a|b
13 | 	int mask = a|b;
14 | 
15 | 	n = n&mask;
16 | 
17 | 	return n;
18 | }
19 | 
20 | int main()
21 | {
22 | 	int n,i,j;
23 | 	cin>>n>>i>>j;
24 | 	cout<<clearBitsFromItoJ(n,i,j);
25 | 	return 0;
26 | }


--------------------------------------------------------------------------------
/Bitmasking/7. Replace bits in N by M.txt:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int replaceNbitsByMFromItoJ(int n, int m, int i, int j)
 5 | {
 6 |   //lets first clear the bits in n from i to j
 7 |   int a = (~0)<<(j+1);
 8 | 
 9 |   int b = (1<<i) -1;
10 |   int mask = a|b;
11 | 
12 |   n = n&mask;
13 | 
14 |   m = (m<<i);
15 | 
16 |   return n|m;
17 | }
18 | 
19 | int main()
20 | {
21 | 	int n = 15;
22 | 	int m = 2;
23 | 	int i = 1;
24 | 	int j = 3;
25 | 
26 | 	cout<<replaceNbitsByMFromItoJ(n,m,i,j);
27 | 	return 0;
28 | }


--------------------------------------------------------------------------------
/Bitmasking/8. Convert Decimal to Binary.txt:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int convertToBinary(int n)
 5 | {
 6 | 	//we will convert the n into is base 10 representation which will look like binary representation of n
 7 | 
 8 | 	int ans = 0;
 9 | 	int p = 1;
10 | 
11 | 	while(n>0)
12 | 	{
13 | 		int last_bit = (n&1);
14 | 		ans+= p*last_bit;
15 | 		p*=10;
16 | 		n=(n>>1);
17 | 	}
18 | 	return ans;
19 | }
20 | 
21 | int main()
22 | {
23 | 	int n;
24 | 	cin>>n;
25 | 	cout<<convertToBinary(n);
26 | 	return 0;
27 | }


--------------------------------------------------------------------------------
/Bitmasking/9. Unique Number II.txt:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | /*
 5 | We are given an array containg n numbers. All the numbers are present twice except for two numbers which are present only once. 
 6 | Find the unique numbers in linear time without using any extra space. ( Hint - Use Bitwise )
 7 | */
 8 | 
 9 | 
10 | void uniqueNumberII(int n, int a[])
11 | {
12 | 	int xo = 0;
13 | 	for(int i=0; i<n; i++)
14 | 	{
15 | 		xo = xo^a[i];
16 | 	}
17 | 	//we have xor of two unique numbers in our xor basically
18 | 
19 | 	//we will find the position of first set bit in our xor
20 | 	//because out of both numbers, only one number will have set bit at that position
21 | 
22 | 	int pos = 0;
23 | 	int temp = xo;
24 | 	while((temp&1)!=1)
25 | 	{
26 | 		pos++;
27 | 		temp = temp>>1;
28 | 	}
29 | 
30 | 	//now we will check, out of all numbers in array which numbers have set bit at position pos
31 |     int mask = 1<<pos;
32 | 	int x = 0; //first unique number
33 | 	int y = 0; //second unique number
34 | 	for(int i=0; i<n; i++)
35 | 	{
36 |       if((a[i]&mask)>0)
37 | 	  {
38 |          x = x^a[i];
39 | 	  }
40 | 	}
41 | 	//here we have our first unique number x
42 | 
43 | 	//if we xor our unique number with the xor value of whole array then we will get our second unique number
44 | 
45 | 	y = x^xo;
46 | 
47 | 	cout<<min(x,y)<<" "<<max(x,y);
48 | }
49 | 
50 | int main()
51 | {
52 | 	int n;
53 | 	cin>>n;
54 | 	int arr[n];
55 | 	for(int i=0; i<n; i++)
56 | 	{
57 | 	   cin>>arr[i];
58 | 	}
59 |     uniqueNumberII(n,arr);
60 | 	return 0;
61 | }


--------------------------------------------------------------------------------
/Graph/Adjancency_List_Representation.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | class Graph
 4 | {
 5 |     int V;
 6 |     list<int> *l;
 7 |     public:
 8 |     Graph(int v)
 9 |     {
10 |         V=v;
11 |         l=new list<int>[V];
12 |     }
13 |     void addEdge(int i,int j,bool undir=true)
14 |     {
15 |         l[i].push_back(j);
16 |         if(undir){
17 |             l[j].push_back(i);
18 |         }
19 |     }
20 |     void printGraph()
21 |     {
22 |         for(int i=0;i<V;i++)
23 |         {
24 |             // Iterate all vertices...
25 |             cout<<i<<"-->";
26 |             for(auto node:l[i]){
27 |                 cout<<node<<",";
28 |             }
29 |             cout<<endl;
30 |         }
31 |     }
32 | };
33 | int main()
34 | {
35 |     Graph g(6);
36 |     g.addEdge(0,1);
37 |     g.addEdge(0,4);
38 |     g.addEdge(2,1);
39 |     g.addEdge(3,4);
40 |     g.addEdge(4,5);
41 |     g.addEdge(2,3);
42 |     g.addEdge(3,5);
43 |     g.printGraph();
44 | }
45 | 


--------------------------------------------------------------------------------
/Graph/BFS.cpp:
--------------------------------------------------------------------------------
  1 | // BFS Breadth First Search is a Searching Algorithm where the nodes closer to source node are searched and printed and then the neighbour nodes is searched and printed.
  2 | #include<bits/stdc++.h>
  3 | using namespace std;
  4 | class Graph{
  5 |     int V;
  6 |     list<int> *l;
  7 |     public:
  8 |     Graph(int v)
  9 |     {
 10 |         V=v;
 11 |         l=new list<int>[v];
 12 |     }
 13 |     void addEdge(int u,int v,bool undir=true)
 14 |     {
 15 |         l[u].push_back(v);
 16 |         if(undir)
 17 |         {
 18 |             l[v].push_back(u);
 19 |         }
 20 |     }
 21 |     void printGraph()
 22 |     {
 23 |         for(int i=0;i<V;i++)
 24 |         {
 25 |             cout<<i<<" --> ";
 26 |             for(auto connected:l[i])
 27 |             {
 28 |                 cout<<connected<<",";
 29 |             }
 30 |             cout<<endl;
 31 |         }
 32 |     }
 33 |     void BFS(int source)
 34 |     {
 35 |         queue<int> q;
 36 |         // Enqueuing Source to the Queue.
 37 |         q.push(source);
 38 | 
 39 |         bool *visited=new bool[V]{0};
 40 |         
 41 |         // visited array to get info about visited vertices.
 42 | 
 43 |         visited[source]=true;
 44 | 
 45 |         while(!q.empty())
 46 |         {
 47 |             int vertice=q.front();
 48 |             q.pop();
 49 |             cout<<vertice<<" ";
 50 |             for(auto neighbours:l[vertice])
 51 |             {
 52 |                 // Checking for every neighbour node it is visited or not.
 53 |                 if(!visited[neighbours]){
 54 | 
 55 |                     q.push(neighbours);
 56 |                     // Marked Visited.
 57 |                     visited[neighbours]=true;
 58 |                 }
 59 |                 
 60 |             }
 61 |         }
 62 |         cout<<endl;
 63 |     }
 64 |     void Shortest_Distance_and_Path_from_Source(int src,int dest=-1)
 65 |     {
 66 | 
 67 |         queue<int> q;
 68 |         // Enqueuing Source to the Queue.
 69 |         q.push(src);
 70 | 
 71 |         bool *visited=new bool[V]{0};
 72 |         int *parent=new int[V];
 73 |         int *distance=new int[V];
 74 |         parent[src]=src;
 75 |         distance[src]=0;
 76 |         // visited array to get info about visited vertices.
 77 | 
 78 |         visited[src]=true;
 79 | 
 80 |         while(!q.empty())
 81 |         {
 82 |             int vertice=q.front();
 83 |             q.pop();
 84 |             for(auto neighbours:l[vertice])
 85 |             {
 86 |                 // Checking for every neighbour node it is visited or not.
 87 |                 if(!visited[neighbours]){
 88 | 
 89 |                     q.push(neighbours);
 90 |                     // Marked Visited.
 91 |                     parent[neighbours]=vertice;
 92 |                     distance[neighbours]=distance[vertice]+1;
 93 |                     visited[neighbours]=true;
 94 |                 }
 95 |                 
 96 |             }
 97 |         }
 98 |         // Shortest distance of every Node from source.
 99 |         cout<<src<<":-\n";
100 |         for(int i=0;i<V;i++)
101 |         {
102 |             cout<<distance[i]<<" ";
103 |         }
104 |         cout<<endl;
105 |         // Path of node from src.
106 |         if(dest!=-1)
107 |         {
108 |             int temp=dest;
109 |             while(temp!=src)
110 |             {
111 |                 cout<<temp<<"--";
112 |                 temp=parent[temp];
113 |             }
114 |             cout<<temp<<" ";
115 |         }
116 |         
117 |         cout<<endl;
118 |     }
119 | };
120 | int main()
121 | {
122 |     Graph g(7);
123 |     g.addEdge(0,1);
124 |     g.addEdge(1,2);
125 |     g.addEdge(3,5);
126 |     g.addEdge(2,3);
127 |     g.addEdge(5,6);
128 |     g.addEdge(4,5);
129 |     g.addEdge(0,4);
130 |     g.addEdge(3,4);
131 |     g.printGraph();
132 |     g.BFS(1);
133 |     g.Shortest_Distance_and_Path_from_Source(1);
134 |     g.Shortest_Distance_and_Path_from_Source(1,6);
135 | }


--------------------------------------------------------------------------------
/Graph/DFS.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | class Graph
 4 | {
 5 |     int V;
 6 |     list<int> *l;
 7 |     public:
 8 |     Graph(int v)
 9 |     {
10 |         V=v;
11 |         l=new list<int>[V];
12 |     }
13 |     void addEdge(int u,int v,bool undir=true)
14 |     {
15 |         l[u].push_back(v);
16 |         if(undir)
17 |         {
18 |             l[v].push_back(u);
19 |         }
20 |     }
21 |     void dfshelper(int node,bool *visited)
22 |     {
23 |         visited[node]=true;
24 |         cout<<node<<" ";
25 |         for(auto nbr:l[node]){
26 |             if(!visited[nbr])
27 |             {
28 |                 dfshelper(nbr,visited);
29 |             }
30 |         }
31 |         return;
32 |     }
33 |     void DFS(int source)
34 |     {
35 |         bool *visited=new bool[V]{0};
36 |         dfshelper(source,visited);
37 |         cout<<endl;
38 |     }
39 |     void printGraph()
40 |     {
41 |         for(int i=0;i<V;i++)
42 |         {
43 |             cout<<i<<" --> ";
44 |             for(auto connected:l[i])
45 |             {
46 |                 cout<<connected<<",";
47 |             }
48 |             cout<<endl;
49 |         }
50 |     }
51 | };
52 | int main()
53 | {
54 |     Graph g(7);
55 |     g.addEdge(0,1);
56 |     g.addEdge(1,2);
57 |     g.addEdge(3,5);
58 |     g.addEdge(2,3);
59 |     g.addEdge(5,6);
60 |     g.addEdge(4,5);
61 |     g.addEdge(0,4);
62 |     g.addEdge(3,4);
63 |     g.printGraph();
64 |     g.DFS(0);
65 | }


--------------------------------------------------------------------------------
/Graph/Graph.py:
--------------------------------------------------------------------------------
 1 | """
 2 | Undirected Graph Representation using a matrix and their traversals (BFS, DFS)
 3 | -------------------------------------------------------------------
 4 | """
 5 | 
 6 | class UndirectedGraph : 
 7 |     def __init__(self, vertices) -> None : 
 8 |         self.vertices = vertices
 9 |         self.graph = [[0 for _ in range(vertices)] for _ in range(vertices)] 
10 |     
11 | 
12 |     #   function to add an edge into the graph
13 |     def addEdge(self, u, v) -> None : 
14 |         self.graph[u][v] = 1
15 |         self.graph[v][u] = 1
16 |     
17 | 
18 |     #   function check if an edge exists between two edges
19 |     def edgeExists(self, u, v) -> bool : 
20 |         return self.graph[u][v] == 1 and self.graph[v][u] == 1
21 |     
22 | 
23 |     #   function to remove an edge from the graph
24 |     def removeEdge(self, u, v) -> None : 
25 |         if self.edgeExists(u, v) : 
26 |             self.graph[u][v] = 0
27 |             self.graph[v][u] = 0
28 |     
29 | 
30 |     #   function to get the bfs traversal of the graph
31 |     def bfsTraversal(self, source) -> None : 
32 |         visited = [False] * self.vertices
33 |         visited[source] = True
34 |         queue = list()
35 |         queue.append(source)
36 | 
37 |         while queue : 
38 |             node = queue.pop(0)
39 |             print(node, end = " ")
40 | 
41 |             for i in range(self.vertices) : 
42 |                 if self.graph[node][i] == 1 and visited[i] is False : 
43 |                     queue.append(i)
44 |                     visited[i] = True
45 |     
46 | 
47 |     #   function to get the depth first traversal of the graph
48 |     def dfsTraversal(self, source, visited) -> None : 
49 |         visited[source] = True
50 |         print(source, end = " ")
51 | 
52 |         for i in range(self.vertices) : 
53 |             if self.graph[source][i] == 1 and visited[i] is False : 
54 |                 self.dfsTraversal(i, visited)
55 |     
56 | 
57 | 
58 |     #   function to print the graph
59 |     def printGraph(self) -> None : 
60 |         for row in self.graph : 
61 |             print(row)
62 | 
63 | 
64 | def main() : 
65 |     #   enter the number of vertices and edges
66 |     vertices, edges = map(int, input().split())
67 | 
68 |     graph = UndirectedGraph(vertices)
69 |     
70 |     for _ in range(edges) : 
71 |         u, v = map(int, input().split())
72 |         graph.addEdge(u, v)
73 |     
74 | 
75 |     
76 |     graph.bfsTraversal(1)
77 |     print()
78 |     visited = [False] * vertices
79 |     graph.dfsTraversal(0, visited)
80 | 
81 | 
82 | 
83 | if __name__ == '__main__' : 
84 |     main()
85 | 


--------------------------------------------------------------------------------
/Graph/README.md:
--------------------------------------------------------------------------------
1 | ## Example
2 | 
3 | ![Adjacency List](https://i.imgur.com/JwA2sxn.png)
4 | 
5 | ## DFS and BFS example.
6 | ![giphy](https://i.stack.imgur.com/7BcgD.png)
7 | 
8 | 
9 | Made with ❤️ by @Mithil G Anchan


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Algorithms
 2 | This repository contains computer science algorithms code.
 3 | 
 4 | ## Contribution Guidelines 
 5 | 
 6 | * Fork the algorithms Repository from Coding Minutes
 7 | * Now from your Github account Clone the Repository
 8 | * Add new algorithms from your working directory
 9 | * commit the changes when your code is errorfree
10 | * push the code and click on contribute in your github (server)
11 | * Click on Create a pull Request
12 | * Done.
13 | 
14 | If your Contribution is genuine it will get merged with main Repository (i.e algorithms)
15 | 
16 | 


--------------------------------------------------------------------------------
/Tree/Sorted_to_BST.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<vector>
 3 | #include<queue>
 4 | 
 5 | using namespace std;
 6 | 
 7 | /*
 8 |  Given a sorted, we need to build a BST out of it.
 9 | */
10 | 
11 | class Node{
12 | public:
13 |     int data;
14 |     Node *left,*right;
15 |     Node(int data){
16 |         this->data = data;
17 |         left=right= NULL;
18 |     }
19 | };
20 | 
21 | // Function to convert sorted array to BST
22 | Node* sortedToBST(vector<int> num,int s,int e){
23 |     if(s > e){
24 |         return NULL;
25 |     }
26 |     int mid = (s+e)/2;
27 |     Node* root = new Node(num[mid]);
28 |     root->left = sortedToBST(num,s,mid-1);
29 |     root->right = sortedToBST(num,mid+1,e);
30 |     return root;
31 | }
32 | 
33 | // Printing the level order traversal
34 | void LevelOrder(Node* root){
35 |     if(root == NULL){
36 |         return;
37 |     }
38 |     queue<Node*> q;
39 |     q.push(root);
40 |     while(!q.empty()){
41 |         int n = q.size();
42 |         for(int i=0;i<n;i++){
43 |             Node* temp = q.front();
44 |             q.pop();
45 |             cout << temp->data << "->";
46 |             if(temp->left != NULL){
47 |                 q.push(temp->left);
48 |             }
49 |             if(temp->right != NULL){
50 |                 q.push(temp->right);
51 |             }
52 |         }
53 |     }
54 | }
55 | 
56 | int main(){
57 |     vector<int> v = {1,2,3,4,5,6,7,8,9,10};
58 |     Node* root = sortedToBST(v,0,v.size()-1);
59 |     LevelOrder(root);
60 |     return 0;
61 | }
62 | 
63 | // Output : 5->2->8->1->3->6->9->4->7->10->
64 | /*
65 |              5
66 |            /  \
67 |           2     8
68 |         /  \   /  \
69 |        1   3  6    9
70 |             \  \    \
71 |             4   7   10
72 | */


--------------------------------------------------------------------------------
/Tree/Tree_traversal.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<queue>
  3 | 
  4 | using namespace std;
  5 | 
  6 | /*
  7 | PreOrder = Printing node first then going left then right.
  8 | InOrder = First going left, printing the node and then going right.
  9 | PostOrder = First going left and right then printing the node.
 10 | LevelOrder = Printing the nodes which are at same level.
 11 | */
 12 | 
 13 | class Node{
 14 | public:
 15 |     int data;
 16 |     Node *left, *right;
 17 |     Node(int data){
 18 |         this->data = data;
 19 |         left = right = NULL;
 20 |     }
 21 | };
 22 | 
 23 | // Pre-order Traversal of Tree
 24 | void PreOrder(Node* root){
 25 |     if(root == NULL){
 26 |         return;
 27 |     }
 28 |     
 29 |     cout << root->data << "->";
 30 |     PreOrder(root->left);
 31 |     PreOrder(root->right);
 32 | }
 33 | 
 34 | // In-order Traversal of Tree
 35 | void InOrder(Node* root){
 36 |     if(root == NULL){
 37 |         return;
 38 |     }
 39 | 
 40 |     InOrder(root->left);
 41 |     cout << root->data << "->";
 42 |     InOrder(root->right);
 43 | }
 44 | 
 45 | // Post-Order Traversal Of Tree
 46 | void PostOrder(Node* root){
 47 |     if(root == NULL){
 48 |         return;
 49 |     }
 50 | 
 51 |     PostOrder(root->left);
 52 |     PostOrder(root->right);
 53 |     cout << root->data << "->";
 54 | }
 55 | 
 56 | // Level-Order Traversal of Tree
 57 | void LevelOrder(Node* root){
 58 |     if(root == NULL){
 59 |         return;
 60 |     }
 61 |     queue<Node*> q;
 62 |     q.push(root);
 63 |     while(!q.empty()){
 64 |         int n = q.size();
 65 |         for(int i=0;i<n;i++){
 66 |             Node* temp = q.front();
 67 |             q.pop();
 68 |             cout << temp->data << "->";
 69 |             if(temp->left != NULL){
 70 |                 q.push(temp->left);
 71 |             }
 72 |             if(temp->right != NULL){
 73 |                 q.push(temp->right);
 74 |             }
 75 |         }
 76 |     }
 77 | }
 78 | 
 79 | int main() {
 80 |   Node* root = new Node(1);
 81 |   root->left = new Node(12);
 82 |   root->right = new Node(9);
 83 |   root->left->left = new Node(5);
 84 |   root->left->right = new Node(6);
 85 |   root->right->left = new Node(8);
 86 |   root->right->right = new Node(15);
 87 | 
 88 |   /*-Tree structure
 89 |              1
 90 |            /   \
 91 |           12    9
 92 |         /   \  /  \
 93 |         5   6 8    15
 94 |   */
 95 | 
 96 |   cout << "\nIn-Order traversal \n";
 97 |   InOrder(root);
 98 |   // Output :- 5->12->6->1->8->9->15->
 99 | 
100 |   cout << "\nPre-Order Traversal \n";
101 |   PreOrder(root);
102 |   // Output :- 1->12->5->6->9->8->15->
103 | 
104 |   cout << "\nPost-Order Traversal \n";
105 |   PostOrder(root);
106 |   // Output :- 5->6->12->8->15->9->1->
107 |   
108 |   cout << "\nLevel-Order Traversal \n";
109 |   LevelOrder(root);
110 |   // Output :- 1->12->9->5->6->8->15->
111 | 
112 |   return 0;
113 | }


--------------------------------------------------------------------------------
/Tree/tree_vertical_order_print:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | class node{
 5 |     public:
 6 |     int data;
 7 |     node* left;
 8 |     node* right;
 9 |     node(int d){
10 |         data=d;
11 |         left=NULL;
12 |         right=NULL;
13 |     }
14 | };
15 | node * binary_tree(int dis,map<int,vector<int>>&m){
16 |     int d;cin>>d;
17 |     if(d==-1){
18 |         return NULL;
19 |     }
20 |     node* tree=new node(d);
21 |     m[dis].push_back(d);
22 |     tree->left=binary_tree(dis-1,m);
23 |     tree->right=binary_tree(dis+1,m);
24 |     return tree;
25 | }
26 | void print(node *t){
27 |     if(t==NULL){
28 |         return;
29 |     }
30 |     cout<<(t->data)<<" ";
31 |     print(t->left);
32 |     print(t->right);
33 | }
34 | int main() {
35 |     int dis=0;
36 |     map<int,vector<int>>m;
37 |     node *t=binary_tree(dis,m);
38 |     print(t);
39 |     cout<<endl;
40 |     for(auto x:m){
41 |         cout<<x.first<<" -> ";
42 |         for(auto y:x.second){
43 |             cout<<y<<" ";
44 |         }
45 |         cout<<endl;
46 |     }
47 |    return 0;
48 | }
49 | 


--------------------------------------------------------------------------------
/banker's algo/banker_algo_implementation.txt:
--------------------------------------------------------------------------------
  1 | #include <bits/stdc++.h>
  2 | using namespace std;
  3 | 
  4 | bool ek_bhi_mil_rha(vector<vector<int>>remaining_need, vector<int>currrently_available,vector<int>done_process){
  5 |     int count=0;
  6 |     for(auto x:done_process){
  7 |         if(x==0){
  8 |             count++;
  9 |         }
 10 |     }
 11 |     for(int i=0;i<remaining_need.size();i++){
 12 |         if(done_process[i]==1){
 13 |             continue;
 14 |         }
 15 |         bool flag=false;
 16 |         for(int j=0;j<remaining_need[i].size();j++){
 17 |             if(remaining_need[i][j] > currrently_available[j]){
 18 |                 flag=true;
 19 |                 break;
 20 |             }
 21 |         }
 22 |         if(flag==true){
 23 |             count--;
 24 |         }    
 25 |     }
 26 |     if(count>0){
 27 |         return true;
 28 |     }
 29 |     return false;
 30 | }
 31 | 
 32 | int main() {
 33 |     // input number of processes
 34 |     int number_of_process;
 35 |     cout<<"Enter Number of Processes:"<<endl;
 36 |     cin>>number_of_process;
 37 |     // input number of resources
 38 |     int number_of_resources;
 39 |     cout<<"Enter Number of Resources:"<<endl;
 40 |     cin>>number_of_resources;
 41 |     // input total instances of each resources
 42 |     int total_resources_count[number_of_resources];
 43 |     cout<<"Enter Total instances of each resource:"<<endl;
 44 |     int temp=1;
 45 |     for(int i=0;i<number_of_resources;i++){
 46 |         cout<<"Enter total instances of Resource "<<(temp++)<<" :"<<endl;
 47 |         int a;
 48 |         cin>>a;
 49 |         total_resources_count[i]=a;
 50 |     }
 51 | 
 52 |     vector<vector<int>>allocation;
 53 |     vector<vector<int>>max_need;
 54 |     vector<int>currrently_available;
 55 |     vector<vector<int>>remaining_need;
 56 | 
 57 |     // fill allocation and max_need now
 58 |     temp=1;
 59 |     cout<<"Now, Enter Allocation and maximum need of each resource for each process: "<<endl;
 60 |     for(int i=0;i<number_of_process;i++){
 61 |         // input for allocation
 62 |         vector<int>k;
 63 |         cout<<"Enter Allocation for process "<<(temp)<<" :"<<endl;
 64 |         for(int j=0;j<number_of_resources;j++){
 65 |             cout<<"For resources "<<(j+1)<<" :"<<endl;
 66 |             int a;cin>>a;
 67 |             k.push_back(a);
 68 |         }
 69 |         allocation.push_back(k);
 70 |         // input for max_need
 71 |         vector<int>l;
 72 |         cout<<"Enter maximum need for process "<<(temp)<<" :"<<endl;
 73 |         for(int j=0;j<number_of_resources;j++){
 74 |             cout<<"For resources "<<(j+1)<<" :"<<endl;
 75 |             int a;cin>>a;
 76 |             l.push_back(a);
 77 |         }
 78 |         max_need.push_back(l);
 79 |         temp++;
 80 |     }
 81 |     // remaining need
 82 |     
 83 |     for(int i=0;i<number_of_process;i++){
 84 |         vector<int>k;
 85 |         for(int j=0;j<number_of_resources;j++){
 86 |             k.push_back(max_need[i][j]-allocation[i][j]);
 87 |         }
 88 |         remaining_need.push_back(k);
 89 |     }
 90 |     
 91 |     // 3 tables done
 92 |     // now for available
 93 |     int resources_in_use[number_of_resources]={};
 94 |     for(auto x:allocation){
 95 |         for(int i=0;i<x.size();i++){
 96 |             resources_in_use[i]+=x[i];
 97 |         }
 98 |     }
 99 |     // complete current available at beginning
100 |     for(int i=0;i<number_of_resources;i++){
101 |         currrently_available.push_back(total_resources_count[i]-resources_in_use[i]);
102 |     }
103 |     // all directed to zero, means none of the process is completed right now.
104 |     vector<int>done_process(number_of_process,0);
105 |     cout<<endl;
106 |     // jb tk pure process me se, ek tho bhi complete hone layak hai, chalate rho
107 |     while(ek_bhi_mil_rha(remaining_need,currrently_available,done_process)){
108 |         for(int i=0;i<remaining_need.size();i++){
109 |             bool flag=false;
110 |             for(int j=0;j<remaining_need[i].size();j++){
111 |                 if(remaining_need[i][j] > currrently_available[j]){
112 |                     flag=true;
113 |                 }
114 |             }
115 |             // if flag is true means that process can't be processed right now.
116 |             if(flag==true){
117 |                 continue;
118 |             }
119 |             // else if not true, means that process can be processed
120 |             // lets complete that process
121 |             if(done_process[i]==0){
122 |                 done_process[i]=1;
123 |                 cout<<"completed process: "<<(i+1)<<endl;
124 |                 for(int j=0;j<allocation[i].size();j++){
125 |                     currrently_available[j]+=allocation[i][j];
126 |                 }
127 |             }
128 |             // current available also updated
129 |         }
130 |     }
131 |     int ans=0;
132 |     for(int i=0;i<number_of_resources;i++){
133 |         if(currrently_available[i]==total_resources_count[i]){
134 |             continue;
135 |         }
136 |         ans=1;
137 |     }
138 |     cout<<endl;
139 |     if(ans==0){
140 |         cout<<"In safe state!!"<<endl;
141 |         cout<<"Current Avalilable instances for each resources are:"<<endl;
142 |         for(int i=0;i<number_of_resources;i++){
143 |             cout<<"For Resource "<<(i+1)<<": "<<currrently_available[i]<<endl;
144 |         }
145 |         cout<<endl;
146 |     }
147 |     else{
148 |         cout<<"Not in safe state."<<endl;
149 |         cout<<"Current Avalilable instances for each resources are:"<<endl;
150 |         for(int i=0;i<number_of_resources;i++){
151 |             cout<<"For Resource "<<(i+1)<<": "<<currrently_available[i]<<endl;
152 |         }
153 |         cout<<endl;
154 |     }
155 |     cout<<endl;
156 |     return 0;
157 | }
158 | 


--------------------------------------------------------------------------------
/basic_algo/Bucket sort:
--------------------------------------------------------------------------------
 1 | #include <algorithm>
 2 | #include <iostream>
 3 | #include <vector>
 4 | using namespace std;
 5 | 
 6 | 
 7 | void bucketSort(float arr[], int n)
 8 | {
 9 | 	
10 | 	// 1) Create n empty buckets
11 | 	vector<float> b[n];
12 | 
13 | 	// 2) Put array elements
14 | 	// in different buckets
15 | 	for (int i = 0; i < n; i++) {
16 | 		int bi = n * arr[i]; // Index in bucket
17 | 		b[bi].push_back(arr[i]);
18 | 	}
19 | 
20 | 	// 3) Sort individual buckets
21 | 	for (int i = 0; i < n; i++)
22 | 		sort(b[i].begin(), b[i].end());
23 | 
24 | 	// 4) Concatenate all buckets into arr[]
25 | 	int index = 0;
26 | 	for (int i = 0; i < n; i++)
27 | 		for (int j = 0; j < b[i].size(); j++)
28 | 			arr[index++] = b[i][j];
29 | }
30 | 
31 | /* Driver program to test above function */
32 | int main()
33 | {
34 | 	float arr[]
35 | 		= { 0.897, 0.565, 0.656, 0.1234, 0.665, 0.3434 };
36 | 	int n = sizeof(arr) / sizeof(arr[0]);
37 | 	bucketSort(arr, n);
38 | 
39 | 	cout << "Sorted array is \n";
40 | 	for (int i = 0; i < n; i++)
41 | 		cout << arr[i] << " ";
42 | 	return 0;
43 | }
44 | 


--------------------------------------------------------------------------------
/basic_algo/Cycle Sort:
--------------------------------------------------------------------------------
 1 | // C++ program to implement cycle sort
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | // Function sort the array using Cycle sort
 6 | void cycleSort(int arr[], int n)
 7 | {
 8 | 	// count number of memory writes
 9 | 	int writes = 0;
10 | 
11 | 	// traverse array elements and put it to on
12 | 	// the right place
13 | 	for (int cycle_start = 0; cycle_start <= n - 2; cycle_start++) {
14 | 		// initialize item as starting point
15 | 		int item = arr[cycle_start];
16 | 
17 | 		// Find position where we put the item. We basically
18 | 		// count all smaller elements on right side of item.
19 | 		int pos = cycle_start;
20 | 		for (int i = cycle_start + 1; i < n; i++)
21 | 			if (arr[i] < item)
22 | 				pos++;
23 | 
24 | 		// If item is already in correct position
25 | 		if (pos == cycle_start)
26 | 			continue;
27 | 
28 | 		// ignore all duplicate elements
29 | 		while (item == arr[pos])
30 | 			pos += 1;
31 | 
32 | 		// put the item to it's right position
33 | 		if (pos != cycle_start) {
34 | 			swap(item, arr[pos]);
35 | 			writes++;
36 | 		}
37 | 
38 | 		// Rotate rest of the cycle
39 | 		while (pos != cycle_start) {
40 | 			pos = cycle_start;
41 | 
42 | 			// Find position where we put the element
43 | 			for (int i = cycle_start + 1; i < n; i++)
44 | 				if (arr[i] < item)
45 | 					pos += 1;
46 | 
47 | 			// ignore all duplicate elements
48 | 			while (item == arr[pos])
49 | 				pos += 1;
50 | 
51 | 			// put the item to it's right position
52 | 			if (item != arr[pos]) {
53 | 				swap(item, arr[pos]);
54 | 				writes++;
55 | 			}
56 | 		}
57 | 	}
58 | 
59 | 	// Number of memory writes or swaps
60 | 	// cout << writes << endl ;
61 | }
62 | 
63 | // Driver program to test above function
64 | int main()
65 | {
66 | 	int arr[] = { 1, 8, 3, 9, 10, 10, 2, 4 };
67 | 	int n = sizeof(arr) / sizeof(arr[0]);
68 | 	cycleSort(arr, n);
69 | 
70 | 	cout << "After sort : " << endl;
71 | 	for (int i = 0; i < n; i++)
72 | 		cout << arr[i] << " ";
73 | 	return 0;
74 | }
75 | 


--------------------------------------------------------------------------------
/basic_algo/bubble_sort.py:
--------------------------------------------------------------------------------
 1 | 
 2 | value = [81, 24 , 4783, 38, -37, 10]
 3 | 
 4 | def bubbleSort(arr):
 5 | 
 6 |   for i in range(len(arr)):
 7 | 
 8 |     for j in range(0, len(arr) - i - 1):
 9 |       if arr[j] > arr[j + 1]:
10 | 
11 |         temp = arr[j]
12 |         arr[j] = arr[j+1]
13 |         arr[j+1] = temp
14 | 
15 | 
16 | 
17 | bubbleSort(value)
18 | print(value)


--------------------------------------------------------------------------------
/basic_algo/cycle_sort.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>  
 2 | void sort(int a[], int n)  
 3 | {  
 4 |     int writes = 0,start,element,pos,temp,i;  
 5 |    
 6 |     for (start = 0; start <= n - 2; start++) {  
 7 |         element = a[start];  
 8 |         pos = start;  
 9 |         for (i = start + 1; i < n; i++)  
10 |             if (a[i] < element)  
11 |                 pos++;  
12 |         if (pos == start)  
13 |             continue;  
14 |         while (element == a[pos])  
15 |             pos += 1;  
16 |         if (pos != start) {  
17 |             //swap(element, a[pos]);  
18 |         temp = element;  
19 |         element = a[pos];  
20 |             a[pos] = temp;    
21 |             writes++;  
22 |         }  
23 |         while (pos != start) {  
24 |             pos = start;  
25 |             for (i = start + 1; i < n; i++)  
26 |                 if (a[i] < element)  
27 |                     pos += 1;  
28 |             while (element == a[pos])  
29 |                 pos += 1;  
30 |             if (element != a[pos]) {  
31 |               temp = element;  
32 |           element = a[pos];  
33 |               a[pos] = temp;    
34 |                 writes++;  
35 |             }  
36 |         }  
37 |     }  
38 |    
39 |  }  
40 |    
41 | int main()  
42 | {  
43 |     int a[] = {1, 9, 2, 4, 2, 10, 45, 3, 2};  
44 |     int n = sizeof(a) / sizeof(a[0]),i;  
45 |     sort(a, n);  
46 |     printf("After sort, array : ");  
47 |     for (i = 0; i < n; i++)  
48 |         printf("%d  ",a[i]);  
49 |     return 0;  
50 | }  
51 | 


--------------------------------------------------------------------------------
/basic_algo/heapSort.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | void heapify(int arr[], int n, int i) {
 5 | 
 6 |     int left = (i * 2) + 1, right = (i * 2) + 2;
 7 |     int largest = i;
 8 | 
 9 |     if (left < n && arr[left] > arr[largest])
10 |         largest = left;
11 |     if (right < n && arr[right] > arr[largest])
12 |         largest = right;
13 | 
14 |     if (largest != i) {
15 |         swap(arr[i], arr[largest]);
16 |         heapify(arr, n, largest);
17 |     }
18 | }
19 | void buildHeap(int arr[], int n) {
20 | 
21 |     for (int i = (n - 2) / 2; i >= 0; i--) {
22 |         heapify(arr, n, i);
23 |     }
24 | }
25 | void heapSort(int arr[], int n) {
26 |     buildHeap(arr, n);
27 |     for (int i = n - 1; i > 0; i--) {
28 |         swap(arr[0], arr[i]);
29 |         heapify(arr, i, 0);
30 |     }
31 | }
32 | int32_t main()
33 | {
34 |     ios_base::sync_with_stdio(false); cin.tie(0);
35 | #ifndef ONLINE_JUDGE
36 |     freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
37 | #endif
38 | 
39 | 
40 |     int n;
41 |     cin >> n;
42 |     int a[n];
43 |    
44 |     for (int i = 0; i < n; i++) {
45 |         cin >> a[i];
46 |     }
47 |    
48 |     heapSort(a, n);
49 | 
50 |     for (int i = 0; i < n; i++)
51 |         cout << a[i] << " ";
52 |     cout << endl;
53 | 
54 |     return 0;
55 | 
56 | }
57 | 
58 | 


--------------------------------------------------------------------------------
/basic_algo/insertion_sort.py:
--------------------------------------------------------------------------------
 1 | 
 2 | value = [81, 24 , 4783, 38, -37, 10]
 3 | 
 4 | def insertionSort(arr):
 5 | 
 6 |     for i in range(1, len(arr)):
 7 |         ins = arr[i]
 8 |         j = i - 1
 9 |                 
10 |         while j >= 0 and ins < arr[j]:
11 |             arr[j + 1] = arr[j]
12 |             j = j - 1
13 |         
14 |         arr[j + 1] = ins
15 | 
16 | 
17 | insertionSort(value)
18 | print(value)


--------------------------------------------------------------------------------
/basic_algo/mergeSort.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | void merge(vector<int> &a, int s, int m, int e) {
 5 |     int temp[e];
 6 |     int i = s, j = m + 1, k = s;
 7 |     while (i <= m and j <= e) {
 8 |         if (a[i] < a[j]) {
 9 |             temp[k++] = a[i++];
10 |         } else {
11 |             temp[k++] = a[j++];
12 |         }
13 |     }
14 |     while (i <= m) {
15 |         temp[k++] = a[i++];
16 |     }
17 |     while (j <= e) {
18 |         temp[k++] = a[j++];
19 |     }
20 |     for (int i = s; i <= e; i++) {
21 |         a[i] = temp[i];
22 |     }
23 | }
24 | void mergeSort(vector<int> &a, int s, int e) {
25 |     if (s >= e)
26 |         return;
27 |     int m = (s + e) / 2;
28 |     mergeSort(a, s, m );
29 |     mergeSort(a, m + 1, e);
30 |     merge(a, s, m, e);
31 | }
32 | 
33 | int32_t main()
34 | {
35 |     ios_base::sync_with_stdio(false); cin.tie(0);
36 |     int n;
37 |     cin >> n;
38 |     vector<int> a(n);
39 |     for (int i = 0; i < n; i++) {
40 |         cin >> a[i];
41 |     }
42 |     mergeSort(a, 0, n - 1);
43 |     for (int i = 0; i < n; i++)
44 |         cout << a[i] << " ";
45 |     cout << endl;
46 | 
47 |     return 0;
48 | 
49 | }
50 | 
51 | 


--------------------------------------------------------------------------------
/basic_algo/mergesort.py:
--------------------------------------------------------------------------------
 1 | # Python program for implementation of MergeSort
 2 | 
 3 | # Merges two subarrays of arr[].
 4 | # First subarray is arr[l..m]
 5 | # Second subarray is arr[m+1..r]
 6 | 
 7 | 
 8 | def merge(arr, l, m, r):
 9 |     n1 = m - l + 1
10 |     n2 = r - m
11 | 
12 |     # create temp arrays
13 |     L = [0] * (n1)
14 |     R = [0] * (n2)
15 | 
16 |     # Copy data to temp arrays L[] and R[]
17 |     for i in range(0, n1):
18 |         L[i] = arr[l + i]
19 | 
20 |     for j in range(0, n2):
21 |         R[j] = arr[m + 1 + j]
22 | 
23 |     # Merge the temp arrays back into arr[l..r]
24 |     i = 0	 # Initial index of first subarray
25 |     j = 0	 # Initial index of second subarray
26 |     k = l	 # Initial index of merged subarray
27 | 
28 |     while i < n1 and j < n2:
29 |         if L[i] <= R[j]:
30 |             arr[k] = L[i]
31 |             i += 1
32 |         else:
33 |             arr[k] = R[j]
34 |             j += 1
35 |         k += 1
36 | 
37 |     # Copy the remaining elements of L[], if there
38 |     # are any
39 |     while i < n1:
40 |         arr[k] = L[i]
41 |         i += 1
42 |         k += 1
43 | 
44 |     # Copy the remaining elements of R[], if there
45 |     # are any
46 |     while j < n2:
47 |         arr[k] = R[j]
48 |         j += 1
49 |         k += 1
50 | 
51 | # l is for left index and r is right index of the
52 | # sub-array of arr to be sorted
53 | 
54 | 
55 | def mergeSort(arr, l, r):
56 |     if l < r:
57 | 
58 |         # Same as (l+r)//2, but avoids overflow for
59 |         # large l and h
60 |         m = l+(r-l)//2
61 | 
62 |         # Sort first and second halves
63 |         mergeSort(arr, l, m)
64 |         mergeSort(arr, m+1, r)
65 |         merge(arr, l, m, r)
66 | 
67 | 
68 | # Driver code to test above
69 | arr = [12, 11, 13, 5, 6, 7]
70 | n = len(arr)
71 | print("Given array is")
72 | for i in range(n):
73 |     print("%d" % arr[i]),
74 | 
75 | mergeSort(arr, 0, n-1)
76 | print("\n\nSorted array is")
77 | for i in range(n):
78 |     print("%d" % arr[i]),
79 | 
80 | # This code is contributed by Mohit Kumra
81 | 


--------------------------------------------------------------------------------
/basic_algo/quickSort.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int partition(vector<int> &a, int s, int e) {
 5 |     int i = s - 1;
 6 |     int j = s;
 7 |     int pivot = a[e];
 8 |     for (; j < e; j++) {
 9 |         if (a[j] <= pivot) {
10 |             i++;
11 |             swap(a[i], a[j]);
12 |         }
13 |     }
14 |     swap(a[i + 1], a[e]);
15 |     return i + 1;
16 | 
17 | }
18 | 
19 | void quickSort(vector<int> &a, int s, int e) {
20 |     if (s >= e)
21 |         return;
22 |     int p = partition(a, s, e);
23 |     quickSort(a, s, p - 1);
24 |     quickSort(a, p + 1, e);
25 |     return;
26 | }
27 | 
28 | int32_t main()
29 | {
30 |     ios_base::sync_with_stdio(false); cin.tie(0);
31 |     int n;
32 |     cin >> n;
33 |   
34 |     vector<int> a(n);
35 |     for (int i = 0; i < n; i++) {
36 |         cin >> a[i];
37 |     }
38 | 
39 |     quickSort(a, 0, n - 1);
40 |   
41 |     for (int i = 0; i < n; i++)
42 |         cout << a[i] << " ";
43 |     cout << endl;
44 | 
45 |     return 0;
46 | 
47 | }
48 | 


--------------------------------------------------------------------------------
/basic_algo/radix-sort.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 |  
 3 | using namespace std;
 4 |  
 5 | // Get maximum value from array.
 6 | int getMax(int arr[], int n)
 7 | {
 8 | 	int max = arr[0];
 9 | 	for (int i = 1; i < n; i++)
10 | 		if (arr[i] > max)
11 | 			max = arr[i];
12 | 	return max;
13 | }
14 |  
15 | // Count sort of arr[].
16 | void countSort(int arr[], int n, int exp)
17 | {
18 | 	// Count[i] array will be counting the number of array values having that 'i' digit at their (exp)th place.  
19 | 	int output[n], i, count[10] = {0};
20 |  
21 | 	// Count the number of times each digit occurred at (exp)th place in every input.
22 | 	for (i = 0; i < n; i++)
23 | 		count[(arr[i] / exp) % 10]++;
24 |  
25 | 	// Calculating their cumulative count.
26 | 	for (i = 1; i < 10; i++)
27 | 		count[i] += count[i-1];
28 |  
29 | 	// Inserting values according to the digit '(arr[i] / exp) % 10' fetched into count[(arr[i] / exp) % 10].
30 | 	for (i = n - 1; i >= 0; i--)
31 | 	{
32 | 		output[count[(arr[i] / exp) % 10] - 1] = arr[i];
33 | 		count[(arr[i] / exp) % 10]--;
34 | 	}
35 |  
36 | 	// Assigning the result to the arr pointer of main().
37 | 	for (i = 0; i < n; i++)
38 | 		arr[i] = output[i];
39 | }
40 |  
41 | // Sort arr[] of size n using Radix Sort.
42 | void radixsort(int arr[], int n)
43 | {
44 | 	int exp, m;
45 | 	m = getMax(arr, n);
46 |  
47 | 	// Calling countSort() for digit at (exp)th place in every input.
48 | 	for (exp = 1; m/exp > 0; exp *= 10)
49 | 		countSort(arr, n, exp);
50 | }
51 |  
52 | int main()
53 | {
54 | 	int n, i;
55 | 	cout<<"\nEnter the number of data element to be sorted: ";
56 | 	cin>>n;
57 |  
58 | 	int arr[n];
59 | 	for(i = 0; i < n; i++)
60 | 	{
61 | 		cout<<"Enter element "<<i+1<<": ";
62 | 		cin>>arr[i];
63 | 	}
64 |  
65 | 	radixsort(arr, n);
66 |  
67 | 	// Printing the sorted data.
68 | 	cout<<"\nSorted Data ";
69 | 	for (i = 0; i < n; i++)
70 | 		cout<<"->"<<arr[i];
71 | 	return 0;
72 | }


--------------------------------------------------------------------------------
/basic_algo/selection_sort.py:
--------------------------------------------------------------------------------
 1 | value = [81, 24, 4783, 38, -37, 10]
 2 | size = len(value)
 3 | 
 4 | 
 5 | def selectionSort(array, size):
 6 | 
 7 |     for i in range(size):
 8 |         min = i
 9 | 
10 |         for j in range(i + 1, size):
11 | 
12 |             if array[j] < array[min]:
13 |                 min = j
14 | 
15 |         (array[i], array[min]) = (array[min], array[i])
16 | 
17 | 
18 | selectionSort(value, size)
19 | print(value)
20 | 


--------------------------------------------------------------------------------
/machine-learning/knn.py:
--------------------------------------------------------------------------------
 1 | def dist(x1,x2):
 2 |     return np.sqrt(sum((x1-x2)**2))
 3 | 
 4 | # Test Time 
 5 | def knn(X,Y,queryPoint,k=5):
 6 |     
 7 |     vals = []
 8 |     m = X.shape[0]
 9 |     
10 |     for i in range(m):
11 |         d = dist(queryPoint,X[i])
12 |         vals.append((d,Y[i]))
13 |         
14 |     
15 |     vals = sorted(vals)
16 |     # Nearest/First K points
17 |     vals = vals[:k]
18 |     
19 |     vals = np.array(vals)
20 |         
21 |     new_vals = np.unique(vals[:,1],return_counts=True)
22 | 
23 |     
24 |     index = new_vals[1].argmax()
25 |     pred = new_vals[0][index]
26 |     
27 |     return pred
28 | 


--------------------------------------------------------------------------------
/machine-learning/linear_regression.py:
--------------------------------------------------------------------------------
 1 | def hypothesis(x,theta):
 2 |     y_ = theta[0] + theta[1]*x
 3 |     return y_
 4 | 
 5 | def gradient(X,Y,theta):
 6 |     m = X.shape[0]
 7 |     grad = np.zeros((2,))
 8 |     for i in range(m):
 9 |         x = X[i]
10 |         y_ = hypothesis(x,theta)
11 |         y = Y[i]
12 |         grad[0] += (y_ - y)
13 |         grad[1] += (y_ - y)*x
14 |     return grad/m
15 | 
16 | def error(X,Y,theta):
17 |     m = X.shape[0]
18 |     total_error = 0.0
19 |     for i in range(m):
20 |         y_ = hypothesis(X[i],theta)
21 |         total_error += (y_ - Y[i])**2
22 |         
23 |     return (total_error/m)
24 |     
25 | 
26 | def gradientDescent(X,Y,max_steps=100,learning_rate =0.1):
27 |     
28 |     theta = np.zeros((2,))
29 |     error_list = []
30 |     theta_list = []
31 |     
32 |    
33 |     for i in range(max_steps):
34 |         
35 |         # Compute grad
36 |         grad = gradient(X,Y,theta)
37 |         e = error(X,Y,theta)[0]
38 |         
39 |         
40 |         #Update theta
41 |         theta[0] = theta[0] - learning_rate*grad[0]
42 |         theta[1] = theta[1] - learning_rate*grad[1]
43 |         # Storing the theta values during updates
44 |         theta_list.append((theta[0],theta[1]))
45 |         error_list.append(e)
46 |         
47 |     return theta,error_list,theta_list


--------------------------------------------------------------------------------
/recursion/README.md:
--------------------------------------------------------------------------------
1 | ## Example
2 | ![factorial](https://user-images.githubusercontent.com/40532644/128869589-35749010-c05d-4c9a-92df-819d459fe44a.png)
3 | 
4 | ## This is how recursion Works
5 | ![giphy](https://user-images.githubusercontent.com/40532644/128869583-8ec9e387-86be-466e-a3f8-10982b312d47.gif)
6 | 
7 | Made with ❤️ by @PranaV-Shimpi


--------------------------------------------------------------------------------
/recursion/Sudoku.cpp:
--------------------------------------------------------------------------------
 1 | 	#include<bits/stdc++.h>
 2 | using namespace std;
 3 | bool isSafe(int mat[][9],int i,int j,int n,int no)
 4 | {
 5 | 	for(int k=0;k<n;k++)
 6 | 	{
 7 | 		if(mat[i][k]==no or mat[k][j]==no)
 8 | 			return false;
 9 | 	}
10 | 	int sx=(i/3)*3;
11 | 	int sy=(j/3)*3;
12 | 	for (int a=sx; a <sx+3 ; ++a)
13 | 	{
14 | 		for (int b = sy; b <sy+3 ; ++b)
15 | 		{
16 | 			if(mat[a][b]==no)
17 | 				return false;
18 | 		}
19 | 	}
20 | 	return true;
21 | }
22 | bool sudoku(int mat[][9],int i,int j,int n)
23 | {
24 | 	// Base condition for the Sudoku problem.
25 | 	if(j==n){
26 | 		return sudoku(mat,i+1,0,n);
27 | 	}
28 | 	if(i==n)
29 | 	{
30 | 		for (int a = 0; a < n; ++a)
31 | 		{
32 | 			for (int b = 0; b < n; ++b)
33 | 			{
34 | 				cout<<mat[a][b]<<" ";
35 | 			}
36 | 			cout<<endl;
37 | 		}
38 | 		return true;
39 | 
40 | 	}
41 | 	
42 | 	// If current no is not zero then skip to the next column.
43 | 	if(mat[i][j]!=0){
44 | 		return sudoku(mat,i,j+1,n);
45 | 	}
46 | 
47 | 	// check for every case 
48 | 	for(int no=1;no<=9;no++)
49 | 	{
50 | 		if(isSafe(mat,i,j,n,no))
51 | 		{
52 | 			mat[i][j]=no;
53 | 			bool subProblem=sudoku(mat,i,j+1,n);
54 | 			if(subProblem==true){
55 | 				return true;
56 | 			}
57 | 		}
58 | 	}
59 | 	mat[i][j]=0;
60 | 	return false;
61 | }
62 | int main()
63 | {
64 | 	int n=9;
65 | 	int mat[n][9]={
66 | 		{5,3,0,0,7,0,0,0,0},
67 | 		{6,0,0,1,9,5,0,0,0},
68 | 		{0,9,8,0,0,0,0,6,0},
69 | 		{8,0,0,0,6,0,0,0,3},
70 | 		{4,0,0,8,0,3,0,0,1},
71 | 		{7,0,0,0,2,0,0,0,6},
72 | 		{0,6,0,0,0,0,2,0,8},
73 | 		{0,0,0,4,1,9,0,0,5},
74 | 		{0,0,0,0,8,0,0,7,9}
75 | 	};
76 | 	if(!sudoku(mat,0,0,n)){
77 | 		cout<<"No Solution exist\n";
78 | 	}
79 | }


--------------------------------------------------------------------------------
/recursion/factorial.py:
--------------------------------------------------------------------------------
 1 | # Recursion : function calling itself is called recursion
 2 | 
 3 | 
 4 | """"
 5 | Program to print factorial of a number recursively.
 6 | def func(): <--
 7 |               |
 8 |               | (recursive call)
 9 |               |
10 |     func() ----
11 | """
12 | 
13 | 
14 | def recursive_factorial(n):
15 |     if n == 1:
16 |         return n
17 |     else:
18 |         return n * recursive_factorial(n-1)
19 | 
20 | 
21 | # user input
22 | num = int(input())
23 | 
24 | # check if the input is valid or not
25 | if num < 0:
26 |     print("Invalid input ! Please enter a positive number.")
27 | elif num == 0:
28 |     print("Factorial of number 0 is 1")
29 | else:
30 |     print("Factorial of number", num, "=", recursive_factorial(num))
31 | 
32 | """
33 |  cd recursion/python factorial.py
34 |  output: Factorial of number 5 = 120
35 |  
36 | """
37 | 


--------------------------------------------------------------------------------
/searching/binary-search.py:
--------------------------------------------------------------------------------
 1 | def binary_search(my_list, ele):
 2 |     low = 0
 3 |     high = len(my_list) - 1
 4 |     while low <= high:
 5 |         middle = low + (high - low) // 2
 6 |         if my_list[middle] == ele:
 7 |             return middle+1
 8 |         elif my_list[middle] < ele:
 9 |             low = middle + 1
10 |         else:
11 |             high = middle - 1
12 |     return -1
13 | 
14 | 
15 | my_list = [0, 1, 3, 4, 7, 8, 9]
16 | ele = int(input())
17 | pos = binary_search(my_list, ele)
18 | if pos > 0:
19 |     print("Element found at", pos)
20 | else:
21 |     print("Element not found")
22 | 


--------------------------------------------------------------------------------
/searching/linear-search.py:
--------------------------------------------------------------------------------
 1 | my_list = [4,8,3,7,1,0,9]
 2 | 
 3 | ele = int(input())
 4 | 
 5 | flag = False
 6 | for i in my_list:
 7 |     if(i == ele):
 8 |         flag = True
 9 |         break
10 | 
11 | if(flag==True):
12 |     print("Element found")
13 | else:
14 |     print("Element not found")


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