使用智能算法缩短 switch case

Question

我正在寻找一种智能算法来获得（或多或少）与以下方法相同的结果。

实际上哪个数字得到 returned 并不重要。重要的是 low/high 的每个组合都有一个唯一的 return 值，并且 return 值介于 1 和 36 之间。

idx 介于 0 和 8（9 个值）之间，从不低于，从不高于。

有什么想法吗？

// idx1 is never = idx2
private long getIdentifier(int idx1, int idx2) {
    int low = (idx1>idx2)?idx2:idx1;
    int high = ((idx1>idx2)?idx1:idx2);
    switch (low) {
        case 0:
            return high;
        case 1:
            switch (high) {
                case 2:
                    return 9;
                case 3:
                    return 10;
                case 4:
                    return 11;
                case 5:
                    return 12;
                case 6:
                    return 13;
                case 7:
                    return 14;
                case 8:
                    return 15;
            }
        case 2:
            switch (high) {
                case 3:
                    return 16;
                case 4:
                    return 17;
                case 5:
                    return 18;
                case 6:
                    return 19;
                case 7:
                    return 20;
                case 8:
                    return 21;
            }
        case 3:
            switch (high) {
                case 4:
                    return 22;
                case 5:
                    return 23;
                case 6:
                    return 24;
                case 7:
                    return 25;
                case 8:
                    return 26;
            }
        case 4:
            switch (high) {
                case 5:
                    return 27;
                case 6:
                    return 28;
                case 7:
                    return 29;
                case 8:
                    return 30;
            }
        case 5:
            switch (high) {
                case 6:
                    return 31;
                case 7:
                    return 32;
                case 8:
                    return 33;
            }
        case 6:
            switch (high) {
                case 7:
                    return 34;
                case 8:
                    return 35;
            }
        case 7:
            return 36;
    }
    return 0;
}

Answer 1

您可以将返回值存储在二维数组中。

int[] res = new int[9][9];
...
res[3][8] = 26;
...
return res[low][high];

您可以使用单独的赋值（例如 res[3][8]=26）初始化数组，也可以在一行中初始化数组：

int[] res = {{0,1,2,3,4,5,6,7,8},{...},{...},{...},{...},{...},{...},{...},{...}};

您可以轻松修改二维数组以仅包含您实际使用的位置：

int[] res = {{0,1,2,3,4,5,6,7,8},
             {9,10,11,12,13,14,15},
             {16,17,18,19,20,21},
             {22,23,24,25,26},
             {27,28,29,30},
             {31,32,33},
             {34,35},
             {36}};

现在您需要在访问数组之前测试以下条件:

if (low < high && low < res.length && (high - low - 1) < res[low].length) {
    return res[low][high-low-1];
} else {
    return 0;
}

Answer 2

这就是你想要的：

private static long getIdentifier(int idx1, int idx2) {
  int min = min(idx1, idx2);
  int max = max(idx1, idx2);
  return factor(min) + (max - min);
}

private static long factor(int n) {
  int sum = 0;
  for (int i = 8; i > 8 - n; i--) {
    sum += i;
  }
  return sum;
}

如果 low 为 0，则因子加 0，如果 low 为 1，则加 8，如果 low 为 2，则加 15 等等。可能可以通过给出公式而不是通过循环重新计算来改进它。

示例（准确打印从 1 到 36 的所有数字）：

public static void main(String args[]) {
  for (int i = 0; i <= 7; i++) {
    for (int j = i + 1; j <= 8; j++) {
      System.out.println(getIdentifier(i, j));
    }
  }
}

Answer 3

您不需要 switch 语句。

private long getIdentifier(int idx1, int idx2) {
    int low  = idx1>idx2 ? idx2 : idx1;
    int high = idx1>idx2 ? idx1 : idx2;
    return (15-low)*low/2+high;
}

这returns正是原来的方法returns。

使用智能算法缩短 switch case

Shortening a switch case with a smart algorithm

java

algorithm