使用LINQ获取列表之间的差异并将其插入中间？

Question

假设我有这样一个列表: 1，4，6，8。

我想知道每一种不同的大小，有一个简单的LINQ解决方案吗？所以我会得到3，2，2(因为4-1，6-4，等等)的最终列表: 1,3,4,2,6,2,8。

有人知道我怎么用linq编码这个吗？对于我实际需要它们的内容，这是一个带有DateTime (而不是int)的结构列表。

Answer 1

还有另一个变体--使用这样的聚合扩展

var s = new List<int>(){1, 4, 6, 8};
var tt = s.Aggregate(new List<int>(), (a, b) => {
             if (a.Count % 2 != 0)
             {
                 a.Add(b - a[a.Count - 1]);
             }
             a.Add(b);
             return a; 
         });

更新Ver2

var s = new List<int>(){1, 4, 6, 8};
var tt = s.Aggregate(new List<int>(), (a, b) => {
             var c = new List<int>(a);
             if (c.Count % 2 != 0)
             {
                 c.Add(b - c[c.Count - 1]);
             }
             c.Add(b);
             return c; 
         });

带foreach的版本

var s = new List<int>(){1, 4, 6, 8};
var tt = new List<int>();
foreach(var i in s){
    if (tt.Count % 2 != 0)
        {
            tt.Add(i - tt[tt.Count - 1]);
        }
    tt.Add(i);
 }

带有for的版本

var s = new List<int>(){1, 4, 6, 8};
var tt = new List<int>(){s[0]};
for (int i=1;i<s.Count,i++){
     tt.Add(s[i] - s[i-1]);
     tt.Add(s[i]);
 }

Answer 2

因此，首先，我们可以使用一种方法，该方法可以获取任意序列，并将每一项与其前一项配对，这很容易为任何序列的一般情况编写：

public static IEnumerable<TResult> Pairwise<TSource, TResult>(
    this IEnumerable<TSource> source,
    Func<TSource, TSource, TResult> resultSelector)
{
    using (var iterator = source.GetEnumerator())
    {
        if (!iterator.MoveNext())
            yield break;
        var previous = iterator.Current;
        while (iterator.MoveNext())
        {
            yield return resultSelector(previous, iterator.Current);
            previous = iterator.Current;
        }
    }
}

使用它，我们现在可以编写：

var differences = list.Pairwise((prev, next) => (prev - next));

Answer 3

我最喜欢的解决方案是使用拉链。

var result = list.Zip(list.Skip(1), (current, next) => Math.Abs(next - current))

这将获得一个列表和那个没有第一个元素的列表，并对它们进行迭代，而这两个元素都有当前位置的一个元素，从而产生每对之间差的绝对值。

编辑:刚刚意识到你想把它插回里面。那样的话..。

var result = 
  list
    .Zip(list.Skip(1), (current, next) => new[]{current, current - next, next})
    .SelectMany(x => x);

...could是你想要的，虽然现在变得越来越混乱。最好是压缩到一个新对象，或者退出SelectMany，这样您就可以拥有单独的{current, difference, next}集合，因为这些集合将更容易处理。