Swiftでインデックスを使用してマップまたは縮小する


143

配列のインデックスを取得する方法がありますmapreduceスウィフトでは?each_with_indexRubyのようなものを探しています。

func lunhCheck(number : String) -> Bool
{
    var odd = true;
    return reverse(number).map { String($0).toInt()! }.reduce(0) {
        odd = !odd
        return $0 + (odd ? ($1 == 9 ? 9 : ($1 * 2) % 9) : $1)
    }  % 10 == 0
}

lunhCheck("49927398716")
lunhCheck("49927398717")

上記odd変数を削除したいと思います。

回答:


313

あなたが使用できるenumerate配列(変換するためにArrayString一緒に対に整数カウンタと要素とタプルのシーケンスに、など)。あれは:

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、メソッドシグネチャに累積/現在のタプルが既にあるため、タプルのインデックスと要素を分離することはできません。代わりに、あなたが使用する必要があります.0し、.1あなたの2番目のパラメータにreduce閉鎖:

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-syntax / inlineを使用して、ディクショナリに配列をマップできます。

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)]

1
仕上げの楽しさを奪いたくないので、必要に応じて、変更されたLuhnチェックを答えではなく要旨に入れます。gist.github.com
Nate Cook

5
SWIFT 2.0では、あなたは何をする必要があります:numbers.enumerate().map { (index, element) in ...
ロバート・

@CharlieMartin:またはの.reduce後に使用できます。enumerate()zip
ネイト・クック

しかし、インデックス付き?関数が2つのパラメーターしか必要とせず、reduceが最初のパラメーターとして最初のオブジェクト(reduceの結果)を受け取り、2番目のパラメーターとして現在の値が繰り返されるというエラーが発生します。現在、代わりにfor..inを使用しています
Charlie Martin

Swift 5 enumerateは今ですenumerated
lustig

10

以下のために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)")

8

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")]

したがって、最も単純なケースでは、次のようにプレイグラウンドで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

2

ネイトクックのの例に加えて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]

ように注意しEnumerateSequenceたようにクロージャに渡さenumeratedネストされた様式で分解することができないが、このようにしてタプルのメンバーは、閉鎖内部分解されなければならない(すなわち、。 enumerated.index)。


2

これは、スローと再スローを使用するSwift 2.1のCollectionType拡張機能です。

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
}
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.