Comment puis-je supprimer les doublons d’un tableau C #?

Vous pouvez éventuellement utiliser une requête LINQ pour faire ceci:

 int[] s = { 1, 2, 3, 3, 4}; int[] q = s.Distinct().ToArray(); 

Voici l’ approche HashSet :

 public static ssortingng[] RemoveDuplicates(ssortingng[] s) { HashSet set = new HashSet(s); ssortingng[] result = new ssortingng[set.Count]; set.CopyTo(result); return result; } 

Malheureusement, cette solution nécessite également .NET Framework 3.5 ou version ultérieure car HashSet n’a pas été ajouté avant cette version. Vous pouvez également utiliser array.Distinct () , qui est une fonctionnalité de LINQ.

Si vous deviez le sortinger, vous pourriez alors implémenter un sorting qui supprime également les doublons.

Tue deux oiseaux avec une pierre, alors.

Cela peut dépendre de la façon dont vous souhaitez concevoir la solution – si la baie ne sera jamais aussi grande et que vous ne vous souciez pas du sorting de la liste, vous pouvez essayer quelque chose de similaire à ce qui suit:

  public ssortingng[] RemoveDuplicates(ssortingng[] myList) { System.Collections.ArrayList newList = new System.Collections.ArrayList(); foreach (ssortingng str in myList) if (!newList.Contains(str)) newList.Add(str); return (ssortingng[])newList.ToArray(typeof(ssortingng)); } 

Le code testé et fonctionnel suivant supprime les doublons d’un tableau. Vous devez inclure l’espace de noms System.Collections.

 ssortingng[] sArray = {"a", "b", "b", "c", "c", "d", "e", "f", "f"}; var sList = new ArrayList(); for (int i = 0; i < sArray.Length; i++) { if (sList.Contains(sArray[i]) == false) { sList.Add(sArray[i]); } } var sNew = sList.ToArray(); for (int i = 0; i < sNew.Length; i++) { Console.Write(sNew[i]); } 

Vous pourriez envelopper une fonction si vous le vouliez.

