我需要一种可扩展的方法，用于增加 inputA：inputB：output、2：1：2、3：2：3、4：3：4 的比率中 2 种类型的布尔输入和输出的数量，

I need a scalable method for increasing numbers of 2 types of Boolean inputs and outputs in the ratio inputA:inputB:output, 2:1:2, 3:2:3, 4:3:4,

提问人：P.Ellis 提问时间：8/17/2021 更新时间：8/17/2021 访问量：52

问：

考虑 4 个布尔输出和 4 个布尔输入。

Input1, Output1 
Input2, Output2 
Input3, Output3 
Input4, Output4

它们是相关的，因此如果 Input1=true，则 Output1=true。如果 Input2=true，则 Output2=true，依此类推。

现在考虑 3 个额外的布尔输入，它们决定了相邻的输出是否“连接在一起”。

Output1Output2Joined (true=yes, false=no)
Output2Output3Joined
Output3Output4Joined

如果两个（或更多）输出被“联接”，则布尔 OR 操作需要处理现在“联接”的布尔输入，以便设置现在“联接”的布尔输出的值。

下面显示了一些示例方案的输出。

Output1Output2Joined = false
Output2Output3Joined = false
Output3Output4Joined = false
Input1 = false, Output1 = false
Input2 = false, Output2 = false
Input3 = false, Output3 = false
Input4 = false, Output4 = false
---------------------
Output1Output2Joined = false
Output2Output3Joined = false
Output3Output4Joined = false
Input1 = true, Output1 = true
Input2 = false, Output2 = false
Input3 = false, Output3 = false
Input4 = false, Output4 = false
---------------------
Output1Output2Joined = true
Output2Output3Joined = false
Output3Output4Joined = false
Input1 = true, Output1 = true
Input2 = false, Output2 = true
Input3 = false, Output3 = false
Input4 = false, Output4 = false
---------------------
Output1Output2Joined = false
Output2Output3Joined = false
Output3Output4Joined = true
Input1 = true, Output1 = true
Input2 = false, Output2 = false
Input3 = false, Output3 = true
Input4 = true, Output4 = true
---------------------
Output1Output2Joined = true
Output2Output3Joined = false
Output3Output4Joined = true
Input1 = true, Output1 = true
Input2 = false, Output2 = true
Input3 = false, Output3 = true
Input4 = true, Output4 = true
---------------------
Output1Output2Joined = true
Output2Output3Joined = true
Output3Output4Joined = false
Input1 = true, Output1 = true
Input2 = false, Output2 = true
Input3 = false, Output3 = true
Input4 = false, Output4 = false

这是我用于上述场景的代码，但我想要一个动态算法，以便我可以使用 5：4：5、6：5：6、7：6：7、输入/连接/输出

public void changed()
    {
        // Evaluate state of joins
        int joinsState = 0;
        if (getOutput1Output2Joined ) joinsState += 1;
        if (getOutput2Output3Joined ) joinsState += 2;
        if (getOutput3Output4Joined ) joinsState += 4;
        switch (joinsState) {
            case 0: {
                // All joins true therefore perform OR on inputs
                boolean[] inputArray = new boolean [4];
                inputArray[0] = getInput1();
                inputArray[1] = getInput2();
                inputArray[2] = getInput3();
                inputArray[3] = getInput4();
                boolean out = evaluateInput(inputArray);
                setOutput1(out);
                setOutput2(out);
                setOutput3(out);
                setOutput4(out);
                break;
            }
            case 1: {
           // Output1Output2Joined false, Output2Output3Joined true, Output3Output4Joined true
                setOutput1(getInput1());
                boolean[] inputArray = new boolean [3];
                inputArray[0] = getInput2();
                inputArray[1] = getInput3();
                inputArray[2] = getInput4();
                boolean out = evaluateInput(inputArray);
                setOutput2(out);
                setOutput3(out);
                setOutput4(out);
                break;
            }
            case 2: {
           // Output1Output2Joined true, Output2Output3Joined false, Output3Output4Joined true
                boolean[] inputArray = new boolean [2];
                inputArray[0] = getInput1();
                inputArray[1] = getInput2();
                boolean out = evaluateInput(inputArray);
                setOutput1(out);
                setOutput2(out);
                inputArray[0] = getInput3();
                inputArray[1] = getInput4();
                out = evaluateInput(inputArray);
                setOutput3(out);
                setOutput4(out);
                break;
            }
            case 3: {
          // Output1Output2Joined false, Output2Output3Joined false, Output3Output4Joined true
                setOutput1(getInput1());
                setOutput2(getInput2());
                boolean[] inputArray = new boolean [2];
                inputArray[0] = getInput3();
                inputArray[1] = getInput4();
                boolean out = evaluateInput(inputArray);
                setOutput3(out);
                setOutput4(out);
                break;
            }
            case 4: {
           // Output1Output2Joined true, Output2Output3Joined true, Output3Output4Joined false
                boolean[] inputArray = new boolean [3];
                inputArray[0] = getInput1();
                inputArray[1] = getInput2();
                inputArray[2] = getInput3();
                boolean out = evaluateInput(inputArray);
                setOutput1(out);
                setOutput2(out);
                setOutput3(out);
                setOutput4(getInput4());
                break;
            }
            case 5: {
          // Output1Output2Joined false, Output2Output3Joined true, Output3Output4Joined false
                setOutput1(getInput1());
                boolean[] inputArray = new boolean [2];
                inputArray[0] = getInput2();
                inputArray[1] = getInput3();
                boolean out = evaluateInput(inputArray);
                setOutput2(out);
                setOutput3(out);
                setOutput4(getInput4());
                break;
            }
            case 6: {
          // Output1Output2Joined true, Output2Output3Joined false, Output3Output4Joined false
                boolean[] inputArray = new boolean [2];
                inputArray[0] = getInput1();
                inputArray[1] = getInput2();
                boolean out = evaluateInput(inputArray);
                setOutput1(out);
                setOutput2(out);
                setOutput3(getInput3());
                setOutput4(getInput4());
                break;
            }
            case 7: {
         // Output1Output2Joined false, Output2Output3Joined false, Output3Output4Joined false
                setOutput1(getInput1());
                setOutput2(getInput2());
                setOutput3(getInput3());
                setOutput4(getInput4());
                break;
            }
        }
    }
    private boolean evaluateInput (boolean[] input) {
        boolean pOr = false;
        // Loop through array of input status
        for (int i = 0; i < input.length; i++)
        {
            // If any input true then set output true
            if (input[i]) {
                pOr = true;
                break;
            }
        }
        return pOr;
    }
