Question

所以目前我正在为我上一篇comp sci文章编写一些代码，它要求你在system.in上输入一些红色，处理它，第一行总是一组数字，最多25个数字。接下来是单个N或L，另一个是目标。使用此输入，您必须找到使用int值创建目标的正确操作集（+和*）。

我正在使用一个布尔数组来跟踪我正在使用的操作数，但是我不确定如何＆＃34;暴力＆＃34;通过尝试每个不同的操作数集的解决方案，我有代码检查每个集但是我不确定是否有一个简单而简单的方法来更改数组，如[0,0,0,0]（0为假）到[0,0,0,1]，[0,0,1,0]，[0,0,1,1]等？

我确信我忽略了一种非常简单的方式，但对于我的生活，我不确定它是什么。

static boolean evlN(int[] input, boolean[]ops, int aim){
    boolean run = true, found = false;
    int[] used = new int[input.length];
    int runs = 0 ,ans = 0;
    while(!found && runs < (1 << ops.length)){
        //finding all multiplys and doing them first
        search:
        for(int x = 0; x < ops.length; x++){
            if(!ops[x]){
                used[x] = input[x] * input[x+1];
                //need to stop working out and change the ops
                if(used[x] > aim){
                    run = false;
                    break;
                }
            }
        }
        //once multiplys have been done need to do all the adds
        if(run){
            for(int x = 0; x < ops.length; x++){
                if(ops[x]){
                    if(used[x] != 0) ans += used[x] + input[x+1];
                    else if(used[x+1] != 0) ans += input[x] + used[x];
                }
                if(ans > aim) break;
            }
        }
        if(ans == aim) found = true;
        used = new int[input.length];
        ans= 0;
        runs++;
        run = !run;
    }
    if(found) return true;
    else return false;

}

这就是我用来计算每组操作数和数字的方法我只是想改变布尔数组来强制回答

Answer 1

您的输入组合看起来像二进制整数（称之为N）。您可以通过递增N来完成不同的组合。

Answer 2

有一种相当通用的机制可用于递增一组组合，就像对整数中的数字一样。我将使用一个界面来演示它，这样你就可以看到它是如何应用的。

public interface UnitValue {
    boolean isLast();
    UnitValue next();
}

public class <T extends UnitValue> MultiUnitValue {
    private final int size;
    private final T first;
    private final T[] units;
    private boolean complete = false;

    public MultiUnitValue(int size, T first) {
        this.size = size;
        this.first = first;
        this.units = new T[size];
        for (int i = 0; i < size; i++)
            units[i] = first;
    }

    public void next() {
        if (!complete) {
            int i = 0;
            while (units[i].isLast())
                units[i++] = first;
            units[i].next();
            complete = i == size - 1 && units[i].isLast();
        }
    }
}

为了清晰起见，我省略了吸气剂，但它们应该是显而易见的。

对于布尔值的非通用解决方案，它看起来像：

boolean[] values = new boolean[size];

int i = 0;
while (values[i])
    values[i++] = false;
values[i] = true;

一个非常类似的解决方案适用于字符，数字，枚举和其他任何符合相同模式的内容。

布尔数组和尝试每种组合的简单方法

2 个答案: