upload rest of the codes

Author: Prasannjit Kumar

go/11.container-with-most-water.189690800.ac.go

@@ -0,0 +1,20 @@
+func getArea(h, max int, values []int) int {
+    for i, v := range values{
+        height := h
+        if v < h{
+            height = v
+        }
+        area := i*height
+        if area > max{
+            max = area
+        }
+    }
+    return max
+}
+func maxArea(height []int) int {
+    max := 0
+    for i := 0; i < len(height); i++{
+        max = getArea(height[i], max, height[i:])
+    }
+    return max
+}

go/41.first-missing-positive.155809249.ac.go

@@ -0,0 +1,30 @@
+func firstMissingPositive(nums []int) int {
+    if len(nums) == 0{
+        return 1
+    }
+    m := make(map[int]bool)
+    max := nums[0]
+    for _, v := range nums{
+        m[v] = true
+        if max < v && v > 0 {
+            max = v
+        }
+    }
+    if max <= 0{
+        return 1
+    }
+    if max == 1{
+        return 2
+    }
+    i := 1
+    for ; i < max; i++ {
+        if !m[i] {
+            return i
+        }
+    }
+    if i == 1 {
+        return 1
+    } else {
+        return i + 1
+    }
+}

go/434.number-of-segments-in-a-string.175218537.ac.go

@@ -0,0 +1,10 @@
+func countSegments(s string) int {
+    strs := strings.Split(s, " ")
+    count := 0
+    for _, v := range strs{
+        if v != ""{
+            count++
+        }
+    }
+    return count
+}

go/6.zigzag-conversion.155804282.ac.go

@@ -0,0 +1,62 @@
+import "fmt"
+type MyPoint struct {
+	x, y int
+}
+
+func createPoints(l, n int) ([]MyPoint, int) {
+	count := 0
+	var points []MyPoint
+	j := 0
+	i := 0
+	for count < l {
+		for i = 0; i < n; i++ {
+			var p MyPoint
+			p.x = i
+			p.y = j
+			points = append(points, p)
+			count++
+			if count == l {
+				return points, j
+			}
+		}
+        j++
+		for i = n - 2; i > 0; i-- {
+			var p MyPoint
+			p.x = i
+			p.y = j
+			j++
+			points = append(points, p)
+			count++
+			if count == l {
+				return points, j
+			}
+		}
+	}
+	return points, j
+}
+
+func convert(s string, numRows int) string {
+    points, col := createPoints(len(s), numRows)
+    mat := make([][]rune, numRows)
+    for i := range mat{
+        mat[i] = make([]rune, col+1)
+    }
+    runes := []rune(s)
+    for i := 0; i < len(mat); i++{
+        for j := 0; j < len(mat[i]); j++{
+            mat[i][j] = '0'
+        }
+    }
+    for i := 0; i < len(points); i++{
+        mat[points[i].x][points[i].y] = runes[i]
+    }
+    str := ""
+    for i := 0; i < len(mat); i++{
+        for j := 0; j < len(mat[i]); j++{
+            if mat[i][j] != '0' {
+                str += string(mat[i][j])    
+            }
+        }
+    }
+    return str
+}

go/700.search-in-a-binary-search-tree.167914973.ac.go

@@ -1,3 +1,49 @@
+/*
+ * @lc app=leetcode id=700 lang=golang
+ *
+ * [700] Search in a Binary Search Tree
+ *
+ * https://leetcode.com/problems/search-in-a-binary-search-tree/description/
+ *
+ * algorithms
+ * Easy (63.18%)
+ * Total Accepted:    24.2K
+ * Total Submissions: 38.3K
+ * Testcase Example:  '[4,2,7,1,3]\n2'
+ *
+ * Given the root node of a binary search tree (BST) and a value. You need to
+ * find the node in the BST that the node's value equals the given value.
+ * Return the subtree rooted with that node. If such node doesn't exist, you
+ * should return NULL.
+ * 
+ * For example, 
+ * 
+ * 
+ * Given the tree:
+ * ⁠       4
+ * ⁠      / \
+ * ⁠     2   7
+ * ⁠    / \
+ * ⁠   1   3
+ * 
+ * And the value to search: 2
+ * 
+ * 
+ * You should return this subtree:
+ * 
+ * 
+ * ⁠     2     
+ * ⁠    / \   
+ * ⁠   1   3
+ * 
+ * 
+ * In the example above, if we want to search the value 5, since there is no
+ * node with value 5, we should return NULL.
+ * 
+ * Note that an empty tree is represented by NULL, therefore you would see the
+ * expected output (serialized tree format) as [], not null.
+ * 
+ */
 /**
  * Definition for a binary tree node.
  * type TreeNode struct {

go/705.design-hashset.184751839.ac.go

@@ -0,0 +1,35 @@
+type MyHashSet struct {
+    b []bool
+}
+
+
+/** Initialize your data structure here. */
+func Constructor() MyHashSet {
+    b := make([]bool, 1000001)
+    return MyHashSet{b}
+}
+
+
+func (this *MyHashSet) Add(key int)  {
+    this.b[key] = true
+}
+
+
+func (this *MyHashSet) Remove(key int)  {
+    this.b[key] = false
+}
+
+
+/** Returns true if this set contains the specified element */
+func (this *MyHashSet) Contains(key int) bool {
+    return this.b[key]
+}
+
+
+/**
+ * Your MyHashSet object will be instantiated and called as such:
+ * obj := Constructor();
+ * obj.Add(key);
+ * obj.Remove(key);
+ * param_3 := obj.Contains(key);
+ */

