OD机试 - 贪吃的猴子

题目

一只贪吃的猴子，来到一个果园，发现许多串香蕉排成一行，每串香蕉上有若干根香蕉。每串香蕉的根数由数组numbers给出。猴子获取香蕉，每次都只能从行的开头或者末尾获取，并且只能获取N次，求猴子最多能获取多少根香蕉。

输入描述

第一行为数组numbers的长度

第二行为数组numbers的值每个数字通过空格分开

第三行输入为N，表示获取的次数

输出描述

按照题目要求能获取的最大数值。

输入

4
4 2 2 3
2

输出

7

说明

第一次获取香蕉为行的开头，第二次获取为行的末尾，因此最终根数为4+3 =7

理解

本体整理条件如下：
1.一维无序数组
2.每次只能首或尾取数
要取最大的，会下意识的判断首尾哪个大，然后取哪个，但问题是数组是无序的，你不知道数组的中间哪个数会突然超过前面累加的和，比如：
1 999 2 3 4 5 6 7 如果是这样的数组，每次简单判断首尾大小，则999在取7以下的次数下永远娶不到，所以要抽出题目的跳转转化自己的理解：
不管哪一次取的是首还是尾，最终结果都是：头部取M，尾部取M - N

代码

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

public class Test024 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int size = Integer.parseInt(sc.nextLine());
        List<Integer> list =
            Arrays.stream(sc.nextLine().split(" "))
                .map(Integer::parseInt).toList();
        if (list.size() != size) {
            System.out.println("輸入异常");
        }
        int totle = Integer.parseInt(sc.nextLine());
        // 取数次数大于集合，不用判断，直接累加
        if (totle >= size) {
            System.out.println(list.stream().reduce(0, Integer::sum));
            return;
        }
        int sum = 0;
        int left = 0;
        int right = 0;
        while (left <= totle) {
            right = size - totle + left;
            int tempSum = list.subList(0, left).stream().reduce(0, Integer::sum);
            // subList 不取toindex，取的是toindex - 1 所以size不能减1
            tempSum = list.subList(right, size).stream().reduce(tempSum, Integer::sum);
            if (sum < tempSum) {
                sum = tempSum;
            }
            left++;
        }
        System.out.println(sum);
    }
}