Невозможно найти пересечение двух массивов

Question

У меня есть один массив int[] com, который содержит два значения 0 и 1 (на начальном этапе).

Я определяю еще один массив в качестве String[] arr = new String[100];

arr содержит 6 элементов, которые являются:

arr[0]={4,8,10,11,12,14} 
arr[1]={1,2,3,4,8,12,14} 
.. arr[6]=something 

Я хочу найти пересечение обр [0] и обр [1], так что я написал код as:

foreach (int value1 in intersect) 
{ 
    //perform logic 
} 

Здесь я должен получить значение1 как 4,8, но я получаю значение1 как 52,44.

Что не так с тем, что я делаю?

Answer 1

Хорошо, вот что вы делаете, у вас есть строковые массивы, а не массивы int. Если вы сделаете это

arr[0]="4,8,10,11,12,14"; 
arr[1]="1,2,3,4,8,12,14"; 
var intersection = arr[0].Intersect(arr[1]); 

так arr[0] и arr[1] являются строками, вы получите в результате этого список символов '4', ',' , '8', '1', '2' который соответствует соответственно к целым значениям 52 44 56 49 50 это именно то, что вы получаете.

Вы должны объявить целочисленную матрицу вместо массива строк int [,] arr = new int[100,100]; или даже лучше List<List<int>>. Вы не можете использовать целые числа, такие как строки, по крайней мере, не в этом контексте.

List<List<int>> arr = new List<List<int>>(); 
arr.Add(new List<int>{4,8,10,11,12,14}); 
arr.Add(new List<int>{1,2,3,4,8,12,14}); 
var intersection = arr[0].Intersect(arr[1]); 

Но если вы не верите мне, и хотите быть уверены, что ваш предыдущий код не имеет смысла, изменить цикл foreach и посмотреть, что происходит:

foreach (char value1 in intersect) 
{ 
    //perform logic 
} 

Кроме того, вам не нужно делать это:

int zero= Convert.ToInt32(com[0].ToString()); 
int one= Convert.ToInt32(com[1].ToString()); 

вы могли бы заменить его чем-то вроде:

int zero= com[0]; 
int one = com[1]; 

но все это бессмысленно, так как вы можете сделать это:

arr[com[0]] 
arr[com[1]] 

Answer 2

LINQ Intersect метод корректно вычисляет пересечение между массивами:

var a = new [] {4,8,10,11,12,14}; 
var b = new [] {1,2,3,4,8,12,14}; 
var intersection = a.Intersect(b); 
// intersection: 
// IEnumerable<int> { 4, 8, 12, 14 } 

приведенный выше код - который представляет собой минимальную без неудачу счетчик пример - был запущен в LINQPad.

Обратите внимание, что Intersect полагается на равных, так что можно «сломать» его:

var a = new object[] {4,8,10,11,12,14}; 
var b = new object[] {"1","2","3","4","8","12","14"}; 
var intersection = a.Intersect(b); 
// intersection: 
// IEnumerable<object> { } 

Конечно, это не счетов для «случайных новых ценностей» - это просто ошибка в другом месте.