C# 查找值类似于列表中的任何值

如何检查我正在查看的值

I

是否等于或在列表中的数字范围内

---

例如，我在列表中有一个数字

I=2

，还有一个数字

I=2.1

，我不想在列表中添加

I=2

，因为它们是非常相似的数字。我很难找到一个干净的方法来做这件事。有什么建议吗？

测试某个值是否在某个范围内的常用方法正在使用。例如，如果您正在从

2

查找

0.5

中的所有数字，您可以按如下方式找到它们：

var target = 2;
var tolerance = 0.5;
var twoPlusMinusHalf = list.Where(x => Math.Abs(x-target) <= tolerance).ToList();

var目标=2；
var公差=0.5；
var twoPlusMinusHalf=list。其中（x=>Math.Abs（x-target）正在使用一种测试某个值是否在某个范围内的常用方法。例如，如果您正在从
2
中查找
0.5
范围内的所有数字，您可以按如下方式找到它们：

var target = 2;
var tolerance = 0.5;
var twoPlusMinusHalf = list.Where(x => Math.Abs(x-target) <= tolerance).ToList();

var目标=2；
var公差=0.5；
var twoPlusMinusHalf=list.Where（x=>Math.Abs（x-target）正如希尔在他们的评论中提到的，您必须确定“相似数字”对您意味着什么，然后实现该逻辑

例如，您需要执行一个简单的
if
检查，看看数字是否在所需的范围内

if (i >= 2 && i < 2.2)
    listName.Add(i);

如果（i>=2&&i<2.2）
添加（i）；
正如希尔在他们的评论中提到的，你必须确定“相似数字”对你意味着什么，然后实现这个逻辑

例如，您需要执行一个简单的
if
检查，看看数字是否在所需的范围内

if (i >= 2 && i < 2.2)
    listName.Add(i);

如果（i>=2&&i<2.2）
添加（i）；
在添加之前，您可以检查任何类似的值。用LINQ精确表示：

var list = new List<double> { 2.1, 4, 5, 5.1 };
var i = 2;
var e = 0.5;

var hasSimilar = list.Any(x => Math.Abs(x - i) <= e);
if(!hasSimilar)
    list.Add(i);

var list=新列表{2.1,4,5,5.1}；
var i=2；
var e=0.5；
var hasSimilar=list.Any（x=>Math.Abs（x-i）在添加之前，您可以检查任何类似的值。用LINQ精确地表示：

var list = new List<double> { 2.1, 4, 5, 5.1 };
var i = 2;
var e = 0.5;

var hasSimilar = list.Any(x => Math.Abs(x - i) <= e);
if(!hasSimilar)
    list.Add(i);

var list=新列表{2.1,4,5,5.1}；
var i=2；
var e=0.5；
var hasSimilar=list.Any（x=>Math.Abs（x-i）
list myList=newlist（）；
//构建列表
双ε=0.5；
双新值=。。。；
bool addToList=true；
foreach（双值：myList）
if（Math.Abs（val-newValue）
List myList=new List（）；
//构建列表
双ε=0.5；
双新值=。。。；
bool addToList=true；
foreach（双值：myList）
if（Math.Abs（val-newValue）
如果您希望使用负数，请不要使用Abs，尝试使用地板或天花板

    Double i = 4;
    List<double> ListOfNumbers = new List<double>();
    Double Floored = Math.Floor(i);

    if (!ListOfNumbers.Contains(Floored))
    {//If not found add the number for later
        ListOfNumbers.Add(Floored);
    }

Double i=4；
List listofNumber=新列表（）；
双地板=数学地板（i）；
如果（！ListofNumber.Contains（地板））
{//如果找不到，请为以后添加号码
编号列表。添加（地板）；
}
如果您希望使用负数，请不要使用Abs，尝试使用地板或天花板

    Double i = 4;
    List<double> ListOfNumbers = new List<double>();
    Double Floored = Math.Floor(i);

    if (!ListOfNumbers.Contains(Floored))
    {//If not found add the number for later
        ListOfNumbers.Add(Floored);
    }

