C# C语言中动态列表数的比较#

我有一个可变数量的列表对象，我需要比较相同索引中的值。列表中的条目数是给定的，并且没有变化

例如： 4个列表 每4个条目

在这个例子中，我要寻找的是4个布尔值，每个索引一个布尔值。 获取不匹配项的索引也可以

伪：

但我需要以一种适用于可变数量列表的方式来做这件事。我可以有6个列表，但也可以有2个

我想用LINQs

.Except（）

做点什么，但不知道如何在数量可变的列表中使用它

我正在努力寻找一个优雅的解决方案，我确信它就在那里。 非常感谢您的帮助。

bool-AreIndexesEqual（int-index，List-List）
bool AreIndexesEqual(int index, List<List<int>> lists)
{
    int match = lists[0][index];

    foreach(List<int> list in lists.Skip(1))
    {
        if (list[index] != match)
        {
            return false;
        }
    }

    return true;
}

{
int match=列表[0][index]；
foreach（列表中的列表。跳过（1））
{
如果（列表[索引]！=匹配）
{
返回false；
}
}
返回true；
}

如果我理解你的意思，像这样的方法可能会奏效

public static bool IsEqual<T>(int index, params List<T>[] ary)
{
   for (var i = 1; i < ary.Length; i++)
      if (!EqualityComparer<T>.Default.Equals(ary[0][index], ary[i][index]))
         return false;         

   return true;
}

更新

var isSecondelemEqual = IsEqual(1, list1, list2, list3,...)

基本上是一个列表的可变列表，并假设您希望检查每个列表的索引是否相互对应。

例如：

List<List<int>> listOfLists = new List<List<int>>
{
    new List<int> { 1, 100, 2},
    new List<int> { 2, 100, 3},
    new List<int> { 3, 100, 4},
    new List<int> { 4, 100, 5},
};

请注意，这两个程序都可以简化：

newint[0]。All（x=>something）=true

，因此

。空
IEnumerable
上的All（）

为

true

。您可以删除

listOfLists.Count在这里

IEnumerable<bool> CompareAll<T>(IEnumerable<IEnumerable<T>> source)
{
    var lists = source.ToList();
    var firstList = lists[0];
    var otherLists = lists.Skip(1).ToList();

    foreach(var t1 in firstList)
    {
        yield return otherlists.All(tn => tn.Equals(t1));
    }
}

IEnumerable CompareAll（IEnumerable源代码）
{
var list=source.ToList（）；
var firstList=lists[0]；
var otherLists=lists.Skip（1.ToList（）；
foreach（第一个列表中的变量t1）
{
收益率回报率：所有（tn=>tn.Equals（t1））；
}
}
你能想出一个解决方案吗？不用linq就可以了。我看不出有什么问题。没有医生告诉过你需要林克<代码>for（int i…）

对于一代又一代的程序员来说已经足够好了，他们对你来说也足够好了。因为我没有逻辑，我不能。我需要根据索引比较字符串列表。如果我有一个完整的例子，这个问题就没有必要了。我可以粘贴一些代码来制作一些列表。。不确定这是否有帮助。另外，如果不使用linq，我在这方面的逻辑上很困难，因为它需要处理2个列表和6个列表。但是是的，我可能不会最终使用linq。如果列表或序列的长度不同怎么办？不应该

ary.Length

是

ary[index].Count

？，因为然后你使用

ary[index][i]

，所以

0@xanatos-hrm混淆了长度、计数，是的，到最后一位，让我检查一下，我在猜测我自己now@xanatos我的索引方法是错误的，我想他是不是想检查每个列表的索引？长度是param数组的长度，还是我都弄错了？很好的解释，谢谢！是的，林克不是万能的。。仍然很酷，它可能是xD
List<bool> result = Enumerable.Range(0, listOfLists.Count != 0 ? listOfLists[0].Count : 0)
            .Select(x => listOfLists.Count <= 1 ? 
                true : 
                listOfLists.Skip(1).All(y => y[x] == listOfLists[0][x])
            ).ToList();

var result2 = new List<bool>(listOfLists.Count != 0 ? listOfLists[0].Count : 0);

// Note the use of .Capacity here. It is listOfLists.Count != 0 ? listOfLists[0].Count : 0
for (int col = 0; col < result2.Capacity; col++)
{
    if (listOfLists.Count <= 1)
    {
        result2.Add(true);
    }
    else
    {
        bool equal = true;

        for (int row = 1; row < listOfLists.Count; row++)
        {
            if (listOfLists[row][col] != listOfLists[0][col])
            {
                equal = false;
                break;
            }
        }

        result2.Add(equal);
    }
}

var result2 = new List<bool>(listOfLists.Count != 0 ? listOfLists[0].Count : 0);

// Note the use of .Capacity here. It is listOfLists.Count != 0 ? listOfLists[0].Count : 0
for (int col = 0; col < result2.Capacity; col++)
{
    bool equal = true;

    for (int row = 1; row < listOfLists.Count; row++)
    {
        if (listOfLists[row][col] != listOfLists[0][col])
        {
            equal = false;
            break;
        }
    }

    result2.Add(equal);

}

IEnumerable<bool> CompareAll<T>(IEnumerable<IEnumerable<T>> source)
{
    var lists = source.ToList();
    var firstList = lists[0];
    var otherLists = lists.Skip(1).ToList();

    foreach(var t1 in firstList)
    {
        yield return otherlists.All(tn => tn.Equals(t1));
    }
}