C# 在C中使用LINQ从列表中确定较低的值#

我有一个包含四个双值的列表

var numbers2 = new List<double>() { 2, 3, 9, 7 };

var numbers2=newlist（）{2,3,9,7}；

我需要在前两个索引（2和3）之间获得较低的值。 同样，我需要得到索引3和4（9和7）之间的较低值

在C夏普中有没有一种方法可以使用LINQ来确定这一点？ 一旦我得到上面列表中的较低值，即2和7；我需要在下面的循环中传递这些值

for (int i = 0; i < 1; i++)
{
    dac[i] = SetValue(lowerValue[j]); 
}

for（int i=0；i<1；i++）
{
dac[i]=设定值（下限值[j]）；
}

---

如果

i==0

，我希望

lowerValue[j]=2

。如果

i==1

，我希望

lowerValue[j]=7

正如其他人所指出的，似乎没有任何理由使用linq。但如果你一定要想办法，那是可能的。我会抛出3个选项，最后一个是linq

using System;
using System.Linq;
using System.Collections.Generic;
        
public class Program
{
    public static void Main()
    {
        var numbers2 = new List<double>() { 2, 3, 9, 7 };
        
        // you stated it's always 4 values.  There's no reason to use linq. The optimal solution would 
        // be a variation of this (with some constant values instead of magic numbers)..
        
        var first = Math.Min(numbers2[0],numbers2[1]);
        var second = Math.Min(numbers2[2],numbers2[3]);
        
        Console.WriteLine($"Lower values: {first},{second}");
        
        // if it was an arbitry sized list (but always even count) you could use a iterator method
        var listOfLowerValues = ToPairs(numbers2);
        
        var values = string.Join(",", listOfLowerValues.Select(x => x.ToString()));
        
        Console.WriteLine($"Lower values: {values}");
        
        // finally if you absolutely had too, you can make it even more inefficient
        // by using linq.
        
        var indexes = Enumerable.Range(0, numbers2.Count);
        var indexed = numbers2.Zip(indexes, (n,i) => (index: i, num: n));
        var odd = indexed.Where(x => x.index%2 == 0).Select(x => x.num).ToArray();
        var even = indexed.Where(x => x.index%2 > 0).Select(x => x.num).ToArray();
            
        var lower = even.Zip(odd,(v1,v2)=> v1 < v2 ? v1 : v2);
        
        var valuesByLinq = string.Join(",",lower.Select(x => x.ToString()));
        
        Console.WriteLine($"Lower values: {valuesByLinq}");
    }
    
    static IEnumerable<double> ToPairs(IEnumerable<double> source)
    {
        int index = 0;
        double previous = 0;
        foreach(var n in source)
        {
            if(index++%2 > 0)
            {
                yield return (previous < n) ? previous : n;
            }
            else
            {
                previous = n;
            }
        }
    }
}

使用系统；
使用System.Linq；
使用System.Collections.Generic；
公共课程
{
公共静态void Main（）
{
var numbers2=新列表（）{2,3,9,7}；
//您说过它总是4个值。没有理由使用linq。最佳解决方案是
//这是一个变体（使用一些常量值而不是幻数）。。
var first=Math.Min（numbers2[0]，numbers2[1]）；
var second=Math.Min（numbers2[2]，numbers2[3]）；
WriteLine（$“较低的值：{first}，{second}”）；
//如果是任意大小的列表（但总是偶数），则可以使用迭代器方法
var listOfLowerValues=ToPairs（数字2）；
var values=string.Join（“，”，listOfLowerValues.Select（x=>x.ToString（））；
WriteLine（$“下限值：{values}”）；
//最后，如果你确实有太多，你可以使它更低效
//通过使用linq。
var索引=可枚举的范围（0，numbers2.Count）；
var index=numbers2.Zip（索引，（n，i）=>（索引：i，num:n））；
var odd=index.Where（x=>x.index%2==0）。选择（x=>x.num）.ToArray（）；
var even=index.Where（x=>x.index%2>0）。选择（x=>x.num.ToArray（）；
var lower=偶数.Zip（奇数，（v1，v2）=>v1x.ToString（））；
WriteLine（$“较低的值：{valuesByLinq}”）；
}
静态IEnumerable ToPairs（IEnumerable源）
{
int指数=0；
双倍上一次=0；
foreach（源中的变量n）
{
如果（索引+++%2>0）
{
收益率回报率（上一次

如果

i=0

，则比较索引

0

和

1

处的值。如果

i=1

，则比较索引

2

和

3

处的值。你能辨认出图案吗？您看到的是

numbers2[i*2]

和

numbers2[i*2+1]

。您可以使用

Math.Min

或仅使用

I know the pattern查找两个值中的较低值。但是，我想使用LINQ确定较低的值。我还想避免在I=0、lowerValue=index 0Linq不适合这种情况下进行编写：没有内置的方法来获取每一对元素，因此您必须编写自己的方法。我不是建议写“如果I=0，lowerValue=numbers2[0]”，我是建议写“lowerValue=Math.Min（numbers2[I*2]，numbers2[I*2+1]）”听起来像是你想要的，或者与@canton7一起写，这不会起作用，因为lowerValue是double，它会给我一个错误，“无法从double转换为int”