Question

我想要最后一个负值之后的所有正整数值。
以下是 Integer 值的列表：

List<int> lst = new List<int>();
lst.Add(1);
lst.Add(3);
lst.Add(5);
lst.Add(-3);
lst.Add(4);
lst.Add(-4);
lst.Add(5);
lst.Add(6);

我尝试了

lst.Skip(lst.Max(0, lst.Count - 1)).ToList();

预期产量

Last positive values after last negative value:  
in example list last negative value is -4
and last positive values are 5, 6,
So I want 5 and 6 from given list

Answer 1

因为它是列表，所以您可以使用FindLastIndex

    .separation(function(a, b) { return (a.parent == b.parent ? 1 : 10) / a.depth; });

这也可以处理没有负值或者在开始或结束时出现负值的情况。

Answer 2

要获取最后一个负数之后的所有值，您可以

var positivesAfterLastNegative = lst.Reverse().TakeWhile(x => x >= 0).Reverse().ToList()

从结尾开始，直到找到负数，然后反转结果，以便它们以正确的顺序返回。

注意：我只建议使用列表或数组来执行此操作。对于某些需要反复进行直到最后的事情，它的性能将会很差。在这种情况下，您可以改为执行以下操作。

List<int> results = new List<int>();
foreach(var item in lst)
{
    if(item < 0)
    {
        results.Clear();
    }
    else
    {
        results.Add(item);
    }
}

这会将非负值添加到列表中，直到达到负值，然后将清除列表，仅产生最后一个负值之后的值。

如果您希望使用非Linq解决方案来建立索引，则可以执行此操作

List<int> results = new List<int>();
for(int i = lst.Count - 1; i >= 0; i--)
{
    if(lst[i] < 0)
    {
        break;
    }

    results.Insert(0,item);
}

Answer 3

这里有一个班轮：

var result = list.Reverse().TakeWhile(x=> x > 0).Reverse().ToList();

Answer 4

使用LastOrDefault查找最后一个负数，然后通过从index + 1跳过来获取值

var rs = lst.Select((s,i) => new { n = s, index = i })
   .LastOrDefault(x => x.n < 0);    
return lst.Skip(rs.index + 1);

Answer 5

使用Linq：

int result = (lst as IEnumerable<int>).Reverse().TakeWhile(x => x >= 0).Last();

如果列表末尾只有一个负值，则可能引发异常。但是，我不知道列表中可以包含哪些数据，因此无法为您提供完美的解决方案。

Answer 6

也许有两个SkipWhile呼叫：

var listy = new List<int> { 1, 2, 3, -4, -5, 6, 7 };
listy.SkipWhile(x => x >= 0).SkipWhile(x => x < 0)

这将跳过直到遇到负值，然后跳过负值直到遇到正值。但是，如果您有许多交替的负数和正数，则需要使用其他方法。从积极的角度来看，这不必多次迭代列表，例如对Reverse

的调用

结果给与

SkipWhileIterator { 6, 7 }

Answer 7

快速而又肮脏的解决方案，仅针对数组和列表利用LINQ优化。这很脏，因为it copies the source's contents进入了缓冲区：

    list.AsEnumerable().Reverse().TakeWhile(it=>it>0).Reverse();

与每个IEnumerable一起工作的不仅是列表，而且仅对IEnumerable进行一次迭代的事情：：

var finalList=list.Aggregate(
                  new List<int>(),
                  (lst,it)=>{
                              if (it<0)
                              {
                                 return new List<int>();
                              }
                              else
                              {
                                  lst.Add(it);
                                  return lst;
                              }
                 });

这使用带有空白列表的Aggregate作为累加器。只要元素不是负数，就将它们添加到累加器中。当发现新的负数时，累加器将被丢弃，并且操作将再次开始。

当然。最快的方法是使用lst.FindLastIndex(i => i < 0)

从头开始搜索

如何获得列表中最后一个负值之后的正值？

7 个答案: