Gemeinsame Elemente in einem String-Array zählen

Question

Ich versuche, ein Programm zum Zählen von gemeinsamen Elementen zu machen, die in allen Strings in einem String [] -Array vorkommen. Ich habe folgende: -

A Master-Array und ein Flag Array sowohl der Größe 26

nun für jede Saite: Ich Markierungsfrequenz 1 für jedes Zeichen das erscheint, in der Zeichenfolge ohne Inkrementierung in Flag Array.

Jetzt bin Hinzufügen ich die Werte von Flag-Array auf Werte von Master-Arrays entspricht

mein Code sieht wie folgt aus

for(String str : arr) 
{ 
    for(char ch : str.toCharArray()) 
    { 
     flag[ch - 97] = 1; 
     master[ch - 97] =master[ch -97] + flag[ch - 97]; 
    } 
} 

Mein Plan schließlich ist auf die Elemente in der Master-Array zu zählen, die Wert gleich um die Länge eines String-Arrays einzugeben. Diese Anzahl wird die Anzahl der Zeichen darstellen, die allen Strings gemeinsam sind

Aber mein Code hat einen Fehler.

Wenn ein String doppelte Elemente enthält, zum Beispiel "Ball" (mit 2 ls). Der entsprechende Wert des Elements in Master Array wird wieder inkrementiert. Das macht seinen Wert größer als das, was ich wollte.

Also das ist was ich getan habe.

for(String str : arr) 
{ 
    newstr = ""; //to keep track of each character in the string 

    for(char ch : str.toCharArray()) 
    { 
     int counter = 0; 
     for(int i = 0; i < newstr.length();i++) 
     { 
      char ch2 = newstr.charAt(i); 
       if (ch == ch2) 
       { 
        counter = counter + 1; //if duplicate 
        break; 
       } 
     } 

    if(counter == 1) 
    { 
     break; 
    } 
    flag[ch - 97] = 1; 
    master[ch - 97] =master[ch -97] + flag[ch - 97]; 
    newstr = newstr + ch; 

    } 
} 

Ist das der richtige Ansatz? Oder könnte dieser Code optimiert werden?

Answer 1

IMHO - "Der richtige Ansatz" ist einer, den Sie vollständig verstehen und nach Belieben umgestalten können. Es gibt im Allgemeinen immer mehrere Möglichkeiten, irgendein Programmierproblem zu lösen. Persönlich würde ich (was ich denke) das Problem, das Sie versuchen, zu lösen, in einer Art und Weise, die zu Java ideomatischer ist.

Für das gesamte Array von Zeichenfolgen, die Sie untersuchen werden, ist jedes Zeichen in der ersten Zeichenfolge, die Sie untersuchen, in jeder bisher untersuchten Zeichenfolge, so dass jedes Zeichen in der ersten Zeichenfolge in eine Map<Character, Integer>charCountMap.put(aChar, 1) für die zweite Zeichenfolge gehen würde und alle nachfolgenden Zeichenfolgen: Wenn sich ein Zeichen in der zu untersuchenden Zeichenfolge im Schlüsselsatz der Zuordnung befindet, dann erhöhen Sie die zugeordnete Ganzzahl (erhöhen Sie den zugehörigen Wert des Schlüssels) charCountMap.get(aChar)++. Nach der Überprüfung jedes Zeichens in jeder Zeichenfolge werden die Schlüssel im Schlüsselsatz, die Integers mit Werten entsprechen, die der Länge des ursprünglichen Zeichenfolgenarrays entsprechen, genau die Zeichen sein, die in jeder Zeichenfolge gefunden wurden.

Bis jetzt löst diese vorgeschlagene Lösung das oben beschriebene Problem mit sich wiederholenden Zeichen nicht. Um diesen Teil zu lösen, denke ich, dass Sie eine separate Liste von "bisher gesehenen" Zeichen in der "zu untersuchenden Zeichenfolge" aufbewahren müssen (und die Liste für jede neue Zeichenfolge leeren). Du würdest zuerst die Liste "Bisher gesehen" überprüfen und die gesamte weitere Verarbeitung dieses Charakters überspringen, wenn es in "Bis jetzt gesehen" gefunden wurde. Nur Charaktere, die bisher nicht gesehen wurden, würden mit den Karten verglichen Schlüsselsatz. example code

Es gibt auch einen rekursiven Ansatz, um eine Lösung für dieses Problem zu programmieren, aber ich lasse diese Frucht hängen ...