Swift 如何在该数组中搜索特定值，然后返回元组中的其他值？

我有一个很大的

（x，y）

对数组：

 P = 

   [
    (0.0, 500000.09999999998), 
    (0.001, 18.332777589999999), 
    (0.002, 18.332221480000001), 
    (0.0030000000000000001, 18.331665000000001), 
    (0.0040000000000000001, 18.331108140000001), 
    (0.0050000000000000001, 18.33055092), 
    (0.0060000000000000001, 18.32999332), 
    ...
    ]

我现在需要在我的代码中使用它。我需要搜索一个特定的x值，如果x值存在，则返回相应的y值

注意：如果有更好的格式，我可以将我的

（x，y）

成对放入，请随时通知我。例如，两个单独的数组，其中一个保存x值，另一个保存y值。然后我可以使用索引来找到相应的y值或其他东西

---

编辑：

一位用户在评论中提出了一个很好的观点：我如何才能可靠地比较

x==0.001

---

我将使用我的代码的方式是：我正在以

x

的值计算函数

f（x）

。但是，如果在

x

的特定值处，

P

数组中有一个

y

值，那么我需要进行额外的减法计算（这里的细节不太重要）。那么，问题是如果我在那里传递

x

值

0.001

，而

P

数组没有相应的

y

值，但是它有

0.001000000009

的值呢？？然后代码会说没有值，但实际上它相当接近预期的

x

值。

您的x值似乎都增加了0.001。如果是这种情况，还可以计算索引并返回该索引处的y值。这样会更有效率

func calculateIndex(forX x: Double) -> Int {
    let increase = 0.001
    return Int(x/0.001)
}

您可以使用

find

方法查找x值的索引，然后返回y值。我将把你的值乘以1000，然后比较

Int

，而不是比较

Double

func findYValue(forX x: Double) -> Double? {
    let multiply = 1000
    let x = Int(multiply*x)
    if let index = array.index(where: { Int($0.0 * multiply) == x }) {
        return array[index].1 //found the y value
    }
    return nil //x is not in the array
}

---

我个人会使用元组，而不是元组。该类有一个

x

和一个

y

属性，使代码更具可读性。

实现这一点的好方法是声明以下函数：

func getValueFromTuples(tupleArr:[(Double,Double)],n:Double)->Double?{
    for tuple in tupleArr{
        if tuple.0 == n{
            return tuple.1
        }
    }
    return nil
}

然后，您可以这样使用它：

var tupleArray: [(Double,Double)] = [(1.0, 12.0),(2.0,23.0),(3.0,34.0),(4.0,45.0),(5.0,56.0)]
var x:Double = 1.0
print(getValueFromTuples(tupleArr: tupleArray,n:x) ?? "No value found") // 12.0

当

n

参数是要查找的值时，

元组

是由数字组成的键值对，

getValueFromTuples

返回值

y

（如果已找到

x

），否则

nil

）

如果元组数组中不存在值，则返回“未找到值”

---

---

希望这有帮助

我建议让你的数组成为一个数组。很简单：

在二维坐标系中包含点的结构 系统

但是，如果要在搜索

x

的基础上获取

y

值：

let myArray = [
    (0.0, 500000.09999999998),
    (0.001, 18.332777589999999),
    (0.002, 18.332221480000001),
    (0.0030000000000000001, 18.331665000000001),
    (0.0040000000000000001, 18.331108140000001),
    (0.0050000000000000001, 18.33055092),
    (0.0060000000000000001, 18.32999332),
]

// this array should contains y values for a given x value
// for example, I search the x value of 0.0
let yValues = myArray.filter { $0.0 == 0.0 }.map { $0.1 }

print(yValues) // [500000.09999999998]

希望这能有所帮助。

微软给出了一个如何比较两个双打的例子。基本前提是您需要定义一定程度的公差。本文探讨了在大多数情况下如何选择良好的公差

下面是翻译成Swift的代码：

func areEqual(_ lhs: Double, _ rhs: Double, units: Int = 3) -> Bool {
    let lValue = Int64(bitPattern: lhs.bitPattern)
    let rValue = Int64(bitPattern: rhs.bitPattern)
    let delta = lValue - rValue

    return abs(delta) <= Int64(units)
}

---

你说的“搜索”是什么意思@肯尼特：我知道。这是一个非常好的观点。我没想到。你为什么不用字典呢？[双人，双人]？

var n = 0.0
for _ in 0..<10 {
    n += 0.1
}

// n should equal 1 but it does not
print(n == 1.0)          // false
print(areEqual(1.0, n))  // true

let x = 0.003
if let y = p.first(where: { areEqual($0.0, x) })?.1 {
    print(y)
}