如何写一个；所有这些数字都不同；Java中的条件？

好的，我有这个问题要解决，但我不能用Java正确编程。看到下面的图片，你会看到一颗6角星，每个点和线的交点都是一个字母

这个任务是定位数字1到12，这样四个球的所有线的和是26，星星的所有6个点的和也是26。 这归结为：

• （A+C+F+H==26）
• （A+D+G+K==26）
• （B+C+D+E==26）
• （B+F+I+L==26）
• （E+G+J+L==26）
• （H+I+J+K==26）
• （A+B+E+H+K+L==26）

因此，我开始编写一个程序，该程序将循环通过所有选项，强制执行一个解决方案。循环正在工作，但是，它现在显示了一个数字被多次使用的解决方案，这是不允许的。我如何在代码中使它也检查所有变量是否不同

if ((A!= B != C != D != E != F != G != H != I != J != K != L)

我试过上面的方法，但不起作用，因为上面说：

不可比较类型：boolean和int

我如何在1或小范围内检查所有数字是否不同？

（而不是制作一个嵌套的12*12语句来检查每个变量组合）

这是我目前的代码：

    public class code {
   public static void main(String[] args){

    for(int A = 1; A < 13; A++){
     for(int B = 1; B < 13; B++){
      for(int C = 1; C < 13; C++){
       for(int D = 1; D < 13; D++){
        for(int E = 1; E < 13; E++){
         for(int F = 1; F < 13; F++){
          for(int G = 1; G < 13; G++){
           for(int H = 1; H < 13; H++){
            for(int I = 1; I < 13; I++){
             for(int J = 1; J < 13; J++){
              for(int K = 1; K < 13; K++){
               for(int L = 1; L < 13; L++){
                if ((A+C+F+H==26) && (A+D+G+K==26) && (B+C+D+E==26) && (B+F+I+L==26) && (E+G+J+L==26) && (H+I+J+K==26) && (A+B+E+H+K+L==26)){
                 if ((A= C != D != E != F != G != H != I != J != K != L)){
                 System.out.println("A: " + A);
                 System.out.println("B: " + B);
                 System.out.println("C: " + C);
                 System.out.println("D: " + D);
                 System.out.println("E: " + E);
                 System.out.println("F: " + F);
                 System.out.println("G: " + G);
                 System.out.println("H: " + H);
                 System.out.println("I: " + I);
                 System.out.println("J: " + J);
                 System.out.println("K: " + K);
                 System.out.println("L: " + L);
                 }
                }
               }
              }
             }
            }
           }
          }
         }
        }
       }
      }
     }
    }
   }

}

公共类代码{
公共静态void main（字符串[]args）{
对于（int A=1；A<13；A++）{
对于（intb=1；B<13；B++）{
对于（int C=1；C<13；C++）{
对于（int D=1；D<13；D++）{
对于（int E=1；E<13；E++）{
对于（int F=1；F<13；F++）{
对于（int G=1；G<13；G++）{
对于（inth=1；H<13；H++）{
对于（int I=1；I<13；I++）{
对于（int J=1；J<13；J++）{
对于（int K=1；K<13；K++）{
对于（int L=1；L<13；L++）{
如果（（A+C+F+H==26）&&（A+D+G+K==26）&（B+C+D+E==26）&（B+F+I+L==26）&&（E+G+J+L==26）&（H+I+J+K==26）&（A+B+E+H+K+L==26））{
如果（（A=C！=D！=E！=F！=G！=H！=I！=J！=K！=L））{
系统输出打印项次（“A:+A”）；
System.out.println（“B:+B”）；
System.out.println（“C:+C”）；
System.out.println（“D:+D”）；
System.out.println（“E:+E”）；
System.out.println（“F:+F”）；
System.out.println（“G:+G”）；
System.out.println（“H:+H”）；
System.out.println（“I:+I”）；
System.out.println（“J:+J”）；
System.out.println（“K:+K”）；
System.out.println（“L:+L”）；
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}

如果我正确获得它，您需要检查A到L是否都是唯一的。因此，只需将它们放在一个集合中，并找到集合的大小：

if ((new HashSet<Integer>(
        Arrays.asList(A, B, C, D, E, F, G, H, I, J, K, L)))
    .size() == 12) {
    //do your stuff
}

if（（新哈希集）(
asList（A，B，C，D，E，F，G，H，I，J，K，L）））
.size（）==12）{
//做你的事
}

我强烈建议改用递归，这将大大简化代码。这样做：

function generate(set used, array list):
  if list.size() == 12:
    if list matches criteria:
      yield list as solution
  else:
    for next = 1; next < 13; next++:
      if next not in used:
        used.add(next)
        generate(used, list + next)
        used.remove(next)

函数生成（使用的集合，数组列表）：
如果list.size（）==12：
如果列表符合条件：
作为解决方案的产量清单
其他：
对于next=1；其次<13；下一步++：
如果未使用next：
已使用。添加（下一个）
生成（已使用，列表+下一步）
已使用。删除（下一个）

---

但是，要直接回答您的问题：您可以将所有值放入一个表中，并检查其大小是否等于您放入的项目数。这是有效的，因为一个集合会将重复项计算为一个。

在为您寻找好的解决方案之前，我想帮助您解决出现的错误

if（（A=C！=D！=E！=F！=G！=H！=I！=J！=K！=L））{

这一行没有多大意义。编译器将检查的第一件事是：

if（A=C）

你可能想编码<代码>（A.O.C），但是让我们考虑你真正的类型。<代码> A= C < /Cord>是一个属性，所以<代码> A<代码>将接收<代码> C<代码/>值> < /P> 然后，编译器将继续。将

C

的值赋给

A

后，它将检查比较：

如果（A=C！=D）

这将把

A

的值与

D

进行比较，这将产生一个布尔值——假设结果为

false

下一个比较是：

if（false！=E）

此时，布尔值和int值之间存在比较，因此出现错误

不可比较的类型：boolean和int.

---

好的，当你需要检查你的数字是否唯一时，一个很好的解决方案是@abhin4v你的嵌套循环将执行

12^12=8.91610045E12

IF语句，其中许多语句由于错误的数字组合而无效。你需要

1,2,3，…，12

作为你的brute语句的候选者强制方法。12个元素的排列数是

12！=479 001 600

，所以我想蛮力作用会快得多。只要生成有效排列，就不需要检查有效组合

下面是一些示例代码，nextPerm（）中的代码是从以下位置复制和修改的：

导入java.util.array；
公共类图形26{
专用静态最终int A=0；
专用静态最终int B=1；
专用静态最终int C=2；
私有静态最终整数D=3；
私有静态最终整数E=4；
专用静态最终整数F=5；
专用静态最终整数G=6；
专用静态最终int H=7；
专用静态最终int I=8；
专用静态最终int J=9；
专用静态最终整数K=10；
专用静态最终int L=11；
专用最终静态布尔规则1（最终int[]n）{
返回n[A]+n[C]+n[F]+n[H]==
import java.util.Arrays;

public class Graph26 {
    private static final int A = 0;
    private static final int B = 1;
    private static final int C = 2;
    private static final int D = 3;
    private static final int E = 4;
    private static final int F = 5;
    private static final int G = 6;
    private static final int H = 7;
    private static final int I = 8;
    private static final int J = 9;
    private static final int K = 10;
    private static final int L = 11;

    private final static boolean rule1(final int[] n) {
        return n[A] + n[C] + n[F] + n[H] == 26;
    }

    private final static boolean rule2(final int[] n) {
        return n[A] + n[D] + n[G] + n[K] == 26;
    }

    private final static boolean rule3(final int[] n) {
        return n[H] + n[I] + n[J] + n[K] == 26;
    }

    private final static boolean rule4(final int[] n) {
        return n[B] + n[C] + n[D] + n[E] == 26;
    }

    private final static boolean rule5(final int[] n) {
        return n[B] + n[F] + n[I] + n[L] == 26;
    }

    private final static boolean rule6(final int[] n) {
        return n[E] + n[G] + n[J] + n[L] == 26;
    }

    private final static boolean rule7(final int[] n) {
        return n[A] + n[B] + n[E] + n[H] + n[K] + n[L] == 26;
    }

    private final static boolean isValid(final int[] nodes) {
        return rule1(nodes) && rule2(nodes) && rule3(nodes) && rule4(nodes)
                && rule5(nodes) && rule6(nodes) && rule7(nodes);
    }

    class Permutation {
        private final int[] o;
        private boolean perms = true;

        public boolean hasPerms() {
            return perms;
        }

        Permutation(final int[] obj) {
            o = obj.clone();
        }

        private int[] nextPerm() {
            int temp;
            int j = o.length - 2;
            while (o[j] > o[j + 1]) {
            j--;
            if (j < 0) {
            perms = false;
            break;
            }
            }
            if (perms) {
            int k = o.length - 1;
            while (o[j] > o[k]) {
            k--;
            }
            temp = o[k];
            o[k] = o[j];
            o[j] = temp;
            int r = o.length - 1;
            int s = j + 1;
            while (r > s) {
            temp = o[s];
            o[s] = o[r];
            o[r] = temp;
            r--;
            s++;
            }
            }
            return o.clone();
        }
    }

    public static void main(final String[] args) {
        int[] nodes = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
        final Graph26 graph = new Graph26();
        final Permutation p = graph.new Permutation(nodes);
        int i = 0;
        while (p.hasPerms()) {
        if (isValid(nodes)) {
        System.out.println(Arrays.toString(nodes));
        }
        i++;
        nodes = p.nextPerm();
        }
        System.out.println(i);
    }
}