Input: nums = [0,1,0], k = 1
Output: 2
Explanation: Flip nums[0], then flip nums[2].

func minKBitFlips(nums []int, k int) int {
    n := len(nums)
    flip := 0
    flips := 0
    flipQueue := make([]int, n)
    
    for i := 0; i < n; i++ {
        if i >= k {
            flip ^= flipQueue[i - k]
        }
        if nums[i] == flip {
            if i + k > n {
                return -1
            }
            flips++
            flip ^= 1
            flipQueue[i] = 1
        }
    }
    return flips
}

Input: points = [[1,1],[2,2],[3,3]]
Output: 3

func maxPoints(points [][]int) int {
    n := len(points)
    if n == 1 {
        return 1
    }
    result := 2
    for i := 0; i < n; i++ {
        cnt := make(map[float64]int)
        for j := 0; j < n; j++ {
            if j != i {
                key := math.Atan2(
                    float64(points[j][1]-points[i][1]),
                    float64(points[j][0]-points[i][0]),
                )
                cnt[key]++
            }
        }
        maxCnt := 0
        for _, v := range cnt {
            if v > maxCnt {
                maxCnt = v
            }
        }
        result = max(result, maxCnt+1)
    }
    return result
}

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

Input: root = [1,2,3]
Output: 1
Explanation: 
Tilt of node 2 : |0-0| = 0 (no children)
Tilt of node 3 : |0-0| = 0 (no children)
Tilt of node 1 : |2-3| = 1 (left subtree is just left child, so sum is 2; right subtree is just right child, so sum is 3)
Sum of every tilt : 0 + 0 + 1 = 1

type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

func findTilt(root *TreeNode) int {
    totalTilt := 0
    
    var sumAndTilt func(node *TreeNode) int
    sumAndTilt = func(node *TreeNode) int {
        if node == nil {
            return 0
        }
        leftSum := sumAndTilt(node.Left)
        rightSum := sumAndTilt(node.Right)
        nodeTilt := abs(leftSum - rightSum)
        totalTilt += nodeTilt
        return node.Val + leftSum + rightSum
    }
    
    sumAndTilt(root)
    return totalTilt
}

func abs(x int) int {
    if x < 0 {
        return -x
    }
    return x
}

Input: s = "egg", t = "add"
Output: true

package main

func isIsomorphic(s string, t string) bool {
    mappingStoT := make(map[byte]byte)
    mappingTtoS := make(map[byte]byte)

    for i := 0; i < len(s); i++ {
        c1 := s[i]
        c2 := t[i]

        if mappingStoT[c1] == 0 && mappingTtoS[c2] == 0 {
            mappingStoT[c1] = c2
            mappingTtoS[c2] = c1
        } else if mappingStoT[c1] != c2 || mappingTtoS[c2] != c1 {
            return false
        }
    }

    return true
}

func main() {
    s := "egg"
    t := "add"
    result := isIsomorphic(s, t)
    println(result) 
}

Input: grid = [[0,1,0,0],[1,1,1,0],[0,1,0,0],[1,1,0,0]]
Output: 16

Explanation: The perimeter is the 16 yellow stripes in the image above.

package main

func islandPerimeter(grid [][]int) int {
    rows := len(grid)
    cols := len(grid[0])
    
    result := 0
    
    for r := 0; r < rows; r++ {
        for c := 0; c < cols; c++ {
            if grid[r][c] == 1 {
                up := 0
                if r != 0 {
                    up = grid[r-1][c]
                }
                left := 0
                if c != 0 {
                    left = grid[r][c-1]
                }
                down := 0
                if r != rows-1 {
                    down = grid[r+1][c]
                }
                right := 0
                if c != cols-1 {
                    right = grid[r][c+1]
                }
                
                result += 4 - (up + left + right + down)
            }
        }
    }
    
    return result
}

Input: root = [4,2,5,1,3], target = 3.714286, k = 2
Output: [4,3]

import (
    "math"
    "sort"
)

type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

func closestKValues(root *TreeNode, target float64, k int) []int {
    var arr []int
    dfs(root, &arr)
    sort.Slice(arr, func(i, j int) bool {
        return math.Abs(float64(arr[i])-target) < math.Abs(float64(arr[j])-target)
    })
    return arr[:k]
}

func dfs(node *TreeNode, arr *[]int) {
    if node == nil {
        return
    }
    *arr = append(*arr, node.Val)
    dfs(node.Left, arr)
    dfs(node.Right, arr)
}

Input: root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
Output: [1,2,3,6,7,11,14,4,8,12,5,9,13,10]

type Node struct {
    Val      int
    Children []*Node
}

func preorder(root *Node) []int {
    if root == nil {
        return nil
    }
    stack := []*Node{root}
    output := []int{}
    
    for len(stack) > 0 {
        node := stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        output = append(output, node.Val)
        for i := len(node.Children) - 1; i >= 0; i-- {
            stack = append(stack, node.Children[i])
        }
    }
    
    return output
}

Input: nums = [2,3,-2,4]
Output: 6
Explanation: [2,3] has the largest product 6.

func maxProduct(nums []int) int {
    if len(nums) == 0 {
        return 0
    }

    result := nums[0]

    for i := 0; i < len(nums); i++ {
        accu := 1
        for j := i; j < len(nums); j++ {
            accu *= nums[j]
            if accu > result {
                result = accu
            }
        }
    }

    return result
}

Input: s = "the sky is blue"
Output: "blue is sky the"

func reverseWords(s string) string {
    words := strings.Fields(s)
    for i := 0; i < len(words)/2; i++ {
        words[i], words[len(words)-i-1] = words[len(words)-i-1], words[i]
    }
    return strings.Join(words, " ")
}

Input: customers = [1,0,1,2,1,1,7,5], grumpy = [0,1,0,1,0,1,0,1], minutes = 3
Output: 16

package main

import (
    "fmt"
)

func maxSatisfied(customers []int, grumpy []int, minutes int) int {
    totalSatisfied := 0
    additionalSatisfied := 0
    maxAdditionalSatisfied := 0

    for i := 0; i < len(customers); i++ {
        if grumpy[i] == 0 {
            totalSatisfied += customers[i]
        } else {
            additionalSatisfied += customers[i]
        }

        if i >= minutes {
            if grumpy[i - minutes] == 1 {
                additionalSatisfied -= customers[i - minutes]
            }
        }

        if additionalSatisfied > maxAdditionalSatisfied {
            maxAdditionalSatisfied = additionalSatisfied
        }
    }

    return totalSatisfied + maxAdditionalSatisfied
}

Input: root = [5,10,10,null,null,2,3]
Output: true

type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

func checkEqualTree(root *TreeNode) bool {
    totalSum := sumTree(root)
    if totalSum%2 != 0 {
        return false
    }
    target := totalSum / 2
    return checkSubtreeSum(root, target, root)
}

func sumTree(node *TreeNode) int {
    if node == nil {
        return 0
    }
    return node.Val + sumTree(node.Left) + sumTree(node.Right)
}

func checkSubtreeSum(node *TreeNode, target int, root *TreeNode) bool {
    if node == nil {
        return false
    }
    if node != root && sumTree(node) == target {
        return true
    }
    return checkSubtreeSum(node.Left, target, root) || checkSubtreeSum(node.Right, target, root)
}

Input: arr = [0]
Output: 1

package main

func subarrayBitwiseORs(arr []int) int {
    result := make(map[int]struct{})
    current := make(map[int]struct{})
    for _, num := range arr {
        next := make(map[int]struct{})
        next[num] = struct{}{}
        for x := range current {
            next[x|num] = struct{}{}
        }
        current = next
        for x := range current {
            result[x] = struct{}{}
        }
    }
    return len(result)
}