Compter les numéros en double dans une liste

Question

J'ai une liste:

int list = { 1,1,2,3,4,4,5,7,7,7,10}; 

Maintenant, je dois faire un programme qui calcule les doubles chiffres. Un nombre est double lorsque le nombre avant est le même. J'espère que tu comprends. Donc 1 est double, 4 est double et nous avons 2 doubles en 7,7,7.

Answer 1

est ici une solution LINQ:

var doubles = list.Skip(1) 
        .Where((number, index) => list[index] == number); 

Cela crée une autre séquence en sautant le premier membre de la liste, et trouve ensuite des éléments des deux séquences qui ont le même indice et la même valeur. Il fonctionnera en temps linéaire, mais seulement parce qu'une liste offre O(1) accès par index.

Answer 2

quelque chose comme cela peut fonctionner:

list.GroupBy (l => l).Where (l => l.Count() > 1).SelectMany (l => l).Distinct(); 

EDIT:

le code ci-dessus ne soit pas le résultat de l'OP voulait. Voici une version modifiée qui prend l'inspiration de la solution élégante d'Ani ci-dessous: :)

list.GroupBy(l => l).Select(g=>g.Skip(1)).SelectMany (l => l); 

Answer 3

Voilà une approche qui est relativement simple, seulement itère une fois sur la séquence, et travaille avec une séquence (pas de listes seulement):

public IEnumerable<T> FindConsecutiveDuplicates<T>(this IEnumerable<T> source) 
{ 
    using (var iterator = source.GetEnumerator()) 
    { 
     if (!iterator.MoveNext()) 
     { 
      yield break; 
     } 
     T current = iterator.Current; 
     while (iterator.MoveNext()) 
     { 
      if (EqualityComparer<T>.Default.Equals(current, iterator.Current)) 
      { 
       yield return current; 
      } 
      current = iterator.Current; 
     } 
    } 
} 

est ici un autre qui est encore plus simple en ce qu'elle est seulement une requête LINQ, mais il utilise des effets secondaires dans la clause Where, qui est méchant:

IEnumerable<int> sequence = ...; 

bool first = true; 
int current = 0; 
var result = sequence.Where(x => { 
    bool result = !first && x == current; 
    current = x; 
    first = false; 
    return result; 
}); 

Une troisième alternative, qui est un peu plus propre mais utilise une méthode SelectConsecutive qui est essentiellement SelectPairs de this answer, mais renommé être un peu plus clair :)

IEnumerable<int> sequence = ...; 
IEnumerable<int> result = sequence.SelectConsecutive((x, y) => new { x, y }) 
            .Where(z => z.x == z.y); 

Answer 4

Tout le monde semble essayer de trouver de bonnes façons de le faire, donc Voici un très mauvais moyen à la place:

List<int> doubles = new List<int>(); 
Dictionary<int, bool> seenBefore = new Dictionary<int, bool>(); 

foreach(int i in list) 
{ 
    try 
    { 
     seenBefore.Add(i, true); 
    } 
    catch (ArgumentException) 
    { 
     doubles.Add(i); 
    } 
} 

return doubles; 

S'il vous plaît ne le faites pas comme ça.

Answer 5

Ici vous allez avec la réponse en C# :)

int[] intarray = new int[] { 1, 1, 2, 3, 4, 4, 5, 7, 7, 7, 10 }; 

int previousnumber = -1; 
List<int> doubleDigits = new List<int>(); 
for (int i = 0; i < intarray.Length; i++) 
{ 
    if (previousnumber == -1) { previousnumber = intarray[i]; continue; } 
    if (intarray[i] == previousnumber) 
    { 
     if (!doubleDigits.Contains(intarray[i])) 
     { 
      doubleDigits.Add(intarray[i]); 
      //Console.WriteLine("Duplicate int found - " + intarray[i]); 
      continue; 
     } 
    } 
    else 
    { 
     previousnumber = intarray[i]; 
    } 
} 

Answer 6

Un exemple qui (probablement) fonctionne mieux que LINQ, mais est sans doute moins élégante:

for (int i = 1; i < list.Count; i++) 
    if (list[i] == list[i - 1]) 
     doubles.Add(list[i]); 

Answer 7

Vous pouvez le faire :

list.GroupBy(i => i).Where(g => g.Count() > 1).SelectMany(g => g.Skip(1)) 

Ceci est un peu comme la réponse de @ kjn, sauf que je pense qu'il exprime l'article « double » et « deux doubles » dans la question un peu mieux:

groupe
1. tous les entiers ensemble
2. uniquement de ceux qui apparaissent plus d'une fois (g.Count() > 1)
3. sélectionner une liste aplaties des « doubles », étant ceux après la première (g.Skip(1))

PS: Nous partons du principe ici, que GroupBy ne pas d'abord trier la liste et si elle le fait, que ce genre ne soit pas influencée négativement par une liste pré-triés ...