Added Fibonacci, GameScoring

Author: gokivego

.gitignore

@@ -0,0 +1 @@
+.DS_Store

DynamicProgramming/Fibonacci.go

@@ -0,0 +1,36 @@
+/*
+Fibonacci sequence using recursion and Memoization
+Returns the value of the nth Fibonacci number
+*/
+
+package main
+
+import ("fmt")
+
+// Recursion
+func FibonacciRecursion(n int) int {
+	if n == 0 || n == 1 {
+		return 1
+	}
+	return FibonacciRecursion(n-1) + FibonacciRecursion(n-2)
+}
+
+// Memoization can be done using hashmap or also by using an array
+func FibonacciMemoization(n int) int {
+	var MemoizedArray = []int{1,1}
+	if n == 0 || n == 1 {
+		return 1
+	}
+	for i:=2;i<n+1;i++ {
+		MemoizedArray = append(MemoizedArray,MemoizedArray[i-2]+MemoizedArray[i-1])	
+	}
+	return MemoizedArray[n]
+}
+
+func main() {
+	n := 10
+	valRecursion := FibonacciRecursion(n)
+	valMemoization := FibonacciMemoization(n)
+	fmt.Println(fmt.Sprintf("Fibonacci term number %d from recusion method is:%d",n,valRecursion))
+	fmt.Println(fmt.Sprintf("Fibonacci term number %d from memoization method is:%d",n,valMemoization))
+}

DynamicProgramming/GameScoring.go

@@ -0,0 +1,64 @@
+/*
+Find the total number of ways a player can score n runs if he can only score runs from an array in a given shot
+This is a case of dynamic programming and can be done using two methods:
+	1) Memoization using a hash map
+	2) Bottom up using an array
+This class of problem can be extended to many other problems. This is a very important pattern.
+*/
+
+package main
+
+import ("fmt")
+
+// Recursive Memoization
+func GameScoringMemoization(Total int, PossibleRuns []int, MemoizedMap map[int]int) int {
+	if _,ok := MemoizedMap[Total]; ok {
+		return MemoizedMap[Total]
+	} else if Total < 0 {
+		return 0
+	} else {
+		NumWays := 0
+		for _, val := range PossibleRuns {
+			NumWays += GameScoringMemoization(Total - val, PossibleRuns, MemoizedMap)
+		}
+		MemoizedMap[Total] = NumWays 
+	}
+	return MemoizedMap[Total]
+}
+
+// This approach uses an array to store the result and build on it. Returns the total number of ways
+func GameScoringBottomUp(Total int, PossibleRuns []int) int {
+	var MemoizedArray = []int{1}
+	// We iterate for i from 0 to Total and find the number of total number of ways to get to each step
+	// We consider that the number of ways to get to 0 is 1
+	for tot:=1;tot<Total+1;tot++ {
+		NumWays := 0
+		for _, val := range PossibleRuns {
+			if (tot - val) >= 0 {
+				NumWays += MemoizedArray[tot - val]
+			} else {
+				continue
+			}
+		}
+		MemoizedArray = append(MemoizedArray,NumWays)
+	}
+	return MemoizedArray[Total]
+}
+
+func main() {
+	PossibleRuns := []int{5,6,7}
+	Total := 11
+	
+	
+	// Bottom up Approach
+	NumWaysBottomUp := GameScoringBottomUp(Total, PossibleRuns)
+	fmt.Println(fmt.Sprintf("Number of ways of getting to %d with possible runs %v and BottomUp Approach is %d",Total,PossibleRuns,NumWaysBottomUp))
+	
+	
+	// Create a MemoizedMap and pass it to the Memoization Function
+	var MemoizedMap = make(map[int]int)
+	MemoizedMap[0] = 1
+	NumWaysMemoization := GameScoringMemoization(Total, PossibleRuns, MemoizedMap)
+	fmt.Println(fmt.Sprintf("Number of ways of getting to %d with possible runs %v and Memoization Approach is %d",Total,PossibleRuns,NumWaysMemoization))
+	
+}	

DynamicProgramming/KnapSack.go

@@ -24,7 +24,7 @@ func KnapSackRecursion(ItemWeight,ItemValue []int,n,c int) int {
     }
 }
 
