Merge branch 'master' into master

Author: 0xbrayo

.github/workflows/golangci-lint.yml

@@ -4,18 +4,31 @@ on: [push, pull_request]
 jobs:
   golangci-lint:
     runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
     steps:
-    - uses: actions/setup-go@v1
-      with:
-        go-version: 1.13
-    - uses: actions/checkout@v1
-    - run: curl -sfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s v1.21.0
-    - run: |
-        go version ; ./bin/golangci-lint --version
-        ./bin/golangci-lint run --no-config                        || true    
-    - run: ./bin/golangci-lint run --no-config ciphers strings
-    - run: ./bin/golangci-lint run --no-config data-structures     || true
-    - run: ./bin/golangci-lint run --no-config dynamic-programming || true
-    - run: ./bin/golangci-lint run --no-config other               || true
-    - run: ./bin/golangci-lint run --no-config searches            || true
-    - run: ./bin/golangci-lint run --no-config sorts
+      - uses: actions/checkout@v2
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v1
+        with:
+          # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
+          version: v1.27
+          working-directory: sorts
+          args: --issues-exit-code=0  # Hopefully someday we can remove this...
+          # Only show new issues if this is a pull request...
+          # only-new-issues: true
+      - run: echo "::set-env name=PATH::/home/runner/golangci-lint-1.27.0-linux-amd64:$PATH"
+      - run: go version ; golangci-lint --version  # Fix the following and remove || true
+      - run: golangci-lint run --no-config ciphers                            || true
+      - run: golangci-lint run --no-config data-structures/binary-tree        || true
+      - run: golangci-lint run --no-config data-structures/dynamic-array      || true
+      - run: golangci-lint run --no-config data-structures/hash-map           || true
+      - run: golangci-lint run --no-config data-structures/linked-list        || true
+      - run: golangci-lint run --no-config data-structures/trie               || true
+      - run: golangci-lint run --no-config dynamic-programming                || true
+      - run: golangci-lint run --no-config other                              || true
+      - run: golangci-lint run --no-config searches                           || true
+      - run: golangci-lint run --no-config sorts
+      - run: golangci-lint run --no-config strings
+      - run: golangci-lint run --no-config "strings/multiple string matching" || true
+      # - run: golangci-lint run --no-config "strings/single string matching"   || true

DIRECTORY.md

