func numberOfSubarrays(nums []int, k int) int {
    return atMost(nums, k) - atMost(nums, k-1)
}

func atMost(nums []int, k int) int {
    res, left, count := 0, 0, 0
    for right := 0; right < len(nums); right++ {
        if nums[right] % 2 == 1 {
            count++
        }
        for count > k {
            if nums[left] % 2 == 1 {
                count--
            }
            left++
        }
        res += right - left + 1
    }
    return res
}

Input: n = 4, edges = [[1,0],[1,2],[1,3]]
Output: [1]
Explanation: As shown, the height of the tree is 1 when the root is the node with label 1 which is the only MHT.

package main

func findMinHeightTrees(n int, edges [][]int) []int {
  if n == 1 {
    return []int{0}
  }

  adj := make([]map[int]bool, n)
  for i := 0; i < n; i++ {
    adj[i] = make(map[int]bool)
  }
  for _, edge := range edges {
    adj[edge[0]][edge[1]] = true
    adj[edge[1]][edge[0]] = true
  }

  leaves := []int{}
  for i := 0; i < n; i++ {
    if len(adj[i]) == 1 {
      leaves = append(leaves, i)
    }
  }

  remainingNodes := n
  for remainingNodes > 2 {
    remainingNodes -= len(leaves)
    newLeaves := []int{}
    for _, leaf := range leaves {
      for neighbor := range adj[leaf] {
        delete(adj[neighbor], leaf)
        if len(adj[neighbor]) == 1 {
          newLeaves = append(newLeaves, neighbor)
        }
      }
      delete(adj, leaf)
    }
    leaves = newLeaves
  }

  return leaves
}

Input: n = 2
Output: 2
Explanation: There are two ways to climb to the top.
1. 1 step + 1 step
2. 2 steps

func climbStairs(n int) int {
    return climb_Stairs(0, n)
}

func climb_Stairs(i int, n int) int {
    if i > n {
        return 0
    }
    if i == n {
        return 1
    }
    return climb_Stairs(i+1, n) + climb_Stairs(i+2, n)
}

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, " ")
}