Swift Language
Array

introduzione

Sintassi

• Array <Elemento> // Il tipo di una matrice con elementi di tipo Elemento
• [Elemento] // Zucchero sintattico per il tipo di una matrice con elementi di tipo Elemento
• [element0, element1, element2, ... elementN] // Un array letterale
• [Element] () // Crea una nuova matrice vuota di tipo [Element]
• Array (count: repeatValue :) // Crea un array di elementi count , ciascuno inizializzato su repeatedValue
• Matrice (_ :) // Crea una matrice da una sequenza arbitraria

Osservazioni

Semantica del valore

La copia di un array copierà tutti gli elementi all'interno dell'array originale.

La modifica del nuovo array non cambierà la matrice originale.

var originalArray = ["Swift", "is", "great!"]
var newArray = originalArray
newArray[2] = "awesome!"
//originalArray = ["Swift", "is", "great!"]
//newArray = ["Swift", "is", "awesome!"]

Gli array copiati condividono lo stesso spazio in memoria dell'originale finché non vengono modificati. Di conseguenza, si verifica un impatto sulle prestazioni quando all'array copiato viene assegnato il proprio spazio in memoria mentre viene modificato per la prima volta.

Nozioni di base sugli array

Array è un tipo di raccolta ordinato nella libreria standard Swift. Fornisce O (1) accesso casuale e riallocazione dinamica. La matrice è un tipo generico , quindi il tipo di valori che contiene sono noti al momento della compilazione.

Come Array è un tipo di valore , la sua mutabilità è definita dal fatto che sia annotata come var (mutabile) o let (immutabile).

Il tipo [Int] (che significa: un array contenente Int s) è zucchero sintattico per Array<T> .

Ulteriori informazioni sugli array in Swift Programming Language .

Matrici vuote

Le seguenti tre dichiarazioni sono equivalenti:

// A mutable array of Strings, initially empty.

var arrayOfStrings: [String] = []      // type annotation + array literal
var arrayOfStrings = [String]()        // invoking the [String] initializer
var arrayOfStrings = Array<String>()   // without syntactic sugar

Letterali di matrice

Un array letterale è scritto con parentesi quadre che circondano gli elementi separati da virgole:

// Create an immutable array of type [Int] containing 2, 4, and 7
let arrayOfInts = [2, 4, 7]

Il compilatore può solitamente dedurre il tipo di un array in base agli elementi nel letterale, ma le annotazioni di tipo esplicito possono ignorare il valore predefinito:

let arrayOfUInt8s: [UInt8] = [2, 4, 7]   // type annotation on the variable
let arrayOfUInt8s = [2, 4, 7] as [UInt8] // type annotation on the initializer expression
let arrayOfUInt8s = [2 as UInt8, 4, 7]   // explicit for one element, inferred for the others

Matrici con valori ripetuti

// An immutable array of type [String], containing ["Example", "Example", "Example"]
let arrayOfStrings = Array(repeating: "Example",count: 3)

Creare matrici da altre sequenze

let dictionary = ["foo" : 4, "bar" : 6]

// An immutable array of type [(String, Int)], containing [("bar", 6), ("foo", 4)]
let arrayOfKeyValuePairs = Array(dictionary)

Matrici multidimensionali

In Swift, una matrice multidimensionale viene creata nidificando gli array: una matrice bidimensionale di Int è [[Int]] (o Array<Array<Int>> ).

let array2x3 = [
    [1, 2, 3],
    [4, 5, 6]
]
// array2x3[0][1] is 2, and array2x3[1][2] is 6.

Per creare una matrice multidimensionale di valori ripetuti, utilizzare le chiamate nidificate dell'inizializzatore dell'array:

var array3x4x5 = Array(repeating: Array(repeating: Array(repeating: 0,count: 5),count: 4),count: 3)

Accesso ai valori dell'array

I seguenti esempi useranno questo array per dimostrare l'accesso ai valori

var exampleArray:[Int] = [1,2,3,4,5]
//exampleArray = [1, 2, 3, 4, 5]

Per accedere a un valore in un indice noto, utilizzare la seguente sintassi:

let exampleOne = exampleArray[2]
//exampleOne = 3

Nota: il valore all'indice due è il terzo valore nella Array . Array usano un indice a base zero, il che significa che il primo elemento Array trova all'indice 0.