@@ -2,6 +2,7 @@
 ## Ciphers
   * [Caesarcipher](https://github.com/TheAlgorithms/Go/blob/master/ciphers/CaesarCipher.go)
   * [Diffiehellmankeyexchange](https://github.com/TheAlgorithms/Go/blob/master/ciphers/diffieHellmanKeyExchange.go)
+  * [Rsacipher(Big)](https://github.com/TheAlgorithms/Go/blob/master/ciphers/RSAcipher(Big).go)
   * [Rsacipher](https://github.com/TheAlgorithms/Go/blob/master/ciphers/RSAcipher.go)
   * [Xorcipher](https://github.com/TheAlgorithms/Go/blob/master/ciphers/xorCipher.go)
 
@@ -22,13 +23,21 @@
     * [Trie Test](https://github.com/TheAlgorithms/Go/blob/master/data-structures/trie/trie_test.go)
 
 ## Dynamic-Programming
+  * [Binomial-Coeffecient](https://github.com/TheAlgorithms/Go/blob/master/dynamic-programming/binomial-coeffecient.go)
+  * [Knapsack](https://github.com/TheAlgorithms/Go/blob/master/dynamic-programming/knapsack.go)
   * [Longest-Palindromic-Subsequence](https://github.com/TheAlgorithms/Go/blob/master/dynamic-programming/longest-palindromic-subsequence.go)
   * [Longestcommonsubsequence](https://github.com/TheAlgorithms/Go/blob/master/dynamic-programming/longestCommonSubsequence.go)
   * [Matrix-Multiplication](https://github.com/TheAlgorithms/Go/blob/master/dynamic-programming/matrix-multiplication.go)
   * [Rod-Cutting](https://github.com/TheAlgorithms/Go/blob/master/dynamic-programming/rod-cutting.go)
 
+## Graphs
+  * [Floyd Warshall](https://github.com/TheAlgorithms/Go/blob/master/graphs/floyd_warshall.go)
+
 ## Other
   * [Maxsubarraysum](https://github.com/TheAlgorithms/Go/blob/master/other/maxSubarraySum.go)
+  * Monte Carlo Pi
+    * [Monte Carlo Pi](https://github.com/TheAlgorithms/Go/blob/master/other/monte_carlo_pi/monte_carlo_pi.go)
+    * [Monte Carlo Pi Test](https://github.com/TheAlgorithms/Go/blob/master/other/monte_carlo_pi/monte_carlo_pi_test.go)
   * [Nestedbrackets](https://github.com/TheAlgorithms/Go/blob/master/other/NestedBrackets.go)
   * [Passwordgenerator](https://github.com/TheAlgorithms/Go/blob/master/other/PasswordGenerator.go)
   * [Prime Numbers](https://github.com/TheAlgorithms/Go/blob/master/other/prime_numbers.go)
@@ -37,10 +46,14 @@
 
 ## Searches
   * [Binary Search](https://github.com/TheAlgorithms/Go/blob/master/searches/binary_search.go)
+  * [Breadth First Search](https://github.com/TheAlgorithms/Go/blob/master/searches/breadth_first_search.go)
+  * [Depth First Search](https://github.com/TheAlgorithms/Go/blob/master/searches/depth_first_search.go)
   * [Linear Search](https://github.com/TheAlgorithms/Go/blob/master/searches/linear_search.go)
+  * [Search Test](https://github.com/TheAlgorithms/Go/blob/master/searches/search_test.go)
 
 ## Sorts
   * [Bubble Sort](https://github.com/TheAlgorithms/Go/blob/master/sorts/bubble_sort.go)
+  * [Counting Sort](https://github.com/TheAlgorithms/Go/blob/master/sorts/counting_sort.go)
   * [Heap Sort](https://github.com/TheAlgorithms/Go/blob/master/sorts/heap_sort.go)
   * [Insertion Sort](https://github.com/TheAlgorithms/Go/blob/master/sorts/insertion_sort.go)
   * [Merge Sort](https://github.com/TheAlgorithms/Go/blob/master/sorts/merge_sort.go)

README.md

@@ -1,5 +1,9 @@
 # The Algorithms - Go
 
+![golangci-lint](https://github.com/TheAlgorithms/Go/workflows/golangci-lint/badge.svg)
+![Go](https://github.com/TheAlgorithms/Go/workflows/Go/badge.svg)
+![update_directory_md](https://github.com/TheAlgorithms/Go/workflows/update_directory_md/badge.svg)
+
 ### Algorithms implemented in Go (for education)
 
 These algorithms are for demonstration purposes only. There are many sort implementations in the Go standard library that may have better performance.

data-structures/binary-tree/binary-tree.go

@@ -42,16 +42,16 @@ func preorder(n *node) {
 		return
 	}
 	fmt.Print(n.val, " ")
-	inorder(n.left)
-	inorder(n.right)
+	preorder(n.left)
+	preorder(n.right)
 }
 
 func postorder(n *node) {
 	if n == nil {
 		return
 	}
-	inorder(n.left)
-	inorder(n.right)
+	postorder(n.left)
+	postorder(n.right)
 	fmt.Print(n.val, " ")
 }
 

dynamic-programming/binomial-coeffecient.go

@@ -0,0 +1,47 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+func main() {
+	myArrayOfK := [4]int{5, 6, 7, 8}
+	var x int
+
+	fmt.Println("\nBinomial Coefficient Using Dynamic Programming:", bin2(50, 5))
+	for _, element := range myArrayOfK {
+		start := time.Now()
+		x = bin2(50, element)
+		elapsed := time.Since(start)
+		fmt.Println("bin2 (50,", element, ") = ", x, "    took ", elapsed)
+
+	}
+
+}
+
+func bin2(n int, k int) int {
+	var i, j int
+	B := make([][]int, (n + 1))
+	for i := range B {
+		B[i] = make([]int, k+1)
+	}
+
+	for i = 0; i <= n; i++ {
+		for j = 0; j <= min(i, k); j++ {
+			if j == 0 || j == i {
+				B[i][j] = 1
+			} else {
+				B[i][j] = B[i-1][j-1] + B[i-1][j]
+			}
+		}
+	}
+	return B[n][k]
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}

dynamic-programming/knapsack.go

@@ -0,0 +1,49 @@
+// Knapsack Problem
+// https://www.geeksforgeeks.org/0-1-knapsack-problem-dp-10/
+package Knapsack
+
+// package main
+
+import (
+	"math"
+)
+
+func max(a, b int) int {
+	return int(math.Max(float64(a), float64(b)))
+}
+
+// solve knapsack problem
+// return maxProfit
+func solve(maxWeight int, weights, values []int) int {
+	n := len(weights)
+	m := maxWeight
+	// create dp data structure
+	dp := make([][]int, n+1)
+	for i := range dp {
+		dp[i] = make([]int, m+1)
+	}
+	for i := 0; i < len(weights); i++ {
+		for j := 0; j <= maxWeight; j++ {
+			if weights[i] > j {
+				dp[i+1][j] = dp[i][j]
+			} else {
+				dp[i+1][j] = max(dp[i][j-weights[i]]+values[i], dp[i][j])
+			}
+		}
+	}
+	return dp[n][m]
+}
+
+/*
+func main() {
+	maxWeight := 50
+	values := []int{
+		60, 100, 120,
+	}
+	weights := []int{
+		10, 20, 30,
+	}
+	maxProfit := solve(maxWeight, weights, values)
+	fmt.Println(maxProfit)
+}
+*/

graphs/floyd_warshall.go

@@ -0,0 +1,63 @@
+// Floyd-Warshall algorithm
+// https://en.wikipedia.org/wiki/Floyd%E2%80%93Warshall_algorithm
+
+package graph
+
+import (
+	"math"
+)
+
+// Defining matrix to use 2d array easier
+type Matrix [][]float64
+
+// Defining maximum value. If two vertices share this value, it means they are not connected
+var maxValue = math.Inf(1)
+
+// Returns all pair's shortest path using Floyd Warshall algorithm
+func FloydWarshall(graph Matrix) Matrix {
+	// If graph is empty or width != height, returns nil
+	if len(graph) == 0 || len(graph) != len(graph[0]) {
+		return nil
+	}
+
+	numVertecies := len(graph)
+
+	// Initializing result matrix and filling it up with same values as given graph
+	result := make(Matrix, numVertecies)
+
+	for i := 0; i < numVertecies; i++ {
+		result[i] = make([]float64, numVertecies)
+		for j := 0; j < numVertecies; j++ {
+			result[i][j] = graph[i][j]
+		}
+	}
+
+	// Running over the result matrix and following the algorithm
+	for k := 0; k < numVertecies; k++ {
+		for i := 0; i < numVertecies; i++ {
+			for j := 0; j < numVertecies; j++ {
+				// If there is a less costly path from i to j node, remembering it
+				if result[i][j] > result[i][k]+result[k][j] {
+					result[i][j] = result[i][k] + result[k][j]
+				}
+			}
+		}
+	}
+
+	return result
+}
+
+// func main() {
+// 	var graph Matrix
+// 	graph = Matrix{{0, maxValue, -2, maxValue},
+// 		{4, 0, 3, maxValue},
+// 		{maxValue, maxValue, 0, 2},
+// 		{maxValue, -1, maxValue, 0}}
+
+// 	result := FloydWarshall(graph)
+
+// 	// Print result
+// 	for i := 0; i < len(result); i++ {
+// 		fmt.Printf("%4g\n", result[i])
+// 	}
+// }

other/monte_carlo_pi/monte_carlo_pi.go

@@ -0,0 +1,40 @@
+// Monte Carlo Pi
+// [Monte Carlo method](https://en.wikipedia.org/wiki/Monte_Carlo_method) to calculate Pi
+//
+// The basic idea of Monte Carlo is:
+//  1. Define a domain of possible inputs
+//  2. Generate inputs randomly from a probability distribution over the domain
+//  3. Perform a deterministic computation on the inputs
+//  4. Aggregate the results
+//
+// Thus the algorithm to calculate Pi is:
+//
+// 1. Given a circle inscribed in a square with side length 1.
+// 2. randomly draw n points (x, y) | x,y in [0.0,1.0)
+// 3. Count the amount of points inside the circle
+// 4. pi = 4 * (points inside the circle) / n
+//
+// A point (x, y) is inside the circle if:
+//
+// x*x + y*y <= 1
+//
+
+package main
+
+import (
+	"math"
+	"math/rand"
+)
+
+// MonteCarloPi calculates Pi using the Monte Carlo method
+func MonteCarloPi(iterations uint) float64 {
+	var inside, total uint
+
+	for total = uint(0); total < iterations; total++ {
+		if in := math.Hypot(rand.Float64(), rand.Float64()) <= 1; in {
+			inside++
+		}
+	}
+
+	return float64(4) * (float64(inside) / float64(total))
+}

other/monte_carlo_pi/monte_carlo_pi_test.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"math"
+	"testing"
+)
+
+func TestMonteCarloPi(t *testing.T) {
+	delta := 0.0001
+
+	pi := MonteCarloPi(100000000)
+
+	if math.Abs(pi-math.Pi) > delta {
+		t.Errorf("Given: %.4f, expected: %.4f", pi, math.Pi)
+	}
+}