Double i=4；
List listofNumber=新列表（）；
双地板=数学地板（i）；
如果（！ListofNumber.Contains（地板））
{//如果找不到，请为以后添加号码
编号列表。添加（地板）；
}
试试这个

        List<double> list = new List<double>();
        list.Add(1);
        list.Add(2.1);
        list.Add(3.5);
        list.Add(4.9);
        list.Add(5);

        double i=2;

        int cnt = 0;
        foreach(var item in list)
        {
            if(i==item || i==(item-0.1))
            {
                cnt = 1;
            }
        }

        if(cnt<1)
        {
            list.Add(i);
        }

List List=新列表（）；
增加第（1）款；
列表。添加（2.1）；
列表。添加（3.5）；
列表。添加（4.9）；
增加（5）；
双i=2；
int-cnt=0；
foreach（列表中的变量项）
{
如果（i==项目| | i==（项目-0.1））
{
cnt=1；
}
}
如果（cnt试试这个

        List<double> list = new List<double>();
        list.Add(1);
        list.Add(2.1);
        list.Add(3.5);
        list.Add(4.9);
        list.Add(5);

        double i=2;

        int cnt = 0;
        foreach(var item in list)
        {
            if(i==item || i==(item-0.1))
            {
                cnt = 1;
            }
        }

        if(cnt<1)
        {
            list.Add(i);
        }

List List=新列表（）；
增加第（1）款；
列表。添加（2.1）；
列表。添加（3.5）；
列表。添加（4.9）；
增加（5）；
双i=2；
int-cnt=0；
foreach（列表中的变量项）
{
如果（i==项目| | i==（项目-0.1））
{
cnt=1；
}
}
如果（cnt如果您创建如下自定义比较器：

class CloseEnough : IEqualityComparer<double>
{
    public bool Equals(double a, double b)
    {
        return Math.Abs(a - b) <= 0.5;
    }

    public int GetHashCode(double a)
    {
        return 2 * (Convert.ToInt32(a) / 2);
    }
}

上面的结果是
set=={1,1.6,2.11,10}


请注意，
closevery.GetHashCode（）
很有趣。相等的两个元素必须具有相同的哈希代码。如果在生产代码中使用此代码，则需要测试此代码是否始终为真。
如果创建如下自定义比较器：

class CloseEnough : IEqualityComparer<double>
{
    public bool Equals(double a, double b)
    {
        return Math.Abs(a - b) <= 0.5;
    }

    public int GetHashCode(double a)
    {
        return 2 * (Convert.ToInt32(a) / 2);
    }
}

上面的结果是
set=={1,1.6,2.11,10}


请注意，
closevery.GetHashCode（）
很有趣。相等的两个元素必须具有相同的哈希代码。如果在生产代码中使用此代码，则需要测试此代码是否始终为真。
您需要决定“close”是什么在您的情况下是指。之后，只需在列表中循环查看数字是否“接近”。请定义在这种情况下“相似”应该是什么。只有这样，才有可能找到解决方案。“相似”和“接近”是任意的。对于这种情况，假设
0.5
。我如何检查列表中的值是否在该范围内，以便确定是将该值添加到列表中，还是放弃该值？您需要决定“关闭”的内容在您的情况下是指。之后，只需在列表中循环查看数字是否“接近”。请定义在这种情况下“相似”应该是什么。只有这样，才有可能找到解决方案。“相似”和“接近”是任意的。在这种情况下，假设
0.5
。我如何检查列表中的值是否在该范围内，以便确定是将该值添加到列表中，还是放弃该值？此方法仅检查特定的给定值，不能处理各种各样的数字。@John这只是一个说明我观点的示例t使用他提供的数字。上面代码中的常量可以很容易地