A bunch of edits

Author: gokivego

DynamicProgramming/MaxSumSubsequenceNonAdjacent.go

@@ -0,0 +1,40 @@
+/*
+Maximum Subsequence of Non Adjacent Elements
+
+Example - [1,3,10,14,-5,-3,2,-2,3]
+Output - 22 from elements [3,14,2,3]
+
+We will use dynamic programming to solve this problem
+*/
+
+package main 
+
+import ("fmt")
+
+func Max(a,b int) int {
+if a>=b {
+return a
+}
+return b
+}
+
+func MaxSubsequenceNonAdjacent(array []int) int {
+var maxSoFarArray = make([]int,len(array))
+maxSoFarArray[0] = array[0]
+maxSoFarArray[1] = Max(maxSoFarArray[0],array[1])
+for idx,val := range array {
+if (idx == 0 || idx == 1) {
+continue
+} else {
+maxSoFarArray[idx] = Max(maxSoFarArray[idx-1],maxSoFarArray[idx-2]+val)
+}
+}
+return maxSoFarArray[len(array)-1] 
+}
+
+func main() {
+array := []int{1,6,10,14,-5,-1,2,-1,3}
+//array := []int{1,-1,6,-4,2,2}
+maxSubsequenceNonAdjacentSum := MaxSubsequenceNonAdjacent(array)
+fmt.Println("The Maximum sum of Non adjacent subsequence is:",maxSubsequenceNonAdjacentSum)
+}

README.md

@@ -1,6 +1,19 @@
 # AlgorithmsGolang
 
+I started working on this repo as a way to showcase my skills in algorithms and data structures. During the process I realized that there are some common pattern which can be extended to many type of algorithms. Any problem can be converted into one of these base patterns.
+
+The number of problems I have here is more than the base patterns.
+
 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
 
+## Patterns
+
+### Dynamic Programming 
+- Fibonacci Problem
+- Frog Jumping Problem
+- Coin Change Problem
+- Game Scoring Problem
+
+### 

StackAndQueue/StackUsingQueue.go

@@ -0,0 +1,43 @@
+/*
+Implemet a Stack using Queues
+
+Method 1: Use two Queues to implement a stack. PUSH:O()	POP:O()
+
+Method 2: Use two Queues to implement a stack. PUSH:O()	POP:O()
+
+"github.com/golang-collections/collections/stack"
+type Stack
+func New() *Stack
+func (this *Stack) Len() int
+func (this *Stack) Peek() interface{}
+func (this *Stack) Pop() interface{}
+func (this *Stack) Push(value interface{})
+
+"github.com/golang-collections/go-datastructures/queue"
+type Queue
+func New(hint int64) *Queue
+func (q *Queue) Dispose()
+func (q *Queue) Disposed() bool
+func (q *Queue) Empty() bool
+func (q *Queue) Get(number int64) ([]interface{}, error)
+func (q *Queue) Len() int64
+func (q *Queue) Put(items ...interface{}) error
+func (q *Queue) TakeUntil(checker func(item interface{}) bool) ([]interface{}, error)
+
+*/
+
+package main
+
+import ("github.com/golang-collections/go-datastructures/queue"
+"github.com/golang-collections/collections/stack"
+)
+
+type StackUsingQueue struct {
+// Initialized
+}
+
+func (*)
+
+func main() {
+
+}

arrays/maxInSlidingWindow.go

