Swift Äquivalent von Rubys "each_cons"

Question

Rubin

Ruby hat each_cons, die wie dieser

verwendet werden kann

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

Swift

den gleichen Code in schnellen, aber ohne die each_cons Funktion

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

Wie kann dieser schnelle Code kürzer oder einfacher gemacht werden?

Answer 1

zip(votes, votes.dropFirst()) 

Dies erzeugt eine Sequenz von Tupeln.

Beispiel

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

Dies ist die allgemeine Lösung kam ich mit, aber es scheint eine Art schrecklich ineffizient. Zur Umsetzung each_cons(n), setzen Sie meine clump zu n:

 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 
      } 
     }