Помогите найти решение задачи на java [закрыт]

Например так

    List<Integer> weights = Arrays.asList(1, 2, 3, 6);
    int size = weights.stream()
            .mapToInt(x -> x)
            .sum() / 2 + 1;
    int[] arr = new int[size];
    arr[0] = 2;
    for (int weight : weights) {
        for (int i = size - 1; i >= 0; i--) {
            if (arr[i] > 0 && i + weight < size) {
                arr[i + weight]++;
            }
        }
    }
    for (int i = size - 1; i > 0; i--) {
        if (arr[i] >= 2) {
            System.out.println(i);
            break;
        }
    }

EDIT

Я все таки домучал. Решение получилось почти в лоб. Оно строит все возможные способы получить все возможные суммы. Затем находит наибольшую сумму у которой есть два не пересекающихся разложения.

public class App {
    public static void main(String[] args) {
        List<W> weights = Stream.of(1, 2, 3, 4, 5, 9)
                .map(W::new)
                .collect(Collectors.toList());
        Map<Integer, List<List<W>>> arr = new HashMap<>();
        arr.put(0, Collections.singletonList(Collections.emptyList()));
        for (W weight : weights) {
            arr = arr.entrySet().stream()
                    .flatMap(x -> {
                                int newWeight = x.getKey() + weight.value;
                                List<List<W>> newList = x.getValue().stream()
                                        .map(ArrayList::new)
                                        .peek(y -> y.add(weight))
                                        .collect(Collectors.toList());
                                return Stream.of(
                                        new Pair<>(newWeight, newList),
                                        new Pair<>(x.getKey(), x.getValue())
                                );
                            }
                    )
                    .collect(Collectors.toMap(
                            Pair::getIndex,
                            Pair::getValue,
                            (x, y) -> {
                                List<List<W>> r = new ArrayList<>(x);
                                r.addAll(y);
                                return r;
                            }));
        }
        arr.entrySet().
                stream()
                .sorted(Comparator.comparing(Map.Entry::getKey, Comparator.reverseOrder()))
                .filter(x ->
                {
                    for (List<W> a : x.getValue()) {
                        for (List<W> b : x.getValue()) {
                            if(a == b) continue;
                            if (a.stream().noneMatch(b::contains)) {
                                return true;
                            }
                        }
                    }
                    return false;
                })
                .map(Map.Entry::getKey)
                .findFirst()
                .ifPresent(System.out::println);
    }
    @Data
    static class Pair<T> {
        private final int index;
        public final T value;
    }
    @AllArgsConstructor
    @Getter
    static class W {
        public final int value;
    }
}

Класс W нужен чтобы различать блины с одинаковыми весами.