Merge branch 'master' of https://github.com/ephremdeme/data-structure-and-algorithms into issue-128__implement-fibonacci-series

Author: gebleksengek

.all-contributorsrc

@@ -288,6 +288,33 @@
  "contributions": [
  "code"
  ]
+ },
+ {
+ "login": "Palak-137",
+ "name": "Lethal_Moana",
+ "avatar_url": "https://avatars0.githubusercontent.com/u/54790525?v=4",
+ "profile": "https://github.com/Palak-137",
+ "contributions": [
+ "code"
+ ]
+ },
+ {
+ "login": "nikunjagarwal321",
+ "name": "Nikunj Agarwal",
+ "avatar_url": "https://avatars0.githubusercontent.com/u/35420775?v=4",
+ "profile": "http://www.nikunjagarwal.social",
+ "contributions": [
+ "code"
+ ]
+ },
+ {
+ "login": "Druffl3",
+ "name": "Goutham R",
+ "avatar_url": "https://avatars2.githubusercontent.com/u/28187687?v=4",
+ "profile": "https://github.com/Druffl3",
+ "contributions": [
+ "code"
+ ]
  }
  ],
  "contributorsPerLine": 7,

Algorithms/KadaneAlgorithm.cpp

@@ -0,0 +1,41 @@
+#include <iostream>
+
+using namespace std;
+
+
+class Kadane{
+ public:
+ int max_sum(int p[],int n){
+ int max_sum=p[0],max_in=p[0];
+ for(int i=1;i<n;i++){
+ max_sum = max(p[i],max_sum+p[i]);
+ max_in = max(max_in,max_sum);
+ }
+ return max_in;
+ }
+
+ void display(int p[],int n){
+ cout<<"Element in array "<<endl;
+ for(int i=0;i<n;i++){
+ cout<<p[i]<<" ";
+ }
+ }
+};
+
+
+int main()
+{
+ Kadane algo;
+ int n;
+ cout<<"Enter the size of array ";
+ cin>>n;
+ int p[n];
+ for (int i=0;i<n;i++){
+ cout<<"Enter the element in array ";
+ cin>>p[i];
+ }
+ algo.display(p,n);
+ int a = algo.max_sum(p,n);
+ cout<<"\n Largest sum of subarray using kadane algorithm is "<<a;
+ return 0;
+}

Algorithms/dijkstra_algo.cpp

@@ -0,0 +1,70 @@
+#include <limits.h> 
+#include <stdio.h> 
+
+#define V 9 
+
+int minDistance(int dist[], bool sptSet[])
+{
+// Initialize min value 
+int min = INT_MAX, min_index;
+
+for (int v = 0; v < V; v++)
+if (sptSet[v] == false && dist[v] <= min)
+min = dist[v], min_index = v;
+
+return min_index;
+}
+
+// A utility function to print the constructed distance array 
+int printSolution(int dist[], int n)
+{
+printf("Vertex Distance from Source\n");
+for (int i = 0; i < V; i++)
+printf("%d tt %d\n", i, dist[i]);
+}
+
+
+void dijkstra(int graph[V][V], int src)
+{
+int dist[V];
+bool sptSet[V];
+for (int i = 0; i < V; i++)
+dist[i] = INT_MAX, sptSet[i] = false;
+
+dist[src] = 0;
+
+for (int count = 0; count < V - 1; count++) {
+
+int u = minDistance(dist, sptSet);
+
+// Mark the picked vertex as processed 
+sptSet[u] = true;
+
+// Update dist value of the adjacent vertices of the picked vertex. 
+for (int v = 0; v < V; v++)
+if (!sptSet[v] && graph[u][v] && dist[u] != INT_MAX
+&& dist[u] + graph[u][v] < dist[v])
+dist[v] = dist[u] + graph[u][v];
+}
+
+printSolution(dist, V);
+}
+
+// driver program to test above function 
+int main()
+{
+
+int graph[V][V] = { { 0, 4, 0, 0, 0, 0, 0, 8, 0 },
+{ 4, 0, 8, 0, 0, 0, 0, 11, 0 },
+{ 0, 8, 0, 7, 0, 4, 0, 0, 2 },
+{ 0, 0, 7, 0, 9, 14, 0, 0, 0 },
+{ 0, 0, 0, 9, 0, 10, 0, 0, 0 },
+{ 0, 0, 4, 14, 10, 0, 2, 0, 0 },
+{ 0, 0, 0, 0, 0, 2, 0, 1, 6 },
+{ 8, 11, 0, 0, 0, 0, 1, 0, 7 },
+{ 0, 0, 2, 0, 0, 0, 6, 7, 0 } };
+
+dijkstra(graph, 0);
+
+return 0;
+}

