java - 检查 Java 数组中的总和

Question

我正在用 Java 做一个名为“三十”的骰子游戏。我有一个数组，其中包含骰子的值，例如 [1, 3, 4, 5, 5, 6]。我希望能够从该数组中找到给出给定总和的每个组，但每个骰子只能计算一次。

例如，如果我有数组 [1, 3, 4, 5, 5, 6] 并且想要找到每个等于 12 的组，那么就会得到 1+5+6=12 和 3+4 +5=12。

以 [1, 1, 1, 1, 2, 6] 为例，我将得到 1+1+1+1+2+6=12。

总会有 6 个骰子，但我要寻找的总和可以是 4 到 12 之间的任意值。

有人可以帮我吗？我实际上没有任何代码可以提供，这只会令人困惑并且根本没有帮助。

Answer 1

这是一个没有经过充分测试且可能有点幼稚的解决方案。我使用整数列表，因为我不喜欢数组，抱歉!

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

import org.junit.Before;
import org.junit.Test;

public class PickNumbersTest {

    private List<Integer> numbers;

    @Before
    public void before() {
        Integer[] ints = new Integer[] { 1, 3, 4, 5, 5, 6 };
        numbers = new ArrayList<>();
        numbers.addAll(Arrays.asList(ints));        
    }

    @Test
    public void test() {

        PickNumbers p = new PickNumbers();
        List<List<Integer>> result = p.pick(12,  numbers);

        System.out.println(result);
    }
}

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

public class PickNumbers {

    public List<List<Integer>> pick(final int sum, final List<Integer> values) {

        // make a copy to avoid making changes to passed in List
        List<Integer> numbers = copy(values);

        List<List<Integer>> results = new ArrayList<List<Integer>>();

        while (!pickSingle(sum, numbers).isEmpty()) {

            List<Integer> currentResult = pickSingle(sum, numbers);

            results.add(currentResult);
            currentResult.forEach(i -> numbers.remove(i));

        }

        return results;
    }

    protected List<Integer> pickSingle(final int sum, final List<Integer> values) {
        int rest = sum;
        List<Integer> result = new ArrayList<>();
        Picker p = new Picker(values);

        while (rest > 0 && p.hasNext()) {

            int i = p.next();

            if (i > rest) {
                p.remove();
            } else if (i == rest) {
                result.add(i);
                return result;
            } else { // i < rest
                result.add(i);
                p.remove();
                rest = rest - i;
            }
        }

        return new ArrayList<>();
    }

    private List<Integer> copy(final List<Integer> values) {

        List<Integer> copy = new ArrayList<Integer>();
        copy.addAll(values);

        return copy;
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Picker {

    private List<Integer> values = new ArrayList<Integer>();

    public Picker(final List<Integer> values) {

        this.values.addAll(values);
        this.values.sort(null);
        Collections.reverse(this.values);
    }

    public int next() {

        return values.get(0);
    }

    public void remove() {

        values.remove(0);
    }

    public boolean hasNext() {

        return values.size() > 0;
    }
}