Đếm số trùng lặp trong danh sách

Question

Tôi có một danh sách:

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

Bây giờ tôi cần phải thực hiện một chương trình mà sẽ tính toán các con số gấp đôi. Một con số là gấp đôi khi số trước khi nó là như nhau. Tôi hy vọng bạn hiểu. Vì vậy, 1 là gấp đôi, 4 là tăng gấp đôi và chúng tôi có 2 đôi trong 7,7,7.

Answer 1

Dưới đây là một giải pháp trong LINQ:

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

Điều này tạo ra chuỗi khác bằng cách bỏ qua các thành viên đầu tiên của danh sách, và sau đó phát hiện các yếu tố từ cả hai chuỗi có chỉ số giống nhau và cùng giá trị. Nó sẽ chạy trong thời gian tuyến tính, nhưng chỉ vì một danh sách cung cấp truy cập O(1) theo chỉ mục.

Answer 2

một cái gì đó như thế này có thể làm việc:

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

EDIT:

mã trên không có được kết quả OP muốn. Dưới đây là một phiên bản được chỉnh sửa là được lấy cảm hứng từ giải pháp thanh lịch của Ani dưới đây: :)

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

Answer 3

Dưới đây là một cách tiếp cận đó là tương đối đơn giản, chỉ lặp một lần trong suốt chuỗi, và làm việc với bất kỳ chuỗi (không chỉ liệt kê):

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

Dưới đây là một số khác mà thậm chí còn đơn giản hơn ở chỗ nó chỉ là một truy vấn LINQ, nhưng nó sử dụng tác dụng phụ trong mệnh đề ở đâu, đó là khó chịu:

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

Một lựa chọn thứ ba, trong đó có phần sạch hơn nhưng sử dụng một phương pháp SelectConsecutive mà về cơ bản là SelectPairs từ this answer, nhưng đổi tên thành thể hơi rõ ràng hơn :)

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

Answer 4

Mọi người dường như được cố gắng tìm những cách tốt để làm việc đó, vì vậy dưới đây là một cách thực sự xấu:

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; 

Xin đừng làm như vậy.

Answer 5

Ở đây bạn đi với câu trả lời trong 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

Một ví dụ đó (có lẽ) thực hiện tốt hơn so với sử dụng LINQ, mặc dù được cho là ít thanh lịch:

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

Answer 7

Bạn có thể làm điều này :

Câu trả lời này giống như câu trả lời của @ KJN, ngoại trừ tôi nghĩ nó thể hiện mệnh đề "tăng gấp đôi" và "gấp đôi" trong câu hỏi tốt hơn một chút:

1. nhóm tất cả các số nguyên với nhau
2. chỉ quan tâm đến những người xuất hiện nhiều hơn một lần (g.Count() > 1)
3. chọn một danh sách phẳng của "đôi", là những người sau khi người đầu tiên (g.Skip(1))

PS: Chúng tôi giả định ở đây, rằng GroupBy không đầu tiên sắp xếp danh sách và nếu có, mà loại đó là không bị ảnh hưởng tiêu cực bởi một danh sách được sắp xếp trước ...