Java 用智能算法缩短开关箱

我正在寻找一种智能算法，以获得与以下方法相同的结果

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

---

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

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

---

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

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

---

这正是您想要的：

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，则因子thingy加0，如果low为1，则因子thingy加8，如果low为2，则因子thingy加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));
    }
  }
}

---

这正是您想要的：

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，则因子thingy加0，如果low为1，则因子thingy加8，如果low为2，则因子thingy加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));
    }
  }
}

---

您不需要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;
}

---

这将返回与原始方法完全相同的结果。

您不需要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;
}

---

---

这返回的正是原始方法返回的值。

那么我就有了未使用的数组值。超过50%。这不是解决办法。如果有那么简单的话，我就不会问了。@Unicate为什么要关心未使用的值？这是一个小数组。@Unicate所有未使用的数组位置都可以包含0，因为这是您的默认返回值。这是任务中的难点。没有未使用的值；大于40*4=160无用Bytes@Unicate好的，编辑后的答案是使用一个只包含使用过的索引的2D数组。那么我就有了未使用的数组值。超过50%。这不是解决办法。如果有那么简单的话，我就不会问了。@Unicate为什么要关心未使用的值？这是一个小数组。@Unicate所有未使用的数组位置都可以包含0，因为这是您的默认返回值。这是任务中的难点。没有未使用的值；大于40*4=160无用Bytes@Unicate好的，编辑答案以使用仅包含所用索引的2D数组。如果有81个组合，并且只有36个甚至37个组合，则每个组合都不能有唯一的返回值，就像在代码示例输出中一样。您有许多返回0的组合。当然，我想这是很清楚的。如果有81个组合，并且只有36个甚至37个，那么每个组合都不能有唯一的返回值，就像在代码示例输出中一样。您有许多返回0的组合。当然，我认为这很清楚。谢谢！这就是我一直在寻找的！如果数字范围发生变化：将15替换为2*可能的最高数字-1谢谢！这就是我一直在寻找的！如果数字范围发生变化：将15替换为2*可能的最高数字-1