From a83454b4f99887e4fa068d22bf40b7305b97ec63 Mon Sep 17 00:00:00 2001 From: CHAITANYA KODAVALI Date: Thu, 28 Oct 2021 22:47:15 +0530 Subject: [PATCH 1/3] sorted existing matrices and improved performance --- C++/Algorithms/sorting.cpp | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 C++/Algorithms/sorting.cpp diff --git a/C++/Algorithms/sorting.cpp b/C++/Algorithms/sorting.cpp new file mode 100644 index 00000000..f0dbd560 --- /dev/null +++ b/C++/Algorithms/sorting.cpp @@ -0,0 +1,28 @@ +#include +using namespace std; +void selectionSort(int a[], int n) { + int i, j, min, temp; + for (i = 0; i < n - 1; i++) { + min = i; + for (j = i + 1; j < n; j++) + if (a[j] < a[min]) + min = j; + temp = a[i]; + a[i] = a[min]; + a[min] = temp; + } +} +int main() { + int a[] = { 22, 91, 35, 78, 10, 8, 75, 99, 1, 67 }; + int n = sizeof(a)/ sizeof(a[0]); + int i; + cout<<"Given array is:"< Date: Thu, 28 Oct 2021 23:09:16 +0530 Subject: [PATCH 2/3] Enhanced integrity check for Database schema --- .../Divide-and-Conquer/Intergrity.java | 53 +++++++++++++++++++ 1 file changed, 53 insertions(+) create mode 100644 Java/Algorithms/Divide-and-Conquer/Intergrity.java diff --git a/Java/Algorithms/Divide-and-Conquer/Intergrity.java b/Java/Algorithms/Divide-and-Conquer/Intergrity.java new file mode 100644 index 00000000..cd0a865d --- /dev/null +++ b/Java/Algorithms/Divide-and-Conquer/Intergrity.java @@ -0,0 +1,53 @@ +// Java program to calculate SHA-1 hash value + +import java.math.BigInteger; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; + +public class GFG { + public static String encryptThisString(String input) + { + try { + // getInstance() method is called with algorithm SHA-1 + MessageDigest md = MessageDigest.getInstance("SHA-1"); + + // digest() method is called + // to calculate message digest of the input string + // returned as array of byte + byte[] messageDigest = md.digest(input.getBytes()); + + // Convert byte array into signum representation + BigInteger no = new BigInteger(1, messageDigest); + + // Convert message digest into hex value + String hashtext = no.toString(16); + + // Add preceding 0s to make it 32 bit + while (hashtext.length() < 32) { + hashtext = "0" + hashtext; + } + + // return the HashText + return hashtext; + } + + // For specifying wrong message digest algorithms + catch (NoSuchAlgorithmException e) { + throw new RuntimeException(e); + } + } + + // Driver code + public static void main(String args[]) throws + NoSuchAlgorithmException + { + + System.out.println("HashCode Generated by SHA-1 for: "); + + String s1 = "GeeksForGeeks"; + System.out.println("\n" + s1 + " : " + encryptThisString(s1)); + + String s2 = "hello world"; + System.out.println("\n" + s2 + " : " + encryptThisString(s2)); + } +} From 966ae11ac3cceba1bbcf9d2951096aca5ad30a0f Mon Sep 17 00:00:00 2001 From: CHAITANYA KODAVALI Date: Thu, 28 Oct 2021 23:47:06 +0530 Subject: [PATCH 3/3] Amplified the traversal of the desirable node using greedy approach --- .../Greedy-Algorithms/greedy_ford.cpp | 136 ++++++++++++++++++ 1 file changed, 136 insertions(+) create mode 100644 C++/Algorithms/Greedy-Algorithms/greedy_ford.cpp diff --git a/C++/Algorithms/Greedy-Algorithms/greedy_ford.cpp b/C++/Algorithms/Greedy-Algorithms/greedy_ford.cpp new file mode 100644 index 00000000..6c9b6ac2 --- /dev/null +++ b/C++/Algorithms/Greedy-Algorithms/greedy_ford.cpp @@ -0,0 +1,136 @@ +// A C++ program for Bellman-Ford's single source +// shortest path algorithm. +#include + +// a structure to represent a weighted edge in graph +struct Edge { + int src, dest, weight; +}; + +// a structure to represent a connected, directed and +// weighted graph +struct Graph { + // V-> Number of vertices, E-> Number of edges + int V, E; + + // graph is represented as an array of edges. + struct Edge* edge; +}; + +// Creates a graph with V vertices and E edges +struct Graph* createGraph(int V, int E) +{ + struct Graph* graph = new Graph; + graph->V = V; + graph->E = E; + graph->edge = new Edge[E]; + return graph; +} + +// A utility function used to print the solution +void printArr(int dist[], int n) +{ + printf("Vertex Distance from Source\n"); + for (int i = 0; i < n; ++i) + printf("%d \t\t %d\n", i, dist[i]); +} + +// The main function that finds shortest distances from src to +// all other vertices using Bellman-Ford algorithm. The function +// also detects negative weight cycle +void BellmanFord(struct Graph* graph, int src) +{ + int V = graph->V; + int E = graph->E; + int dist[V]; + + // Step 1: Initialize distances from src to all other vertices + // as INFINITE + for (int i = 0; i < V; i++) + dist[i] = INT_MAX; + dist[src] = 0; + + // Step 2: Relax all edges |V| - 1 times. A simple shortest + // path from src to any other vertex can have at-most |V| - 1 + // edges + for (int i = 1; i <= V - 1; i++) { + for (int j = 0; j < E; j++) { + int u = graph->edge[j].src; + int v = graph->edge[j].dest; + int weight = graph->edge[j].weight; + if (dist[u] != INT_MAX && dist[u] + weight < dist[v]) + dist[v] = dist[u] + weight; + } + } + + // Step 3: check for negative-weight cycles. The above step + // guarantees shortest distances if graph doesn't contain + // negative weight cycle. If we get a shorter path, then there + // is a cycle. + for (int i = 0; i < E; i++) { + int u = graph->edge[i].src; + int v = graph->edge[i].dest; + int weight = graph->edge[i].weight; + if (dist[u] != INT_MAX && dist[u] + weight < dist[v]) { + printf("Graph contains negative weight cycle"); + return; // If negative cycle is detected, simply return + } + } + + printArr(dist, V); + + return; +} + +// Driver program to test above functions +int main() +{ + /* Let us create the graph given in above example */ + int V = 5; // Number of vertices in graph + int E = 8; // Number of edges in graph + struct Graph* graph = createGraph(V, E); + + // add edge 0-1 (or A-B in above figure) + graph->edge[0].src = 0; + graph->edge[0].dest = 1; + graph->edge[0].weight = -1; + + // add edge 0-2 (or A-C in above figure) + graph->edge[1].src = 0; + graph->edge[1].dest = 2; + graph->edge[1].weight = 4; + + // add edge 1-2 (or B-C in above figure) + graph->edge[2].src = 1; + graph->edge[2].dest = 2; + graph->edge[2].weight = 3; + + // add edge 1-3 (or B-D in above figure) + graph->edge[3].src = 1; + graph->edge[3].dest = 3; + graph->edge[3].weight = 2; + + // add edge 1-4 (or A-E in above figure) + graph->edge[4].src = 1; + graph->edge[4].dest = 4; + graph->edge[4].weight = 2; + + // add edge 3-2 (or D-C in above figure) + graph->edge[5].src = 3; + graph->edge[5].dest = 2; + graph->edge[5].weight = 5; + + // add edge 3-1 (or D-B in above figure) + graph->edge[6].src = 3; + graph->edge[6].dest = 1; + graph->edge[6].weight = 1; + + // add edge 4-3 (or E-D in above figure) + graph->edge[7].src = 4; + graph->edge[7].dest = 3; + graph->edge[7].weight = -3; + + BellmanFord(graph, 0); + + return 0; +}