Swift에서 인덱스로 매핑 또는 축소

Swift에서 인덱스로 매핑 또는 축소

배열의 인덱스를 가져올 수 있는 방법이 있습니까?map또는reduce스위프트에서?저는 그런 것을 찾고 있습니다.each_with_index루비로.

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위의 변수.

사용할 수 있습니다.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메서드 서명에 이미 누적/현재 튜플이 있기 때문에 인덱스와 요소를 튜플에서 분리할 수 없습니다.대신, 당신은 사용해야 할 것입니다..0그리고..1당신의 두 번째 매개변수에.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)]

위해서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)")

Swift 3과 함께, 당신이 다음과 일치하는 객체를 가지고 있을 때.Sequence프로토콜 내부의 각 요소를 인덱스와 연결하려면 방법을 사용할 수 있습니다.

예:

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

---

따라서 가장 간단한 경우 다음과 같은 Lunn 알고리즘을 Playground에 구현할 수 있습니다.

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

네이트 쿡의 예에 더하여.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).

작업 컬렉션입니다.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)
    }

}

이것이 당신이 묻고 있던 것이 아니라 당신의 문제를 해결한다는 것을 압니다.다음과 같은 swift 2.0 Lunn 방법을 확장하지 않고도 사용할 수 있습니다.

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
}

신속하게 감소:

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

제 말뜻을 이해해주시길 바랍니다 :)

언급URL : https://stackoverflow.com/questions/28012205/map-or-reduce-with-index-in-swift