Merge pull request ephremdeme#1 from ephremdeme/master

Synced

Author: jaydulera

.all-contributorsrc

@@ -0,0 +1,22 @@
+//program to check if a number is armstrong number
+
+#include <iostream> 
+using namespace std; 
+int main() 
+{ 
+int n,r,sum=0,temp; 
+cout<<"Enter the Number= "; 
+cin>>n; 
+temp=n; 
+while(n>0) 
+{ 
+r=n%10; 
+sum=sum+(r*r*r); 
+n=n/10; 
+} 
+if(temp==sum) 
+cout<<"Armstrong Number."<<endl; 
+else 
+cout<<"Not Armstrong Number."<<endl; 
+return 0; 
+} 

Algorithms/Armstrong number.cpp

@@ -0,0 +1,16 @@
+def check_armstrong_num(n):
+ sum_of_cubes = 0
+ orig_n = n
+ while n > 0:
+ digit = n%10
+ sum_of_cubes = sum_of_cubes + pow(digit, 3)
+ n = n//10
+ 
+ if sum_of_cubes == orig_n:
+ return "Is an Armstrong Number"
+ else:
+ return "Not an Armstrong Number"
+
+number = int(input())
+result = check_armstrong_num(number)
+print(result)

Algorithms/ArmstrongNumber.py

@@ -0,0 +1,44 @@
+#include <bits/stdc++.h>
+
+using namespace std ; 
+vector <bool> vis ; 
+vector < vector <int> > adj ; 
+
+void BFS(int s)
+{
+ queue <int> q ; 
+ q.push(s) ;
+ vis[s] = true ; 
+ while (!q.empty())
+ {
+ int f = q.front() ; 
+ q.pop() ; 
+ cout<<f<<" " ; 
+ for(auto u : adj[f])
+ {
+ if(vis[u]==false)
+ {
+ q.push(u) ; 
+ vis[u] = true ; 
+ }
+ }
+ }
+ 
+}
+
+int main()
+{ cout<<"Enter number of Nodes and Edges\n" ; 
+ int n , e ; 
+ cin>>n>>e ; 
+ vis.assign(n ,false) ; 
+ adj.assign(n , vector <int> ()) ; 
+ int x , y ; 
+ cout<<"Enter Edges\n" ; 
+ for (int i = 0; i < e; i++) { 
+ cin>>x>>y ; 
+ adj[x].push_back(y) ; 
+ adj[y].push_back(x) ; 
+ } 
+ cout<<"BFS path from source node 0 : " ;
+ BFS(0) ; 
+}

Algorithms/BFS.cpp

@@ -0,0 +1,39 @@
+/*
+ * Checks if the entered string is a pallindrome or not.
+ */
+
+
+using System;
+using System.Collections.Generic;
+
+namespace DSA
+{
+ class Program
+ {
+ static void Main(string[] args)
+ {
+ Dictionary<char, int> characterPairs = new Dictionary<char, int>();
+ string input = Console.ReadLine();
+
+ foreach (char c in input)
+ {
+ if (characterPairs.ContainsKey(c))
+ characterPairs[c]++;
+ else
+ characterPairs[c] = 1;
+ }
+
+ int oddPairs = 0;
+ foreach (KeyValuePair<char, int> kvp in characterPairs)
+ {
+ 
+ if (characterPairs[kvp.Key] % 2 != 0)
+ oddPairs++;
+ }
+ if (oddPairs > 1)
+ Console.WriteLine("The string CANNOT be rearranged to a pallindrome");
+ else
+ Console.WriteLine("The string CAN be rearranged to a pallindrome");
+ }
+ }
+}

Algorithms/CheckStringPallindrome.cs

@@ -0,0 +1,63 @@
+
+using System;
+using System.Collections.Generic;
+using DataStructures.Graphs;
+
+namespace Algorithms.Graphs
+{
+ public class DijkstraAllPairsShortestPaths<TGraph, TVertex>
+ where TGraph : IGraph<TVertex>, IWeightedGraph<TVertex>
+ where TVertex : IComparable<TVertex>
+ {
+
+ Dictionary<TVertex, DijkstraShortestPaths<TGraph, TVertex>> _allPairsDjkstra;
+
+ public DijkstraAllPairsShortestPaths(TGraph Graph)
+ {
+ if (Graph == null)
+ throw new ArgumentNullException();
+
+ // Initialize the all pair
+ _allPairsDjkstra = new Dictionary<TVertex, DijkstraShortestPaths<TGraph, TVertex>>();
+
+ var vertices = Graph.Vertices;
+
+ foreach (var vertex in vertices)
+ {
+ var dijkstra = new DijkstraShortestPaths<TGraph, TVertex>(Graph, vertex);
+ _allPairsDjkstra.Add(vertex, dijkstra);
+ }
+ }
+
+
+ public bool HasPath(TVertex source, TVertex destination)
+ {
+ if (!_allPairsDjkstra.ContainsKey(source) || !_allPairsDjkstra.ContainsKey(destination))
+ throw new Exception("Either one of the vertices or both of them don't belong to Graph.");
+
+ return _allPairsDjkstra[source].HasPathTo(destination);
+ }
+
+
+ /// Returns the distance between source vertex and destination vertex.
+ public long PathDistance(TVertex source, TVertex destination)
+ {
+ if (!_allPairsDjkstra.ContainsKey(source) || !_allPairsDjkstra.ContainsKey(destination))
+ throw new Exception("Either one of the vertices or both of them don't belong to Graph.");
+
+ return _allPairsDjkstra[source].DistanceTo(destination);
+ }
+
+ /// Returns an enumerable collection of nodes that specify the shortest path from source vertex to destination vertex.
+ public IEnumerable<TVertex> ShortestPath(TVertex source, TVertex destination)
+ {
+ if (!_allPairsDjkstra.ContainsKey(source) || !_allPairsDjkstra.ContainsKey(destination))
+ throw new Exception("Either one of the vertices or both of them don't belong to Graph.");
+
+ return _allPairsDjkstra[source].ShortestPathTo(destination);
+ }
+
+ }
+
+}
+

Algorithms/Dijkstra Algorithm in c#/DijkstraAllPairsShortestPaths.cs

@@ -0,0 +1,158 @@
+using DataStructures.Graphs;
+using DataStructures.Heaps;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Algorithms.Graphs
+{
+ /// Computes Dijkstra's Shortest-Paths for Directed Weighted Graphs from a single-source to all destinations.
+ public class DijkstraShortestPaths<TGraph, TVertex>
+ where TGraph : IGraph<TVertex>, IWeightedGraph<TVertex>
+ where TVertex : IComparable<TVertex>
+ {
+ private const long Infinity = long.MaxValue;
+ private const int NilPredecessor = -1;
+
+ private long[] _distances;
+ private int[] _predecessors;
+
+ private Dictionary<TVertex, int> _nodesToIndices;
+ private Dictionary<int, TVertex> _indicesToNodes;
+
+ private MinPriorityQueue<TVertex, long> _minPriorityQueue;
+
+ private readonly TGraph _graph;
+ private readonly TVertex _source;
+
+ public DijkstraShortestPaths(TGraph graph, TVertex source)
+ {
+ if (graph == null)
+ throw new ArgumentNullException(nameof(graph));
+
+ if (source == null)
+ throw new ArgumentNullException(nameof(source));
+
+ if (!graph.HasVertex(source))
+ throw new ArgumentException("The source vertex doesn't belong to graph.");
+
+ if (graph.Edges.Any(edge => edge.Weight < 0))
+ throw new ArgumentException("Negative edge weight detected.");
+
+ _graph = graph;
+ _source = source;
+
+ _initialize();
+ _dijkstra();
+ }
+
+ /// The Dijkstra's algorithm.
+ private void _dijkstra()
+ {
+ while (!_minPriorityQueue.IsEmpty)
+ {
+ var currentVertex = _minPriorityQueue.DequeueMin();
+ var currentVertexIndex = _nodesToIndices[currentVertex];
+
+ var outgoingEdges = _graph.OutgoingEdges(currentVertex);
+ foreach (var outgoingEdge in outgoingEdges)
+ {
+ var adjacentIndex = _nodesToIndices[outgoingEdge.Destination];
+ var delta = _distances[currentVertexIndex] != Infinity ? _distances[currentVertexIndex] + outgoingEdge.Weight : Infinity;
+
+ if (delta < _distances[adjacentIndex])
+ {
+ _distances[adjacentIndex] = delta;
+ _predecessors[adjacentIndex] = currentVertexIndex;
+
+ if (_minPriorityQueue.Contains(outgoingEdge.Destination))
+ {
+ _minPriorityQueue.UpdatePriority(outgoingEdge.Destination, delta);
+ }
+ else
+ {
+ _minPriorityQueue.Enqueue(outgoingEdge.Destination, delta);
+ }
+ }
+ }
+ }
+ }
+
+ private void _initialize()
+ {
+ var verticesCount = _graph.VerticesCount;
+
+ _distances = new long[verticesCount];
+ _predecessors = new int[verticesCount];
+
+ _nodesToIndices = new Dictionary<TVertex, int>();
+ _indicesToNodes = new Dictionary<int, TVertex>();
+ _minPriorityQueue = new MinPriorityQueue<TVertex, long>((uint)verticesCount);
+
+ var vertices = _graph.Vertices.ToList();
+ for (int i = 0; i < verticesCount; i++)
+ {
+ if (_source.Equals(vertices[i]))
+ {
+ _distances[i] = 0;
+ _predecessors[i] = 0;
+ }
+ else
+ {
+ _distances[i] = Infinity;
+ _predecessors[i] = NilPredecessor;
+ }
+
+ _minPriorityQueue.Enqueue(vertices[i], _distances[i]);
+
+ _nodesToIndices.Add(vertices[i], i);
+ _indicesToNodes.Add(i, vertices[i]);
+ }
+ }
+
+ /// Determines whether there is a path from the source vertex to this specified vertex.
+ public bool HasPathTo(TVertex destination)
+ {
+ if (!_nodesToIndices.ContainsKey(destination))
+ throw new ArgumentException("Graph doesn't have the specified vertex.");
+
+ var index = _nodesToIndices[destination];
+ return _distances[index] != Infinity;
+ }
+
+ /// Returns the distance between the source vertex and the specified vertex.
+ public long DistanceTo(TVertex destination)
+ {
+ if (!_nodesToIndices.ContainsKey(destination))
+ throw new ArgumentException("Graph doesn't have the specified vertex.");
+
+ var index = _nodesToIndices[destination];
+ return _distances[index];
+ }
+
+ /// Returns an enumerable collection of nodes that specify the shortest path from the source vertex to the destination vertex.
+ public IEnumerable<TVertex> ShortestPathTo(TVertex destination)
+ {
+ if (!_nodesToIndices.ContainsKey(destination))
+ throw new ArgumentException("Graph doesn't have the specified vertex.");
+
+ if (!HasPathTo(destination))
+ {
+ return null;
+ }
+
+ var dstIndex = _nodesToIndices[destination];
+ var stack = new Stack<TVertex>();
+
+ int index;
+ for (index = dstIndex; _distances[index] != 0; index = _predecessors[index])
+ {
+ stack.Push(_indicesToNodes[index]);
+ }
+ stack.Push(_indicesToNodes[index]);
+
+ return stack;
+ }
+ }
+}
+