Comment supprimer les doublons d’un tableau C# ?

Question

J'ai travaillé avec un string[] tableau en C# qui est renvoyé par un appel de fonction.Je pourrais éventuellement lancer un casting sur un Generic collection, mais je me demandais s'il y avait une meilleure façon de le faire, éventuellement en utilisant un tableau temporaire.

Quelle est la meilleure façon de supprimer les doublons d’un tableau C# ?

Answer 1

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

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

Answer 2

Voici la HashSet<chaîne> approche:

public static string[] RemoveDuplicates(string[] s)
{
    HashSet<string> set = new HashSet<string>(s);
    string[] result = new string[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 été ajouté qu'à cette version.Vous pouvez également utiliser tableau.Distinct(), qui est une fonctionnalité de LINQ.

Answer 3

Si vous aviez besoin de le trier, vous pouvez implémenter un tri qui supprime également les doublons.

Cela fait donc d'une pierre deux coups.

Answer 4

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

string[] 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 pouvez résumer cela dans une fonction si vous le souhaitez.

Answer 5

Cela peut dépendre de la manière dont vous souhaitez concevoir la solution - si le tableau ne sera jamais aussi grand et que vous ne vous souciez pas de trier la liste, vous voudrez peut-être essayer quelque chose de similaire à ce qui suit :

    public string[] RemoveDuplicates(string[] myList) {
        System.Collections.ArrayList newList = new System.Collections.ArrayList();

        foreach (string str in myList)
            if (!newList.Contains(str))
                newList.Add(str);
        return (string[])newList.ToArray(typeof(string));
    }

Answer 6

-- C'est Question d'entretien demandé à chaque fois.Maintenant j'ai fait son codage.

static void Main(string[] 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();
        }

Answer 7

List<String> myStringList = new List<string>();
foreach (string s in myStringArray)
{
    if (!myStringList.Contains(s))
    {
        myStringList.Add(s);
    }
}

C'est O(n^2), ce qui n'aura pas d'importance pour une courte liste qui sera insérée dans un combo, mais pourrait rapidement poser problème sur une grande collection.

Answer 8

protected void Page_Load(object sender, EventArgs e)
{
    string a = "a;b;c;d;e;v";
    string[] b = a.Split(';');
    string[] 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 ");
    }
}

Answer 9

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

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';
    }
}

Le hachage/linq les approches ci-dessus sont celles que vous utiliseriez généralement dans la vie réelle.Cependant, lors des entretiens, ils souhaitent généralement imposer certaines contraintes, par ex.espace constant qui exclut le hachage ou l'absence de contenu interne API - ce qui exclut l'utilisation LINQ.

Answer 10

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 d'origine.

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

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 au dictionnaire et à la liste

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

Assurez-vous de prendre en compte des éléments tels que la culture, etc. lors de la construction de votre dictionnaire, pour vous assurer de gérer correctement les doublons avec des lettres accentuées.

Answer 11

Le morceau de code suivant tente de supprimer les doublons d’une ArrayList bien que ce ne soit pas une solution optimale.On m'a posé cette question lors d'un entretien pour supprimer les doublons par récursion et sans utiliser de seconde liste de tableaux/temporaire :

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;

            string val = arr[idx].ToString();
            foreach (String s in arr)
            {
                if (s.Equals(arr[idx]))
                {
                    count++;
                }
            }

            if (count > 1)
            {
                arr.Remove(val);
                GetDistinctArrayList(arr, idx);
            }
            else
            {
                idx += 1;
                GetDistinctArrayList(arr, idx);
            }
        }

Answer 12

Peut-être que HashSet qui ne stocke pas des éléments en double et ignorez silencieusement les demandes d'ajouter des doublons.

