如何检测“丢失”的信息？ IEnumerable中的元素？

Question

我有一个 IEnumerable ，其中包含在其中一个属性中具有一致间隔的数据元素列表：

List<Interval> list = new List<Interval>
            { 
                new Interval{ TIME_KEY = 600},
                new Interval{ TIME_KEY = 605},
                new Interval{ TIME_KEY = 615},
                new Interval{ TIME_KEY = 620},
                new Interval{ TIME_KEY = 630}
            };

如何查询此列表（最好使用 Linq），以获得看起来像的列表像这样：

 List<Interval> list = new List<Interval>
                { 
                    new Interval{ TIME_KEY = 610},
                    new Interval{ TIME_KEY = 625}
                };

？

编辑：我可能会知道间隔距离应该是多少，但是如果有一种方法可以通过检查数据来确定它，那将是一个巨大的好处！

编辑：更改为数值

Answer 1

看看这个问题，了解选择连续值的扩展方法。从那里，你可以做类似的事情：（

// I'd probably rename SelectBetween to SelectConsecutive
list.SelectConsecutive((x, y) => new { Original = x, Interval = y - x})
    .Where(pair => pair.Interval != 5)
    .Select(pair => new Interval(pair.Original + 5));

有点伪代码，但我希望你明白我要去哪里。）

但是，当它丢失时，只会生成一个元素......如果你从0 到 20，它不会生成 5、10、15。

为 Henk 的第二个建议添加一些内容：

var missing = Enumerable.Range(0, expectedElementCount)
                        .Select(x => new Interval(baseInterval + 5 * x)
                        .Except(list);

Answer 2

var newList = 
     Enumerable.Range(0, 6)
               .Select(r=> new Interval() {TIME_KEY = ((r*5)+600) })
               .Except(list )

Answer 3

一种高效且简单的方法就是使用 foreach 遍历该列表并检测间隙。
我认为 5 分钟节拍是固定的？

要使用 LINQ，您可以创建完整列表并找出差异，但这似乎有点过分了。

---

考虑第二部分，确定间隔：

从您的示例中，可能需要 3 或 4 个值的样本。但即使在检查了所有值之后，您也不能绝对确定。您的示例数据不排除具有大量缺失值的 1 分钟频率。

所以你需要关于这部分的非常好的规格。

Answer 4

如果间隔已知，并且您有权访问 Zip 方法（.NET 4 附带）：

list.Zip(list.Skip(1), (x,y) => new { x, delta = y - x })
    .SelectMany(a => Enumerable.Range(1, a.delta/interval - 1)
                               .Select(i => a.x + i*interval));

请注意，这会迭代列表两次，因此如果源是惰性可枚举，则需要先对其进行缓冲。使用 Zip 和 Skip 构建是将连续元素投影在一起的快速而肮脏的方法。 Reactive Extensions 的 System.Interactive 库有一个 Scan 方法为此，Jon 在另一个答案中展示了可能的实现。这些都不会迭代列表两次，因此它们将是更好的选择。

如果要确定间隔，您可以获得最小增量：

var deltas = list.Zip(list.Skip(1), (x,y) => y - x );
var interval = deltas.Min();
list.Zip(deltas, (x, delta) => new { x, delta })
    .SelectMany(a => Enumerable.Range(1, a.delta/interval - 1)
                               .Select(i => a.x + i*interval));

不过，我做了一些假设：

• 元素之间的所有差异都是间隔的倍数；
• 输入已排序。

它是如何工作的：

1. 首先，它用每个元素构建一个对序列，但最后一个元素和它后面的元素的间隔;
2. 然后，对于每一对，它都会生成增量内的所有缺失值：在每个增量内，恰好有 a.delta/interval - 1 值，并且每个值都相距一定数量的间隔来自对中的元素存储，因此 ax + i*interval 。
3. SelectMany 负责将所有这些缺失值序列展平为一个。

Answer 5

试试这个：

private static IEnumerable<Interval> CalculateMissingIntervals(IEnumerable<Interval> list, int step) {
  return list.Zip(list.Skip(1), 
    (i1, i2) => IntervalRange(i1.TIME_KEY + step, i2.TIME_KEY, step)).
    SelectMany(x => x);
}
private static IEnumerable<Interval> IntervalRange(int start, int end, int step) {
  for (var i = start; i < end; i += step) {
    yield return new Interval { TIME_KEY = i };
  }
}

假设初始列表已排序。

Answer 6

IEnumerable<Interval> missingIntervals =
    Enumerable.Range(list.Min(listMember => listMember.TIME_KEY), list.Max(listMember => listMember.TIME_KEY))
              .Where(enumMember => enumMember % intervalDistance == 0)
              .Select(enumMember => new Interval { TIME_KEY = enumMember}
              .Except(list);