Arrays/maxHourGlass.py

@@ -0,0 +1,59 @@
+# This python3 script accepts a nxn two dimensional matrix
+# and calculates the maximum hourglass sum possible from it.
+
+'''
+Example:
+In this 6x6 Matrix:
+
+1 1 1 0 0 0
+0 1 0 0 0 0
+1 1 1 0 0 0
+0 0 0 1 1 1
+0 0 0 0 1 0
+0 0 0 1 1 2
+
+The pattern:
+1 1 1
+0 1 0
+1 1 1
+
+makes 1 hour glass. And the sum of this hour glass is:
+1 + 1 + 1 + 1 + 1 + 1 + 1 = 7
+Similarly we need to find sum of all hourglasses in the Matrix
+And print the maximum sum.
+'''
+
+#Taking rank of the matrix from user
+n = int(input())
+l = []
+
+#Converting each string of row values into list and appending it to The
+#main two dimensional list 'l'
+for i in range(n):
+ il = list(map(int, input().split()))
+ l.append(il)
+
+#This will store our expected result
+finalSum = 0
+
+#Creating a 3x3 grid index to iterate over the two dimensional list And
+#calculate sum of the hourglasses.
+#-2 is added to make sure not to index beyond the actual list range.
+for r1 in range(n-2):
+ r2 = r1+1
+ r3 = r2+1
+ for c1 in range(n-2):
+ #to store sum of all hourglasses
+ res = 0
+ c2 = c1+1
+ c3 = c2+1
+ res = l[r1][c1] + l[r1][c2] + l[r1][c3] + l[r2][c2] + l[r3][c1] + l[r3][c2] + l[r3][c3]
+ #Maybe the first element is -ve, therefore need to store it no matter what.
+ if r1 == 0 and c1 == 0:
+ finalSum = res
+ #will always store the maximum result
+ if res > finalSum:
+ finalSum = res
+
+#print the maximum hourglass sum.
+print(finalSum)

README.md

@@ -59,6 +59,9 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d
  </tr>
  <tr>
  <td align="center"><a href="https://github.com/swastikchugh"><img src="https://avatars0.githubusercontent.com/u/17880938?v=4" width="100px;" alt=""/><br /><sub><b>swastikchugh</b></sub></a><br /><a href="https://github.com/ephremdeme/data-structure-and-algorithms/commits?author=swastikchugh" title="Code">💻</a></td>
+ <td align="center"><a href="https://github.com/Palak-137"><img src="https://avatars0.githubusercontent.com/u/54790525?v=4" width="100px;" alt=""/><br /><sub><b>Lethal_Moana</b></sub></a><br /><a href="https://github.com/ephremdeme/data-structure-and-algorithms/commits?author=Palak-137" title="Code">💻</a></td>
+ <td align="center"><a href="http://www.nikunjagarwal.social"><img src="https://avatars0.githubusercontent.com/u/35420775?v=4" width="100px;" alt=""/><br /><sub><b>Nikunj Agarwal</b></sub></a><br /><a href="https://github.com/ephremdeme/data-structure-and-algorithms/commits?author=nikunjagarwal321" title="Code">💻</a></td>
+ <td align="center"><a href="https://github.com/Druffl3"><img src="https://avatars2.githubusercontent.com/u/28187687?v=4" width="100px;" alt=""/><br /><sub><b>Goutham R</b></sub></a><br /><a href="https://github.com/ephremdeme/data-structure-and-algorithms/commits?author=Druffl3" title="Code">💻</a></td>
  </tr>
 </table>
 

graphs/dfs.cpp

