Como faço para remover duplicatas de uma matriz c #?

Eu tenho trabalhado com uma matriz string[] em C # que é retornado de uma chamada de function. Eu poderia lançar em uma coleção Generic , mas eu queria saber se havia uma maneira melhor de fazê-lo, possivelmente usando uma matriz temporária.

Qual é a melhor maneira de remover duplicatas de uma matriz c #?

Você poderia usar uma consulta LINQ para fazer isso:

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

Aqui está a abordagem HashSet :

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

Infelizmente, essa solução também requer o .NET framework 3.5 ou posterior, pois o HashSet não foi adicionado até essa versão. Você também pode usar array.Distinct () , que é um recurso do LINQ.

Se você precisasse classificá-lo, poderia implementar uma sorting que também removesse duplicatas.

Mata dois pássaros com uma pedra, então.

Isso pode depender de quanto você deseja projetar a solução – se a matriz nunca for tão grande e você não se importar em classificar a lista, tente testar algo semelhante ao seguinte:

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

O código testado e em funcionamento a seguir removerá as duplicatas de uma matriz. Você deve include o namespace 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]); } 

Você poderia envolver isso em uma function se quisesse.

– Esta é a pergunta da entrevista feita todas as vezes. Agora eu fiz sua codificação.

 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(); } 
 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 "); } } 
 List myStringList = new List(); foreach (string s in myStringArray) { if (!myStringList.Contains(s)) { myStringList.Add(s); } } 

Isso é O (n ^ 2) , o que não importa para uma pequena lista que será colocada em um combo, mas pode ser rapidamente um problema em uma grande coleção.

Adicione todas as strings a um dictionary e obtenha a propriedade Keys posteriormente. Isso produzirá cada string única, mas não necessariamente na mesma ordem em que sua input original as continha.

Se você exigir que o resultado final tenha a mesma ordem da input original, ao considerar a primeira ocorrência de cada sequência, use o seguinte algoritmo:

  1. Tenha uma lista (saída final) e um dictionary (para verificar se há duplicatas)
  2. Para cada string na input, verifique se ela já existe no dictionary
  3. Caso contrário, adicione-o ao dictionary e à lista

No final, a lista contém a primeira ocorrência de cada string única.

Certifique-se de considerar coisas como cultura e tal quando estiver construindo seu dictionary, para ter certeza de lidar com as duplicatas com letras acentuadas corretamente.

O seguinte trecho de código tenta remover duplicatas de uma ArrayList, embora essa não seja uma solução ideal. Fiz esta pergunta durante uma entrevista para remover duplicatas por recursion e sem usar um segundo / arraylist temporário:

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

Talvez hashset, que não armazena elementos duplicados e silenciosamente ignora solicitações para adicionar duplicatas.

 static void Main() { string 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 + ","); } 

Aqui está uma abordagem O (n * n) que usa o espaço 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'; } } 

As abordagens hash / linq acima são o que você geralmente usaria na vida real. No entanto, em entrevistas, eles geralmente querem colocar algumas restrições, por exemplo, espaço constante que exclui hash ou nenhuma API interna - o que exclui o uso do LINQ .

NOTA: não testado!

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

Pode fazer o que você precisa …

EDIT Argh !!! espancado por roubar por menos de um minuto!

Testado o abaixo e funciona. O que é legal é que ele também faz uma pesquisa sensível à 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

Este código 100% remove valores duplicados de uma matriz [como eu usei um [i]] ….. Você pode convertê-lo em qualquer idioma OO ….. 🙂

 for(int i=0;i 

Solução simples:

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

você pode usar este código quando trabalhar com um 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]); 
 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; } 

Abaixo está uma lógica simples em java você percorre os elementos do array duas vezes e se você ver qualquer mesmo elemento que você atribuir zero a ele, mais você não tocar no índice do elemento que você está comparando.

 import java.util.*; class removeDuplicate{ int [] y ; public removeDuplicate(int[] array){ y=array; for(int b=0;b 
  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(ref outputArray, outputArray.Length + 1); outputArray[outputArray.Length-1] = inputArray[i]; } } return outputArray; }