let value0 = exampleArray[0]
let value1 = exampleArray[1]
let value2 = exampleArray[2]
let value3 = exampleArray[3]
let value4 = exampleArray[4]
//value0 = 1
//value1 = 2 
//value2 = 3
//value3 = 4
//value4 = 5

Accedi a un sottoinsieme di una Array usando il filtro:

var filteredArray = exampleArray.filter({ $0 < 4 })
//filteredArray = [1, 2, 3]

I filtri possono avere condizioni complesse come filtrare solo numeri pari:

var evenArray = exampleArray.filter({ $0 % 2 == 0 })
//evenArray = [2, 4]

È anche possibile restituire l'indice di un dato valore, restituendo nil se il valore non è stato trovato.

exampleArray.indexOf(3) // Optional(2)

Ci sono metodi per il primo, ultimo, massimo o minimo valore in una Array . Questi metodi restituiranno nil se l' Array è vuoto.

exampleArray.first // Optional(1)
exampleArray.last // Optional(5)
exampleArray.maxElement() // Optional(5)
exampleArray.minElement() // Optional(1)

Metodi utili

Determina se una matrice è vuota o restituisce la sua dimensione

var exampleArray = [1,2,3,4,5]
exampleArray.isEmpty //false
exampleArray.count //5

Invertire una matrice Nota: il risultato non viene eseguito sull'array su cui viene chiamato il metodo e deve essere inserito nella propria variabile.

exampleArray = exampleArray.reverse()
//exampleArray = [9, 8, 7, 6, 5, 3, 2]

Modifica dei valori in una matrice

Esistono diversi modi per aggiungere valori a un array

var exampleArray = [1,2,3,4,5]
exampleArray.append(6)
//exampleArray = [1, 2, 3, 4, 5, 6]
var sixOnwards = [7,8,9,10]
exampleArray += sixOnwards
//exampleArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

e rimuovere i valori da una matrice

exampleArray.removeAtIndex(3)
//exampleArray = [1, 2, 3, 5, 6, 7, 8, 9, 10]
exampleArray.removeLast()
//exampleArray = [1, 2, 3, 5, 6, 7, 8, 9]
exampleArray.removeFirst()
//exampleArray = [2, 3, 5, 6, 7, 8, 9]

Ordinamento di una matrice

var array = [3, 2, 1]

Creazione di un nuovo array ordinato

Dato che Array conforme a SequenceType , possiamo generare una nuova matrice di elementi ordinati usando un metodo di ordinamento incorporato.

let sorted = array.sort()  // [1, 2, 3]

let sorted = array.sorted()  // [1, 2, 3]

Ordinamento di un array esistente sul posto

Poiché Array conforme a MutableCollectionType , possiamo ordinare i suoi elementi in posizione.

array.sortInPlace() // [1, 2, 3]

array.sort() // [1, 2, 3]

Nota: per utilizzare i metodi precedenti, gli elementi devono essere conformi al protocollo Comparable .

Ordinamento di un array con un ordine personalizzato

Si può anche ordinare un array usando una chiusura per definire se un elemento debba essere ordinato prima di un altro - il che non è limitato agli array in cui gli elementi devono essere Comparable . Ad esempio, non ha senso che un Landmark di Landmark sia Comparable , ma è comunque possibile ordinare una serie di punti di riferimento in base all'altezza o al nome.

struct Landmark {
    let name : String
    let metersTall : Int
}

var landmarks = [Landmark(name: "Empire State Building", metersTall: 443),
                 Landmark(name: "Eifell Tower", metersTall: 300),
                 Landmark(name: "The Shard", metersTall: 310)]

// sort landmarks by height (ascending)
landmarks.sortInPlace {$0.metersTall < $1.metersTall}

print(landmarks) // [Landmark(name: "Eifell Tower", metersTall: 300), Landmark(name: "The Shard", metersTall: 310), Landmark(name: "Empire State Building", metersTall: 443)]

// create new array of landmarks sorted by name
let alphabeticalLandmarks = landmarks.sort {$0.name < $1.name}

print(alphabeticalLandmarks) // [Landmark(name: "Eifell Tower", metersTall: 300), Landmark(name: "Empire State Building", metersTall: 443), Landmark(name: "The Shard", metersTall: 310)]

// sort landmarks by height (ascending)
landmarks.sort {$0.metersTall < $1.metersTall}

// create new array of landmarks sorted by name
let alphabeticalLandmarks = landmarks.sorted {$0.name < $1.name}

Nota: il confronto tra stringhe può produrre risultati imprevisti se le stringhe sono incoerenti, vedere Ordinamento di una matrice di stringhe .

Trasformare gli elementi di una matrice con la mappa (_ :)

Dato che Array conforme a SequenceType , possiamo usare map(_:) per trasformare un array di A in un array di B usando una chiusura di tipo (A) throws -> B

Ad esempio, potremmo usarlo per trasformare una matrice di Int in una serie di String s in questo modo:

let numbers = [1, 2, 3, 4, 5]
let words = numbers.map { String($0) }
print(words) // ["1", "2", "3", "4", "5"]

map(_:) scorrerà l'array, applicando la chiusura data a ciascun elemento. Il risultato di tale chiusura verrà utilizzato per popolare un nuovo array con gli elementi trasformati.

Poiché String ha un inizializzatore che riceve un Int possiamo usare anche questa sintassi più chiara:

let words = numbers.map(String.init)

Una trasformazione di map(_:) non ha bisogno di cambiare il tipo di array - per esempio, potrebbe anche essere usato per moltiplicare un array di Int s per due:

let numbers = [1, 2, 3, 4, 5]
let numbersTimes2 = numbers.map {$0 * 2}
print(numbersTimes2) // [2, 4, 6, 8, 10]

Estrazione di valori di un determinato tipo da una matrice con flatMap (_ :)

Le things Array contiene valori di Any tipo.

let things: [Any] = [1, "Hello", 2, true, false, "World", 3]

Possiamo estrarre i valori di un determinato tipo e creare una nuova matrice di quel tipo specifico. Diciamo che vogliamo estrarre tutti gli Int(s) e inserirli in un Int Array in modo sicuro.

let numbers = things.flatMap { $0 as? Int }

Ora i numbers sono definiti come [Int] . La funzione flatMap tutti gli elementi nil e il risultato contiene quindi solo i seguenti valori:

[1, 2, 3]

Filtraggio di una matrice

È possibile utilizzare il metodo filter(_:) su SequenceType per creare un nuovo array contenente gli elementi della sequenza che soddisfano un determinato predicato, che può essere fornito come chiusura .

Ad esempio, filtrando i numeri pari da un [Int] :

let numbers = [22, 41, 23, 30]

let evenNumbers = numbers.filter { $0 % 2 == 0 }

print(evenNumbers)  // [22, 30]

Filtrare una [Person] , dove la loro età è inferiore a 30:

struct Person {
    var age : Int
}

let people = [Person(age: 22), Person(age: 41), Person(age: 23), Person(age: 30)]

let peopleYoungerThan30 = people.filter { $0.age < 30 }

print(peopleYoungerThan30) // [Person(age: 22), Person(age: 23)]

Filtraggio nullo da una trasformazione di array con flatMap (_ :)

È possibile utilizzare flatMap(_:) in modo simile alla map(_:) per creare un array applicando una trasformazione agli elementi di una sequenza.

extension SequenceType {
    public func flatMap<T>(@noescape transform: (Self.Generator.Element) throws -> T?) rethrows -> [T]
}

La differenza con questa versione di flatMap(_:) è che si aspetta che la chiusura della trasformazione restituisca un valore opzionale T? per ciascuno degli elementi. Sarà quindi in grado di scartare in modo sicuro ciascuno di questi valori opzionali, filtrando nil - risultando in una matrice di [T] .

Ad esempio, puoi farlo per trasformare una [String] in una [Int] usando l' inizializzatore di String failable di Int , filtrando tutti gli elementi che non possono essere convertiti:

let strings = ["1", "foo", "3", "4", "bar", "6"]

let numbersThatCanBeConverted = strings.flatMap { Int($0) }

print(numbersThatCanBeConverted) // [1, 3, 4, 6]

Puoi anche usare la capacità di flatMap(_:) di filtrare nil per convertire semplicemente un array di optionals in una serie di non-optionals:

let optionalNumbers : [Int?] = [nil, 1, nil, 2, nil, 3]

let numbers = optionalNumbers.flatMap { $0 }

print(numbers) // [1, 2, 3]

Sottoscrizione di una matrice con un intervallo

Si può estrarre una serie di elementi consecutivi da una matrice usando un intervallo.

