update

easy/453.minimum-moves-to-equal-array-elements.go

@@ -0,0 +1,14 @@
+func minMoves(nums []int) int {
+	n := len(nums)
+	if n <= 1 {
+		return 0
+	}
+	min, sum := nums[0], nums[0]
+	for i := 1; i < n; i++ {
+		sum += nums[i]
+		if nums[i] < min {
+			min = nums[i]
+		}
+	}
+	return sum - n*min
+}

easy/455.assign-cookies.go

@@ -0,0 +1,13 @@
+func findContentChildren(g []int, s []int) int {
+	sort.Ints(g)
+	sort.Ints(s)
+	cnt := 0
+	for i, j := len(g)-1, len(s)-1; 0 <= i && 0 <= j; {
+		if g[i] <= s[j] {
+			j--
+			cnt++
+		}
+		i--
+	}
+	return cnt
+}

easy/458.poor-pigs.go

@@ -0,0 +1,5 @@
+func poorPigs(buckets int, minutesToDie int, minutesToTest int) int {
+	base := minutesToTest/minutesToDie + 1 // Status of a pig: die at x min or still alive
+	// So the number of pigs is log(buckets)/log(base)
+	return int(math.Ceil(math.Log(float64(buckets)) / math.Log(float64(base))))
+}

easy/459.repeated-substring-pattern.go

@@ -0,0 +1,16 @@
+func repeatedSubstringPattern(s string) bool {
+	n := len(s)
+	runes := []rune(s)
+	for i := n / 2; 1 <= i; i-- {
+		if n%i != 0 {
+			continue
+		}
+		k := i
+		for ; k < n && runes[k] == runes[k%i]; k++ {
+		}
+		if k == n {
+			return true
+		}
+	}
+	return false
+}

easy/461.hamming-distance.go

@@ -0,0 +1,8 @@
+func hammingDistance(x int, y int) (cnt int) {
+	for diff := x ^ y; diff != 0; diff >>= 1 {
+		if diff&1 == 1 {
+			cnt++
+		}
+	}
+	return
+}

easy/463.island-perimeter.go

@@ -0,0 +1,29 @@
+func islandPerimeter(grid [][]int) (cnt int) {
+	m := len(grid)
+	if m == 0 {
+		return
+	}
+	n := len(grid[0])
+	if n == 0 {
+		return
+	}
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			if grid[i][j] == 1 {
+				if i == 0 || grid[i-1][j] == 0 {
+					cnt++
+				}
+				if i == m-1 || grid[i+1][j] == 0 {
+					cnt++
+				}
+				if j == 0 || grid[i][j-1] == 0 {
+					cnt++
+				}
+				if j == n-1 || grid[i][j+1] == 0 {
+					cnt++
+				}
+			}
+		}
+	}
+	return
+}

easy/475.heaters.go

@@ -0,0 +1,37 @@
+func findRadius(houses []int, heaters []int) (radius int) {
+	sort.Ints(heaters)
+	n := len(heaters)
+	for _, i := range houses {
+		beg, end := 0, n-1
+		for beg <= end {
+			mid := beg + (end-beg)/2
+			if heaters[mid] < i {
+				beg = mid + 1
+			} else {
+				end = mid - 1
+			}
+		}
+		if beg == 0 {
+			radius = maxInt(radius, heaters[beg]-i)
+		} else if beg == n {
+			radius = maxInt(radius, i-heaters[n-1])
+		} else {
+			radius = maxInt(radius, minInt(i-heaters[beg-1], heaters[beg]-i))
+		}
+	}
+	return
+}
+
+func minInt(x, y int) int {
+	if x < y {
+		return x
+	}
+	return y
+}
+
+func maxInt(x, y int) int {
+	if x < y {
+		return y
+	}
+	return x
+}

easy/476.number-complement.go

@@ -0,0 +1,10 @@
+func findComplement(num int) (res int) {
+	if num == 0 {
+		return 1
+	}
+	mask := 0
+	for i := num; i != 0; i >>= 1 {
+		mask = (mask << 1) | 1
+	}
+	return mask ^ num
+}

easy/479.largest-palindrome-product.go

@@ -0,0 +1,39 @@
+func largestPalindrome(n int) int {
+	// mod 1337
+	if n == 1 {
+		return 9
+	}
+	upper := int(math.Pow10(n)) - 1
+	lower := upper / 10
+	for i := upper; lower < i; i-- {
+		pa := toPalindrome(i)
+		bound := int(math.Sqrt(float64(pa)))
+		for j := upper; j >= bound; j-- {
+			if pa%j != 0 {
+				continue
+			}
+			if ratio := pa / j; lower < ratio && ratio <= upper {
+				return pa % 1337
+			}
+		}
+	}
+	return -1 // Not found
+}
+
+func toPalindrome(x int) (res int) {
+	num := make([]int, 64)
+	lo, hi := 0, 0
+	for ; x != 0; x /= 10 {
+		num[lo] = x % 10
+		lo++
+	}
+	copy(num[lo:], num[:lo])
+	for hi, lo = lo, lo-1; 0 <= lo; lo, hi = lo-1, hi+1 {
+		num[lo] = num[hi]
+	}
+	for i, base := 0, 1; i < hi; i, base = i+1, base*10 {
+		res += num[i] * base
+	}
+	return
+}
+