update

hard/315.count-of-smaller-numbers-after-self.go

@@ -1,4 +1,37 @@
 func countSmaller(nums []int) []int {
 	n := len(nums)
-	if n 
+	res := make([]int, n)
+	if n < 1 {
+		return res
+	}
+	arr := []int{nums[n-1]}
+	for i := n - 2; 0 <= i; i-- {
+		l, r, target := 0, n-1-i, nums[i]
+		for l < r {
+			m := l + (r-l)/2
+			if arr[m] < target {
+				l = m + 1
+			} else if target < arr[m] {
+				r = m
+			} else {
+				l = m
+				break
+			}
+		}
+		for 0 < l && arr[l-1] == target {
+			l-- // Filter out same elements
+		}
+		res[i] = l
+		if l == n-1-i {
+			arr = append(arr, target)
+		} else {
+			tmp := make([]int, n-i)
+			copy(tmp, arr[:l])
+			copy(tmp[l+1:], arr[l:])
+			tmp[l] = target
+			arr = tmp
+		}
+	}
+	return res
 }
+

hard/316.remove-duplicate-letters.go

@@ -0,0 +1,26 @@
+func removeDuplicateLetters(s string) string {
+	cnt := make([]int, 256)
+	for _, c := range s {
+		cnt[c]++
+	}
+	set := make([]bool, 256)
+	res := make([]rune, 0)
+	tp := -1
+	for _, c := range s {
+		cnt[c]--
+		if set[c] {
+			continue
+		}
+		// If c is not in stack && stack is not empty && c less than top && top'll appear again, pop top
+		for tp != -1 && c < res[tp] && 0 < cnt[res[tp]] {
+			set[res[tp]] = false
+			res = res[:tp]
+			tp--
+		}
+		res = append(res, c)
+		set[c] = true
+		tp++
+	}
+	return string(res)
+}
+

hard/321.create-maximum-number.go

@@ -0,0 +1,101 @@
+func maxNumber(nums1 []int, nums2 []int, k int) []int {
+	m, n := len(nums1), len(nums2)
+	max := make([]int, m+n)
+	for i := maxInt(0, k-n); i <= minInt(k, m); i++ {
+		num := merge(pick(nums1, i), pick(nums2, k-i))
+		if less(max, num) {
+			max = num
+		}
+	}
+	return max
+}
+
+func less(nums1, nums2 []int) bool {
+	for i := range nums1 {
+		if nums1[i] < nums2[i] {
+			return true
+		} else if nums2[i] < nums1[i] {
+			return false
+		}
+	}
+	return false
+}
+
+func pick(nums []int, k int) []int {
+	n := len(nums)
+	st := make([]int, 0)
+loop:
+	for i := 0; i < n; i++ {
+		for {
+			if l := len(st); l+n-i == k {
+				st = append(st, nums[i:]...)
+				break loop
+			} else if 0 < l && st[l-1] < nums[i] {
+				st = st[:l-1]
+			} else {
+				st = append(st, nums[i])
+				break
+			}
+		}
+	}
+	return st[:k]
+}
+
+func merge(nums1, nums2 []int) []int {
+	m, n := len(nums1), len(nums2)
+	res := make([]int, m+n)
+	i, i1, i2 := 0, 0, 0
+	for mv1 := false; i1 < m && i2 < n; i++ {
+		if nums1[i1] < nums2[i2] {
+			mv1 = false
+		} else if nums2[i2] < nums1[i1] {
+			mv1 = true
+		} else {
+			for j1, j2, n1, n2 := i1+1, i2+1, 0, 0; (j1 < m || j2 < n) && n1 == n2; j1, j2 = j1+1, j2+1 {
+				if m <= j1 {
+					n1 = 0
+				} else {
+					n1 = nums1[j1]
+				}
+				if n <= j2 {
+					n2 = 0
+				} else {
+					n2 = nums2[j2]
+				}
+				if n1 < n2 {
+					mv1 = false
+				} else if n2 < n1 {
+					mv1 = true
+				}
+			}
+		}
+		if mv1 {
+			res[i] = nums1[i1]
+			i1++
+		} else {
+			res[i] = nums2[i2]
+			i2++
+		}
+	}
+	if i1 != m {
+		copy(res[i:], nums1[i1:])
+	}
+	if i2 != n {
+		copy(res[i:], nums2[i2:])
+	}
+	return res
+}
+
+func maxInt(x, y int) int {
+	if x < y {
+		return y
+	}
+	return x
+}
+
+func minInt(x, y int) int {
+	if x < y {
+		return x
+	}
+	return y
+}

hard/327.count-of-range-sum.go

@@ -0,0 +1,49 @@
+func countRangeSum(nums []int, lower int, upper int) int {
+	n := len(nums)
+	sum := make([]int, n+1)
+	for i := 1; i <= n; i++ {
+		sum[i] = sum[i-1] + nums[i-1]
+	}
+	return mergeSort(sum, lower, upper, 0, n+1)
+}
+
+func mergeSort(nums []int, lower, upper, beg, end int) int {
+	if end-beg <= 1 {
+		return 0
+	}
+	mid := (beg + end) / 2
+	m, n := mid, mid
+	cnt := mergeSort(nums, lower, upper, beg, mid) + mergeSort(nums, lower, upper, mid, end)
+	for i := beg; i < mid; i++ {
+		for ; m < end && nums[m]-nums[i] < lower; m++ {
+		}
+		for ; n < end && nums[n]-nums[i] <= upper; n++ {
+		}
+		cnt += n - m
+	}
+	merge(nums, beg, mid, end)
+	return cnt
+}
+
+func merge(nums []int, beg, mid, end int) {
+	sorted := make([]int, end-beg)
+	i, j, k := 0, beg, mid
+	for ; j < mid && k < end; i++ {
+		if nums[j] < nums[k] {
+			sorted[i] = nums[j]
+			j++
+		} else {
+			sorted[i] = nums[k]
+			k++
+		}
+	}
+	if j != mid {
+		copy(sorted[i:], nums[j:mid])
+	}
+	if k != end {
+		copy(sorted[i:], nums[k:end])
+	}
+	copy(nums[beg:end], sorted)
+}
+
+