Java 算法 逻辑

评论

答：

0赞 josejuan 8/17/2021 #1

你是一个等价类，也就是说，你可以安全地替换每一个for（重要的是，在该等价操作下，没有其他）。A join B = True|FalseBA

注意，如果 和 ，真的，在你的操作下是 finally 。A join B = TrueB join C = FalseC join A = TrueORB join C = True

也就是说，你的操作实际上是一个图的传递闭包（一个更友好的来源可能是这个解释）。OR

如果你想成为强制性的，你就会陷入矛盾。R join T = false

然后，您只需要计算所有句子的传递闭包，例如：

Output1Output2Joined = true
Output2Output3Joined = false
Output3Output4Joined = true
...

上一个链接有一个示例代码，用于计算传递闭包。

传递闭包将为您提供一种方法，给定索引（例如，...）获取等价类（例如），并且，给定等价类（例如）获取所有轨道（全部连接，，...）。Output1Eq38Eq38Output1Output5

例如，使用两张地图：

Map<Integer, String> IndextoEqClass
Map<String, List<Integer>> EqClassIndexes

一旦你有了传递闭包，对于每一个：

Input1 = true, Output1 = true
Input2 = false, Output2 = true
Input3 = false, Output3 = true
...

您将获得操作下的所有输出OR

Integer currentOutputIndex = ...;
List<Integer> allOROutputIndexes = EqClassIndexes.get(IndextoEqClass.get(currentOutputIndex));
1赞 trincot 8/17/2021 #2

您可以使用以下算法：

  1. 将输入复制到输出
  2. 对联接信息执行前向扫描。如果 input[i] 与下一个输入联接，则对 output[i] 与下一个输出执行 OR，并将其存储为下一个输出的新值（即 output[i+1]）
  3. 对联接信息执行向后扫描。如果 input[i+1] 与前一个输入联接，则对前一个输出执行 output[i+1] 的 OR，并将其存储为前一个输出的新值（即 output[i]）

示例代码如下：

public static boolean[] algo(boolean[] inputs, boolean[] joinedWithNext) {
    // Copy input to output
    boolean[] outputs = inputs.clone();

    // Forward sweep
    for (int i = 0; i < joinedWithNext.length; i++) {
        if (joinedWithNext[i]) {
            outputs[i + 1] |= outputs[i];
        }
    }

    // Backward sweep
    for (int i = joinedWithNext.length - 1; i >= 0; i--) {
        if (joinedWithNext[i]) {
            outputs[i] |= outputs[i + 1];
        }
    }

    return outputs;
}

下面是带有一些示例输入的算法运行：

// Sample input:
boolean[] inputs = { false, true, false, false };
boolean[] joinedWithNext = { true, true, false }; // One less value

// Perform algorithm
boolean[] outputs = algo(inputs, joinedWithNext);

// Output results
for (boolean b : outputs) {
    System.out.println(b);
}

上一个：两个布尔变量既为真又为假的解释 [closed]

下一个：if else 语句中的多个布尔值在 Java 中始终为 false