add new solutions

solutions/14/q1415/solution.go

@@ -0,0 +1,46 @@
+// Package q1415 implements a solution for https://leetcode.com/problems/the-k-th-lexicographical-string-of-all-happy-strings-of-length-n/
+package q1415
+
+import (
+	"math"
+	"strings"
+)
+
+func getHappyString(n, k int) string {
+	// The base is ababababab...
+	// Behaves like binary, except the first character, which has three choices: a, b, c.
+	// Max of k is 2^n + 2^(n-1)
+
+	if k > int(math.Pow(2, float64(n))+math.Pow(2, float64(n-1))) {
+		return ""
+	}
+	k -= 1
+
+	sb := strings.Builder{}
+	var last byte
+	switch k >> (n - 1) {
+	case 0:
+		last = 'a'
+	case 1:
+		last = 'b'
+	case 2:
+		last = 'c'
+	}
+	sb.WriteByte(last)
+
+	lut := [][2]byte{
+		{'b', 'c'},
+		{'a', 'c'},
+		{'a', 'b'},
+	}
+
+	for i := n - 1; i > 0; i-- {
+		lookup := k >> (i - 1) & 1
+		c := lut[last-'a'][lookup]
+		sb.WriteByte(c)
+		last = c
+	}
+	return sb.String()
+}
+
+var _ = getHappyString

solutions/16/q1622/solution.go

@@ -0,0 +1,68 @@
+// Package q1622 implements a solution for https://leetcode.com/problems/fancy-sequence/
+// ref: https://en.wikipedia.org/wiki/Fermat%27s_little_theorem
+package q1622
+
+const MOD int = 1e9 + 7
+
+type Fancy struct {
+	numbers       []int
+	states        []fancyState // this can be optimized out
+	add, mul, inv int
+}
+
+type fancyState struct{ add, inv int }
+
+func Constructor() Fancy {
+	return Fancy{
+		numbers: make([]int, 0, 128),
+		states:  make([]fancyState, 0, 128),
+		mul:     1,
+		inv:     1,
+	}
+}
+
+// findInv calculates num^(MOD-2), which is the inverse of num under mod MOD
+// when MOD is a prime number. `inv(num) * num % MOD == 1`.
+func findInv(num int) int {
+	pow := MOD - 2
+	ret := 1
+	cur := num % MOD
+	for i := 1; 1<<(i-1) <= pow; i++ {
+		if (pow>>(i-1))&1 == 1 {
+			ret = (ret * cur) % MOD
+		}
+		cur = cur * cur % MOD
+	}
+	return ret
+}
+
+func (f *Fancy) Append(val int) {
+	f.numbers = append(f.numbers, val)
+	f.states = append(f.states, fancyState{add: f.add, inv: f.inv})
+}
+
+func (f *Fancy) AddAll(inc int) { f.add = (f.add + inc) % MOD }
+
+func (f *Fancy) MultAll(m int) {
+	f.mul = f.mul * m % MOD
+	f.add = f.add * m % MOD
+	f.inv = findInv(f.mul)
+}
+
+func (f *Fancy) GetIndex(idx int) int {
+	if idx >= len(f.numbers) {
+		return -1
+	}
+	num := f.numbers[idx] * f.mul % MOD * f.states[idx].inv % MOD
+	savedAdd := f.states[idx].add * f.mul % MOD * f.states[idx].inv % MOD
+	return (num + MOD + f.add - savedAdd) % MOD
+}
+
+/**
+ * Your Fancy object will be instantiated and called as such:
+ * obj := Constructor();
+ * obj.Append(val);
+ * obj.AddAll(inc);
+ * obj.MultAll(m);
+ * param_4 := obj.GetIndex(idx);
+ */

solutions/18/q1888/solution.go

