时间戳

首页 > 解决方案 > 我需要一种可扩展的方法来增加 2 种布尔输入和输出的数量，比例为 inputA:inputB:output, 2:1:2, 3:2:3, 4:3:4,

java - 我需要一种可扩展的方法来增加 2 种布尔输入和输出的数量，比例为 inputA:inputB:output, 2:1:2, 3:2:3, 4:3:4,

问题描述

考虑 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;
    }

标签： javaalgorithmlogicboolean-logic

解决方案

您可以使用以下算法：

  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);
}

推荐阅读