Added multiple Go solution

go/1-Two-Sum.go

@@ -0,0 +1,17 @@
+package leetcode
+
+func twoSum(nums []int, target int) []int {
+
+	for i := 0; i < len(nums); i++ {
+		for j := 0; j < len(nums); j++ {
+			if i == j {
+				continue
+			}
+			if nums[i]+nums[j] == target {
+				return []int{i, j}
+			}
+		}
+	}
+
+	return []int{-1, -1}
+}

go/110-Balanced-Binary-Tree.go

@@ -0,0 +1,33 @@
+package leetcode
+
+import (
+	"math"
+)
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func isBalanced(root *TreeNode) bool {
+
+	if root == nil {
+		return true
+	}
+
+	left := findHeight(root.Left)
+	right := findHeight(root.Right)
+
+	return math.Abs(float64(left)-float64(right)) <= 1 && isBalanced(root.Left) && isBalanced(root.Right)
+
+}
+
+func findHeight(node *TreeNode) int {
+
+	if node == nil {
+		return 0
+	}
+
+	return 1 + int(math.Max(float64(findHeight(node.Left)), float64(findHeight(node.Right))))
+}

go/121-Best-Time-to-Buy-and-Sell-Stock.go

@@ -0,0 +1,22 @@
+package leetcode
+
+import "math"
+
+func maxProfit(prices []int) int {
+	left := 0
+	right := 1
+	maxProf := 0
+	profit := 0
+
+	for right < len(prices) {
+		if prices[left] < prices[right] {
+			profit = prices[right] - prices[left]
+			maxProf = int(math.Max(float64(profit), float64(maxProf)))
+		} else {
+			left = right
+		}
+		right++
+	}
+
+	return maxProf
+}

go/13-Roman-to-Integer.go

@@ -0,0 +1,61 @@
+package leetcode
+
+func romanToInt(s string) int {
+
+	romans := map[string]int{
+		"I": 1,
+		"V": 5,
+		"X": 10,
+		"L": 50,
+		"C": 100,
+		"D": 500,
+		"M": 1000,
+	}
+
+	sum := 0
+
+	for i := len(s) - 1; i > 0; i-- {
+		// IV : 4
+		if romans[string(s[i])] == romans["V"] {
+			if romans[string(s[i-1])] == romans["I"] {
+				sum -= 1 * 2
+			}
+		}
+		// IX : 4
+		if romans[string(s[i])] == romans["X"] {
+			if romans[string(s[i-1])] == romans["I"] {
+				sum -= 1 * 2
+			}
+		}
+		// XL : 40
+		if romans[string(s[i])] == romans["L"] {
+			if romans[string(s[i-1])] == romans["X"] {
+				sum -= 10 * 2
+			}
+		}
+		// XC : 90
+		if romans[string(s[i])] == romans["C"] {
+			if romans[string(s[i-1])] == romans["X"] {
+				sum -= 10 * 2
+			}
+		}
+		// CD : 400
+		if romans[string(s[i])] == romans["D"] {
+			if romans[string(s[i-1])] == romans["C"] {
+				sum -= 100 * 2
+			}
+		}
+		// CM : 900
+		if romans[string(s[i])] == romans["M"] {
+			if romans[string(s[i-1])] == romans["C"] {
+				sum -= 100 * 2
+			}
+		}
+
+		sum += romans[string(s[i])]
+	}
+
+	sum += romans[string(s[0])]
+
+	return sum
+}

go/143-Reorder-List.go

@@ -0,0 +1,39 @@
+package leetcode
+
+import (
+	"math"
+)
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func reorderList(head *ListNode) {
+
+	arr := make([]int, 0)
+
+	loop := head
+
+	for loop != nil {
+		arr = append(arr, loop.Val)
+		loop = loop.Next
+	}
+
+	sortedArr := make([]int, 0)
+
+	for i := 0; i < int(math.Floor(float64(len(arr)/2))); i++ {
+		sortedArr = append(sortedArr, arr[i])
+		sortedArr = append(sortedArr, arr[len(arr)-1-i])
+	}
+
+	if len(arr)%2 != 0 {
+		sortedArr = append(sortedArr, arr[int(math.Floor(float64(len(arr)/2)))])
+	}
+
+	for i := 0; i < len(sortedArr); i++ {
+		head.Val = sortedArr[i]
+		head = head.Next
+	}
+
+}

go/150-Evaluate-Reverse-Polish-Notation.go

