2 स्ट्रिंग्स

Question

के बीच हैमिंग दूरी प्राप्त करने के लिए लूप के लिए उपयोग करना इस कार्य में मुझे हैमिंग दूरी प्राप्त करने की आवश्यकता है (समान लंबाई के दो तारों के बीच हैमिंग दूरी उन स्थितियों की संख्या है जिन पर संबंधित प्रतीकों अलग हैं - विकिपीडिया से) दो तार अनुक्रम 1 और अनुक्रम 2 के बीच।

सबसे पहले मैंने 2 नए तारों को बनाया जो 2 मूल तार हैं लेकिन कम लागत वाले दोनों के साथ तुलना करना आसान है। फिर मैंने लूप के लिए उपयोग किया और 2 तारों की तुलना करने के लिए उपयोग किया। स्ट्रिंग के इन 2 जोड़ी में वर्णों में किसी भी अंतर के लिए, लूप एक int x = 0. में जोड़ देगा। विधि का रिटर्न इस एक्स का मान होगा।

public static int getHammingDistance(String sequence1, String sequence2) { 
    int a = 0; 
    String sequenceX = sequence1.toLowerCase(); 
    String sequenceY = sequence2.toLowerCase(); 
    for (int x = 0; x < sequenceX.length(); x++) { 
     for (int y = 0; y < sequenceY.length(); y++) { 
      if (sequenceX.charAt(x) == sequenceY.charAt(y)) { 
       a += 0; 
      } else if (sequenceX.charAt(x) != sequenceY.charAt(y)) { 
       a += 1; 
      } 
     } 
    } 
    return a; 
} 

तो क्या कोड अच्छा और कार्यात्मक दिखता है? कोड को अनुकूलित या अनुकूलित करने के लिए मैं कुछ भी कर सकता था? अग्रिम में धन्यवाद। मैं एक बड़ा नोब हूं इसलिए मुझे माफ़ कर दो अगर मैंने कुछ मूर्खता से पूछा

Answer 1

आपका कोड पूरी तरह से बंद है। जैसा कि आपने स्वयं कहा था, दूरी उन स्थानों की संख्या है जहां तार भिन्न होते हैं - इसलिए आपके पास केवल एक ही लूप होना चाहिए, दोनों तारों को एक साथ चलाना चाहिए। इसके बजाय आपके पास 2 नेस्टेड लूप हैं जो स्ट्रिंग बी में प्रत्येक इंडेक्स को स्ट्रिंग में प्रत्येक इंडेक्स की तुलना करते हैं।

भी, अगर ऐसी स्थिति लिखती है जिसके परिणामस्वरूप a+=0 समय बर्बाद हो जाता है।

ऐसा करें:

for (int x = 0; x < sequenceX.length(); x++) { //both are of the same length 
    if (sequenceX.charAt(x) != sequenceY.charAt(x)) { 
     a += 1; 
    } 
} 

भी, यह अभी भी एक अनुभवहीन दृष्टिकोण है जो probbaly जटिल यूनिकोड वर्ण (जहां 2 पात्रों अभी तक तार्किक बराबर हो सकता है एक ही चरित्र कोड नहीं)

साथ काम नहीं करेंगे है

Answer 2

आपका कोड ठीक है, हालांकि, मैं आपको निम्न सुधारों का सुझाव दूंगा।

1. स्ट्रिंग के charAt() का उपयोग न करें। लूप से पहले toCharArray() का उपयोग कर स्ट्रिंग से चार सरणी प्राप्त करें और फिर इस सरणी के साथ काम करें। यह अधिक पठनीय और अधिक प्रभावी है।

2. संरचना

   if (sequenceX.charAt(x) == sequenceY.charAt(y)) { 
        a += 0; 
       } else if (sequenceX.charAt(x) != sequenceY.charAt(y)) { 
        a += 1; 
       } 
   

   बेमानी लग रहा है। इसे ठीक करें: यदि (sequenceX.charAt (x) == अनुक्रम Y.charAt (y)) { a + = 0; } अन्य { ए + = 1; }

इसके अलावा खाते है कि मैं आप सरणी के साथ काम करने की तरह कुछ के लिए इसे बदल सिफारिश को ध्यान में रखकर:

a += seqx[x] == seqY[x] ? 0 : 1

कम कोड कम कीड़े ...

संपादित करें: के रूप में @radai द्वारा उल्लिखित आपको if/else संरचना की आवश्यकता नहीं है: 0 से a अनावश्यक है।

Answer 3

मेरी बात से निम्नलिखित कार्यान्वयन ठीक होगा:

public static int getHammingDistance(String sequence1, String sequence2) { 
    char[] s1 = sequence1.toCharArray(); 
    char[] s2 = sequence2.toCharArray(); 

    int shorter = Math.min(s1.length, s2.length); 
    int longest = Math.max(s1.length, s2.length); 

    int result = 0; 
    for (int i=0; i<shorter; i++) { 
     if (s1[i] != s2[i]) result++; 
    } 

    result += longest - shorter; 

    return result; 
} 

1. सरणी का उपयोग करता है, जो प्रत्येक एकल चार तुलना किए जाने की जरूरत है कि के लिए दो विधि (charAt) के आह्वान से बचा जाता है;
2. अपवाद से बचें जब एक स्ट्रिंग दूसरे से अधिक लंबी होती है।

Answer 4

public static int getHammingDistance(String sequenceX, String sequenceY) { 
    int a = 0; 
    // String sequenceX = sequence1.toLowerCase(); 
    //String sequenceY = sequence2.toLowerCase(); 
    if (sequenceX.length() != sequenceY.length()) { 
     return -1; //input strings should be of equal length 
    } 

    for (int i = 0; i < sequenceX.length(); i++) { 
     if (sequenceX.charAt(i) != sequenceY.charAt(i)) { 
      a++; 
     } 
    } 
    return a; 
}