Как написать условие "все эти числа разные" в Java?

Question

ОК, мне нужно решить эту проблему, но я не могу правильно запрограммировать ее на 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)
• (А + В + Е + Н + К + L == 26) * * тысяча двадцать один

Итак, я начал программировать программу, которая бы перебирала все варианты, используя грубое решение проблемы. Цикл работает, однако теперь он показывает решения, в которых одно число используется более одного раза, что недопустимо. Как я могу сделать это в коде, чтобы он также проверял, все ли переменные разные или нет?

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

Я попробовал выше, но это не работает, потому что он говорит:

несопоставимые типы: логические и 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);
                 }
                }
               }
              }
             }
            }
           }
          }
         }
        }
       }
      }
     }
    }
   }

}

Answer 1

Если я правильно понял, вы хотите проверить, все ли от 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
}

Answer 2

Я настоятельно рекомендую вместо этого использовать рекурсию, что значительно упростит код. Сделайте что-то вроде этого:

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)

Однако, чтобы ответить на ваш вопрос напрямую: вы можете бросить все значения в набор и проверить, что его размер равен числу брошенных вами предметов. Это работает, потому что набор будет считать дубликаты как один.

Answer 3

Прежде чем искать хорошее решение для вас, я хотел бы помочь с ошибкой, которую вы получаете.

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

Эта строка не имеет особого смысла. Первое, что проверит компилятор:

if (A=C)

Возможно, вы хотели написать if (A!=C), но давайте рассмотрим, что вы на самом деле печатаете. A=C является атрибуцией, поэтому A получит C значение.

Затем компилятор продолжит работу. После присвоения значения C значению A он проверит сравнение:

if (A=C != D)

Это будет сравнивать значение A с D, что приведет к логическому значению - скажем, что результат false.

Следующее сравнение будет:

if (false != E)

На этом этапе выполняется сравнение между логическим и int, поэтому возникает ошибка incomparable types: boolean and int..

Ну, так как вам нужно проверить, являются ли ваши номера уникальными, хорошим решением будет предложение, предложенное @abhin4v.

Answer 4

Ваши вложенные циклы будут выполнять 12^12 = 8.91610045E12 IF-операторов, многие из которых недействительны из-за неправильных комбинаций чисел. Вам нужно перестановок из 1,2,3,..,12 в качестве кандидатов для вашего подхода к брутфорсу. Число перестановок из 12 элементов составляет 12!= 479 001 600, так что брутфорс будет намного быстрее, я думаю. С генерацией только действительных перестановок вам не нужно проверять допустимые комбинации.

Вот пример кода, код в nextPerm () копируется и изменяется из Генератор перестановок :

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