依次选择所有元素的索引

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

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

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 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

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 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));