go/896.monotonic-array.173179107.ac.go

@@ -0,0 +1,102 @@
+/*
+ * @lc app=leetcode id=896 lang=golang
+ *
+ * [896] Monotonic Array
+ *
+ * https://leetcode.com/problems/monotonic-array/description/
+ *
+ * algorithms
+ * Easy (54.11%)
+ * Total Accepted:    20.2K
+ * Total Submissions: 37.4K
+ * Testcase Example:  '[1,2,2,3]'
+ *
+ * An array is monotonic if it is either monotone increasing or monotone
+ * decreasing.
+ * 
+ * An array A is monotone increasing if for all i <= j, A[i] <= A[j].  An array
+ * A is monotone decreasing if for all i <= j, A[i] >= A[j].
+ * 
+ * Return true if and only if the given array A is monotonic.
+ * 
+ * 
+ * 
+ * 
+ * 
+ * 
+ * 
+ * Example 1:
+ * 
+ * 
+ * Input: [1,2,2,3]
+ * Output: true
+ * 
+ * 
+ * 
+ * Example 2:
+ * 
+ * 
+ * Input: [6,5,4,4]
+ * Output: true
+ * 
+ * 
+ * 
+ * Example 3:
+ * 
+ * 
+ * Input: [1,3,2]
+ * Output: false
+ * 
+ * 
+ * 
+ * Example 4:
+ * 
+ * 
+ * Input: [1,2,4,5]
+ * Output: true
+ * 
+ * 
+ * 
+ * Example 5:
+ * 
+ * 
+ * Input: [1,1,1]
+ * Output: true
+ * 
+ * 
+ * 
+ * 
+ * Note:
+ * 
+ * 
+ * 1 <= A.length <= 50000
+ * -100000 <= A[i] <= 100000
+ * 
+ * 
+ * 
+ * 
+ * 
+ * 
+ * 
+ */
+func isMonotonic(A []int) bool {
+    if len(A) < 2 {
+        return true
+    }
+    count1 := 0
+    for i := 1; i < len(A); i++{
+        if A[i-1] <= A[i] {
+            count1++
+        }
+    }
+    count2 := 0
+    for i := 1; i < len(A); i++{
+        if A[i-1] >= A[i] {
+            count2++
+        }
+    }
+    if count1 == len(A)-1 || count2 == len(A)-1 {
+        return true
+    }
+    return false
+}

go/925.long-pressed-name.184232748.ac.go

@@ -0,0 +1,33 @@
+func getCounts(s string) (string, []int) {
+    runes := []rune(s)
+    str := ""
+    var values []int
+    for i := 0; i < len(runes); {
+        c := runes[i]
+        str += string(c)
+        count := 1
+        j := i+1
+        for ; j < len(runes); j++{
+            if c != runes[j] {
+                break
+            }
+            count++
+        }
+        i = j
+        values = append(values, count)
+    }
+    return str, values
+}
+func isLongPressedName(name string, typed string) bool {
+    v1, v2 := getCounts(name)
+    v3, v4 := getCounts(typed)
+    if v1 != v3 {
+        return false
+    }
+    for i := 0; i < len(v2); i++{
+        if v2[i] > v4[i]{
+            return false
+        }
+    }
+    return true
+}