Find value ranges of one array in another

Question

I have an array in 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)

I also have a second array

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)

I have to find all elements of "b" that are >= a[0] & <= a[a.count-1] and populate a vector "c" with these values.

So that

let c = [0.0, 0.004, 0.008, 0.012, 0.016, 0.02, 0.024] // ANSWER

What would be the most efficient way to do this?

Answer 1

Since you know the both sequences to be increasing, you need only make use of the first and last element of the array a. Using these, you can make use of the index(where:) method to find the corresponding indices in the b array, fulfilling the predicate >= (first of a) and <= (last of a). E.g.

if let aFirst = a.first, let aLast = a.last,
   let startIndex = b.index(where: { $0 >= aFirst }),
   case let endIndex = b.index(where: { $0 > aLast }) ?? a.endIndex {
    let c = b[startIndex..<endIndex] // note: this is an ArraySlice<Double>
                                     // wrap in Array(..) to construct a new array
    print(c) 
       // [0.0, 0.0040000000000000001, 0.0080000000000000002, 0.012, 0.016, 0.02, 0.024]
}

Or, as proposed by @MartinR, we can make a guess that we will, on avarage, more quickly fulfil the predicate of the second index(where:) call if we start from the end of b when checking for the first element that fulfills the $0 <= aLast condition:

if let aFirst = a.first, let aLast = a.last,
   let startIndex = b.index(where: { $0 >= aFirst }),
   case let endIndex = b.reversed().index(where: { $0 <= aLast })!.base {
                    /* ^^^^^- as proposed by @MartinR */
    let c = b[startIndex..<endIndex]
    print(c) 
       // [0.0, 0.0040000000000000001, 0.0080000000000000002, 0.012, 0.016, 0.02, 0.024]
}

In the end this approach (as well as the filter approach in the currently available other answers) runs in O(n). A more performant approach would be using binary search, which runs in O(log n) asymptotically. As also mentioned by @MartinR, a good starting point could be the binary search Swift implementations from the Rosetta code:

• http://rosettacode.org/wiki/Binary_search#Swift

as mentioned in this Q&A:

• How do I insert an element at the correct position into a sorted array in Swift?

---

Answering the comment:

... I also have another issue that I forgot to mention. I have another array y that has exactly the same number of elements as b. We can regard these as X and Y values of a signal. I have to choose the matching elements from y for the elements I choose in b.

The simplest solution would simply apply the calculated startIndex and endIndex to slice out a part of the y array (just like you sliced out a part of b to construct c).

let d = y[startIndex..<endIndex] 
// assumes y.count == b.count, and that these are not slices
// with non-matching indices

However, I believe a better approach would be using zip. Simply zip y and b and use the result to construct an array of tuples, whereafter you can apply the predicate above to the b members of the zipped sequence:

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)] */
}

Naturally constructing the cAndD array will yield a minor overhead, but unless you're coding some really HPC application, you shouldn't need to worry about that.

Answer 2

You can use the filter function on your array which will return you a new array. You can compare if the value is >= a[0] and <= a[a.count-1]. Obviously, you should always check if the array has more than 0 elements.

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

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

Calculate the indexes

Since b is always increased by a fixed amount, e.g. 0.004 in your case, you could calculate your index. This is really efficient because you only have two comparisons and at max two calculations which are really fast.

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]

Answer 3

Another way of doing this would be:

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

Answer 4

You should not save there values to be a array.

if it is not equal for each other,

save there to be a set and use

let c = a.intersection(b)

https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/CollectionTypes.html