@@ -62,10 +62,11 @@ func maxInSlidingWindow(arr *[]int,windowSize int) {
 }
 
 func main() {
- arr := []int{-4,2,-5,1,-1,6}
- 
- 
- maxInSlidingWindow(&arr,3)
+ //arr := []int{-4,2,-5,1,-1,6}
+ arr := []int{1,3,-1,-3,5,3,6,7}
+ k := 3
+
+ maxInSlidingWindow(&arr,k)
 
  //fmt.Println(dll)
  //fmt.Println(l.Front())

arrays/maxSingleSellProfit.go

@@ -0,0 +1,51 @@
+/*
+Find maximum single sell profit
+Given a list of stock prices for n days, find the maximum profit with a single buy/sell activity.
+
+Description:
+Given a list of day stock prices (integers for simplicity), find the maximum single sell profit.
+
+We need to maximize the single buy/sell profit and in case we can't make any profit, we'll try to minimize the loss. 
+For below examples, buy and sell prices for making maximum profit are highlighted.
+*/
+
+package main
+
+import ("fmt"
+"math"
+)
+
+type BuySell struct {
+buy,sell int
+}
+
+func maxSingleSellProfit(array []int) *BuySell {
+currentBuy := array[0]
+globalSell := array[1]
+globalProfit := globalSell - currentBuy
+currentProfit := math.MinInt64
+var BS = new(BuySell)
+
+for i:=1;i<len(array);i++ {
+currentProfit = array[i] - currentBuy
+if (currentProfit > globalProfit) {
+globalProfit = currentProfit
+globalSell = array[i]
+}
+
+if (array[i] < currentBuy) {
+currentBuy = array[i]
+}
+}
+BS.buy = globalSell - globalProfit
+BS.sell = globalSell
+return BS
+}
+
+
+func main() {
+array := []int{21,12,11,9,6,3}
+//array := []int{12,5,9,19}
+BS := maxSingleSellProfit(array)
+fmt.Println("BuyPrice:",BS.buy,"SellPrice:",BS.sell)
+}

arrays/mergeSort.go

@@ -0,0 +1,17 @@
+/*
+Sorting an Array through Merge Sort
+*/
+
+package main
+
+import ("fmt")
+
+func MergeSort(array []int) []int {
+
+}
+
+func main() {
+array := []int{7,2,4,9,10,1,3,1,24,12}
+sortedArray := MergeSort(array)
+fmt.Println(sortedArray)
+}

binarySearchTree/BST.go

@@ -0,0 +1,133 @@
+/*
+Implementation of a binary search tree operations (Insert, Search, Delete)
+*/
+
+package main
+
+import ("fmt"
+//"container/list"
+)
+
+type Element struct {
+
+// The value in stored in the element
+Value interface{}
+left, right *Element
+
+// The binary search tree to which the element belongs
+bst *Bst
+}
+
+type Bst struct {
+root Element
+}
+
+// Creates a new Bst Element and initializes it
+func New() *Bst {
+return new(Bst).Init()
+} 
+
+func (b *Bst) Init() *Bst {
+b.root.right = nil
+b.root.left = nil
+return b
+}
+
+func (b *Bst) Insert(val interface{}) {
+temp := &b.root
+for true {
+if (temp.Value == nil) {
+temp.Value = val
+temp.bst = b
+return
+} else if (val.(int) >= temp.Value.(int) && temp.right == nil) {
+temp.right = new(Element)
+temp.right.Value = val
+temp.right.bst = b
+return
+} else if (val.(int) < temp.Value.(int) && temp.left == nil) {
+temp.left = new(Element)
+temp.left.Value = val
+temp.left.bst = b
+return
+} else if (val.(int) >= temp.Value.(int) && temp.right != nil) {
+temp = temp.right
+} else {
+temp = temp.left
+}
+}
+}
+
+// Returns if a value exists in the Binary Search Tree
+func (b *Bst) Search(val interface{}) bool {
+temp := &b.root
+for true {
+if (temp.Value.(int) == val.(int)) {
+return true
+} else if (val.(int) >= temp.Value.(int) && temp.right != nil) {
+temp = temp.right
+} else if (val.(int) < temp.Value.(int) && temp.left != nil) {
+temp = temp.left
+} else {
+return false
+}
+}
+return false
+}
+
+func (b *Bst) Remove(val interface{}) {
+
+}
+
+// Inorder Traversal (Left, Root, Right)
+func (b *Bst) Inorder(root *Element) {
+if (root == nil) {
+return
+}
+b.Inorder(root.left)
+fmt.Println(root.Value)
+b.Inorder(root.right)
+}
+
+func (b *Bst) Preorder(root *Element) {
+if (root == nil) {
+return
+}
+fmt.Println(root.Value)
+b.Preorder(root.left)
+b.Preorder(root.right)
+}
+
+func (b *Bst) Postorder(root *Element) {
+if (root == nil) {
+return
+}
+b.Postorder(root.left)
+b.Postorder(root.right)
+fmt.Println(root.Value)
+}
+
+func (b *Bst) Levelorder() {
+
+}
+
+/*
+func ArrayToBST(array []int) {
+
+}
+*/
+
+func main() {
+// Instantiate a random BST with the root element
+array := []int{5,10,12,7,6,21,35,45,22,100}
+b := New()
+for _, val := range array {
+b.Insert(val)
+}
+fmt.Println(b.Search(7))
+b.Inorder(&b.root)
+b.Preorder(&b.root)
+b.Postorder(&b.root)
+//fmt.Println(b.root)
+//fmt.Println(b.root.right)
+}