Comment puis-je compter le nombre de caractères dans une chaîne de caractères? - Mise à jour

Par exemple, la chaîne "abc" devrait donner les 3 personnages uniques, tandis que la chaîne "abcccd" donnerait 4 personnages. Je ne suis pas autorisé à utiliser la Carte, table de hachage, TreeMap, Ensemble, HashSet, StringBuffer ou TreeSet dans ce.

Jusqu'à présent, je suis en train d'utiliser une boucle for, mais quand je lance le programme, j'obtiens 0 caractères uniques. Je suis un peu nouveau à Java, donc je n'ai vraiment aucune idée de ce que je suis en train de faire.

Edit: j'ai donc modifié le code et je suis arriver à un résultat, mais il finit par être 1 de moins que ce que je veux. Je vais taper " abc " et le résultat viendra comme "2 caractères uniques", au lieu de trois. De compteur que j'ai mis (uniqueChars + 1) dans la println déclaration. Est-ce une bonne correction? Si l'utilisateur met rien, il va encore dire qu'il y a 1 caractère unique.

Code mis à jour:

    userText = userText.toLowerCase(); //userText is declared earlier in the program 
                                       //as the user's input. Setting this to lowercase 
                                       //so it doesn't say "a" and "A" are two different 
                                       //characters.
    int uniqueChars = 0;
    for (int i = 0; i < lengthText-1; i++) { //lengthText is declared earlier 
                                              //as userText.length();
        if (userText.charAt(i) != userText.charAt(i+1))
            uniqueChars++;
    }
    System.out.println("there are " + (uniqueChars + 1) + " unique characters in your string.");
}

Pensez-vous que votre boucle sera exécuté? Regardez votre arrêt maladie. En plus de cela, votre logique est erronée, vous êtes seulement à la comparaison des caractères adjacents.
La boucle s'exécute, il me donne juste la réponse incorrecte. Si je tape "abc", le programme retourne 0 caractères uniques au lieu de 3. J'ai aussi essayé de mettre "i < lengthText" dans la boucle et qui me donne encore la mauvaise réponse.

OriginalL'auteur newJavaUser | 2014-03-25

2

C'est ce que je suis venu avec:
```
public static int countUniqueCharacters(String s) {
    String lowerCase = s.toLowerCase();
    char characters[] = lowerCase.toCharArray();
    int countOfUniqueChars = s.length();
    for (int i = 0; i < characters.length; i++) {
        if (i != lowerCase.indexOf(characters[i])) {
            countOfUniqueChars--;
        }
    }
    return countOfUniqueChars;
}
```
Je viens de vérifier les index de chaque personnage, et si c'est différent de l'indice d'origine, il y a plusieurs occurrences.

Votre réponse fonctionne! Donc, vous, au départ, le nombre de caractères = la longueur et faire de la chaîne de caractères en minuscules. Ensuite, si le personnage apparaît à plusieurs reprises, vous soustrayez le nombre de caractères par le nombre de fois que les occurrences multiples d'arriver. Merci!!!!!
Dire si String s = "abcbc"; Votre méthode de retour de 3 au lieu de 1 à droite ? Bcoz indexOf() renvoie toujours l'index à l'intérieur de cette chaîne de la première occurrence du caractère spécifié. Ainsi, pour la première occurence il ne serait pas détecter les doublons de char qui se produit plus tard dans la Chaîne
Oui, exactement.
Exactement ce que je dis est, cette solution ne fonctionne pas, comme il enregistrera également la première occurence du caractère unique, même si il y a des doublons, plus tard dans la Chaîne de
Mais c'est prévu. Lire le post original de nouveau.

OriginalL'auteur Veluria
3

Comment à ce sujet? C'est une regex solution plutôt que d'une boucle:
```
public static int countUniqueCharacters(String input)
{
    String unique = input.replaceAll("(.)(?=.*?\)", "");
    return unique.length();
}
```
Si le programme doit être sensible à la casse, vous pouvez l'utiliser à la place:
```
public static int countUniqueCharacters(String input)
{
    String unique = input.replaceAll("(?i)(.)(?=.*?\)", "");
    return unique.length();
}
```
Vous pourrait faire cela une seule méthode de ligne avec return input.replaceAll(...).length();

