C# intersect with lists

Question

Working on a leetcode.com problem I tried the following approach with included the correct results with one duplicate. The code is supposed to find all possibilities of 3 numbers that equal zero without any duplicates.

I am looking for dupes in a list of lists using this if statement: if(!returnList.Where(x=>x.Intersect(fullResult).Count()==3).Any())

This filters dupes in all but one case. Does anyone know why or perhaps a better way to eliminate dupes from a list of lists?

it will consistently not filter -1, -1, 2 which is a valid set but returned 2 times.

Paste into a console app to recreate.

class Program
{
    static void Main(string[] args)
    {
        var output = ThreeSum(new int[] { -1, 0, 1, 2, -1, -4 });
        foreach(var outie in output)
        Console.WriteLine(String.Format("{0}, {1}, {2}", outie[0], outie[1], outie[2]));

        Console.Read();

    }
    static public IList<IList<int>> ThreeSum(int[] nums)
    {

        List<int> lookup = new List<int>();
        foreach (int i in nums)
        {
            lookup.Add(i);
        }

        IList<IList<int>> returnList = new List<IList<int>>();
        for (var i = 0; i < nums.Count(); i++)
        {

            var result = TwoSum(i, lookup);
            if (result != null)
            {
                var fullResult = new List<int>() { nums[i], nums[result[0]], nums[result[1]] };

                if(!returnList.Where(x=>x.Intersect(fullResult).Count()==3).Any())
                {
                    returnList.Add(fullResult);
                }
            }
        }
        return returnList;
    }

    static private int[] TwoSum(int thirdnumIndex, List<int> nums)
    {

        var target = nums[thirdnumIndex];

        for (var i = 0; i < nums.Count(); i++)
        {
            var comp = (target + nums[i]) * -1;
            if (nums.Contains(comp))
            {
                var indexOfComp = nums.IndexOf(comp);

                if (indexOfComp == i || indexOfComp == thirdnumIndex)
                {
                    return null;
                }

                return new int[] { i, indexOfComp };
            }

        }
        return null;
    }
}

Answer 1

Using Sort and SequenceEqual should work

using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
    public static void Main(string[] args)
    {
        var output = ThreeSum(new int[] { -1, 0, 1, 2, -1, -4 });
        foreach (var outie in output)
        {
            Console.WriteLine($"{outie[0]}, {outie[1]}, {outie[2]}");
        }

        Console.Read();

    }
    private static IList<IList<int>> ThreeSum(int[] nums)
    {
        var lookup = new List<int>(nums);
        var returnList = new List<IList<int>>();

        for (var i = 0; i < nums.Length; i++)
        {
            var result = TwoSum(i, lookup);
            if (result != null)
            {
                var fullResult = new List<int> { nums[i], nums[result[0]], nums[result[1]] };
                fullResult.Sort();
                if (!returnList.Any(b => b.SequenceEqual(fullResult)))
                {
                    returnList.Add(fullResult);
                }
            }
        }
        return returnList;
    }

    private static int[] TwoSum(int thirdnumIndex, List<int> nums)
    {
        var target = nums[thirdnumIndex];

        for (var i = 0; i < nums.Count; i++)
        {
            var comp = (target + nums[i]) * -1;
            if (nums.Contains(comp))
            {
                var indexOfComp = nums.IndexOf(comp);
                if (indexOfComp == i || indexOfComp == thirdnumIndex)
                {
                    return null;
                }

                return new[] { i, indexOfComp };
            }

        }
        return null;
    }
}