-// Memoized  version of the problem, which minimizes recusrsion
+// Memoized  version of the problem, which minimizes recursion
 func KnapSackMemoization(MemoizedMap map[string]int,ItemWeight,ItemValue []int,n,c int) int { 
     nc := fmt.Sprintf("%d:%d",n,c)
     if val,ok := MemoizedMap[nc];ok {

MathAndStats/AllSubset.go

@@ -0,0 +1,50 @@
+/*
+Find all the subsets of a given set
+Two methods will be discussed here
+1) Using the bit representation approach
+2) Using a recursion tree type of approach
+*/
+
+package main
+
+import ("fmt"
+        "math"
+)
+
+func GetBit(num int,bit uint) uint {
+    temp := 1 << bit
+    temp = temp & num
+    if temp == 0 {
+        return 0
+    } else {
+        return 1
+    }
+}
+
+func AllSubsetsBit(array []int) *[][]int {
+    var SubsetsArray [][]int
+    var ArrayLen uint = uint(len(array)) 
+    NumSubsets := math.Pow(float64(2),float64(len(array)))
+    for i:=0;i<int(NumSubsets);i++ {
+        var SubArray []int
+        for j:=uint(0);j<ArrayLen;j++ {
+            bit := GetBit(i,j)
+            if bit == 1 {
+                SubArray = append(SubArray,array[j])
+            }
+        }
+        SubsetsArray = append(SubsetsArray,SubArray)
+    }
+    return &SubsetsArray
+}
+
+/*
+func AllSubsetRecursion(array []int)
+*/
+
+func main() {
+    array := []int{2,3,4}
+    AllSubsetsBitPtr := AllSubsetsBit(array)
+    //AllSubsetsBit(array)
+    fmt.Println(*AllSubsetsBitPtr)
+}

MathAndStats/FindKthPermutation.go

@@ -44,7 +44,6 @@ func FindKthPermutation(num []int,k int,) *[]int {
     return &KthPermutation
 }
 
-
 func main() {
     array := []int{1,2,3,4}
     KthPermutationPtr := FindKthPermutation(array,8)

README.md

@@ -1 +1,6 @@
-# AlgorithmsGolang
+# AlgorithmsGolang
+
+I have created this repository to provide those important patterns that will help people to prepare for interviews.
+
+The algorithms here are not comprehensive and the repo is still a work in progress
+

arrays/MergeOverlappingIntervals.go

@@ -0,0 +1,35 @@
+/*
+Merge overlapping intervals
+List of intervals is given in sorted order and we need to merge the overlapping intervals to give a larger interval
+If the intervals are not in sorted order we need to sort them first and then we can use the below approach
+Input: {{1,5},{3,7},{4,6},{6,8},{10,12},{11,15}}
+Output: {{1,8},{10,15}}
+*/
+
+package main
+
+import ("fmt"
+)
+
+// Defining a tuple type to hold the intervals as go doesn't have a tuple by default
+type tuple struct {
+    first,second interface{}
+}
+
+func MergeOverlappingIntervals(arr *[]tuple) *[]tuple {
+    outputArray := []tuple
+    if len(*arr) == 0 {
+        return arr
+    }
+    for _,val := range *arr {
+           
+    }
+
+}
+
+func main() {
+    array := []tuple{{1,5},{3,7},{4,6},{6,8},{10,12},{11,15}}
+    fmt.Println(array)
+    MergeOverlappingIntervals(&array)
+    
+}

linkedList/deleteNodeLinkedList.go

@@ -0,0 +1,16 @@
+/*
+Delete a node in a linkedlist with a given key (All the occurances)
+*/
+
+package main
+
+import ("fmt"
+        "AlgorithmsGolang/LinkedList/LinkedList"
+)
+
+func main() {
+    
+    array := []interface{}{1,3,5,2,70,21,34}
+    ll := LinkedList.ArrayToLinkedList(&array) 
+    ll.Remove()
+}

linkedList/mergeTwoLinkedLists.go

@@ -0,0 +1,38 @@
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ This solution is for a question on LeetCode, This wouldn't work directly
+ */
+
+package main
+
+import ("AlgorithmsGolang/linkedList/LinkedList"
+)
+
+func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
+    mll := new(ListNode)
+    temp := mll
+    for (l1 != nil && l2 != nil) {
+        e := new(ListNode)
+        if (l1.Val <= l2.Val) {
+            e.Val = l1.Val
+            l1 = l1.Next
+        } else {
+            e.Val = l2.Val
+            l2 = l2.Next
+        }
+        temp.Next = e
+        temp = temp.Next
+    }
+    if l1 == nil && l2 == nil {
+        return nil
+    } else if l1 == nil {
+        temp.Next = l2
+    } else {
+        temp.Next = l1
+    }
+    return mll.Next
+}