求一个正整数数组中 连续不断的 子元素数组 的最大长度l，要求子数组的和是 ＞=s 的最小数组。

方法一、二、三是我解这道题心路历程。

import com.alibaba.fastjson.JSONObject;

import java.util.Arrays;
import java.util.List;

/**
 * @description: 大致题意：
 * 求一个正整数数组中 连续不断的 子元素数组 的最大长度l，要求子数组的和是 >=s 的最小数组。
 * @author: Asker
 * @create: 2020/8/15 10:52 下午
 **/
public class fun2 {

    private static final int length = 0;

    public static void main(String[] args) {
//        List<Integer> list = Arrays.asList();
//        List<Integer> list = Arrays.asList(3);
//        List<Integer> list = Arrays.asList(23);
        List<Integer> list = Arrays.asList(19, 2, 3, 5, 1, 7, 4, 24, 5, 2, 1, 3, 2, 2, 1, 1, 2, 1, 2, 2, 11, 2);
        calculate(list, 15);
    }

    public static void calculate(List<Integer> list, int sum) {
        System.out.println("=============================方法一================================");
        int fun = fun(list, sum, length);
        System.out.println(fun);

        System.out.println("=============================方法二================================");
        int fun2 = fun2(list, sum, length);
        System.out.println(fun2);

        System.out.println("=============================方法三================================");
        int fun3 = fun3(list, sum, length);
        System.out.println(fun3);
    }

    private static int fun(List<Integer> list, int sum, int po) {
        System.out.println(JSONObject.toJSONString(list));
        if (list == null || list.isEmpty()) {
            return po;
        }
        if (list.size() <= po) {
            return po;
        }
        int tempSum = 0;
        boolean flag = true;
        for (int i = 0; i < po; i++) {
            tempSum += list.get(i);
            if (tempSum >= sum) {
                flag = false;
                break;
            }
        }
        if (flag) {
            for (; po < list.size(); ) {
                tempSum += list.get(po++);
                if (tempSum >= sum) {
                    break;
                }
            }
        }
        System.out.println(po);
        return po == list.size() && tempSum < sum ? -1 :
                fun(list.subList(1, list.size()), sum, po);
    }

    private static int fun2(List<Integer> list, int sum, int po) {
        System.out.println(JSONObject.toJSONString(list));
        if (list == null || list.isEmpty()) {
            return po;
        }
        if (list.size() <= po) {
            return po;
        }
        int left = 0;
        int right = list.size() - 1;
        int lSum = 0;
        int rSum = 0;
        //是否需要延长po
        boolean flag = true;
        for (int i = 0; i < po; i++) {
            lSum += list.get(left + i);
            if (lSum >= sum) {
                left++;
                flag = false;
                break;
            }
            rSum += list.get(right - i);
            if (rSum >= sum) {
                right--;
                flag = false;
                break;
            }
        }
        if (flag) {
            for (; po < right - left + 1; ) {
                lSum += list.get(left + po);
                rSum += list.get(right - po);
                po++;
                if (lSum >= sum) {
                    left++;
                    break;
                }
                if (rSum >= sum) {
                    right--;
                    break;
                }
            }
        }
        System.out.println(po);
        return po == list.size() && lSum < sum ? -1 :
                left + 1 >= right - 1 ? po : fun2(list.subList(left, right + 1), sum, po);
    }

    private static int fun3(List<Integer> list, int sum, int po) {
        System.out.println(JSONObject.toJSONString(list));
        if (list == null || list.isEmpty()) {
            return po;
        }
        if (list.size() <= po) {
            return po;
        }
        int left = 0;
        int right = list.size() - 1;
        int lSum = 0;
        int rSum = 0;
        //是否需要延长po
        boolean flag = true;
        for (int i = 0; i < po; i++) {
            lSum += list.get(left + i);
            rSum += list.get(right - i);
            if (lSum >= sum && rSum >= sum) {
                left++;
                right--;
                flag = false;
                break;
            }
        }
        if (flag) {
            for (; po < right - left + 1; ) {
                int temL = lSum + list.get(left + po);
                int temR = rSum + list.get(right - po);
                if (temL >= sum && temR >= sum) {
                    po++;
                    lSum = temL;
                    break;
                } else if (temL >= sum && temR < sum) {
                    lSum = temL - list.get(left++);
                } else if (temR >= sum && temL < sum) {
                    rSum = temR - list.get(right--);
                } else {
                    lSum = temL;
                    rSum = temR;
                    po++;
                }
            }
        }
        //如果集合总和都不超过sum，返回-1；
        return po == list.size() && lSum < sum ? -1 :
                left + 1 >= right - 1 ? po : fun3(list.subList(left + 1, right - 1), sum, po);
    }

}

输出结果：
================================方法三================================
[19,2,3,5,1,7,4,24,5,2,1,3,2,2,1,1,2,1,2,2,11,2]
[1,3,2,2,1,1,2,1]
9