add new solutions

solutions/10/q1022/solution.go

@@ -0,0 +1,29 @@
+package q1022
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func sum(node *TreeNode, prefix int, ret *int) {
+	if node == nil {
+		return
+	}
+	num := prefix<<1 + node.Val
+
+	if node.Left == nil && node.Right == nil {
+		*ret += num
+	} else {
+		sum(node.Left, num, ret)
+		sum(node.Right, num, ret)
+	}
+}
+
+func sumRootToLeaf(root *TreeNode) int {
+	ret := 0
+	sum(root, 0, &ret)
+	return ret
+}
+
+var _ = sumRootToLeaf

solutions/13/q1356/solution.go

@@ -0,0 +1,26 @@
+package q1356
+
+import "slices"
+
+func count1s(n int) int {
+	c := 0
+	for n > 0 {
+		c++
+		n = n & (n - 1)
+	}
+	return c
+}
+
+func sortByBits(arr []int) []int {
+	for i := range arr {
+		arr[i] += count1s(arr[i]) << 16
+	}
+	slices.Sort(arr)
+
+	for i := range arr {
+		arr[i] &= 1<<16 - 1
+	}
+	return arr
+}
+
+var _ = sortByBits

solutions/14/q1404/solution.go

@@ -0,0 +1,25 @@
+package q1404
+
+func numSteps(s string) int {
+	steps := 0
+	carry := false
+	for i := len(s) - 1; i > 0; i-- {
+		switch {
+		case !carry && s[i] == '0':
+			steps++
+		case !carry && s[i] == '1':
+			steps += 2
+			carry = true
+		case carry && s[i] == '0':
+			steps += 2
+		default:
+			steps++
+		}
+	}
+	if carry {
+		steps++
+	}
+	return steps
+}
+
+var _ = numSteps

solutions/6/q693/solution.go

@@ -0,0 +1,15 @@
+package q693
+
+func hasAlternatingBits(n int) bool {
+	last := -1
+	for n > 0 {
+		if last == n%2 {
+			return false
+		}
+		last = n % 2
+		n >>= 1
+	}
+	return true
+}
+
+var _ = hasAlternatingBits

solutions/6/q696/solution.go

@@ -0,0 +1,20 @@
+package q696
+
+func countBinarySubstrings(s string) int {
+	cnt := 0
+	last := byte('0')
+	lastLen, curLen := 0, 0
+	for i := range len(s) {
+		if s[i] != last {
+			last, lastLen = s[i], curLen
+			curLen = 0
+		}
+		curLen++
+		if curLen <= lastLen {
+			cnt++
+		}
+	}
+	return cnt
+}
+
+var _ = countBinarySubstrings

solutions/7/q761/solution.go

@@ -0,0 +1,84 @@
+package q761
+
+func toNumber(arrs ...[]byte) int {
+	r := 0
+	for i := range arrs {
+		for _, num := range arrs[i] {
+			r = r<<1 + int(num)
+		}
+	}
+	return r
+}
+
+func fromNumber(arr []byte, num int) {
+	for i := len(arr) - 1; i >= 0; i-- {
+		arr[i] = byte(num % 2)
+		num >>= 1
+	}
+}
+
+func move(arr []byte) int {
+	specials := [][2]int{}
+	specialsMap := make(map[int][]int, len(arr)+1)
+	val := toNumber(arr)
+
+	for i := range len(arr) - 1 {
+		if arr[i] == 0 {
+			continue
+		}
+		bal := 1
+		for j := i + 1; j < len(arr); j++ {
+			switch arr[j] {
+			case 0:
+				bal--
+			case 1:
+				bal++
+			}
+
+			if bal < 0 {
+				break
+			}
+			if bal == 0 {
+				specials = append(specials, [2]int{i, j})
+				specialsMap[i] = append(specialsMap[i], j)
+			}
+		}
+	}
+
+	for i := range specials {
+		l1, r1 := specials[i][0], specials[i][1]
+		l2 := r1 + 1
+		for _, r2 := range specialsMap[l2] {
+			swapped := toNumber(arr[:l1], arr[l2:r2+1], arr[l1:l2], arr[r2+1:])
+			if swapped > val {
+				val = swapped
+			}
+		}
+	}
+	return val
+}
+
+func makeLargestSpecial(s string) string {
+	arr := []byte(s)
+	for i := range arr {
+		arr[i] -= '0'
+	}
+
+	val := toNumber(arr)
+	for {
+		newVal := move(arr)
+		if newVal > val {
+			val = newVal
+			fromNumber(arr, newVal)
+		} else {
+			break
+		}
+	}
+
+	for i := range arr {
+		arr[i] += '0'
+	}
+	return string(arr)
+}
+
+var _ = makeLargestSpecial

solutions/9/q918/solution.go

@@ -0,0 +1,22 @@
+package q918
+
+func maxSubarraySumCircular(nums []int) int {
+	maxSum, minSum, maxPfx, minPfx := nums[0], nums[0], 0, 0
+
+	sum := 0
+	for _, num := range nums {
+		sum += num
+		maxSum = max(maxSum, sum-minPfx)
+		minSum = min(minSum, sum-maxPfx)
+
+		maxPfx = max(maxPfx, sum)
+		minPfx = min(minPfx, sum)
+	}
+
+	if sum == minSum {
+		return maxSum
+	}
+	return max(maxSum, sum-minSum)
+}
+
+var _ = maxSubarraySumCircular