let words = ["Hey", "Hello", "Bonjour", "Welcome", "Hi", "Hola"]
let range = 2...4
let slice = words[range] // ["Bonjour", "Welcome", "Hi"]

La sottoscrizione di una matrice con intervallo restituisce un oggetto ArraySlice . È una sottosequenza della matrice.

Nel nostro esempio, abbiamo una matrice di stringhe, quindi torniamo ad ArraySlice<String> .

Sebbene ArraySlice sia conforme a CollectionType e possa essere utilizzato con sort , filter , ecc., Il suo scopo non è l'archiviazione a lungo termine ma i calcoli transitori: dovrebbe essere riconvertito in una matrice non appena hai finito di lavorare con essa.

Per questo, usa l'inizializzatore Array() :

let result = Array(slice)

Per riassumere in un semplice esempio senza passaggi intermedi:

let words = ["Hey", "Hello", "Bonjour", "Welcome", "Hi", "Hola"]
let selectedWords = Array(words[2...4]) // ["Bonjour", "Welcome", "Hi"]

Raggruppamento di valori di matrice

Se abbiamo una struttura come questa

struct Box {
    let name: String
    let thingsInside: Int
}

e una serie di Box(es)

let boxes = [
    Box(name: "Box 0", thingsInside: 1),
    Box(name: "Box 1", thingsInside: 2),
    Box(name: "Box 2", thingsInside: 3),
    Box(name: "Box 3", thingsInside: 1),
    Box(name: "Box 4", thingsInside: 2),
    Box(name: "Box 5", thingsInside: 3),
    Box(name: "Box 6", thingsInside: 1)
]

possiamo raggruppare le caselle in base alla proprietà thingsInside per ottenere un Dictionary cui la key è il numero di elementi e il valore è un array di caselle.

let grouped = boxes.reduce([Int:[Box]]()) { (res, box) -> [Int:[Box]] in
    var res = res
    res[box.thingsInside] = (res[box.thingsInside] ?? []) + [box]
    return res
}

Ora raggruppato è un [Int:[Box]] e ha il seguente contenuto

[
    2: [Box(name: "Box 1", thingsInside: 2), Box(name: "Box 4", thingsInside: 2)], 
    3: [Box(name: "Box 2", thingsInside: 3), Box(name: "Box 5", thingsInside: 3)],
    1: [Box(name: "Box 0", thingsInside: 1), Box(name: "Box 3", thingsInside: 1), Box(name: "Box 6", thingsInside: 1)]
]

Appiattimento del risultato di una trasformazione di matrice con flatMap (_ :)

Oltre a essere in grado di creare un array filtrando nil dagli elementi trasformati di una sequenza, esiste anche una versione di flatMap(_:) che si aspetta che la chiusura della trasformazione restituisca una sequenza S

extension SequenceType {
    public func flatMap<S : SequenceType>(transform: (Self.Generator.Element) throws -> S) rethrows -> [S.Generator.Element]
}

Ogni sequenza dalla trasformazione sarà concatenata, risultante in una matrice contenente gli elementi combinati di ciascuna sequenza: [S.Generator.Element] .

Combinare i personaggi in una serie di stringhe

Ad esempio, possiamo usarlo per prendere una serie di stringhe prime e combinare i loro caratteri in un unico array:

let primes = ["2", "3", "5", "7", "11", "13", "17", "19"]
let allCharacters = primes.flatMap { $0.characters }
// => "["2", "3", "5", "7", "1", "1", "1", "3", "1", "7", "1", "9"]"

Rompendo l'esempio precedente in basso:

1. primes is a [String] (Dato che una matrice è una sequenza, possiamo chiamare flatMap(_:) su di essa).
2. La chiusura della trasformazione prende uno degli elementi di primes , una String ( Array<String>.Generator.Element ).
3. La chiusura quindi restituisce una sequenza di tipo String.CharacterView .
4. Il risultato è quindi un array contenente gli elementi combinati di tutte le sequenze da ciascuna delle chiamate di chiusura della trasformazione: [String.CharacterView.Generator.Element] .

Appiattimento di un array multidimensionale

Quando flatMap(_:) concatena le sequenze restituite dalle chiamate di chiusura della trasformazione, può essere utilizzato per appiattire un array multidimensionale, ad esempio un array 2D in un array 1D, un array 3D in un array 2D, ecc.