Regex Explique:
- . correspond à tout caractère
- (...) crée une capture d'un groupe, d'être référencé par la suite
- (?=...) crée une anticipation, de regarder vers l'avant à l'entrée
- .*? correspond à quoi que ce soit entre le personnage et son match (non-greedy matching)
- \\1 correspond à la première capture d'un groupe
- (?i) définit la casse drapeau
Donc, la regex recherchera n'importe quel caractère qui a deux plus loin dans la chaîne, puis replaceAll va le remplacer par la chaîne vide. Ainsi, une entrée comme "cabbacbdbadbcabdaadcb" devient "adcb" (en gardant le dernier de chaque caractère unique). Puis, avec une chaîne de caractères contenant des caractères uniques, que la longueur de la chaîne est la réponse.

Si, pour une raison quelconque, vous avez besoin d'une unique chaîne de caractères et vous en avez besoin, dans l'ordre d'origine, vous devez inverser la chaîne d'origine avant de le dépouiller des personnages en double (et puis d'inverser à nouveau lorsque vous avez terminé). Cela nécessiterait une bibliothèque tierce, StringBuffer, ou d'une boucle.

OriginalL'auteur Brian S
1

Vous pourriez faire un nouveau String, appelé uniqueChars et l'initialiser à "". Itérer sur les personnages dans le String vous êtes à la vérification. Si uniqueChars.contains(charToCheck) est false, puis ajouter à ce personnage uniqueChars. À la fin de la boucle, uniqueChars.length() vous indique le nombre de caractères uniques que vous aviez. C'est moche et inefficace, mais il devrait fonctionner.

OriginalL'auteur Mike B

utiliser un ArrayList et ajouter un charactar si pas déjà là:

list = new ArrayList<String>();
for ( /*   */ ) {  //same for loop you wrote
      String character = (String) text.charAt(i);

       if(!list.contains(character)) {  //note the '!'
            list.add(character);
       }
}

//and finally
int quantity = list.size();

OriginalL'auteur Christopher Francisco

Voici le programme pour savoir comment écrire un fichier, comment lire le même fichier, et comment compter le nombre de fois que le personnage en particulier, a répété:

package filereadexple;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;

        /*
         * This is a program here I am creating a file by using "filewriter" 
         * and it is named as count.char and I am reading a same file and 
         * then how count number of times the particular character repeated.
         */

public class CountNoOfPartChar {

    public static void main (String args[]){

        File file = new File ("count.char");

        try{
            FileWriter fw = new FileWriter("count.char");
            fw.write("In Xanadu did Kubla Khan");
            fw.write("\r\n");
            fw.write("A stately pleasure-dome decree:");
            fw.write("\r\n");
            fw.write("Where Alph, the sacred river, ran");
            fw.write("\r\n");
            fw.write("Through caverns measureless to man");
            fw.write("\r\n");
            fw.write("Down to a sunless sea.");
            fw.close();
            FileInputStream fis = new FileInputStream(file);
            int i;
            int occurs = 0;
            char current;
            while ((i=fis.available()) > 0){
                current = (char)fis.read();
                if(current == 'a'){
                    occurs++;
                }
            }
            System.out.println("The number of particular character repeated is : " + occurs);
        }
        catch (Exception e){
            System.out.println(e.getMessage());
        }
    }
}

OriginalL'auteur Yogi

0

Utilisation d'un vecteur.
```
    char[] letters = new char[26];
    for (char c : letters)
    {
        letters[c]=0;
    }
```
Ensuite, pour chaque lettre, incrémenter la position dans le vecteur. Si toutes les entrées ont un compteur est supérieure à 1, alors vous avez répète

Comment cela fonctionnerait-il? Un personnage a une valeur habituellement dans la gamme de 65-122, ce tableau n'a pas une telle position.
utilisation c - 'A' (ou tout ce qui est jugé approprié pour le résultat souhaité) pour l'index. Toutefois, le tableau devrait être de plus de 26 éléments, sauf si seules les lettres sont utilisées et le chèque n'est pas sensible à la casse/entrée est garanti d'être dans un cas. Avec zéro restrictions sur ce qui est permis dans la chaîne de caractères, la taille de la matrice aurait à 65535 (moins de 26 si le programme est insensible à la casse).
En fait, la boucle spécifique affiché est d'aller à maintes reprises letters[0] être '\0'. Vous devez utiliser une normale for boucle pour initialiser les valeurs par défaut (même si c'est pas nécessaire, car char est un type primitif). Faire le tableau d'une int[] serait mieux pour le comptage des doublons, ou boolean[] si nombre de différentes lettres, c'est tout ce qui est nécessaire.