– Ceci est la question de l’interview demandé à chaque fois. Maintenant j’ai fait son codage.

 static void Main(ssortingng[] args) { int[] array = new int[] { 4, 8, 4, 1, 1, 4, 8 }; int numDups = 0, prevIndex = 0; for (int i = 0; i < array.Length; i++) { bool foundDup = false; for (int j = 0; j < i; j++) { if (array[i] == array[j]) { foundDup = true; numDups++; // Increment means Count for Duplicate found in array. break; } } if (foundDup == false) { array[prevIndex] = array[i]; prevIndex++; } } // Just Duplicate records replce by zero. for (int k = 1; k <= numDups; k++) { array[array.Length - k] = '\0'; } Console.WriteLine("Console program for Remove duplicates from array."); Console.Read(); } 

 protected void Page_Load(object sender, EventArgs e) { ssortingng a = "a;b;c;d;e;v"; ssortingng[] b = a.Split(';'); ssortingng[] c = b.Distinct().ToArray(); if (b.Length != c.Length) { for (int i = 0; i < b.Length; i++) { try { if (b[i].ToString() != c[i].ToString()) { Response.Write("Found duplicate " + b[i].ToString()); return; } } catch (Exception ex) { Response.Write("Found duplicate " + b[i].ToString()); return; } } } else { Response.Write("No duplicate "); } } 

 List mySsortingngList = new List(); foreach (ssortingng s in mySsortingngArray) { if (!mySsortingngList.Contains(s)) { mySsortingngList.Add(s); } } 

Ceci est O (n ^ 2) , ce qui ne compte pas pour une courte liste qui va être fourrée dans un combo, mais pourrait être rapidement un problème sur une grande collection.

Ajoutez toutes les chaînes à un dictionnaire et obtenez ensuite la propriété Keys. Cela produira chaque chaîne unique, mais pas nécessairement dans le même ordre que votre entrée originale.

Si vous souhaitez que le résultat final ait le même ordre que l’entrée d’origine, utilisez plutôt l’algorithme suivant lorsque vous considérez la première occurrence de chaque chaîne:

1. Avoir une liste (sortie finale) et un dictionnaire (pour vérifier les doublons)
2. Pour chaque chaîne de l’entrée, vérifiez si elle existe déjà dans le dictionnaire
3. Sinon, ajoutez-le à la fois au dictionnaire et à la liste

À la fin, la liste contient la première occurrence de chaque chaîne unique.

Assurez-vous de tenir compte de facteurs tels que la culture et autres lors de la construction de votre dictionnaire, pour vous assurer que vous gérez correctement les doublons avec des lettres accentuées.

Le morceau de code suivant tente de supprimer les doublons d’un ArrayList bien que ce ne soit pas une solution optimale. On m’a posé cette question lors d’une interview pour supprimer les doublons lors de la récursivité et sans utiliser de second arraylist:

 private void RemoveDuplicate() { ArrayList dataArray = new ArrayList(5); dataArray.Add("1"); dataArray.Add("1"); dataArray.Add("6"); dataArray.Add("6"); dataArray.Add("6"); dataArray.Add("3"); dataArray.Add("6"); dataArray.Add("4"); dataArray.Add("5"); dataArray.Add("4"); dataArray.Add("1"); dataArray.Sort(); GetDistinctArrayList(dataArray, 0); } private void GetDistinctArrayList(ArrayList arr, int idx) { int count = 0; if (idx >= arr.Count) return; ssortingng val = arr[idx].ToSsortingng(); foreach (Ssortingng s in arr) { if (s.Equals(arr[idx])) { count++; } } if (count > 1) { arr.Remove(val); GetDistinctArrayList(arr, idx); } else { idx += 1; GetDistinctArrayList(arr, idx); } } 

Peut-être hashset qui ne stocke pas les éléments en double et ignore silencieusement les requêtes pour append des doublons.

 static void Main() { ssortingng textWithDuplicates = "aaabbcccggg"; Console.WriteLine(textWithDuplicates.Count()); var letters = new HashSet(textWithDuplicates); Console.WriteLine(letters.Count()); foreach (char c in letters) Console.Write(c); Console.WriteLine(""); int[] array = new int[] { 12, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2 }; Console.WriteLine(array.Count()); var distinctArray = new HashSet(array); Console.WriteLine(distinctArray.Count()); foreach (int i in distinctArray) Console.Write(i + ","); } 

Voici une approche O (n * n) qui utilise un espace O (1) .

 void removeDuplicates(char* strIn) { int numDups = 0, prevIndex = 0; if(NULL != strIn && *strIn != '\0') { int len = strlen(strIn); for(int i = 0; i < len; i++) { bool foundDup = false; for(int j = 0; j < i; j++) { if(strIn[j] == strIn[i]) { foundDup = true; numDups++; break; } } if(foundDup == false) { strIn[prevIndex] = strIn[i]; prevIndex++; } } strIn[len-numDups] = '\0'; } } 

Les approches de hachage / linq ci-dessus sont ce que vous utiliseriez généralement dans la vie réelle. Cependant, dans les entretiens, ils veulent généralement mettre en place des contraintes, par exemple un espace constant qui exclut le hachage ou aucune API interne - ce qui exclut l'utilisation de LINQ .

NOTE: PAS testé!

 ssortingng[] test(ssortingng[] mySsortingngArray) { List mySsortingngList = new List(); foreach (ssortingng s in mySsortingngArray) { if (!mySsortingngList.Contains(s)) { mySsortingngList.Add(s); } } return mySsortingngList.ToSsortingng(); } 

Pourrais-tu faire ce qu’il te faut …

EDIT Argh !!! battu par rob par moins d’une minute!

Testé ci-dessous et ça marche. Ce qui est cool, c’est qu’il fait aussi une recherche sensible à la culture

 class RemoveDuplicatesInSsortingng { public static Ssortingng RemoveDups(Ssortingng origSsortingng) { Ssortingng outSsortingng = null; int readIndex = 0; CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo; if(Ssortingng.IsNullOrEmpty(origSsortingng)) { return outSsortingng; } foreach (var ch in origSsortingng) { if (readIndex == 0) { outSsortingng = Ssortingng.Concat(ch); readIndex++; continue; } if (ci.IndexOf(origSsortingng, ch.ToSsortingng().ToLower(), 0, readIndex) == -1) { //Unique char as this char wasn't found earlier. outSsortingng = Ssortingng.Concat(outSsortingng, ch); } readIndex++; } return outSsortingng; } static void Main(ssortingng[] args) { Ssortingng inputSsortingng = "aAbcefc"; Ssortingng outputSsortingng; outputSsortingng = RemoveDups(inputSsortingng); Console.WriteLine(outputSsortingng); } 

}

–AptSenSDET

Ce code 100% supprime les valeurs en double d’un tableau [comme j’ai utilisé un [i]] ….. Vous pouvez le convertir dans n’importe quel langage OO ….. 🙂

 for(int i=0;i