@@ -0,0 +1,38 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+void dfsUtil(int currentNode, vector< vector<int> > &adj, vector<bool> &visited) {
+ visited[currentNode] = true;
+ cout << currentNode << " ";
+ for(int i = 0; i < adj[currentNode].size(); i++) {
+ int neighbour = adj[currentNode][i];
+ if(!visited[neighbour])
+ dfsUtil(neighbour, adj, visited);
+ }
+ return;
+}
+
+void dfs(int nodes, vector< vector<int> > &adj) {
+ vector<bool> visited(nodes+1, false);
+ for(int i = 1; i <= nodes; i++) {
+ if(!visited[i])
+ dfsUtil(i, adj, visited);
+ }
+ return;
+}
+
+
+int main() {
+ int nodes, edges, x, y;
+ cout << "Input number of nodes and edges: ";
+ cin >> nodes >> edges;
+ cout << "Input edges: \n";
+ vector< vector<int> > adj(nodes+1);
+ for(int i = 1; i <= edges; i++) {
+ cin >> x >> y;
+ adj[x].push_back(y);
+ adj[y].push_back(x);
+ } 
+ dfs(nodes, adj);
+ return 0;
+}

Algorithms/firstDuplicate.py renamed to problems/firstDuplicate.py

@@ -1,67 +1,74 @@
-#include<bits/stdc++.h>
-
-using namespace std ; 
-
-
-
-
-void heapify(int arr[], int n, int i) 
-{ 
- int largest = i; 
- int l = 2*i + 1; 
- int r = 2*i + 2; 
- 
- if (l < n && arr[l] > arr[largest]) 
- largest = l; 
- 
- if (r < n && arr[r] > arr[largest]) 
- largest = r; 
- 
- if (largest != i) 
- { 
- swap(arr[i], arr[largest]); 
- heapify(arr, n, largest); 
- } 
+#include <iostream>
+using namespace std;
+#include <iostream>
+using namespace std;
+
+
+void heapify(int n,int p[],int i)
+{
+//intilizing root
+int root = i;
+int left = i*2+1;
+int right = i*2+2;
+
+
+//finding largest element
+ if(p[right]>p[root]&& right<n){
+ root = right;
+ }
+ if(p[left]>p[root]&& left<n){
+ root = left;
+ }
+ if(root != i){
+ int temp = p[i];
+ p[i] = p[root];
+ p[root] = temp;
+
+
+ heapify(n,p,root);
+
+ }
+}
+
+void heap_sort(int p[],int n)
+{
+ //starting heapify from bottom
+ for(int i=n/2-1;i>=0;i--){
+ heapify(n,p,i);
+ }
+ //deleting element from heap
+ for(int i= n-1;i>0;i--)
+ {
+ //swaping to the root
+ int temp= p[0];
+ p[0] = p[i];
+ p[i] = temp;
+ //now heapify again
+ heapify(i,p,0);
+ }
+
 }
 
-void heapSort(int arr[], int n) 
-{ 
- 
- for (int i = n / 2 - 1; i >= 0; i--) 
- heapify(arr, n, i); 
- 
- 
- for (int i=n-1; i>0; i--) 
- { 
- 
- swap(arr[0], arr[i]); 
- 
- 
- heapify(arr, i, 0); 
- } 
-} 
 int main()
 {
- int n ; 
- cout<<"Enter Size of Array\n" ; 
- cin>>n ; 
- cout<<"Enter Numbers\n" ; 
- int arr[n] ; 
- for(int i = 0 ; i<n ; i++)
- {
- cin>>arr[i] ; 
- }
- cout<<"Unsorted Array: " ; 
- for(int i = 0 ; i<n ; i++)
- {
- cout<<arr[i]<<" " ; 
- }
- cout<<endl ; 
- cout<<"Sorted Array: " ; 
- heapSort(arr ,n ) ;
- for(int i = 0 ; i<n ; i++)
- {
- cout<<arr[i]<<" " ; 
- }
-
-}
+int n;
+cout <<"enter the size of array";
+cin >>n;
+int p[n];
+for(int i=0;i<n;i++){
+ cout <<"Enter the element in array : " ;
+ cin >>p[i];
+}
+
+heap_sort(p,n);
+
+for(int i=0;i<n;i++){
+ cout<<p[i]<<" ";
+}
+return 0;
+}
+
+
+
+
+