Montrant unique de caractères d'une chaîne en une seule fois

J'ai une chaîne de caractères avec la répétition des lettres. Je veux des lettres qui sont répétés plus d'une fois de montrer qu'une seule fois. Par exemple, j'ai une chaîne aaabbbccc je veux que le résultat soit abc. jusqu'à présent ma fonction fonctionne comme ceci:

si la lettre ne le répétez pas, il n'est pas montrée
si c'est répété une fois, c'est montrer qu'une seule fois (c'est à dire aa montre une)
si c'est répété deux fois, montre tous (c'est à dire aaa montre aaa)
si c'est répété 3 fois, il montre 6 (si aaaa il montre aaaaaa)

function unique_char(string) {
    var unique = '';
    var count = 0;
    for (var i = 0; i < string.length; i++) {
        for (var j = i+1; j < string.length; j++) {
            if (string[i] == string[j]) {
                count++;
                unique += string[i];
            }
        }
    }
    return unique;
}

document.write(unique_char('aaabbbccc'));

La fonction doit être avec boucle à l'intérieur d'une boucle; c'est pourquoi la deuxième for est à l'intérieur de la première.

Dans regexp vous pouvez écrire 'aaabbbccc'.replace(/(.)\1+/g, "$1")
quel doit être le résultat de unique_char('abracadabra') être?
le résultat devrait être abrcd
Comment ça? Il ne correspond pas à votre description. Btw, ce qui est le cas d'utilisation de ce (ou de devoirs)?

OriginalL'auteur Zlatko Soleniq | 2012-12-13

Convertir un tableau en premier, puis la réponse ici, et rejoindre, comme suit:

var nonUnique = "ababdefegg";
var unique = nonUnique.split('').filter(function(item, i, ar){ return ar.indexOf(item) === i; }).join('');

Dans une seule ligne 🙂

OriginalL'auteur Upayavira

Vous pouvez utiliser un expression régulière avec un personnalisé la fonction de remplacement:

function unique_char(string) {
    return string.replace(/(.)*/g, function(sequence, char) {
         if (sequence.length == 1) //if the letter doesn't repeat
             return ""; //its not shown
         if (sequence.length == 2) //if its repeated once
             return char; //its show only once (if aa shows a)
         if (sequence.length == 3) //if its repeated twice
             return sequence; //shows all(if aaa shows aaa)
         if (sequence.length == 4) //if its repeated 3 times
             return Array(7).join(char); //it shows 6( if aaaa shows aaaaaa)
         //else ???
         return sequence;
    });
}

OriginalL'auteur Bergi

Trop tard peut-être, mais encore ma version de réponse à ce post:

function extractUniqCharacters(str){
    var temp = {};
    for(var oindex=0;oindex<str.length;oindex++){
        temp[str.charAt(oindex)] = 0; //Assign any value
    }
    return Object.keys(temp).join("");
}

OriginalL'auteur Parthasarathy K

Par le libellé de la question: "si la lettre n'est pas de répéter ses pas montré"

function unique_char(str)
{
    var obj = new Object();

    for (var i = 0; i < str.length; i++)
    {
        var chr = str[i];
        if (chr in obj)
        {
            obj[chr] += 1;
        }
        else
        {
            obj[chr] = 1;
        }
    }

    var multiples = [];
    for (key in obj)
    {
        //Remove this test if you just want unique chars
        //But still keep the multiples.push(key)
        if (obj[key] > 1)
        {
            multiples.push(key);
        }
    }

    return multiples.join("");
}

var str = "aaabbbccc";
document.write(unique_char(str));

OriginalL'auteur brian buck

0

Votre problème est que vous ajoutez à unique chaque fois que vous trouvez le caractère dans string. Vraiment, vous devriez probablement faire quelque chose comme ceci (depuis que vous avez spécifié la réponse doit être imbriquée pour la boucle):
```
function unique_char(string){

    var str_length=string.length;
    var unique='';

    for(var i=0; i<str_length; i++){

        var foundIt = false;
        for(var j=0; j<unique.length; j++){

            if(string[i]==unique[j]){

                foundIt = true;
                break;
            }

        }

        if(!foundIt){
            unique+=string[i];
        }

    }

   return unique;
}

document.write( unique_char('aaabbbccc'))
```
À cela nous ajoutons seulement le caractère trouvé dans string à unique si elle n'est pas déjà là. Ce n'est vraiment pas un moyen efficace de faire tout cela ... mais en fonction de vos besoins, il doit travailler.

Je ne peux pas courir ce depuis que je n'ai rien d'utile pour exécuter JavaScript ... mais la théorie de cette méthode devrait fonctionner.

Il n'est pas en C#. Son JavaScript.
Mon commentaire est encore un peu valables ... je n'ai rien d'utile pour exécuter JavaScript. Et je ne pense pas être utilisé de quelque chose qui est vraiment dépendant d'une langue.
Pour la plupart -- Cette ligne ne fonctionne pas: bool foundIt = false; Devrait être var foundIt = false;
Les chiffres ... depuis je n'ai jamais programmé dans les deux langues 😉
il fonctionne avec le var, mais j'ai une question qu'est-ce que (!foundIT) et peut-il être écrit d'une manière différente

OriginalL'auteur cottonke
0

À l'aide de lodash:
```
_.uniq('aaabbbccc').join(''); //gives 'abc'
```
OriginalL'auteur Lukasz Wiktor
0

Essayer si des personnages en double doivent être affichées une fois, c'est à dire,
pour i/p: aaabbbccc o/p: abc
```
var str="aaabbbccc";
Array.prototype.map.call(str, 
  (obj,i)=>{
    if(str.indexOf(obj,i+1)==-1 ){
     return obj;
    }
  }
).join("");
//output: "abc"
```
Et essayer si seulement unique de caractères(String Bombarder Algo) doivent être affichées, ajouter une autre condition "et" supprimer les caractères qui sont venus plus d'une fois et de n'afficher que des caractères uniques, c'est à dire,
pour i/p: aabbbkaha o/p: kh
```
var str="aabbbkaha";
Array.prototype.map.call(str, 
 (obj,i)=>{
   if(str.indexOf(obj,i+1)==-1 && str.lastIndexOf(obj,i-1)==-1){ //another and condition
     return obj;
   }
 }
).join("");
//output: "kh"
```
OriginalL'auteur jayad aadrit

Ici est la fonction plus simple à faire que

  function remove(text) 
    {
      var unique= "";
      for(var i = 0; i < text.length; i++)
      {
        if(unique.indexOf(text.charAt(i)) < 0) 
        {
          unique += text.charAt(i);
        }
      }
      return unique;
    }

OriginalL'auteur Ahmad Adel

Vous devez vous connecter pour publier un commentaire.