objects - ¿Cómo elimino los duplicados de una matriz de C#?

remove duplicates list c#

Question

He estado trabajando con una matriz de string[] en C # que se devuelve desde una llamada a función. Podría lanzar a una colección Generic , pero me preguntaba si había una mejor manera de hacerlo, posiblemente mediante el uso de una matriz temporal.

¿Cuál es la mejor manera de eliminar duplicados de una matriz de C #?

Answer 1

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

Este es O (n ^ 2) , que no importará para una lista corta que se va a rellenar en un combo, pero podría ser un problema rápidamente en una gran colección.

Answer 2

- Esta es la pregunta de la entrevista que se hace siempre. Ahora hice su codificación.

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 3

A continuación se muestra una lógica simple en java, recorre los elementos de la matriz dos veces y si ve un mismo elemento, le asigna cero además de no tocar el índice del elemento que está comparando.

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 4

Agregue todas las cadenas a un diccionario y obtenga la propiedad Llaves luego. Esto producirá cada cadena única, pero no necesariamente en el mismo orden en que las ingresó originalmente.

Si necesita que el resultado final tenga el mismo orden que la entrada original, cuando considera la primera ocurrencia de cada cadena, use el siguiente algoritmo:

1. Tener una lista (resultado final) y un diccionario (para buscar duplicados)
2. Para cada cadena en la entrada, verifique si ya existe en el diccionario
3. Si no, agréguelo tanto al diccionario como a la lista

Al final, la lista contiene la primera ocurrencia de cada cadena única.

Asegúrese de tener en cuenta cosas como la cultura y cosas así cuando construya su diccionario, para asegurarse de manejar correctamente los duplicados con letras acentuadas.

Answer 5

Aquí está el HashSet<string> :

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

Lamentablemente, esta solución también requiere .NET Framework 3.5 o posterior ya que HashSet no se agregó hasta esa versión. También podría usar array.Distinct() , que es una característica de LINQ.

Answer 6

Aquí hay un enfoque O (n * n) que usa O (1) espacio.

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

Los enfoques hash / linq anteriores son los que generalmente usarías en la vida real. Sin embargo, en las entrevistas, por lo general, quieren poner algunas restricciones, por ejemplo, espacio constante que excluye el hash o ninguna API interna, lo que descarta usar LINQ .

Answer 7

El siguiente código probado y operativo eliminará los duplicados de una matriz. Debe incluir el espacio de nombres 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]);
}

Podría envolver esto en una función si quisiera.

Answer 8

El siguiente fragmento de código intenta eliminar duplicados de un ArrayList, aunque esta no es una solución óptima. Me hicieron esta pregunta durante una entrevista para eliminar duplicados a través de la recursión, y sin usar una segunda / lista de matrices temporal:

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 9

Este código elimina al 100% los valores duplicados de una matriz [como usé un [i]] ..... Puede convertirlo en cualquier idioma 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 10

Esto podría depender de la cantidad que desee para diseñar la solución: si la matriz nunca será tan grande y no le importa ordenar la lista, puede intentar algo similar a lo siguiente:

    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 11

NOTA: ¡NO probado!

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();
}

Podría hacer lo que necesita ...

EDIT Argh !!! ¡golpeado por robar por debajo de un minuto!

Answer 12

Posiblemente pueda usar una consulta LINQ para hacer esto:

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

Answer 13

Probado el siguiente y funciona. Lo bueno es que también hace una búsqueda sensible a la cultura

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 14

Si necesita ordenarlo, puede implementar un ordenamiento que también elimine los duplicados.

Mata a dos pájaros de un tiro, entonces.

Answer 15

Solución simple:

using System.Linq;
...

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

Answer 16

Tal vez hashset que no almacena elementos duplicados e ignora silenciosamente las solicitudes para agregar duplicados.

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 17

puedes usar este código cuando trabajas con una 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 18

  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 19

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 20

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