func lemonadeChange(bills []int) bool {
    five, ten := 0, 0
    for _, bill := range bills {
        if bill == 5 {
            five++
        } else if bill == 10 {
            ten++
            five--
        } else if ten > 0 {
            ten--
            five--
        } else {
            five -= 3
        }
        if five < 0 {
            return false
        }
    }
    return true
}

func arrangeCoins(n int) int {
    if n == 0 {
        return 0
    }
    c := 1
    for {
        if n < c {
            return c - 1
        } else if n == c {
            return c
        }
        n-=c
        c++
    }
}

func canCompleteCircuit(gas []int, cost []int) int {
    curSum := 0
    totalSum := 0
    start := 0
    for i := 0; i < len(gas); i++ {
        curSum += gas[i] - cost[i]
        totalSum += gas[i] - cost[i]
        if curSum < 0 {
            start = i + 1
            curSum = 0
        }
    }
    if totalSum < 0 {
        return -1
    }
    return start
}

func candy(ratings []int) int {
    candy := make([]int, len(ratings))
    for i := range candy {
        candy[i]= 1
    }
    
    for i := 1; i < len(ratings); i++ {
        if ratings[i] > ratings[i - 1] {
            candy[i] = candy[i - 1] + 1
        }
    }
    for i := len(ratings) - 2; i >= 0; i-- {
        if ratings[i] > ratings[i + 1] {
            candy[i] = max(candy[i], candy[i+1]+1)
        }
    }
    result := 0
    for i := range candy {
        result += candy[i]
    }
    return result
}

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

func merge(intervals [][]int) [][]int {
    result := [][]int{}
    if len(intervals) == 0 {
        return result
    }
    
    sort.Slice(intervals, func(i, j int) bool {
        return intervals[i][0] < intervals[j][0]
    })
    
    flag := false // whether to merge last interval
    for i := 1; i < len(intervals); i++ {
        start := intervals[i - 1][0]
        end := intervals[i - 1][1]
        for i < len(intervals) && intervals[i][0] <= end {
            end = max(end, intervals[i][1])
            if i == len(intervals) - 1 {
                flag = true
            }
            i++
        }
        result = append(result, []int{start, end})
    }
    if !flag {
        result = append(result, intervals[len(intervals)-1])
    }
    
    return result
}

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