下面是一个相当简洁的版本，类似于JAB的回应。这使用地图来存储哪个移动战胜其他移动。

public enum Result {
  P1Win, P2Win, BothWin, NeitherWin;
}

public enum Move {
  BLOCK_HIGH, BLOCK_LOW, ATTACK_HIGH, ATTACK_LOW;

  static final Map<Move, List<Move>> beats = new EnumMap<Move, List<Move>>(
      Move.class);

  static {
    beats.put(BLOCK_HIGH, new ArrayList<Move>());
    beats.put(BLOCK_LOW, new ArrayList<Move>());
    beats.put(ATTACK_HIGH, Arrays.asList(ATTACK_LOW, BLOCK_LOW));
    beats.put(ATTACK_LOW, Arrays.asList(ATTACK_HIGH, BLOCK_HIGH));
  }

  public static Result compare(Move p1Move, Move p2Move) {
    boolean p1Wins = beats.get(p1Move).contains(p2Move);
    boolean p2Wins = beats.get(p2Move).contains(p1Move);

    if (p1Wins) {
      return (p2Wins) ? Result.BothWin : Result.P1Win;
    }
    if (p2Wins) {
      return (p1Wins) ? Result.BothWin : Result.P2Win;
    }

    return Result.NeitherWin;
  }
} 

例子:

System.out.println(Move.compare(Move.ATTACK_HIGH, Move.BLOCK_LOW));

打印:

P1Win

相反，你可以这样做

   public int fightMath(int one, int two) {
    return Calculate(one,two)

    }


    private int Calculate(int one,int two){

    if (one==0){
        if(two==0){
     //return value}
    }else if (one==1){
   // return value as per condtiion
    }

    }

最短且仍然可读的解决方案:

static public int fightMath(int one, int two)
{
    if (one < 2 && two < 2) return 0;
    if (one > 1 && two > 1) return 3;
    int n = (one + two) % 2;
    return one < two ? 1 + n : 2 - n;
}

或者更短:

static public int fightMath(int one, int two)
{
    if (one / 2 == two / 2) return (one / 2) * 3;
    return 1 + (one + two + one / 2) % 2;
}

不包含任何“神奇”数字;) 希望能有所帮助。

由于您的数据集非常小，您可以将所有内容压缩为1个长整数并将其转换为公式

public int fightMath(int one,int two)
{
   return (int)(0xF9F66090L >> (2*(one*4 + two)))%4;
}

更多的位变体:

这利用了所有东西都是2的倍数这一事实

public int fightMath(int one,int two)
{
   return (0xF9F66090 >> ((one << 3) | (two << 1))) & 0x3;
}

神奇常数的起源

我能说什么呢?世界需要魔法，有时某些事情的可能性需要它的创造。

解决OP问题的函数的本质是从2个数字(1,2)，域{0,1,2,3}到范围{0,1,2,3}的映射。每个答案都涉及了如何实现该映射。

此外，您可以在许多答案中看到问题的重述，即12个以4为基数的2位数字N(1,2)的映射，其中1是数字1,2是数字2,N = 4* 1 + 2;N ={0,1,2，…，15}——16个不同的值，这很重要。函数的输出是一个以4为基数的1位数字{0,1,2,3}——4个不同的值，这也很重要。

现在，1位以4为底的数可以表示为2位以2为底的数;{0,1,2,3} ={00,01,10,11}，因此每个输出只能用2位编码。从上面来看，只有16种不同的输出可能，所以16*2 = 32位是编码整个地图所必需的;这些都可以装进一个整数。

常数M是映射M的编码，其中M(0)以位M[0:1]编码，M(1)以位M[2:3]编码，M (n)以位M[n*2:n*2+1]编码。

剩下的就是索引和返回常量的右边部分，在这种情况下，你可以将M右移2*N次，并取2个最低有效位，即(M >> 2*N) & 0x3。表达式(one << 3)和(two << 1)只是相乘，同时注意到2*x = x << 1和8*x = x << 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的哪个值对应于哪个返回值。

除了JAB之外，我不喜欢任何提出的解决方案。其他方法都不容易阅读代码和理解正在计算的内容。

以下是我如何编写这段代码——我只会c#，不懂Java，但你可以想象:

const bool t = true;
const bool f = false;
static readonly bool[,] attackResult = {
    { f, f, t, f }, 
    { f, f, f, t },
    { f, t, t, t },
    { t, f, t, t }
};
[Flags] enum HitResult 
{ 
    Neither = 0,
    PlayerOne = 1,
    PlayerTwo = 2,
    Both = PlayerOne | PlayerTwo
}
static HitResult ResolveAttack(int one, int two)
{
    return 
        (attackResult[one, two] ? HitResult.PlayerOne : HitResult.Neither) | 
        (attackResult[two, one] ? HitResult.PlayerTwo : HitResult.Neither);
}    

现在，这里计算的内容更加清楚了:这强调了我们正在计算谁受到了什么攻击，并返回两个结果。

然而，这可能会更好;布尔数组有点不透明。我喜欢表格查找方法，但我更倾向于以一种能够明确游戏语义的方式来编写它。也就是说，与其“攻击为零，防御为一，结果是没有命中”，不如找到一种方法，让代码更清楚地暗示“低踢攻击和低阻挡防御，结果是没有命中”。让代码反映游戏的业务逻辑。