盛水最多的容器

package main

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 *
 * @param height int整型一维数组
 * @return int整型
 */
func maxArea( height []int ) int {
    // write code here
    if len(height) < 1 {return 0}

    res, l, r := 0, 0, len(height) - 1
    for l < r {
        res = getMax(res, getMin(height[l], height[r]) * (r - l))
        if height[l] <= height[r] {
            l ++
        } else {
            r --
        }
    }
    return res
}

func getMin(l, r int) int {
    if l <= r {
        return l
    }
    return r
}

func getMax(res, tmp int) int {
    if res < tmp {
        return tmp
    }
    return res
}

package main
// import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param height int整型一维数组 
 * @return int整型
*/
func maxArea( height []int ) int {
    ans:=0
    i,j:=0,len(height)-1
    for i<j{
        v:=min(height[j],height[i])*(j-i)
        if v>ans{
            ans=v
        }
        if height[i]<height[j]{
            i++
        }else{
            j--
        }
    }
    return ans
}

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

package main

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param height int整型一维数组 
 * @return int整型
*/
func maxArea( height []int ) int {
    if len(height) < 2 {
        return 0
    }
    
    // 左右双指针对比
    left, right := 0, len(height)-1
    res := 0
    for left < right {
        //计算当前面积, 对比得到最大面积
        area := min(height[left], height[right]) * (right-left)
        res = max(res, area)
        // 最短的边内移动
        if height[left] < height[right] {
            left++
        } else {
            right--
        }
    }
    return res
}

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

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

func maxArea( height []int ) (max int) {
    left, right, tmp := 0, len(height)-1, 0
    for left < right {
        if lh, rh, dep := height[left], height[right], right - left; lh < rh {
            tmp = lh * dep
            left++
        } else {
            tmp = rh * dep
            right--
        }
        if max < tmp {max = tmp}
    }
    return
}