Правильное определение того, существует ли IList в IList> ⇐ C#

[Anonymous]

Я использую 3 итератора для перебора объекта int[] и поиска списков, содержащих три целых числа, сумма которых равна 0, без добавления повторяющихся списков к конечному возвращаемому объекту. Как только итераторы находят допустимую последовательность, каждое значение массива, на которое указывает итератор, добавляется во временный объект IList с помощью синтаксиса, такого как «tempList.Add(nums[a]);» и т. д. Этот tempList затем добавляется к окончательному возвращаемому объекту IList.
Чтобы проверить наличие дубликатов, я использую следующий синтаксис:
if ((nums[c] + nums[a] + nums == 0) && !answerList.Contains(tempList))

{
answerList.Add(tempList);
}

Это работает, когда IList изначально пуст, однако второе предложение оценивается как «ложное» для следующего сценария, что предотвращает добавление допустимого tempList в IList Список ответов:
IList == [[-1,0,1]]
tempList == [-1,-1,2]

Нужно ли мне расширять интерфейс Comparable, чтобы исправить это? Я дважды проверил значения массива для a, b и c, и их общая сумма равна 0, поэтому я уверен, что именно сравнение .Contains вызывает проблему.
Вот код:

public IList ThreeSum(int[] nums) // maybe use three index pointers to fill triplet, one starting at index 0, one
// starting at index nums.Lenght - 1 and one starting near or at middle
// 5 billion possible combinations of triplets among array of 3001 triplets
{
IList tempList = new List();
IList answerList = new List();
int countPositive = 0;
int countNegative = 0;
bool addAnswerList = false;
int indexPositive = 0;
int a = 0;
int b = 0;
int c = 0;
bool aExtreme = false;
bool bExtreme = false;
bool cExtreme = false;

if (nums == null)
return answerList;

if (nums.Length == 0 /* || /* nums.Length < 3 */)
return answerList;

if (nums.Length == 1 && nums[0] == 0)
return answerList;

for (int i = 0; i < nums.Length; i++) // corner case where all array values are either postive or negative
// 0 sum triplet not possible
{
if (nums > 0)
countPositive++;
else if (nums < 0)
countNegative++;
}

if ((countPositive == nums.Length || countNegative == nums.Length) || (countNegative == 0 && countPositive == 0))
return answerList;

if (nums.Length < 51)
{
int temp = 0;

for (int i = 1; i < nums.Length; i++) // use recursive sort to go through 3001 elements, use linear if less than 51
{
temp = nums;
int j = i;

while (j > 0 && nums[j-1] > temp)
{
nums[j] = nums[j-1];
j--;
}

nums[j] = temp;

}

Console.WriteLine(String.Join(" ", nums));

}

else if (nums.Length > 50) // recursive sort for larger input array
{
mergeSort(nums);
}

// Now nums is storted, 0 sum triplet will most likely be found where entries change from negative to positive
for (int i = 0; i < nums.Length; i++)
{
if (nums > 0)
{
// toPositive = true;
indexPositive = i;
break;
}

}

Console.WriteLine(indexPositive);

if (indexPositive == 0) // case to make sure accessors do not get invalid number
{
a = 0; // initialize other two index accessors in addition to indexPositive
b = 0;
}
else
{
a = indexPositive - 1; // initialize other two index accessors in addition to indexPositive
b = indexPositive - 1;
}

c = indexPositive; // store initial indexPositive value into variable c as indexPositive will change
// throughtout the interation

// if indexPositive is less than (nums.Length / 2), iterate two other accessors towards end of nums
// else, interate two other accessors towards nums[0]

if (c < (nums.Length / 2)) // use iterator c in place of indexPositive
{
while (c < nums.Length && b < nums.Length && a >= 0)
{

if (a == 0 || a == nums.Length - 3)
{
aExtreme = true;
}
else
{
aExtreme = false;
}

if (b == 1 || b == nums.Length - 2)
{
bExtreme = true;
}
else
{
bExtreme = false;
}

if (c == 2 || c == nums.Length - 1)
{
cExtreme = true;
}
else
{
cExtreme = false;
}

if ((c != a && c != b && a != b) && (nums[c] + nums[a] + nums == 0)) // if nums add to 0, add them to tempList
{
tempList.Add(nums[a]);
tempList.Add(nums);
tempList.Add(nums[c]);
}

// need to check if exact triplet is duplicate or if tempList triplet contains same 3 values in different order
// 3 values in different order not an issues since input list is already sorted!!!!
// but need to be aware order accessors are added to temp list. Accessors cannot "crossover" one another!!!
if ((nums[c] + nums[a] + nums == 0) && !answerList.Any(x => x.SequenceEqual(tempList)) /*!answerList.Contains(tempList)*/)
// Having issues, answerList.Contains does not currently do what is desired
{
answerList.Add(tempList); // add tempList to answerList
addAnswerList = true;
}

else
{
addAnswerList = false;
}

tempList.Clear(); // clear tempList to prepare for next entry

// Make changes here to make sure only 1 accessor iterates at a time, to check all possible and logical combinations
// Since array is now sorted, iteration towards sums[0] only has to continue if sum of 3 accessors is greater than 0
// Once active accessor returns a value that results in 0 sum, further iteration is guaranteed to return
// an identical triplet or one that sums to less than 0. At this point, the two accessors that are going in the same
// direction should be iterated by 1 position and the cycle repeated

if (nums[a] + nums + nums[c] < 0) // still have chance to get to 0 value triplet with rightmost accessor

{
c++;
}

else if ((addAnswerList == true) || nums[a] + nums + nums[c] > 0) // no point in further iteration,
// reset 'c' accessor to original starting
// position and decrement other accessors by 1
// towards first array element
{ // to begin cycle again
c = indexPositive - 1;
b--;
a--;
}

}

}

else // a and b accessors are interated towards 0
{
while (c < nums.Length && a >= 0 && b >= 0)
{
if (a == 0 || a == nums.Length - 3)
{
aExtreme = true;
}
else
{
aExtreme = false;
}

if (b == 1 || b == nums.Length - 2)
{
bExtreme = true;
}
else
{
bExtreme = false;
}

if (c == 2 || c == nums.Length - 1)
{
cExtreme = true;
}
else
{
cExtreme = false;
}

if ((c != a && c != b && a != b) && (nums[c] + nums[a] + nums == 0)) // if nums add to 0, add them to tempList
// need to check if exact triplet is duplicate
{
tempList.Add(nums[a]);
tempList.Add(nums);
tempList.Add(nums[c]);
}

Console.WriteLine(String.Join(" ", tempList));

// need to check if exact triplet is duplicate or if tempList triplet contains same 3 values in different order
// 3 values in different order not an issues since input list is already sorted!!!!
// but need to be aware order accessors are added to temp list. Accessors cannot "crossover" one another!!!
if ((nums[c] + nums[a] + nums == 0) && !answerList.Any(x => x.SequenceEqual(tempList)))
// Having issues, answerList.Contains does not currently do what is desired
{
answerList.Add(tempList); // add tempList to answerList
addAnswerList=true;
}

else
{
addAnswerList = false;
}

tempList.Clear(); // clear tempList to prepare for next entry

// Make changes here to make sure only 1 accessor iterates at a time, to check all possible and logical combinations
// Since array is now sorted, iteration towards sums[0] only has to continue if sum of 3 accessors is greater than 0
// Once active accessor returns a value that results in 0 sum, further iteration is guaranteed to return
// an identical triplet or one that sums to less than 0. At this point, the two accessors that are going in the same
// direction should be iterated by 1 position and the cycle repeated

if (nums[a] + nums + nums[c] > 0) // still have chance to get to 0 value triplet with
// leftmost accessor
{
a--;
}

else if ((addAnswerList == true) || nums[a] + nums[b] + nums[c] < 0) // no point in further iteration,
// reset 'a' accessor to original starting
// position and increment other accessors by 1
// towards last array element
{ // to begin cycle again
a = b; // a = indexPositive - 1;

if ((bExtreme == false && b < nums.Length - 2) && (cExtreme == false && c < nums.Length - 1))
// if there is still room to run towards end of array, increment, else decrement
{
b++;
c++;
}
else
{
bExtreme = true;
cExtreme = true;
a -= 2;
b--;

}

}
}
}

Console.WriteLine(String.Join(" ", answerList));
return answerList;

}

public void merge(int[] array1, int[] array2, int[] outArray)
{
int i = 0;
int j = 0;

while (i + j < outArray.Length)
{
if (j == array2.Length || (i < array1.Length && (array1 < array2[j])))
{
outArray[i + j] = array1[i++];
}

else
{
outArray[i + j] = array2[j++];
}
}
}

public void mergeSort(int[] inputArray)
{
if (inputArray.Length < 2)
return;

int[] firstHalf = new int[inputArray.Length / 2];
int[] secondHalf = new int[inputArray.Length / 2];

for (int i = 0; i < (inputArray.Length / 2); i++)
{
firstHalf = inputArray;
}

for (int i = inputArray.Length / 2; i < inputArray.Length; i++)
{
secondHalf = inputArray;
}

mergeSort(firstHalf);
mergeSort(secondHalf);

merge(firstHalf, secondHalf, inputArray);

}


Подробнее здесь: https://stackoverflow.com/questions/712 ... stilistint