Input: root = [1,2,3,null,5,null,4]
Output: [1,3,4]

package main

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

func rightSideView(root *TreeNode) []int {
    if root == nil {
        return []int{}
    }

    nextLevel := []*TreeNode{root}
    rightside := []int{}

    for len(nextLevel) > 0 {
        currLevel := nextLevel
        nextLevel = []*TreeNode{}

        for _, node := range currLevel {
            if node.Left != nil {
                nextLevel = append(nextLevel, node.Left)
            }
            if node.Right != nil {
                nextLevel = append(nextLevel, node.Right)
            }
        }

        rightside = append(rightside, currLevel[len(currLevel)-1].Val)
    }

    return rightside
}

Input: strs = ["babca","bbazb"]
Output: 3
Explanation: After deleting columns 0, 1, and 4, the final array is strs = ["bc", "az"].
Both these rows are individually in lexicographic order (ie. strs[0][0] <= strs[0][1] and strs[1][0] <= strs[1][1]).
Note that strs[0] > strs[1] - the array strs is not necessarily in lexicographic order.

func minDeletionSize(A []string) int {
    W := len(A[0])
    dp := make([]int, W)
    for i := range dp {
        dp[i] = 1
    }

    for i := W - 2; i >= 0; i-- {
        for j := i + 1; j < W; j++ {
            valid := true
            for _, row := range A {
                if row[i] > row[j] {
                    valid = false
                    break
                }
            }
            if valid {
                dp[i] = max(dp[i], 1 + dp[j])
            }
        }
    }

    kept := 0
    for _, x := range dp {
        kept = max(kept, x)
    }

    return W - kept
}

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

Input: a = 2, b = [3]
Output: 8

package main

import "math"

func getSum(a int, b int) int {
    x, y := int(math.Abs(float64(a))), int(math.Abs(float64(b)))
    if x < y {
        return getSum(b, a)
    }
    sign := 1
    if a < 0 {
        sign = -1
    }

    if a * b >= 0 {
        for y != 0 {
            carry := (x & y) << 1
            x ^= y
            y = carry
        }
    } else {
        for y != 0 {
            borrow := ((^x) & y) << 1
            x ^= y
            y = borrow
        }
    }
    return x * sign
}

Input: s = "aaabbb"
Output: 2
Explanation: Print "aaa" first and then print "bbb".

func strangePrinter(s string) int {
    n := len(s)
    dp := make([][]int, n)
    for i := range dp {
        dp[i] = make([]int, n)
    }

    for length := 1; length <= n; length++ {
        for i := 0; i <= n-length; i++ {
            j := i + length - 1
            if i == j {
                dp[i][j] = 1
            } else {
                dp[i][j] = dp[i][j-1] + 1
                for k := i; k < j; k++ {
                    if s[k] == s[j] {
                        dp[i][j] = min(dp[i][j], dp[i][k]+(if k+1 <= j-1 { dp[k+1][j-1] } else { 0 }))
                    }
                }
            }
        }
    }

    return dp[0][n-1]
}

func min(a, b int) int {
    if a < b {
        return a
    }
    return b
}

Input: nums1 = [1,2,2,1], nums2 = [2,2]
Output: [2,2]

func intersect(nums1 []int, nums2 []int) []int {
    counts := make(map[int]int)
    var result []int
    
    for _, num := range nums1 {
        counts[num]++
    }
    
    for _, num := range nums2 {
        if counts[num] > 0 {
            result = append(result, num)
            counts[num]--
        }
    }
    
    return result
}

Input: head = [1,2,3,4]
Output: [1,4,2,3]

func reorderList(head *ListNode) {
    if head == nil {
        return
    }
    slow := head
    fast := head
    for fast != nil && fast.Next != nil {
        slow = slow.Next
        fast = fast.Next.Next
    }
    var prev, curr *ListNode = nil, slow
    for curr != nil {
        tmp := curr.Next
        curr.Next = prev
        prev = curr
        curr = tmp
    }
    first := head
    second := prev
    for second.Next != nil {
        tmp := first.Next
        first.Next = second
        first = tmp
        tmp = second.Next
        second.Next = first
        second = tmp
    }
}

Input: root = [5,2,-3]
Output: [2,-3,4]

import "math"

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

func findFrequentTreeSum(root *TreeNode) []int {
    sumFreq := make(map[int]int)
    maxFreq := 0

    var subtreeSum func(node *TreeNode) int
    subtreeSum = func(node *TreeNode) int {
        if node == nil {
            return 0
        }
        leftSum := subtreeSum(node.Left)
        rightSum := subtreeSum(node.Right)
        currSum := node.Val + leftSum + rightSum
        sumFreq[currSum]++
        if sumFreq[currSum] > maxFreq {
            maxFreq = sumFreq[currSum]
        }
        return currSum
    }

    subtreeSum(root)
    var result []int
    for sum, freq := range sumFreq {
        if freq == maxFreq {
            result = append(result, sum)
        }
    }
    return result
}

func numHandshakes(numPeople int) int {
    n := numPeople / 2
    catalan := make([]int, n+1)
    catalan[0] = 1

    for i := 1; i <= n; i++ {
        for j := 0; j < i; j++ {
            catalan[i] += catalan[j] * catalan[i-1-j]
        }
    }

    return catalan[n]
}

Input: nums = [3,5,2,6], k = 2
Output: [2,6]
Explanation: Among the set of every possible subsequence: {[3,5], [3,2], [3,6], [5,2], [5,6], [2,6]}, [2,6] is the most competitive.