@@ -0,0 +1,40 @@
+package leetcode
+
+import (
+	"strconv"
+)
+
+func evalRPN(tokens []string) int {
+
+	stack := make([]int, 0, len(tokens))
+
+	for _, token := range tokens {
+
+		v, err := strconv.Atoi(token)
+
+		if err == nil {
+
+			stack = append(stack, v)
+
+		} else {
+
+			num1, num2 := stack[len(stack)-2], stack[len(stack)-1]
+
+			stack = stack[:len(stack)-2]
+
+			switch token {
+			case "+":
+				stack = append(stack, num1+num2)
+			case "-":
+				stack = append(stack, num1-num2)
+			case "*":
+				stack = append(stack, num1*num2)
+			case "/":
+				stack = append(stack, num1/num2)
+			}
+
+		}
+	}
+
+	return stack[0]
+}

go/155-Min-Stack.go

@@ -0,0 +1,39 @@
+package leetcode
+
+type MinStack struct {
+	elements, min []int
+	l             int
+}
+
+func Constructor() MinStack {
+	return MinStack{make([]int, 0), make([]int, 0), 0}
+}
+
+func (this *MinStack) Push(x int) {
+	this.elements = append(this.elements, x)
+	if this.l == 0 {
+		this.min = append(this.min, x)
+	} else {
+		min := this.GetMin()
+		if x < min {
+			this.min = append(this.min, x)
+		} else {
+			this.min = append(this.min, min)
+		}
+	}
+	this.l++
+}
+
+func (this *MinStack) Pop() {
+	this.l--
+	this.min = this.min[:this.l]
+	this.elements = this.elements[:this.l]
+}
+
+func (this *MinStack) Top() int {
+	return this.elements[this.l-1]
+}
+
+func (this *MinStack) GetMin() int {
+	return this.min[this.l-1]
+}

go/167-Two-Sum-II.go

@@ -0,0 +1,19 @@
+package leetcode
+
+func twoSum(numbers []int, target int) []int {
+	i := 0
+	j := len(numbers) - 1
+
+	for i < j {
+		if numbers[i]+numbers[j] == target {
+			return []int{i + 1, j + 1}
+		} else if numbers[i]+numbers[j] > target {
+			j--
+		} else {
+			i++
+		}
+	}
+
+	return []int{}
+
+}

go/19-Remove-Nth-Node-From-End-of-List.go

@@ -0,0 +1,40 @@
+package leetcode
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func NewListNode(val int, next *ListNode) *ListNode {
+	var n ListNode
+	n.Next = next
+	n.Val = val
+	return &n
+}
+
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+func removeNthFromEnd(head *ListNode, n int) *ListNode {
+	dummy := NewListNode(0, head)
+	left := dummy
+	right := head
+
+	for n > 0 && right != nil {
+		right = right.Next
+		n--
+	}
+
+	for right != nil {
+		left = left.Next
+		right = right.Next
+	}
+
+	left.Next = left.Next.Next
+
+	return dummy.Next
+}

go/20-Valid-Parentheses.go

@@ -0,0 +1,34 @@
+package leetcode
+
+func isValid(s string) bool {
+
+	parantheses := map[string]string{
+		")": "(",
+		"}": "{",
+		"]": "[",
+	}
+
+	stack := make([]string, 1)
+
+	for i := 0; i < len(s); i++ {
+		currChar := s[i]
+		lastChar := stack[len(stack)-1]
+		delChar := parantheses[string(currChar)]
+
+		if delChar != "" {
+			if delChar == lastChar {
+				// pop
+				if len(stack) > 0 {
+					stack = stack[:len(stack)-1]
+				}
+			} else {
+				return false
+			}
+		} else {
+			// push
+			stack = append(stack, string(currChar))
+		}
+	}
+
+	return len(stack)-1 <= 0
+}

go/206-Reverse-Linked-List.go

@@ -0,0 +1,41 @@
+package leetcode
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func NewListNode(val int, next *ListNode) *ListNode {
+	var n ListNode
+	n.Next = next
+	n.Val = val
+	return &n
+}
+
+// Iterative
+func reverseList(head *ListNode) *ListNode {
+
+	var prev *ListNode
+	for head != nil {
+		next := head.Next
+		head.Next = prev
+		prev = head
+		head = next
+	}
+	return prev
+}
+
+// Recursive
+func reverseList_1(head *ListNode) *ListNode {
+	var prev *ListNode
+	var reversed *ListNode
+
+	for head != nil {
+		prev = head
+
+		reversed = NewListNode(prev.Val, reversed)
+
+		head = head.Next
+	}
+	return reversed
+}