रूबी के "each_cons"

Question

रूबी

रूबी की स्विफ्ट बराबर each_cons कि इस

class Pair 
    def initialize(left, right) 
     @left = left 
     @right = right 
    end 
end 
votes = ["a", "b", "c", "d"] 
pairs = votes.each_cons(2).map { |vote| Pair.new(*vote) } 
p pairs 
# [#<Pair @left="a", @right="b">, #<Pair @left="b", @right="c">, #<Pair @left="c", @right="d">] 

स्विफ्ट

तेज में एक ही कोड की तरह इस्तेमाल किया जा सकता है, लेकिन each_cons समारोह के बिना

struct Pair { 
    let left: String 
    let right: String 
} 
let votes = ["a", "b", "c", "d"] 
var pairs = [Pair]() 
for i in 1..<votes.count { 
    let left = votes[i-1] 
    let right = votes[i] 
    pairs.append(Pair(left: left, right: right)) 
} 
print(pairs) 
// [Pair(left: "a", right: "b"), Pair(left: "b", right: "c"), Pair(left: "c", right: "d")] 

यह त्वरित कोड छोटा या सरल कैसे बनाया जा सकता है?

Answer 1

zip(votes, votes.dropFirst()) 

यह टुपल्स का अनुक्रम उत्पन्न करता है।

उदाहरण

struct Pair { 
    let left: String 
    let right: String 
} 
let votes = ["a", "b", "c", "d"] 
let pairs = zip(votes, votes.dropFirst()).map { 
    Pair(left: $0, right: $1) 
} 
print(pairs) 
// [Pair(left: "a", right: "b"), Pair(left: "b", right: "c"), Pair(left: "c", right: "d")] 

Answer 2

यह सामान्य समाधान मैं के साथ आया है, लेकिन यह एक तरह से बुरी तरह अक्षम लगता है।

 let arr = [1,2,3,4,5,6,7,8] 
     let clump = 2 
     let cons : [[Int]] = arr.reduce([[Int]]()) { 
      memo, cur in 
      var memo = memo 
      if memo.count == 0 { 
       return [[cur]] 
      } 
      if memo.count < arr.count - clump + 1 { 
       memo.append([]) 
      } 
      return memo.map { 
       if $0.count == clump { 
        return $0 
       } 
       var arr = $0 
       arr.append(cur) 
       return arr 
      } 
     }