小开

最佳答案

您可以使用 enumerate将序列(Array、 String等)转换为具有整数计数器和元素配对的元组序列。那就是:

let numbers = [7, 8, 9, 10]
let indexAndNum: [String] = numbers.enumerate().map { (index, element) in
return "\(index): \(element)"
}
print(indexAndNum)
// ["0: 7", "1: 8", "2: 9", "3: 10"]

链接到 enumerate定义

注意，这与获取集合的索引不同ーー enumerate返回一个整数计数器。这与数组的索引相同，但是对于字符串或字典不会很有用。要获得每个元素的实际索引，可以使用 zip:

let actualIndexAndNum: [String] = zip(numbers.indices, numbers).map { "\($0): \($1)" }
print(actualIndexAndNum)
// ["0: 7", "1: 8", "2: 9", "3: 10"]

当在 reduce中使用枚举序列时，您将无法分离元组中的索引和元素，因为在方法签名中已经有了累加/当前元组。相反，您需要在 reduce闭包的第二个参数上使用 .0和 .1:

let summedProducts = numbers.enumerate().reduce(0) { (accumulate, current) in
return accumulate + current.0 * current.1
//                          ^           ^
//                        index      element
}
print(summedProducts)   // 56

Swift 3.0及以上版本

因为 Swift 3.0的语法完全不同。
此外，还可以使用 short-language/inline 在 dictionary 上映射 array:

let numbers = [7, 8, 9, 10]
let array: [(Int, Int)] = numbers.enumerated().map { ($0, $1) }
//                                                     ^   ^
//                                                   index element

这就产生了:

[(0, 7), (1, 8), (2, 9), (3, 10)]

小开

除了 Nate Cook 的 map示例之外，您还可以将此行为应用于 reduce。

let numbers = [1,2,3,4,5]
let indexedNumbers = reduce(numbers, [:]) { (memo, enumerated) -> [Int: Int] in
return memo[enumerated.index] = enumerated.element
}
// [0: 1, 1: 2, 2: 3, 3: 4, 4: 5]

请注意，由于 enumerated不能以嵌套方式分解传递到闭包中的 EnumerateSequence，因此元组的成员必须在闭包内部分解(即。enumerated.index).

小开

对于 Swift 2.1，我编写了下一个函数:

extension Array {


public func mapWithIndex<T> (f: (Int, Element) -> T) -> [T] {
return zip((self.startIndex ..< self.endIndex), self).map(f)
}
}

然后像这样使用它:

    let numbers = [7, 8, 9, 10]
let numbersWithIndex: [String] = numbers.mapWithIndex { (index, number) -> String in
return "\(index): \(number)"
}
print("Numbers: \(numbersWithIndex)")

小开

这是一个工作的 CollectionType扩展，适用于使用抛出和重新抛出的 Swift 2.1:

extension CollectionType {


func map<T>(@noescape transform: (Self.Index, Self.Generator.Element) throws -> T) rethrows -> [T] {
return try zip((self.startIndex ..< self.endIndex), self).map(transform)
}


}

我知道这不是你想要的，但这解决了你的问题。您可以尝试这种快速的2.0 Luhn 方法，而不需要扩展任何内容:

func luhn(string: String) -> Bool {
var sum = 0
for (idx, value) in string.characters.reverse().map( { Int(String($0))! }).enumerate() {
sum += ((idx % 2 == 1) ? (value == 9 ? 9 : (value * 2) % 9) : value)
}
return sum > 0 ? sum % 10 == 0 : false
}

小开

使用 Swift 3，当您有一个符合 Sequence协议的对象，并且希望将其中的每个元素与其索引链接时，可以使用 enumerated()方法。

例如:

let array = [1, 18, 32, 7]
let enumerateSequence = array.enumerated() // type: EnumerateSequence<[Int]>
let newArray = Array(enumerateSequence)
print(newArray) // prints: [(0, 1), (1, 18), (2, 32), (3, 7)]

let reverseRandomAccessCollection = [1, 18, 32, 7].reversed()
let enumerateSequence = reverseRandomAccessCollection.enumerated() // type: EnumerateSequence<ReverseRandomAccessCollection<[Int]>>
let newArray = Array(enumerateSequence)
print(newArray) // prints: [(0, 7), (1, 32), (2, 18), (3, 1)]

let reverseCollection = "8763".characters.reversed()
let enumerateSequence = reverseCollection.enumerated() // type: EnumerateSequence<ReverseCollection<String.CharacterView>>
let newArray = enumerateSequence.map { ($0.0 + 1, String($0.1) + "A") }
print(newArray) // prints: [(1, "3A"), (2, "6A"), (3, "7A"), (4, "8A")]

因此，在最简单的情况下，您可以在 Playground 中实现 Luhn 算法，如下所示:

let array = [8, 7, 6, 3]
let reversedArray = array.reversed()
let enumerateSequence = reversedArray.enumerated()


let luhnClosure = { (sum: Int, tuple: (index: Int, value: Int)) -> Int in
let indexIsOdd = tuple.index % 2 == 1
guard indexIsOdd else { return sum + tuple.value }
let newValue = tuple.value == 9 ? 9 : tuple.value * 2 % 9
return sum + newValue
}


let sum = enumerateSequence.reduce(0, luhnClosure)
let bool = sum % 10 == 0
print(bool) // prints: true

如果你从 String开始，你可以这样实现它:

let characterView = "8763".characters
let mappedArray = characterView.flatMap { Int(String($0)) }
let reversedArray = mappedArray.reversed()
let enumerateSequence = reversedArray.enumerated()


let luhnClosure = { (sum: Int, tuple: (index: Int, value: Int)) -> Int in
let indexIsOdd = tuple.index % 2 == 1
guard indexIsOdd else { return sum + tuple.value }
let newValue = tuple.value == 9 ? 9 : tuple.value * 2 % 9
return sum + newValue
}


let sum = enumerateSequence.reduce(0, luhnClosure)
let bool = sum % 10 == 0
print(bool) // prints: true

如果需要重复这些操作，可以将代码重构为一个扩展:

extension String {


func luhnCheck() -> Bool {
let characterView = self.characters
let mappedArray = characterView.flatMap { Int(String($0)) }
let reversedArray = mappedArray.reversed()
let enumerateSequence = reversedArray.enumerated()


let luhnClosure = { (sum: Int, tuple: (index: Int, value: Int)) -> Int in
let indexIsOdd = tuple.index % 2 == 1
guard indexIsOdd else { return sum + tuple.value }
let newValue = tuple.value == 9 ? 9 : tuple.value * 2 % 9
return sum + newValue
}


let sum = enumerateSequence.reduce(0, luhnClosure)
return sum % 10 == 0
}


}


let string = "8763"
let luhnBool = string.luhnCheck()
print(luhnBool) // prints: true

或者，以一种更简洁的方式:

extension String {


func luhnCheck() -> Bool {
let sum = characters
.flatMap { Int(String($0)) }
.reversed()
.enumerated()
.reduce(0) {
let indexIsOdd = $1.0 % 2 == 1
guard indexIsOdd else { return $0 + $1.1 }
return $0 + ($1.1 == 9 ? 9 : $1.1 * 2 % 9)
}
return sum % 10 == 0
}


}


let string = "8763"
let luhnBool = string.luhnCheck()
print(luhnBool) // prints: true

小开

迅速减少:

let numbers = [7,3,10]


let sum = numbers.reduce(0) {


$0 + $1


}


print(sum) // 20

快速地图:

将模型转换为我们需要的模型

我们希望将名称数组更改为大写字母的名称数组,

意味着我想要的一切

let names = ["John", "Paul", "George", "Ringo"]


let uppercased = names.map {


$0.uppercased()
}


print(uppercased) // ["JOHN", "PAUL", "GEORGE", "RINGO"]

我希望你明白我的意思:)。

用 Swift 中的索引映射或减少

Swift 3.0及以上版本