c# - 依次选择所有元素的索引

Question

使用 LINQ，我可以编写一个返回项目索引的 IEnumerable 的语句。

非常简单的例子：

{1,2,4,5,3}

只会回来

{0,1,2,3,4}

和

{1,2,4,5,3}.Where(num => num == 4)

会回来

{2}

这不是确切的代码，但它应该可以理解这个想法。

Answer 1

var a = new[] {1, 2, 4, 5, 3};

//** First, generates a simple sequence with {0,1,2,3,4} 
//** using the 2 parameter lambda select

var sequence1 = a.Select((_, index) => index);

//** Second, gets an array with all indexes where the value is 4.

// We need both value and index for the next line to work.
var sequence2 = a.Select((value, index) => new {value, index});

// Get all indexes where the value is 4
var indexArray = sequence2.Where(x => x.value == 4)
                          .Select(x => x.index).ToArray();

Answer 2

var numbers = Enumerable.Range(1,10).ToList();

int index = -1;

var indices = numbers.Select(x => i++).ToList();

Answer 3

IEnumerable<int> seq = new[] { 1, 2, 4, 5, 3 };

// The indexes of all elements.
var indexes = Enumerable.Range(0, seq.Count());

// The index of the left-most element with value 4.
// NOTE: Will return seq.Count() if the element doesn't exist.
var index = seq.TakeWhile(x => x != 4).Count();

// The indexes of all the elements with value 4.
// NOTE: Be careful to enumerate only once.
int current_index = 0;
var all_indexes =
    from e in (
        from x in seq
        select new { x, Index = current_index++ }
    )
    where e.x == 4
    select e.Index;

Answer 4

完整的索引集仅取决于项目的数量，而不是值，因此您可以这样做：

IEnumerable<int> indices = Enumerable.Range(0, 5);

如果您正在处理IEnumerable<T>，您可以执行以下操作来获取匹配 4 的项目的索引：

IEnumerable<int> values = new[] { 1, 2, 3, 4, 5 };
int indexOf4 = (
    values.Select((v, i) => new {v, i})
          .FirstOrDefault(vi => vi.v == 4) ?? new {v = 0, i = -1}).i;

这应对了值源不包含匹配项（返回 -1）的情况。

当然，如果您不介意将您IEnumerable<T>的列表转换为列表，那么您可以致电IndexOf：

int indexOf4a = values.ToList().IndexOf(4);

---

但是，我怀疑这个问题真正要寻找的是一种方法来查找与特定谓词匹配的值的所有索引。例如：

IEnumerable<int> big = values.Select((v, i) => new {v, i})
                             .Where(vi => vi.v > 3)
                             .Select (vi => vi.i);

它返回值的索引> 3：[3, 4]。

如果谓词不匹配任何值，那么您将得到一个空的可枚举结果。

Answer 5

如果您愿意稍微更改语法并使用扩展方法，则以下内容将起作用。我不喜欢它，因为它会为每次通话创建一个新序列。

var sequence = new[] { 1, 2, 4, 5, 3 };

sequence.Indexer().Select(num => num.Item1); // returns {0,1,2,3,4}
sequence.Indexer().Where(num => num.Item2 == 4).Select(num => num.Item1); // returns {2}

private static IEnumerable<Tuple<int, T>> Indexer<T>(this IEnumerable<T> sequence)
{
    return sequence.Select((x, y) => new Tuple<int, T>(y, x));
}

更好的方法是完全改变你编写它的方式：

var sequence = new[] { 1, 2, 4, 5, 3 };

sequence.Select((num, index) => new { Num = num, Index = index }).Select(num => num.Index); // returns {0, 1,2,3,4}
sequence.Select((num, index) => new { Num = num, Index = index }).Where(num => num.Num == 4).Select(num => num.Index); // returns {2}

Answer 6

你可以这样做：

public static IEnumerable<int> WhereIndices<T>(this IEnumerable<T> source, Func<T, bool> predicate)
{
    return source.Select(Tuple.Create<T, int>)
        .Where(z => predicate(z.Item1)).Select(z => z.Item2);
}

它是一个扩展方法，所以把它放在一个静态的非嵌套类中。就像你使用它一样使用它Where，即：

.WhereIndices(num => num == 4)

Answer 7

这应该这样做。虽然不确定它的效率如何..

List<int> list = new List<int>()
{
    1,
    2,
    3,
    4,
    5
};

var indexes = list.Select(item => list.IndexOf(item));

var index = list.Where(item => item == 4).Select(item => list.IndexOf(item));