Formatted code with gofmt -s to meet style requirements

Author: mapcrafter2048

cipher/caesar/caesar.go

@@ -1,6 +1,6 @@
 // Package caesar is the shift cipher
 // description: Caesar cipher
-// details : Caesar cipher is a type of substitution cipher in which each letter in the plaintext is shifted a certain number of places down the alphabet.	
+// details : Caesar cipher is a type of substitution cipher in which each letter in the plaintext is shifted a certain number of places down the alphabet.
 // time complexity: O(n)
 // space complexity: O(n)
 // ref: https://en.wikipedia.org/wiki/Caesar_cipher

cipher/diffiehellman/diffiehellmankeyexchange.go

@@ -1,6 +1,6 @@
 // Package diffiehellman implements Diffie-Hellman Key Exchange Algorithm
 // description: Diffie-Hellman key exchange
-// details : Diffie-Hellman key exchange is a method of securely exchanging cryptographic keys over a public channel by combining private keys of two parties to generate a shared secret key. 
+// details : Diffie-Hellman key exchange is a method of securely exchanging cryptographic keys over a public channel by combining private keys of two parties to generate a shared secret key.
 // time complexity: O(log(n))
 // space complexity: O(1)
 // for more information watch : https://www.youtube.com/watch?v=NmM9HA2MQGI

cipher/railfence/railfence.go

@@ -1,6 +1,6 @@
 // railfence.go
 // description: Rail Fence Cipher
-// details: The rail fence cipher is a an encryption algorithm that uses a rail fence pattern to encode a message. it is a type of transposition cipher that rearranges the characters of the plaintext to form the ciphertext. 
+// details: The rail fence cipher is a an encryption algorithm that uses a rail fence pattern to encode a message. it is a type of transposition cipher that rearranges the characters of the plaintext to form the ciphertext.
 // time complexity: O(n)
 // space complexity: O(n)
 // ref: https://en.wikipedia.org/wiki/Rail_fence_cipher

cipher/rot13/rot13.go

@@ -1,6 +1,6 @@
 // Package rot13 is a simple letter substitution cipher that replaces a letter with the 13th letter after it in the alphabet.
 // description: ROT13
-// details: ROT13 is a simple letter substitution cipher that replaces a letter with the 13th letter after it in the alphabet. it is a special case of the Caesar cipher 
+// details: ROT13 is a simple letter substitution cipher that replaces a letter with the 13th letter after it in the alphabet. it is a special case of the Caesar cipher
 // time complexity: O(n)
 // space complexity: O(n)
 // ref: https://en.wikipedia.org/wiki/ROT13

dynamic/uniquepaths.go

@@ -1,6 +1,6 @@
 // See https://leetcode.com/problems/unique-paths/
 // time complexity: O(m*n) where m and n are the dimensions of the grid
-// space complexity: O(m*n) where m and n are the dimensions of the grid 
+// space complexity: O(m*n) where m and n are the dimensions of the grid
 // author: Rares Mateizer (https://github.com/rares985)
 package dynamic
 

graph/bellmanford.go

@@ -4,7 +4,7 @@
 // https://en.wikipedia.org/wiki/Bellman%E2%80%93Ford_algorithm
 // Implementation is based on the book 'Introduction to Algorithms' (CLRS)
 // time complexity: O(V*E) where V is the number of vertices and E is the number of edges in the graph
-// space complexity: O(V) where V is the number of vertices in the graph 
+// space complexity: O(V) where V is the number of vertices in the graph
 
 package graph
 

graph/breadthfirstsearch.go

@@ -3,7 +3,7 @@ package graph
 // BreadthFirstSearch is an algorithm for traversing and searching graph data structures.
 // It starts at an arbitrary node of a graph, and explores all of the neighbor nodes
 // at the present depth prior to moving on to the nodes at the next depth level.
-// Worst-case performance	 		O(|V|+|E|)=O(b^{d})}O(|V|+|E|)=O(b^{d}) where |V| is the number of vertices and |E| is the number of edges in the graph and b is the branching factor of the graph (the average number of successors of a node). d is the depth of the goal node. 
+// Worst-case performance	 		O(|V|+|E|)=O(b^{d})}O(|V|+|E|)=O(b^{d}) where |V| is the number of vertices and |E| is the number of edges in the graph and b is the branching factor of the graph (the average number of successors of a node). d is the depth of the goal node.
 // Worst-case space complexity	 	O(|V|)=O(b^{d})}O(|V|)=O(b^{d}) where |V| is the number of vertices and |E| is the number of edges in the graph and b is the branching factor of the graph (the average number of successors of a node). d is the depth of the goal node.
 // reference: https://en.wikipedia.org/wiki/Breadth-first_search
 func BreadthFirstSearch(start, end, nodes int, edges [][]int) (isConnected bool, distance int) {

graph/coloring/bipartite.go

@@ -1,13 +1,13 @@
-// bipartite.go
+package coloring
+
+// Bipartite.go
 // description: Implementation of the Bipartite graph coloring algorithm
 // details: A bipartite graph is a graph whose vertices can be divided into two disjoint sets U and V such that every edge connects a vertex in U to one in V. The Bipartite graph coloring algorithm is used to determine if a graph is bipartite or not.
 // time complexity: O(V+E) where V is the number of vertices and E is the number of edges in the graph
 // space complexity: O(V) where V is the number of vertices in the graph
 
-package coloring
-
 func (g *Graph) TryBipartiteColoring() map[int]Color {
-	// 0 is uncolored, 1/2 is colors
+	// 0 is uncolored, 1/2 are colors
 	colors := make(map[int]Color)
 	visited := make(map[int]bool)
 
@@ -16,8 +16,8 @@ func (g *Graph) TryBipartiteColoring() map[int]Color {
 		visited[i] = false
 	}
 
-	var color_node func(int)
-	color_node = func(s int) {
+	var colorNode func(int)
+	colorNode = func(s int) {
 		visited[s] = true
 		coloring := []Color{0, 2, 1}
 
@@ -26,15 +26,15 @@ func (g *Graph) TryBipartiteColoring() map[int]Color {
 				colors[n] = coloring[colors[s]]
 			}
 			if !visited[n] {
-				color_node(n)
+				colorNode(n)
 			}
 		}
 	}
 
 	for i := range g.edges {
 		if colors[i] == 0 {
 			colors[i] = 1
-			color_node(i)
+			colorNode(i)
 		}
 	}
 

graph/lowestcommonancestor.go

@@ -4,7 +4,7 @@
 // Let `T` be a tree. The LCA of `u` and `v` in T is the shared ancestor of `u` and `v`
 // that is located farthest from the root.
 // time complexity: O(n log n) where n is the number of vertices in the tree
-// space complexity: O(n log n) where n is the number of vertices in the tree 
+// space complexity: O(n log n) where n is the number of vertices in the tree
 // references: [cp-algorithms](https://cp-algorithms.com/graph/lca_binary_lifting.html)
 // author(s) [Dat](https://github.com/datbeohbbh)
 // see lowestcommonancestor_test.go for a test implementation.

math/binomialcoefficient.go

@@ -4,7 +4,7 @@
 // a binomial coefficient C(n,k) gives number ways
 // in which k objects can be chosen from n objects.
 // wikipedia: https://en.wikipedia.org/wiki/Binomial_coefficient
-// time complexity: O(k) or O(n-k) whichever is smaller (O(n) in worst case) 
+// time complexity: O(k) or O(n-k) whichever is smaller (O(n) in worst case)
 // space complexity: O(1)
 // author: Akshay Dubey (https://github.com/itsAkshayDubey)
 // see binomialcoefficient_test.go