¿Cómo escribir una condición "todos estos números son diferentes" en Java?

Question

Bien, tengo este problema para resolver pero no puedo programarlo en Java correctamente. Vea la imagen a continuación, verá una estrella de 6 puntas en cada punto y la intersección de líneas es una letra.

la asignación es para posicionar los números 1 a 12 de tal manera que la suma de todas las líneas de cuatro bolas es 26 y la suma de todos los 6 puntos de la estrella es 26 también. Esto se reduce a:

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

Así que comencé a programar un programa que recorría todas las opciones brute forzando una solución. El bucle está funcionando, sin embargo, ahora muestra soluciones donde un número se usa más de una vez, lo que no está permitido. ¿Cómo puedo hacer que en el código también se compruebe si todas las variables son diferentes o no?

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

probé la anterior, pero esto no funciona, porque dice:

tipos incomparables: booleano e int.

¿Cómo puedo verificar dentro de 1 o en una pequeña declaración si todos los números son diferentes o no?

(en vez de hacer un anidado comunicado 12 * 12 que comprueba cada combinación de variables)

Este es mi código hasta ahora:

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

} 

Answer 1

Sus bucles anidados ejecutarán 12^12 = 8.91610045E12 IF-Declaraciones, muchas de ellas inválidas debido a combinaciones incorrectas de números. Necesita permutations de 1,2,3,..,12 como candidatos de su enfoque de fuerza bruta. El número de permutaciones de 12 elementos es 12!= 479 001 600, por lo que la fuerza bruta será mucho más rápida, supongo. Con solo generar permutaciones válidas, no necesita ningún control para combinaciones válidas.

Aquí algunos ejemplos de código, el código en nextPerm() es copiado y modificado a partir de Permutation Generator:

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

Answer 2

Si lo entiendo correctamente, usted quiere comprobar si todas las A a L son únicas. Por lo que sólo los puso en un conjunto y encontrar el tamaño del conjunto:

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

Answer 3

yo recomiendo el uso de la recursividad en cambio, lo que enormemente simplificar el código. Hacer algo como esto:

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) 

Sin embargo, para responder a usted pregunta directamente:. Usted puede lanzar todos los valores en un set y comprobar que su tamaño es igual al número de elementos que tiró Esto funciona porque un conjunto contará los duplicados como uno.

Answer 4

Antes de buscar una buena solución para ti, me gustaría ayudarte con el error que obtienes.

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

esta línea no tiene mucho sentido.Lo primero que el compilador comprobar es:

if (A=C)

Probablemente quería codificar if (A!=C), pero vamos a considerar lo que realmente escribe. A=C es una atribución, por lo que A recibirá C valor.

Luego, el compilador continuará. Después de atribuir C 's valor a A, comprobará la comparación:

if (A=C != D)

Esto comparará A' s valor a D, lo que resultará en un valor lógico - digamos que el resultado es false.

La siguiente comparación sería:

if (false != E)

En este punto, hay una comparación entre un valor booleano y un int, por lo tanto el error incomparable types: boolean and int..

Bueno, como debe comprobar si sus números son únicos, una buena solución sería la propuesta por @ abhin4v.