func mostCompetitive(nums []int, k int) []int {
    queue := make([]int, 0)
    additionalCount := len(nums) - k
    
    for _, num := range nums {
        for len(queue) > 0 && queue[len(queue)-1] > num && additionalCount > 0 {
            queue = queue[:len(queue)-1]
            additionalCount--
        }
        queue = append(queue, num)
    }
    
    return queue[:k]
}

Input: root = [1,3,null,null,2]
Output: [3,1,null,null,2]
Explanation: 3 cannot be a left child of 1 because 3 > 1. Swapping 1 and 3 makes the BST valid.

func recoverTree(root *TreeNode) {
    nums := inorder(root)
    x, y := findTwoSwapped(nums)
    count := 2
    recover(root, &count, x, y)
}

func inorder(root *TreeNode) []int {
    if root == nil {
        return []int{}
    }
    nums := inorder(root.Left)
    nums = append(nums, root.Val)
    nums = append(nums, inorder(root.Right)...)
    return nums
}

func findTwoSwapped(nums []int) (int, int) {
    n := len(nums)
    x, y := -1, -1
    swapped_first_occurrence := false
    for i := 0; i < n-1; i++ {
        if nums[i+1] < nums[i] {
            y = nums[i+1]
            if !swapped_first_occurrence {
                x = nums[i]
                swapped_first_occurrence = true
            } else {
                break
            }
        }
    }
    return x, y
}

func recover(root *TreeNode, count *int, x int, y int) {
    if root != nil {
        if root.Val == x || root.Val == y {
            if root.Val == x {
                root.Val = y
            } else {
                root.Val = x
            }
            *count -= 1
            if *count == 0 {
                return
            }
        }
        recover(root.Left, count, x, y)
        recover(root.Right, count, x, y)
    }
}

Input: s1 = "sea", s2 = "eat"
Output: 231

package main

func minimumDeleteSum(s1 string, s2 string) int {
    dp := make([][]int, len(s1) + 1)
    for i := range dp {
        dp[i] = make([]int, len(s2) + 1)
    }
    for i := 1; i <= len(s1); i++ {
        dp[i][0] = dp[i - 1][0] + int(s1[i - 1])
    }
    for j := 1; j <= len(s2); j++ {
        dp[0][j] = dp[0][j - 1] + int(s2[j - 1])
    }
    for i := 1; i <= len(s1); i++ {
        for j := 1; j <= len(s2); j++ {
            if s1[i - 1] == s2[j - 1] {
                dp[i][j] = dp[i - 1][j - 1]
            } else {
                dp[i][j] = min(dp[i - 1][j] + int(s1[i - 1]), dp[i][j - 1] + int(s2[j - 1]))
            }
        }
    }
    return dp[len(s1)][len(s2)]
}

func min(a, b int) int {
    if a < b {
        return a
    }
    return b
}

Input: root = [1,0,1,0,1,0,1]
Output: 22

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

func sumRootToLeaf(root *TreeNode) int {
    var dfs func(*TreeNode, int) int
    dfs = func(node *TreeNode, current_value int) int {
        if node == nil {
            return 0
        }
        current_value = (current_value << 1) | node.Val
        if node.Left == nil && node.Right == nil {
            return current_value
        }
        return dfs(node.Left, current_value) + dfs(node.Right, current_value)
    }
    
    return dfs(root, 0)
}

Input: x = 4
Output: 2
Explanation: The square root of 4 is 2, so we return 2.

func mySqrt(x int) int {
    if x < 2 {
        return x
    }
    var num int
    pivot, left, right := 2, 2, x/2
    for left <= right {
        pivot = left + (right-left)/2
        num = pivot * pivot
        if num > x {
            right = pivot - 1
        } else if num < x {
            left = pivot + 1
        } else {
            return pivot
        }
    }
    return right
}

Input: arr = [1,0,2,3,0,4,5,0]
Output: [1,0,0,2,3,0,0,4]
Explanation: After calling your function, the input array is modified to: [1,0,0,2,3,0,0,4]

func duplicateZeros(arr []int) {
    possibleDups := 0
    length_ := len(arr) - 1

    for left := 0; left <= length_ - possibleDups; left++ {
        if arr[left] == 0 {
            if left == length_ - possibleDups {
                arr[length_] = 0
                length_--
                break
            }
            possibleDups++
        }
    }

    last := length_ - possibleDups

    for i := last; i >= 0; i-- {
        if arr[i] == 0 {
            arr[i + possibleDups] = 0
            possibleDups--
            arr[i + possibleDups] = 0
        } else {
            arr[i + possibleDups] = arr[i]
        }
    }
}

Input: s = "Let's take LeetCode contest"
Output: "s'teL ekat edoCteeL tsetnoc"

package main

import (
    "fmt"
)

func reverseWords(s string) string {
    chars := []rune(s)
    lastSpaceIndex := -1
    len := len(chars)
    
    for strIndex := 0; strIndex <= len; strIndex++ {
        if strIndex == len || chars[strIndex] == ' ' {
            startIndex := lastSpaceIndex + 1
            endIndex := strIndex - 1
            for startIndex < endIndex {
                chars[startIndex], chars[endIndex] = chars[endIndex], chars[startIndex]
                startIndex++
                endIndex--
            }
            lastSpaceIndex = strIndex
        }
    }
    
    return string(chars)
}

func main() {
    s := "Let's take LeetCode contest"
    fmt.Println(reverseWords(s)) // Output: "s'teL ekat edoCteeL tsetnoc"
}

Input: preorder = "9,3,4,#,#,1,#,#,2,#,6,#,#"
Output: true

func isValidSerialization(preorder string) bool {
    slots := 1
    nodes := strings.Split(preorder, ",")
    
    for _, node := range nodes {
        slots--
        if slots < 0 {
            return false
        }
        if node != "#" {
            slots += 2
        }
    }
    
    return slots == 0
}