@@ -0,0 +1,40 @@
+// Package q1888 implements a solution for https://leetcode.com/problems/minimum-number-of-flips-to-make-the-binary-string-alternating/
+package q1888
+
+// Note: O(1) space is possible.
+
+var buf = make([][2]int, 1e5)
+
+func minFlips(s string) int {
+	backward := buf[:len(s)]
+
+	from0, from1 := 0, 0
+	var alt byte = 0 // alternating byte
+	for i := len(s) - 1; i >= 0; i-- {
+		if s[i]-'0' == alt {
+			from1++
+		} else {
+			from0++
+		}
+		alt = alt ^ 1
+		backward[i] = [2]int{from0, from1}
+	}
+
+	minCost := min(backward[0][0], backward[0][1])
+	from0, from1 = 0, 0
+	for i := range len(s) - 1 {
+		if s[i]-'0' == byte(i%2) {
+			from1++
+		} else {
+			from0++
+		}
+		minCost = min(
+			minCost,
+			from0+backward[i+1][1],
+			from1+backward[i+1][0],
+		)
+	}
+	return minCost
+}
+
+var _ = minFlips

solutions/19/q1980/solution.go

@@ -0,0 +1,37 @@
+// Package q1980 implements a solution for https://leetcode.com/problems/find-unique-binary-string/
+package q1980
+
+import "slices"
+
+func toNumber(s string) int {
+	ret := 0
+	for i := range len(s) {
+		ret = ret<<1 + int(s[i]-'0')
+	}
+	return ret
+}
+
+func fromNumber(n, length int) string {
+	buf := make([]byte, length)
+	for i := range length {
+		buf[i] = byte(n&1) + '0'
+		n >>= 1
+	}
+	slices.Reverse(buf)
+	return string(buf)
+}
+
+func findDifferentBinaryString(nums []string) string {
+	slices.Sort(nums)
+	last := -1
+	for i := range nums {
+		num := toNumber(nums[i])
+		if num > last+1 {
+			break
+		}
+		last = num
+	}
+	return fromNumber(last+1, len(nums[0]))
+}
+
+var _ = findDifferentBinaryString

solutions/35/q3567/solution.go

@@ -0,0 +1,48 @@
+// Package q3567 implements a solution for https://leetcode.com/problems/minimum-absolute-difference-in-sliding-submatrix/
+package q3567
+
+import "slices"
+
+var buf = make([]int, 30*30)
+
+const INF = 1<<63 - 1
+
+func minAbsDiffK(grid [][]int, xOffset, k int) int {
+	if k == 1 {
+		return 0
+	}
+
+	numbers := buf[:0]
+	for y := range k {
+		for x := range k {
+			numbers = append(numbers, grid[y][x+xOffset])
+		}
+	}
+	slices.Sort(numbers)
+	minDiff := INF
+	for i := 1; i < len(numbers); i++ {
+		if numbers[i] == numbers[i-1] {
+			continue
+		}
+		minDiff = min(minDiff, numbers[i]-numbers[i-1])
+	}
+	if minDiff == INF {
+		return 0
+	}
+	return minDiff
+}
+
+func minAbsDiff(grid [][]int, k int) [][]int {
+	w, h := len(grid[0]), len(grid)
+	for i := 0; i < h-k+1; i++ {
+		for j := 0; j < w-k+1; j++ {
+			grid[i][j] = minAbsDiffK(grid[i:], j, k)
+		}
+	}
+	for i := range h - k + 1 {
+		grid[i] = grid[i][:w-k+1]
+	}
+	return grid[:h-k+1]
+}
+
+var _ = minAbsDiff

solutions/36/q3643/solution.go

@@ -0,0 +1,19 @@
+// Package q3643 implements a solution for https://leetcode.com/problems/flip-square-submatrix-vertically/
+package q3643
+
+func reverseSubmatrix(grid [][]int, x int, y int, k int) [][]int {
+	x, y = y, x // lol
+	swapBuf := make([]int, k)
+
+	for i := range k / 2 {
+		y1 := y + i
+		y2 := y + k - 1 - i
+
+		copy(swapBuf, grid[y1][x:x+k])
+		copy(grid[y1][x:x+k], grid[y2][x:x+k])
+		copy(grid[y2][x:x+k], swapBuf)
+	}
+	return grid
+}
+
+var _ = reverseSubmatrix