जावा में "ये सभी संख्याएं अलग-अलग हैं" स्थिति कैसे लिखें?

Question

ठीक है, मुझे हल करने में यह समस्या है लेकिन मैं इसे जावा में सही तरीके से प्रोग्राम नहीं कर सकता। नीचे दी गई तस्वीर देखें, आपको एक 6 प्वाइंट स्टार दिखाई देगा, प्रत्येक बिंदु और लाइनों का चौराहे एक पत्र है।

काम इस तरह से 12 नंबर स्थित करने के लिए 1 है कि चार गेंदों के सभी लाइनों का योग 26 है और सभी 6 स्टार के अंक का योग 26 के रूप में अच्छी है। यह करने के लिए नीचे आता है:

• (ए + सी + एफ + H == 26)
• (ए + डी + जी + K == 26)
• (बी + सी + डी + ई == 26)
• (बी + एफ + मैं एल == 26)
• (ई + G + J + L == 26)
• (एच + मैं + J + K == 26)
+
• (ए + बी + ई + एच + के + एल == 26)

इसलिए मैंने प्रोग्रामिंग प्रोग्राम करना शुरू किया जो एक समाधान को मजबूर करने वाले सभी विकल्पों के माध्यम से लूप करेगा। लूप काम कर रहा है, हालांकि, अब यह समाधान दिखाता है जहां एक नंबर एक से अधिक बार उपयोग किया जाता है, जिसकी अनुमति नहीं है। मैं इसे कोड में कैसे बना सकता हूं कि यह भी जांचता है कि सभी चर अलग हैं या नहीं?

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

मैं ऊपर कोशिश की, लेकिन यह काम नहीं करता है, क्योंकि यह कहते हैं:

अतुलनीय प्रकार: बूलियन और पूर्णांक।

सभी नंबर अलग हैं या नहीं, इसके लिए मैं 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

आपके नेस्टेड लूप 12^12 = 8.91610045E12 आईएफ-स्टेटमेंट निष्पादित करेंगे, उनमें से कई संख्याओं के गलत संयोजनों के कारण अमान्य हैं। आपको permutations1,2,3,..,12 की आवश्यकता है जो आपके ब्रूटफोर्सिंग दृष्टिकोण के उम्मीदवार हैं। 12 तत्वों के क्रमपरिवर्तन की संख्या 12!= 479 001 600 है, इसलिए मुझे लगता है कि ब्रूटफोर्सिंग बहुत तेज होगी। केवल वैध क्रमपरिवर्तन उत्पन्न करने के साथ आपको वैध संयोजनों के लिए किसी भी चेक की आवश्यकता नहीं है।

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

अगर मैं इसे सही ढंग से मिलता है, आप अगर जाँच करना चाहते हैं सभी ए टू एल अद्वितीय हैं। तो बस उन्हें एक सेट में डाल दिया और सेट के आकार पाते हैं:

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

मैं दृढ़ता के बजाय प्रत्यावर्तन का उपयोग कर की सलाह है, जो बेहद कोड को आसान बनाने में होता है। कुछ इस तरह है:

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) 

हालांकि, अगर आप सीधे सवाल का जवाब देने:। आप एक set में सभी मूल्यों को फेंक और जाँच लें कि यह के आकार आइटम आप में फेंक दिया की संख्या के बराबर है सकते हैं इसका कारण यह है एक सेट से काम करता है एक के रूप में डुप्लिकेट गिनती होगी।

Answer 4

आपके लिए एक अच्छा समाधान ढूंढने से पहले, मैं आपको जो त्रुटि प्राप्त करता हूं उससे मदद करना चाहता हूं।

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

यह पंक्ति बहुत समझ में आता है नहीं करता है।पहली बात यह है संकलक की जाँच करेगा है:

if (A=C)

आप शायद if (A!=C) कोड है, लेकिन क्या तुम सच में टाइप करने पर विचार बताना चाहता था। A=C एक विशेषता है, इसलिए AC मान प्राप्त होगा।

फिर, कंपाइलर चालू होगा। C जोड़कर भी बाद 'A के मूल्य, यह तुलना की जाँच करेगा:

if (A=C != D)

यह A तुलना करेंगे' D के मूल्य है, जो एक बूलियन में परिणाम होगा - कहते हैं कि परिणाम false है करते हैं।

अगले तुलना होगा:

if (false != E)

इस बिंदु पर, वहाँ एक बूलियन और एक पूर्णांक है, इसलिए त्रुटि incomparable types: boolean and int. के बीच तुलना है।

ठीक है, क्योंकि आपको अपने नंबरों को पहिया की जांच करने की आवश्यकता है, एक अच्छा समाधान @ abhin4v द्वारा प्रस्तावित किया जाएगा।