当我在1 / 2和结果之间画一个表时，我看到了一个模式，

if(one<2 && two <2) result=0; return;

以上将减少至少3个if语句。我没有看到一个集合模式，也无法从给出的代码中收集到很多信息——但如果可以推导出这样的逻辑，它将减少大量的if语句。

希望这能有所帮助。

说实话，每个人都有自己的代码风格。我没想到性能会受到太大影响。如果您比使用开关箱版本更能理解这一点，那么请继续使用此版本。

您可以嵌套if语句，因此最后的if检查可能会略微提高性能，因为它不会经过那么多if语句。但是在你的java基础课程中，它可能不会有什么好处。

else if(one == 3 && two == 3) { result = 3; }

所以，与其…

if(one == 0 && two == 0) { result = 0; }
else if(one == 0 && two == 1) { result = 0; }
else if(one == 0 && two == 2) { result = 1; }
else if(one == 0 && two == 3) { result = 2; }

你会做……

if(one == 0) 
{ 
    if(two == 0) { result = 0; }
    else if(two == 1) { result = 0; }
    else if(two == 2) { result = 1; }
    else if(two == 3) { result = 2; }
}

按照你的喜好重新格式化。

这并没有使代码看起来更好，但我相信它可能会加快一点速度。

我没有使用Java的经验，所以可能会有一些错字。请将此代码视为伪代码。

我会选择一个简单的开关。为此，您需要一个单一的数字求值。然而，对于这种情况，由于0 <= one < 4 <= 9和0 <= two < 4 <= 9，我们可以将这两个整型都转换为简单的整型，方法是1乘以10再加上2。然后在结果数字中使用一个开关，就像这样:

public int fightMath(int one, int two) {
    // Convert one and two to a single variable in base 10
    int evaluate = one * 10 + two;

    switch(evaluate) {
        // I'd consider a comment in each line here and in the original code
        // for clarity
        case 0: result = 0; break;
        case 1: result = 0; break;
        case 1: result = 0; break;
        case 2: result = 1; break;
        case 3: result = 2; break;
        case 10: result = 0; break;
        case 11: result = 0; break;
        case 12: result = 2; break;
        case 13: result = 1; break;
        case 20: result = 2; break;
        case 21: result = 1; break;
        case 22: result = 3; break;
        case 23: result = 3; break;
        case 30: result = 1; break;
        case 31: result = 2; break;
        case 32: result = 3; break;
        case 33: result = 3; break;
    }

    return result;
}

还有另一个简单的方法，我只是想指出一个理论代码。然而，我不会使用它，因为它有一些额外的复杂性，你通常不想处理。额外的复杂性来自于以4为基数，因为计数是0、1、2、3、10、11、12、13、20，……

public int fightMath(int one, int two) {
    // Convert one and two to a single variable in base 4
    int evaluate = one * 4 + two;

    allresults = new int[] { 0, 0, 1, 2, 0, 0, 2, 1, 2, 1, 3, 3, 1, 2, 3, 3 };

    return allresults[evaluate];
}

这只是额外的说明，以防我在Java中遗漏了一些东西。在PHP中我会这样做:

function fightMath($one, $two) {
    // Convert one and two to a single variable in base 4
    $evaluate = $one * 10 + $two;

    $allresults = array(
         0 => 0,  1 => 0,  2 => 1,  3 => 2,
        10 => 0, 11 => 0, 12 => 2, 13 => 1,
        20 => 2, 21 => 1, 22 => 3, 23 => 3,
        30 => 1, 31 => 2, 32 => 3, 33 => 3 );

    return $allresults[$evaluate];
}

看看我们都知道些什么

1:你的答案对于参与人1 P1和参与人2 P2是对称的。这对于格斗游戏来说很有意义，但你也可以利用它来完善你的逻辑。

2:3拍0拍2拍1拍3。这些情况中唯一不包括的情况是0对1和2对3的组合。换句话说，唯一的胜利表是这样的:0击败2,1击败3,2击败1,3击败0。

3:如果0/1人对位，则平局无命中，但如果2/3人对位，则双方均命中

首先，让我们构建一个单向函数，告诉我们是否赢了:

// returns whether we beat our opponent
public boolean doesBeat(int attacker, int defender) {
  int[] beats = {2, 3, 1, 0};
  return defender == beats[attacker];
}

然后我们可以使用这个函数来组合最终的结果:

// returns the overall fight result
// bit 0 = one hits
// bit 1 = two hits
public int fightMath(int one, int two)
{
  // Check to see whether either has an outright winning combo
  if (doesBeat(one, two))
    return 1;

  if (doesBeat(two, one))
    return 2;

  // If both have 0/1 then its hitless draw but if both have 2/3 then they both hit.
  // We can check this by seeing whether the second bit is set and we need only check
  // one's value as combinations where they don't both have 0/1 or 2/3 have already
  // been dealt with 
  return (one & 2) ? 3 : 0;
}

虽然这可以说比许多答案中提供的查找表更复杂，而且可能更慢，但我相信这是一种更好的方法，因为它实际上封装了代码的逻辑，并向阅读您代码的任何人描述它。我认为这是一个更好的实现。

(这是一段时间以来，我做任何Java，所以抱歉，如果语法错误，希望它仍然是可理解的，如果我有一点错误)

顺便说一下，0-3显然意味着什么;它们不是任意的值，所以给它们命名会有帮助。

我想到的第一件事基本上与Francisco Presencia给出的答案相同，但有所优化:

public int fightMath(int one, int two)
{
    switch (one*10 + two)
    {
    case  0:
    case  1:
    case 10:
    case 11:
        return 0;
    case  2:
    case 13:
    case 21:
    case 30:
        return 1;
    case  3:
    case 12:
    case 20:
    case 31:
        return 2;
    case 22:
    case 23:
    case 32:
    case 33:
        return 3;
    }
}

你可以进一步优化它，使最后的情况(3)为默认情况:

    //case 22:
    //case 23:
    //case 32:
    //case 33:
    default:
        return 3;

此方法的优点是，与其他一些建议的方法相比，更容易看到1和2的哪个值对应于哪个返回值。

((two&2)*(1+((one^two)&1))+(one&2)*(2-((one^two)&1)))/2