数组分组Java

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * 数组分组
 *
 * @author Green.Gee
 * @date 2022/12/23 12:30
 * @email [email protected]
 */
public class GroupOfDeath {

    /**
     * 输入int型数组，询问该数组能否分成两组，使得两组中各元素加起来的和相等，
     * 并且，所有5的倍数必须在其中一个组中，所有3的倍数在另一个组中
     * （不包括5的倍数），不是5的倍数也不是3的倍数能放在任意一组，
     * 可以将数组分为空数组，能满足以上条件，输出true；不满足时输出false。
     */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) {
            int n = Integer.parseInt(in.nextLine());
            List<Integer> A = new ArrayList<>();
            List<Integer> B = new ArrayList<>();
            List<Integer> C = new ArrayList<>();
            String[] arr = in.nextLine().split(" ");
            for (String i : arr) {
                int num = Integer.parseInt(i);
                if (num % 5 == 0) {
                    A.add(num);
                } else if (num % 3 == 0) {
                    B.add(num);
                } else {
                    C.add(num);
                }
            }

            int aSum = A.stream().mapToInt(i -> i).sum();
            int bSum = B.stream().mapToInt(i -> i).sum();
            int cSum = C.stream().mapToInt(i -> i).sum();
            int rest = Math.abs(aSum - bSum);

//            System.out.println(judge(0, C, 0, rest));

            if (C.size() > 0) {
                if (cSum == 0) {
                    System.out.println(true);
                } else {
                    boolean flag = false;
                    for (int i = 0; i < C.size() - 1; i++) {
                        for (int j = i + 1; j < C.size(); j++) {
                            int s1 = C.subList(i, j).stream().mapToInt(it -> it).sum();
                            int s2 = C.subList(0, i).stream().mapToInt(it -> it).sum();
                            int s3 = C.subList(j, C.size()).stream().mapToInt(it -> it).sum();
                            if (Math.abs(s1 - s2 - s3) == rest) {
                                flag = true;
                            }
                        }
                    }
                    System.out.println(flag);
                }
            } else {
                aSum = A.stream().mapToInt(i -> i).sum();
                bSum = B.stream().mapToInt(i -> i).sum();
                System.out.println(aSum == 0 || bSum == 0 || aSum == bSum);
            }
        }
    }

    // 递归方法
    static boolean judge(int i, List<Integer> arr, int sum1, int sum2) {
        if (i == arr.size()) {
            return Math.abs(sum1) == sum2;
        }
        return judge(i + 1, arr, sum1 + arr.get(i), sum2) ||
                judge(i + 1, arr, sum1 - arr.get(i), sum2);
    }
}