static void Main()
{
    string textWithDuplicates = "aaabbcccggg";     

    Console.WriteLine(textWithDuplicates.Count());  
    var letters = new HashSet<char>(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<int>(array);
    Console.WriteLine(distinctArray.Count());

    foreach (int i in distinctArray) Console.Write(i + ",");
}

Answer 13

NOTE :Pas testé!

string[] test(string[] myStringArray)
{
    List<String> myStringList = new List<string>();
    foreach (string s in myStringArray)
    {
        if (!myStringList.Contains(s))
        {
            myStringList.Add(s);
        }
    }
    return myStringList.ToString();
}

Peut-être faire ce dont vous avez besoin...

MODIFIER Argh !!!battu par Robb en moins d'une minute !

Answer 14

J'ai testé ce qui suit et cela fonctionne.Ce qui est cool, c'est qu'il effectue également une recherche sensible à la culture.

class RemoveDuplicatesInString
{
    public static String RemoveDups(String origString)
    {
        String outString = null;
        int readIndex = 0;
        CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo;


        if(String.IsNullOrEmpty(origString))
        {
            return outString;
        }

        foreach (var ch in origString)
        {
            if (readIndex == 0)
            {
                outString = String.Concat(ch);
                readIndex++;
                continue;
            }

            if (ci.IndexOf(origString, ch.ToString().ToLower(), 0, readIndex) == -1)
            {
                //Unique char as this char wasn't found earlier.
                outString = String.Concat(outString, ch);                   
            }

            readIndex++;

        }


        return outString;
    }


    static void Main(string[] args)
    {
        String inputString = "aAbcefc";
        String outputString;

        outputString = RemoveDups(inputString);

        Console.WriteLine(outputString);
    }

}

--AptSenSDET

Answer 15

Ce code supprime à 100 % les valeurs en double d'un tableau [comme j'ai utilisé a[i]]..... Vous pouvez le convertir dans n'importe quel langage OO.....:)

for(int i=0;i<size;i++)
{
    for(int j=i+1;j<size;j++)
    {
        if(a[i] == a[j])
        {
            for(int k=j;k<size;k++)
            {
                 a[k]=a[k+1];
            }
            j--;
            size--;
        }
    }

}

Answer 16

Solution simple :

using System.Linq;
...

public static int[] Distinct(int[] handles)
{
    return handles.ToList().Distinct().ToArray();
}

Answer 17

Méthode d'extension générique :

public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
{
    if (source == null)
        throw new ArgumentNullException(nameof(source));

    HashSet<TSource> set = new HashSet<TSource>(comparer);
    foreach (TSource item in source)
    {
        if (set.Add(item))
        {
            yield return item;
        }
    }
}

Answer 18

vous pouvez utiliser ce code lorsque vous travaillez avec une ArrayList

ArrayList arrayList;
//Add some Members :)
arrayList.Add("ali");
arrayList.Add("hadi");
arrayList.Add("ali");

//Remove duplicates from array
  for (int i = 0; i < arrayList.Count; i++)
    {
       for (int j = i + 1; j < arrayList.Count ; j++)
           if (arrayList[i].ToString() == arrayList[j].ToString())
                 arrayList.Remove(arrayList[j]);

Answer 19

public static int RemoveDuplicates(ref int[] array)
{
    int size = array.Length;

    // if 0 or 1, return 0 or 1:
    if (size  < 2) {
        return size;
    }

    int current = 0;
    for (int candidate = 1; candidate < size; ++candidate) {
        if (array[current] != array[candidate]) {
            array[++current] = array[candidate];
        }
    }

    // index to count conversion:
    return ++current;
}

Answer 20

Vous trouverez ci-dessous une logique simple en Java : vous parcourez deux fois les éléments du tableau et si vous voyez le même élément, vous lui attribuez zéro et vous ne touchez pas l'index de l'élément que vous comparez.

import java.util.*;
class removeDuplicate{
int [] y ;

public removeDuplicate(int[] array){
    y=array;

    for(int b=0;b<y.length;b++){
        int temp = y[b];
        for(int v=0;v<y.length;v++){
            if( b!=v && temp==y[v]){
                y[v]=0;
            }
        }
    }
}

Answer 21

  private static string[] distinct(string[] inputArray)
        {
            bool alreadyExists;
            string[] outputArray = new string[] {};

            for (int i = 0; i < inputArray.Length; i++)
            {
                alreadyExists = false;
                for (int j = 0; j < outputArray.Length; j++)
                {
                    if (inputArray[i] == outputArray[j])
                        alreadyExists = true;
                }
                        if (alreadyExists==false)
                        {
                            Array.Resize<string>(ref outputArray, outputArray.Length + 1);
                            outputArray[outputArray.Length-1] = inputArray[i];
                        }
            }
            return outputArray;
        }

Answer 22

using System;
using System.Collections.Generic;
using System.Linq;


namespace Rextester
{
    public class Program
    {
        public static void Main(string[] args)
        {
             List<int> listofint1 = new List<int> { 4, 8, 4, 1, 1, 4, 8 };
           List<int> updatedlist= removeduplicate(listofint1);
            foreach(int num in updatedlist)
               Console.WriteLine(num);
        }


        public static List<int> removeduplicate(List<int> listofint)
         {
             List<int> listofintwithoutduplicate= new List<int>();


              foreach(var num in listofint)
                 {
                  if(!listofintwithoutduplicate.Any(p=>p==num))
                        {
                          listofintwithoutduplicate.Add(num);
                        }
                  }
             return listofintwithoutduplicate;
         }
    }



}