Questo può essere fatto semplicemente restituendo l'elemento dato $0 (un array annidato) nella chiusura:

// A 2D array of type [[Int]]
let array2D = [[1, 3], [4], [6, 8, 10], [11]]

// A 1D array of type [Int]
let flattenedArray = array2D.flatMap { $0 }

print(flattenedArray) // [1, 3, 4, 6, 8, 10, 11]

Ordinamento di una matrice di stringhe

let words = ["Hello", "Bonjour", "Salute", "Ahola"]
let sortedWords = words.sorted()
print(sortedWords) // ["Ahola", "Bonjour", "Hello", "Salute"]

var mutableWords = ["Hello", "Bonjour", "Salute", "Ahola"]
mutableWords.sort()
print(mutableWords) // ["Ahola", "Bonjour", "Hello", "Salute"]

let words = ["Hello", "Bonjour", "Salute", "Ahola"]
let sortedWords = words.sorted(isOrderedBefore: { $0 > $1 })
print(sortedWords) // ["Salute", "Hello", "Bonjour", "Ahola"]

let words = ["Hello", "Bonjour", "Salute", "Ahola"]
let sortedWords = words.sorted() { $0 > $1 }
print(sortedWords) // ["Salute", "Hello", "Bonjour", "Ahola"]

let words = ["Hello", "bonjour", "Salute", "ahola"]
let unexpected = words.sorted()
print(unexpected) // ["Hello", "Salute", "ahola", "bonjour"]

let words = ["Hello", "bonjour", "Salute", "ahola"]
let sortedWords = words.sorted { $0.lowercased() < $1.lowercased() }
print(sortedWords) // ["ahola", "bonjour", "Hello", "Salute"]

let words = ["Hello", "bonjour", "Salute", "ahola"]
let sortedWords = words.sorted { $0.caseInsensitiveCompare($1) == .orderedAscending }
print(sortedWords) // ["ahola", "bonjour", "Hello", "Salute"]

let files = ["File-42.txt", "File-01.txt", "File-5.txt", "File-007.txt", "File-10.txt"]
let sortedFiles = files.sorted() { $0.compare($1, options: .numeric) == .orderedAscending }
print(sortedFiles) // ["File-01.txt", "File-5.txt", "File-007.txt", "File-10.txt", "File-42.txt"]

Appiattire con parsimonia una matrice multidimensionale con appiattisci ()

Possiamo usare flatten() per ridurre pigramente la nidificazione di una sequenza multidimensionale.

Ad esempio, lazy appiattimento di un array 2D in un array 1D:

// A 2D array of type [[Int]]
let array2D = [[1, 3], [4], [6, 8, 10], [11]]

// A FlattenBidirectionalCollection<[[Int]]>
let lazilyFlattenedArray = array2D.flatten()

print(lazilyFlattenedArray.contains(4)) // true

Nell'esempio sopra, flatten() restituirà un FlattenBidirectionalCollection , che applicherà pigramente l'appiattimento dell'array. Pertanto contains(_:) richiederà solo i primi due array annidati di array2D per essere appiattito - in quanto cortocircuiterà nel trovare l'elemento desiderato.

Combinare gli elementi di una matrice con riduci (_: combina :)

reduce(_:combine:) può essere utilizzato per combinare gli elementi di una sequenza in un singolo valore. Richiede un valore iniziale per il risultato e una chiusura da applicare a ciascun elemento, che restituirà il nuovo valore accumulato.

Ad esempio, possiamo usarlo per sommare una matrice di numeri:

let numbers = [2, 5, 7, 8, 10, 4]

let sum = numbers.reduce(0) {accumulator, element in
    return accumulator + element
}

print(sum) // 36

Stiamo passando 0 al valore iniziale, poiché questo è il valore iniziale logico per una sommatoria. Se passassimo in un valore di N , la sum risultante sarebbe N + 36 . La chiusura passata per reduce ha due argomenti. accumulator è il valore accumulato corrente, a cui viene assegnato il valore che la chiusura restituisce ad ogni iterazione. element è l'elemento corrente nell'iterazione.

Come in questo esempio, stiamo passando una (Int, Int) -> Int chiusura per reduce , che sta semplicemente emettendo l'aggiunta dei due input - possiamo effettivamente passare direttamente nell'operatore + , poiché gli operatori sono funzioni in Swift:

let sum = numbers.reduce(0, combine: +)

Rimozione di un elemento da un array senza conoscere il suo indice

In generale, se vogliamo rimuovere un elemento da un array, dobbiamo conoscere il suo indice in modo che possiamo rimuoverlo facilmente usando remove(at:) function.

Ma cosa succede se non conosciamo l'indice, ma sappiamo il valore dell'elemento da rimuovere!

Quindi ecco la semplice estensione di un array che ci permetterà di rimuovere facilmente un elemento dalla matrice senza sapere che è indice:

Swift3

extension Array where Element: Equatable {

    mutating func remove(_ element: Element) {
        _ = index(of: element).flatMap {
            self.remove(at: $0)
        }
    }
}

per esempio

    var array = ["abc", "lmn", "pqr", "stu", "xyz"]
    array.remove("lmn")
    print("\(array)")    //["abc", "pqr", "stu", "xyz"]
    
    array.remove("nonexistent")
    print("\(array)")    //["abc", "pqr", "stu", "xyz"]
    //if provided element value is not present, then it will do nothing!

Anche se, per errore, abbiamo fatto qualcosa di simile: array.remove(25) ovvero abbiamo fornito un valore con un tipo di dati diverso, il compilatore genererà un errore che menziona:
cannot convert value to expected argument type

Trovare l'elemento minimo o massimo di una matrice

let numbers = [2, 6, 1, 25, 13, 7, 9]

let minimumNumber = numbers.minElement() // Optional(1)
let maximumNumber = numbers.maxElement() // Optional(25)

let minimumNumber = numbers.min() // Optional(1)
let maximumNumber = numbers.max() // Optional(25)

I valori restituiti da questi metodi sono Opzionali per riflettere il fatto che l'array potrebbe essere vuoto - se lo è, verrà restituito nil .

Nota: i metodi precedenti richiedono che gli elementi siano conformi al protocollo Comparable .

Trovare l'elemento minimo o massimo con un ordine personalizzato

È inoltre possibile utilizzare i metodi precedenti con una chiusura personalizzata, definendo se un elemento debba essere ordinato prima di un altro, consentendo di trovare l'elemento minimo o massimo in un array in cui gli elementi non sono necessariamente Comparable .

Ad esempio, con una matrice di vettori:

struct Vector2 {
    let dx : Double
    let dy : Double
    
    var magnitude : Double {return sqrt(dx*dx+dy*dy)}
}

let vectors = [Vector2(dx: 3, dy: 2), Vector2(dx: 1, dy: 1), Vector2(dx: 2, dy: 2)]

// Vector2(dx: 1.0, dy: 1.0)
let lowestMagnitudeVec2 = vectors.minElement { $0.magnitude < $1.magnitude } 

// Vector2(dx: 3.0, dy: 2.0)
let highestMagnitudeVec2 = vectors.maxElement { $0.magnitude < $1.magnitude } 

let lowestMagnitudeVec2 = vectors.min { $0.magnitude < $1.magnitude }
let highestMagnitudeVec2 = vectors.max { $0.magnitude < $1.magnitude }

Accesso sicuro agli indici

Aggiungendo la seguente estensione agli indici di array è possibile accedere senza sapere se l'indice è all'interno dei limiti.

extension Array {
    subscript (safe index: Int) -> Element? {
        return indices ~= index ? self[index] : nil
    }
}

esempio:

if let thirdValue = array[safe: 2] {
    print(thirdValue)
}

Confronto di 2 matrici con zip

La funzione zip accetta 2 parametri di tipo SequenceType e restituisce un Zip2Sequence cui ogni elemento contiene un valore dalla prima sequenza e uno dalla seconda sequenza.

Esempio

let nums = [1, 2, 3]
let animals = ["Dog", "Cat", "Tiger"]
let numsAndAnimals = zip(nums, animals)

nomsAndAnimals ora contiene i seguenti valori

Ciò è utile quando si desidera eseguire una sorta di confronto tra l'n-esimo elemento di ciascuna matrice.

Esempio

Dato 2 matrici di Int(s)

let list0 = [0, 2, 4]
let list1 = [0, 4, 8]

si desidera verificare se ciascun valore in list1 è il doppio del valore correlato in list0 .

let list1HasDoubleOfList0 = !zip(list0, list1).filter { $0 != (2 * $1)}.isEmpty