Jak podzielić tablicę na pół w Swift?

Question

Jak podzielić talię kart? Mam tablicę złożoną z losowego dealera kart, ale nie mam pojęcia, jak podzielić talię.

Dziękuję wszystkim za pomoc! Mam teraz działającą aplikację kartową, napotkaliśmy inne problemy, ale zostały one szybko rozwiązane.

Answer 1

Można użyć Zasięg indeks

let deck: [String] = ["J", "Q", "K", "A"] 

// use ArraySlice only for transient computation 
let leftSplit: ArraySlice<String> = deck[0 ..< deck.count/2] // "J", "Q" 
let rightSplit: ArraySlice<String> = deck[deck.count/2 ..< deck.count] // "K", "A" 

// make arrays from ArraySlice 
let leftDeck: [String] = Array(leftSplit) // "J", "Q" 
let rightDeck: [String] = Array(rightSplit) // "K", "A" 

EDIT: powyżej kod jest dla Swift 2, może 3 do Swift jest bardziej wygodny sposób.

Answer 2

Można dokonać rozszerzenia więc może powrócić tablicę dwóch macierzy, współpracując z Ints, smyczki, etc:

extension Array { 
    func split() -> [[Element]] { 
     let ct = self.count 
     let half = ct/2 
     let leftSplit = self[0 ..< half] 
     let rightSplit = self[half ..< ct] 
     return [Array(leftSplit), Array(rightSplit)] 
    } 
} 

let deck = ["J", "Q", "K", "A"] 
let nums = [0, 1, 2, 3, 4] 

deck.split() // [["J", "Q"], ["K", "A"]] 
nums.split() // [[0, 1], [2, 3, 4]] 

Ale wracając nazwanego krotka jest nawet lepiej, bo to wymusza fakt, że oczekiwać dokładnie dwóch tablic w wyniku:

extension Array { 
    func split() -> (left: [Element], right: [Element]) { 
     let ct = self.count 
     let half = ct/2 
     let leftSplit = self[0 ..< half] 
     let rightSplit = self[half ..< ct] 
     return (left: Array(leftSplit), right: Array(rightSplit)) 
    } 
} 

let deck = ["J", "Q", "K", "A"] 

let splitDeck = deck.split() 
print(splitDeck.left) // ["J", "Q"] 
print(splitDeck.right) // ["K", "A"] 

Uwaga: kredyty idzie do Andrei i Qbyte za udzielenie pierwszej poprawnej odpowiedzi, jestem po prostu dodanie informacji.

Answer 3

Można utworzyć rozszerzenie na SequenceType i utworzyć funkcję o nazwie divide.

Ta funkcja będzie iterować przez elementy sekwencji podczas umieszczania tych, które pasują do predykatu do jednej tablicy (slice) i tych, które nie pasują do innej tablicy (remainder). Ta funkcja zwraca krotkę zawierającą slice i remainder.

extension SequenceType { 

    /** 
    Returns a tuple with 2 arrays. 
    The first array (the slice) contains the elements of self that match the predicate. 
    The second array (the remainder) contains the elements of self that do not match the predicate. 
    */ 
    func divide(@noescape predicate: (Self.Generator.Element) -> Bool) -> (slice: [Self.Generator.Element], remainder: [Self.Generator.Element]) { 
     var slice:  [Self.Generator.Element] = [] 
     var remainder: [Self.Generator.Element] = [] 
     forEach { 
      switch predicate($0) { 
      case true : slice.append($0) 
      case false : remainder.append($0) 
      } 
     } 
     return (slice, remainder) 
    } 

} 

To jest przykład

let tuple = [1, 2, 3, 4, 5].divide({ $0 >= 3 }) 
tuple.slice  // [3, 4, 5] 
tuple.remainder // [1, 2]