Uso de "Mapa" en Swift para crear un superset de dos matrices

Digamos que tengo dos matrices:

let letterArray = ["a", "b", "c", "d", "e"...] let numberArray = [1, 2, 3, 4, 5, 6, 7...] 

Quiero combinar las dos matrices para get una salida de

 ["a1", "b2", "c3", "d4", "e5"] 

¿Cómo iba a hacer eso?

Puede usar zip(_:_:) antes del map:

 let a = ["a", "b", "c", "d", "e"] let b = [1, 2, 3, 4, 5] let result = zip(a, b).map{$0 + String($1)} print(result) 

Puedes probar este código aquí.

zip(_:_:) produce una Zip2Sequence personalizada, que tiene una implementación especial del protocolo SequenceType , de modo que itera pares hechos a partir de las dos collections de origen.

De hecho, ¡ puedes hacerlo usando solo un map !

Si las dos secuencias tienen el mismo tamaño, simplemente enumerate y map :

 let result = letterArray.enumerate().map { $0.element + String(numberArray[$0.index]) } 

Si no está seguro de cuál es más grande y desea recortarlo con el más pequeño, simplemente flatMap los valores indeseados:

 let result = letterArray.enumerate().flatMap { guard numberArray.count > $0.index else { return .None } return $0.element + String(numberArray[$0.index]) } as [String] 

# 1. Usando zip(_:_:) para combinar elementos de una matriz de String con elementos de una matriz de Int en una nueva matriz de String

Con Swift 3, Swift Standard Library proporciona function zip(_:_:) . zip(_:_:) tiene la siguiente statement:

 func zip<Sequence1, Sequence2>(_ sequence1: Sequence1, _ sequence2: Sequence2) -> Zip2Sequence<Sequence1, Sequence2> where Sequence1 : Sequence, Sequence2 : Sequence 

Crea una secuencia de pares construida a partir de dos secuencias subyacentes.


Para get una nueva matriz de una instancia de Zip2Sequence , puede usar el Zip2Sequence de map(_:) Zip2Sequence . El código de Playground que se encuentra debajo que usa map(_:) combina tus elementos de letra y número en una nueva matriz de String :

 let letterArray = ["a", "b", "c", "d", "e"] let numberArray = [1, 2, 3, 4, 5, 6, 7] let zipSequence = zip(letterArray, numberArray) let finalArray = zipSequence.map({ (tuple: (letter: String, number: Int)) -> String in return tuple.letter + String(tuple.number) }) print(finalArray) // prints ["a1", "b2", "c3", "d4", "e5"] 

Puedes refactorizar el código anterior con un estilo muy conciso:

 let letterArray = ["a", "b", "c", "d", "e"] let numberArray = [1, 2, 3, 4, 5, 6, 7] let finalArray = zip(letterArray, numberArray).map { $0.0 + String($0.1) } print(finalArray) // prints ["a1", "b2", "c3", "d4", "e5"] 

Como alternativa al map(_:) , puede usar el Zip2Sequence de networkinguce(_:_:) Zip2Sequence :

 let letterArray = ["a", "b", "c", "d", "e"] let numberArray = [1, 2, 3, 4, 5, 6, 7] let zipSequence = zip(letterArray, numberArray) let finalArray = zipSequence.networkinguce([]) { (partialResult: [String], tuple: (letter: String, number: Int)) -> [String] in return partialResult + [tuple.letter + String(tuple.number)] } print(finalArray) // prints ["a1", "b2", "c3", "d4", "e5"] 

# 2. Utilizando un método personalizado de extensión de Array para combinar elementos de una matriz de String con elementos de una matriz de Int en una nueva matriz de String

Si no desea usar zip(_:_:) , puede crear su propio método de extensión Array para get el resultado esperado. El código de Playground a continuación muestra cómo crearlo:

 extension Array where Element == String { func mergeLettersWithNumbers(from numberArray: [Int]) -> [String] { var index = startIndex let iterator: AnyIterator<String> = AnyIterator { defer { index = self.index(index, offsetBy: 1) } guard index < self.endIndex, index < numberArray.endIndex else { return nil } return self[index] + String(numberArray[index]) } return Array(iterator) } } let letterArray = ["a", "b", "c", "d", "e"] let numberArray = [1, 2, 3, 4, 5, 6, 7] let newArray = letterArray.mergeLettersWithNumbers(from: numberArray) print(newArray) // prints ["a1", "b2", "c3", "d4", "e5"]