Подсчет повторяющихся чисел в списке

Question

У меня есть список:

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

Теперь мне нужно сделать программу, которая вычисляет двойные числа. Число удваивается, когда число до того, как оно будет одинаковым. Надеюсь, вы понимаете. Так что 1 удваивается, 4 удваивается, и мы получили 2 двойных в 7,7,7.

Answer 1

Вот решение в LINQ:

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

Это создает другую последовательность, пропуская первый элемент списка, а затем находит элементы из обеих последовательностей, которые имеют одинаковый индекс и то же значение. Он будет работать в линейном времени, но только потому, что список предлагает O(1) доступ по индексу.

Answer 2

что-то подобное может работать:

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

EDIT:

приведенный выше код не получает результат ОП хотел. Вот отредактированная версия, которая берет вдохновение от элегантного решения Ани ниже: :)

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

Answer 3

Вот подход, который является относительно простым, только перебирает раз над последовательностью, и работает с любой последовательностью (не только перечислены):

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

Вот еще один, который еще проще в том, что это только запрос LINQ, но он использует побочные эффекты в предложении Where, что противно:

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

Третья альтернатива, которая несколько чище, но использует SelectConsecutive метод, который является в основном SelectPairs от this answer, но переименовали быть немного понятнее :)

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

Answer 4

Все, кажется, пытается найти хорошие способы сделать это, так здесь действительно плохой способ:

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; 

Пожалуйста, не делайте этого так.

Answer 5

Здесь вы идете с ответом в 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

Пример, который (вероятно) работает лучше, чем при использовании Linq, хотя, возможно, менее элегантен:

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

Answer 7

Вы можете сделать это :

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

Это немного похоже @ KJN отвечают, за исключением того, я думаю, что он выражает «двойников» и «два дубли» раздел в этом вопросе немного лучше:

1. группа всех целых чисел вместе
2. интересуют только те, которые появляются более одного раза (g.Count() > 1)
3. выберите уплощенную список «двойников», будучи тем, после того, как первый (g.Skip(1))

PS: Мы предполагаем здесь, что GroupBy не первый сортировки списка и если это произойдет, то что-то не негативное влияние предварительного отсортированного списка ...