Arrays 在另一个数组中查找一个数组的值范围

我有一个SWIFT阵型

let a = [0.0, 0.00250, 0.0050, 0.00749, 0.01, 0.01251, 0.01499, 0.0175, 0.02, 0.022, 0.025] // is always a sequence (increasing)

我还有第二个数组

let b = [0.0, 0.004, 0.008, 0.012, 0.016, 0.02, 0.024, 0.028, 0.032, 0.036, 0.04, 0.044, 0.048, 0.052, 0.056] // is always a sequence (increasing)

---

我必须找到“b”中>=a[0]&的所有元素，因为您知道这两个序列都在增加，所以只需要使用数组

a

的第一个和最后一个元素。使用这些，您可以使用该方法在

b

数组中找到相应的索引，实现谓词

=（a的第一个）

和

，因为您知道这两个序列都在增加，所以只需使用数组
a
的第一个和最后一个元素。使用这些，您可以使用该方法在
b
数组中查找相应的索引，满足谓词
=（a的第一个）
和
您可以在数组上使用
过滤器
函数，该函数将返回新数组。如果值>=a[0]，则可以进行比较，并且可以在数组上使用
过滤器
函数，该函数将返回一个新数组。如果值>=a[0]，则可以进行比较，另一种方法是：

let c = b.filter() { return (a.first)! <= $0 && $0 <= (a.last)! }

让c=b.filter（）{return（a.first）！另一种方法是：

let c = b.filter() { return (a.first)! <= $0 && $0 <= (a.last)! }

让c=b.filter（）{return（a.first）！不应将这些值保存为数组

如果彼此不相等

将其保存为一个集合并使用

let c = a.intersection(b)

不应将这些值保存为数组

如果彼此不相等

将其保存为一个集合并使用

let c = a.intersection(b)

事实上，我想要的是范围，而不是精确的匹配值。@Pat啊，我的错。修改过。我喜欢这两个答案——感谢Yannick和dfri！一种方法比另一种快吗？我正在寻找禁食方法，因为我的数组在实践中很大。根据数组大小和值，从数组中搜索结束索引可能更有效数组的末尾：大致是代码> b rReSETHEED（）。索引（{ 0美元谢谢DFRI！是的，我意识到我可以在Y上使用相同的索引。也会考虑其他关于zip的建议。谢谢：）事实上，我想要的是范围，而不是精确的匹配值。@Pat啊，我的错。修改过。我喜欢这两个答案-谢谢Yannick和dfri！一种方法比另一种快吗？我正在寻找禁食方法，因为我的数组在实践中很大。根据数组大小和值，从数组末尾搜索结束索引可能更有效数组向后：大致是代码> b RealSeD（）。索引（{ 0美元谢谢DFRI！是的，我意识到我可以在Y上使用相同的索引。还将考虑您关于Zip的其他建议。谢谢：）b总是增加相同的数字吗？是的，YannickI更新了我的答案，以便计算正确的索引，而不是比较每个值。是的，YannickI更新了我的答案，以便计算正确的索引，而不是比较每个值。Hi Yannick，我刚刚意识到“b”不一定总是以固定的数量增加。由于其时间值，有时可能会出现不均匀的“增量T”。很抱歉造成混淆。没问题！如果它们真的很相似，也许您仍然可以尝试计算值。但是，不要依赖计算出的数字。进行一些检查，看看是否可行。请注意，上面的后一种方法还假设两个数组的起始值相同。可以修改它以在
a中找到第一个值
即
=
到
b
中的第一个值，然后对剩余部分使用数学运算，但此查找操作也是
O（n）
。不，不是！你自己试试。如果smallestValueA小于或等于smallestValueB，那么我们可以从索引0开始。否则，我们计算差异。我刚刚做了：让a=[0.00250,0.00749,0.01,0.01251,0.01499,0.0175,0.02,0.022,0.025]
（注意：
a
的第一个元素从示例中删除）你会看到
c
数组包含
0
，即使它不符合
b_elem>=a[0]
的标准。嗨，Yannick，我刚刚意识到“b”可能并不总是以固定的数量增加。作为它的时间值，有时可能会出现不均匀的“Delta Ts”。很抱歉造成混淆。没问题！如果它们真的很相似，也许您仍然可以尝试计算值。但是，不要依赖计算出的数字。进行一些检查，看看是否可行。请注意，上面的后一种方法还假设两个数组的起始值相同。可以修改它以在
a中找到第一个值
即
=
到
b
中的第一个值，然后对剩余部分使用数学运算，但此查找操作也是
O（n）
。不，不是！你自己试试。如果smallestValueA小于或等于smallestValueB，那么我们可以从索引0开始。否则，我们计算差异。我刚刚做了：让a=[0.00250,0.00749,0.01,0.01251,0.01499,0.0175,0.02,0.022,0.025]
（注意：
a
的第一个元素从示例中删除）您将看到
c
数组包含
0
，即使它不满足
b_elem>=a[0]
。a
Set
是一个非有序集合，OP使用的是有序集合，因此这里的
交集
方法不可行（非有序时间戳在我认为OP正在使用它们的上下文中可能会非常混乱：）。一个
Set
是一个非有序集合，OP正在使用有序集合，因此
intersection
方法在这里不可行（非有序时间戳在我认为OP正在使用它们的上下文中可能会非常混乱：））。
let y = Array(1...b.count)

if let aFirst = a.first, let aLast = a.last,
   let startIndex = bAndY.index(where: { $0.0 >= aFirst }),
   case let endIndex = bAndY.index(where: { $0.0 > aLast }) ?? a.endIndex {
    let cAndD = bAndY[startIndex..<endIndex]
    print(cAndD)
        /* [(0.0040000000000000001, 2),
            (0.0080000000000000002, 3), 
            (0.012,                 4), 
            (0.016,                 5),
            (0.02,                  6), 
            (0.024,                 7)] */
}

let smallestValue = a[0]
let highestValue = a[a.count-1]

let c = b.filter() { return smallestValue <= $0 && $0 <= highestValue }

let smallestValueA = a[0]
let highestValueA = a[a.count-1]
let smallestValueB = b[0]
let highestValueB = b[b.count-1]
let increase = 0.004 //based on your example
var smallestIndex: Int = 0
var highestIndex: Int = b.count

if smallestValueA > smallestValueB {
    smallestIndex = Int((smallestValueA - smallestValueB) / increase).rounded(.up)
}

if highestValueA < highestValueB {
    highestIndex = Int(((highestValueB - highestValueA) - smallestValueB) / increase)
}

let c = b[smallestIndex..<highestIndex] //[0.0, 0.0040000000000000001, 0.0080000000000000002, 0.012, 0.016, 0.02, 0.024]

let c = b.filter() { return (a.first)! <= $0 && $0 <= (a.last)! }

let c = a.intersection(b)