Page Comparison

func kSmallestPairs(nums1 []int, nums2 []int, k int) [][]int {
    result := make([][]int, 0, k)
    
    h_ := make(Heap, 0, k)
    h := &h_
    
    for _, num := range nums1 {
        heap.Push(h, []int{num, nums2[0], 0})
    }
    
    for i := 0; i < k; i++ {
        top := heap.Pop(h).([]int)
        result = append(result, []int{top[0], top[1]})
        
        if p := top[2] + 1; p < len(nums2) {
            heap.Push(h, []int{top[0], nums2[p], p})
        }
    }
    
    return result
}

type Heap [][]int

func (h Heap) Len() int           { return len(h) }
func (h Heap) Less(i, j int) bool { return h[i][0] + h[i][1] < h[j][0] + h[j][1] }
func (h Heap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
func (h *Heap) Push(x any) {
	*h = append(*h, x.([]int))
}

func (h *Heap) Pop() any {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[0 : n-1]
	return x
}

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
    dummy := &ListNode{}
    
    h := dummy
    h1, h2 := l1, l2
    
    carry := 0
    for h1 != nil || h2 != nil {
        num1, num2 := 0, 0
        
        if h1 != nil && h2 != nil {
            num1, num2 = h1.Val, h2.Val
            h1 = h1.Next
            h2 = h2.Next
        } else if h1 != nil {
            num1 = h1.Val
            h1 = h1.Next
        } else {
            num2 = h2.Val
            h2 = h2.Next
        }
        
        result := num1 + num2 + carry
        if result >= 10 {
            result -= 10
            carry = 1
        } else {
            carry = 0
        }

        node := &ListNode{Val: result}
        h.Next = node
        h = node
    }
    
    if carry > 0 {
        node := &ListNode{Val: carry}
        h.Next = node
        h = node
    }
    
    return dummy.Next
}

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
    nodes1 := fromList(l1)
    nodes2 := fromList(l2)
    
    result := add(nodes1, nodes2)
    
    return toList(result)
}

func add(nodes1, nodes2 []int) []int {
    result := make([]int, 0, 101)
    
    p1, p2 := 0, 0
    carry := 0
    
    for p1 < len(nodes1) || p2 < len(nodes2) || carry > 0 {
        val := carry
        if p1 < len(nodes1) {
            val += nodes1[p1]
            p1++
        }
        if p2 < len(nodes2) {
            val += nodes2[p2]
            p2++
        }
        
        if val >= 10 {
            val -= 10
            carry = 1
        } else {
            carry = 0
        }
        
        result = append(result, val)
    }
    
    return result
}

func fromList(h *ListNode) []int {
    nodes := make([]int, 0, 100)
    for h != nil {
        nodes = append(nodes, h.Val)
        h = h.Next
    }
    
    reverse(nodes)
    
    return nodes
}

func toList(nodes []int) *ListNode {
    reverse(nodes)
    
    dummy := &ListNode{}
    
    h := dummy
    for _, num := range nodes {
        h.Next = &ListNode{Val: num}
        h = h.Next
    }
    
    return dummy.Next
}

func reverse(arr []int) {
    i, j := 0, len(arr)-1
    for i < j {
        arr[i], arr[j] = arr[j], arr[i]
        i++
        j--
    }
}

func nthSuperUglyNumber(n int, primes []int) int {
    h_ := make(Heap, 0, n)
    h := &h_
    
    for _, p := range primes {
        heap.Push(h, [3]int{1, p, 0})
    }
    
    uglys := make([]int, 1, n)
    uglys[0] = 1
    
    
    for len(uglys) < n {
        top := heap.Pop(h).([3]int)
        num, p, pi := top[0], top[1], top[2]
        
        if num != uglys[len(uglys) - 1] {
            uglys = append(uglys, num)
        }
        
        heap.Push(h, [3]int{p * uglys[pi], p, pi+1})
    }
    
    return uglys[n-1]
}

type Heap [][3]int

func (h Heap) Len() int           { return len(h) }
func (h Heap) Less(i, j int) bool { return h[i][0] < h[j][0] }
func (h Heap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }

func (h *Heap) Push(x any) {
	*h = append(*h, x.([3]int))
}

func (h *Heap) Pop() any {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[0 : n-1]
	return x
}