用智能算法缩短开关箱

Question

我正在搜索一个智能算法，以获得(更少)与下面方法相同的结果。

实际上，返回哪个数字并不重要。重要的是，低/高的每一个组合都有一个唯一的返回值，返回值在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

你不需要开关语句。

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

这正好返回原始方法返回的内容。

Answer 2

可以将返回的值存储在2D数组中。

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},{...},{...},{...},{...},{...},{...},{...},{...}};

您可以轻松地修改2D数组，使其只包含实际使用的位置：

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 3

这做你想做的事：

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

如果低是0，那么因子是0，如果低是1，则是8，如果低是2，那么它可能会通过给出一个公式来改进，而不是通过循环重新计算。

示例(准确地打印从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));
    }
  }
}