Fonction qui compte et multiplie les caractères dans une chaîne de caractères.

Question

Pour mon devoir, j'ai besoin de compter les caractères d'un fichier String . S'il y a plus de trois caractères identiques l'un derrière l'autre, la méthode devrait renvoyer la réponse suivante true sinon false .

Développez maintenant une méthode noMultiples () qui vérifie s'il y a trois caractères égaux (ou plus) dans une chaîne de caractères. Généraliser noMultiples () maintenant, que le nombre de caractères à répéter est paramétré.

J'ai déjà essayé de renverser le String en sous-chaînes mais a reçu un String index out of Bounds erreur. J'ai également essayé de travailler avec le charAt() mais je suis un peu coincé maintenant. Existe-t-il un moyen de résoudre ce problème ? Merci d'avance

 public static boolean noMultiples(int n, String s) {
    for(int i=0;i<s.length();i++){
        if(s.charAt(i)==s.charAt(i+1)&&s.charAt(i+1)==s.charAt(i+2)){
            return true;
        }
    }
    return false;
}

Ceci devrait être le résultat attendu :

public static void main(String[] args) {
    boolean result = noMultiples("Hello World");
    System.out.println(result); // => true
    System.out.println(noMultiples("faaantastic")); // => false
    System.out.println(noMultiples(2, "Hello World")); // => false
}

Answer 1

Vous pouvez utiliser un champ dans la méthode pour stocker le nombre de répétitions de caractères.

También, surcharge noMultiples pour n'accepter que la chaîne de caractères.

Note car noMultiples retourner true s'il a trouvé plusieurs caractères consécutifs, il est préférable de nommer cette méthode containsMultiples . Ce faisant, il sera plus intuitif à l'avenir, lorsque vous le modifierez ou l'utiliserez ultérieurement.

public class test
{
    public static void main(String[] args)
    {
        System.out.println(containsMultiples("Hello World"));
        System.out.println(containsMultiples("faaaantastic"));
        System.out.println(containsMultiples(2, "Hello World"));
    }

    public static boolean containsMultiples(int n, String s) {
        int len = s.length();
        if(len == 0) return false;
        char lastChar = s.charAt(0);
        int multipliesFound = 1;

        for(int i = 1; i < len; i++) {
            if(s.charAt(i) == lastChar) {
                multipliesFound++;
            }
            else {
                multipliesFound = 1;
            }
            if(multipliesFound == n) {
                return true;
            }
            lastChar = s.charAt(i);
        }
        return false;
    }

    public static boolean containsMultiples(String s) {
        return containsMultiples(3, s);
    }
}

retours :

false
true
true

En se basant sur vos exemples pour le Hello World j'ai supposé que vous cherchiez une méthode pour trouver uniquement les caractères égaux consécutifs.

Answer 2

Mon idée est de créer un HashMap pour les paires de caractères et d'entiers, et y mettre les caractères et leur nombre !

public boolean noMultiples(int maxMultiples, String myString) {
    HashMap<Character, Integer> map = new HashMap<>();
    for(int i=0; i<myString.length(); i++) {
        char c = myString.charAt(i);
        if(map.containsKey(c)) {
           int prevCount = map.get(c);
           map.put(c, prevCount+1); //we found one more of this character
        } else {
           map.put(c, 1); //first occurence
        }
    }
    //here our map is filled with characters and their count in the string
    for(int charCount: map.values()) {
       if(charCount >= maxMultiples) return false; //found a multiple
    }
    return true; //not found a large enough multiple
}

Cela pourrait être optimisé en retournant false de la première boucle si nous y rencontrons une valeur suffisamment grande, mais de cette façon, la carte de hachage remplie peut être utilisée pour généraliser davantage la méthode.

Answer 3

plus court est une solution avec lambda

public static boolean noMultiples(int n, String s) {
  return s.codePoints().distinct().allMatch( c -> {
    int from = 0;
    while( (from = s.indexOf( c, from )) >= 0 ) {
      for( int i = from, count = 1; i < s.length() && c == s.charAt( i ); i++ ) {
        if( count++ >= n )
          return( false );
      }
      from++;
    }
    return( true );
  } );
}

trouver tous les caractères distincts de String s premièrement
puis vérifiez si le nombre de tous les consécutif d'occurrences est inférieur à n
le plus rapide serait de vérifier le contraire - y a-t-il des multiples - si le temps joue un rôle