OriginalL'auteur Alexandre Santos
0

Comment le mettre dans un tableau, les trier par ordre alphabétique, puis appliquer votre logique(en comparant adjacents)?
```
v  = sort(v);//your sort method

int count = 0;
for (int i = 0;i< lengthText-1; i++) 
{ if v[i] == v[i + 1]  {
        i++;
    } else {
        count++;
    }
}
```
Par ailleurs, votre programme ne fonctionne pas parce que vous ne i == lengthText-1 dans votre boucle for.

OriginalL'auteur George Irimiciuc

Même logique avec @Alexandre Santos, mais avec des exemples de codes. La complexité est O(N).
Fonctionne uniquement avec les alphabétique chaîne de caractères sans espace, numériques ou caractères spéciaux.

Cela peut également être utilisé comme comptage de tri.

public class CountChars 
{
    public static int countUniqCharacters(String str) {
        int[] counts = new int['z' - 'a' + 1];
        char[] arr = str.toLowerCase().toCharArray();

        for (char c: arr) {
            counts[c - 'a']++;
        }

        int unique = 0;
        for (int i: counts) {
            if (i > 0)
                unique++;
        }

        return unique;
    }

    public static void main(String[] args) {
        System.out.println("Unique char in " + args[0] 
                + " is " + CountChars.countUniqCharacters(args[0]));
    }
}

OriginalL'auteur Wonil

public class CharacterCount {
    public static void main(String[] args) {
        String s = "aaabbbcccddd";
        String t="";
        int count = 0;

        //Loop to find unique characters in a string and add it to new string called t
        //if a character is not found in a string indexOf returns -1
        for (int i = 0; i < s.length(); i++) {
            if (t.indexOf(s.charAt(i))==-1) t+=s.charAt(i);
        }

        //For every character new string t , loop though s find the count and display
        for (int i = 0; i < t.length(); i++) {
            count = 0;
            for (int j = 0; j < s.length(); j++) {
                if (t.charAt(i) == s.charAt(j)) count++;
            }
            System.out.println(t.charAt(i) + " " + count);
        }
    }
}

OriginalL'auteur thripura

      public class Main {
     public static void main(String[] args) {
   Scanner sc = new Scanner(System.in);
String s1 = sc.nextLine();
getvalues(s1);
   }
         public static void getvalues(String s1) {
String s2 = s1.toLowerCase();
StringBuffer sb = new StringBuffer(s2);
int l = sb.length();
int count = 0;
for (int i = 0; i < l; i++) {
  count = 0;
  for (int j = i + 1; j < l; j++) {
    if (sb.charAt(i) == sb.charAt(j)) {
      sb.deleteCharAt(j);
      count++;
      j--;
      l--;
    }
  }
  if (count > 0) {
    sb.deleteCharAt(i);
    i--;
    l--;
  }
}
if (sb.length() == 0) {
  System.out.println(-1);
} else
  System.out.println(sb.length());
 }
 }

OriginalL'auteur Kiran Patil

Vous devez vous connecter pour publier un commentaire.

Regex Explique: