I have two arrays:
fruitsArray = ["apple", "mango", "blueberry", "orange"] vegArray = ["tomato", "potato", "mango", "blueberry"]
How can I get the list of common items in those two array which gives
ouptput = ["mango", "blueberry"]
I can't use if contains(array, string)
as I want to compare 2 arrays.
first(where:) Returns the first element of the sequence that satisfies the given predicate.
To check if two arrays are equal in Swift, use Equal To == operator. Equal To operator returns a Boolean value indicating whether two arrays contain the same elements in the same order. If two arrays are equal, then the operator returns true , or else it returns false .
In Swift, we are allowed to join the elements of an array in a string using joined() function. This function creates a new string by concatenating all the elements of an array using a specified separator. We can also join all the elements of an array without any separator.
You can also use filter
and contains
in conjunction:
let fruitsArray = ["apple", "mango", "blueberry", "orange"] let vegArray = ["tomato", "potato", "mango", "blueberry"] // only Swift 1 let output = fruitsArray.filter{ contains(vegArray, $0) } // in Swift 2 and above let output = fruitsArray.filter{ vegArray.contains($0) } // or let output = fruitsArray.filter(vegArray.contains)
Set
vs Array
for a single computation of common elementsWe consider the following code snippet:
let array1: Array = ... let array2: Array = ... // `Array` let commonElements = array1.filter(array2.contains) // vs `Set` let commonElements = Array(Set(array1).intersection(Set(array2))) // or (performance wise equivalent) let commonElements: Array = Set(array1).filter(Set(array2).contains)
I have made some (artificial) benchmarks with Int
and short/long String
s (10 to 100 Character
s) (all randomly generated). I always use array1.count == array2.count
I get the following results:
If you have more than critical #(number of) elements
converting to a Set
is preferable
data | critical #elements -------------|-------------------- Int | ~50 short String | ~100 long String | ~200
Using the Array
approach uses "Brute force"-search which has time complexity O(N^2)
where N = array1.count = array2.count
which is in contrast to the Set
approach O(N)
. However the conversion from Array
to Set
and back is very expensive for large data which explains the increase of critical #elements
for bigger data types.
For small Array
s with about 100 elements the Array
approach is fine but for larger ones you should use the Set
approach.
If you want to use this "common elements"-operation multiple times it is advisable to use Set
s only if possible (the type of the elements has to be Hashable
).
A conversion from Array
to Set
is kind of expensive while the conversion from Set
to Array
is in contrast very inexpensive.
Using filter
with .filter(array1.contains)
is performance wise faster than .filter{ array1.contains($0) }
since:
O(N)
)Convert them to Set and use intersect() function:
let fruitsArray = ["apple", "mango", "blueberry", "orange"] let vegArray = ["tomato", "potato", "mango", "blueberry"] let fruitsSet = Set(fruitsArray) let vegSet = Set(vegArray) let output = Array(fruitsSet.intersection(vegSet))
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With