Rapido Ridurre una serie di tuple in

Question

C'è un modo in cui posso chiamare la funzione di riduzione su una serie di tuple per trovare un valore massimo?

Per esempio

struct Gate{ 

    var maxedOpenGates = 1 

    var GatesOpen : [(openOrdered : Int, gateNum : Int)] = [] 

    init(defaultSelected : Int = 0){ 

     GatesOpen.append(openOrdered : 1, gateNum : defaultSelected) 
    } 

    private func manipulateGates(gates : [SegmentButton]){ 
     for i in GatesOpen{ 
      gates[i.gateNum].toggleSelected() 
     } 

    } 

    mutating func openGate(index : Int, buttons : [SegmentButton]){ 

     if GatesOpen.count < maxedOpenGates{ 
      GatesOpen.append( openOrdered: GatesOpen.count , gateNum: index) 

     }else{ 
     //////Finding the gate that was Opened the longest//// 
      let lastGate = GatesOpen.reduce(Int.min,{ max($0,$1) }) 

     } 
     manipulateGates(buttons) 
    } 
} 

in cui una che sto cercando di ridurre basano su openOrdered

let lastGate = GatesOpen.reduce(Int.min,{ max($0,$1) }) 

Answer 1

Sì, è possibile ridurre una serie di tuple come qualsiasi altro array. Gli argomenti della funzione combinata sono elementi dell'array, nel tuo caso "gate tuples" . E se il risultato di ridurre la matrice dovrebbe essere una tupla porta poi l'elemento iniziale e il risultato della funzione combinare deve essere anche di quel tipo:

let lastGate = gatesOpen.reduce(gatesOpen[0]) { 
     $0.openOrdered < $1.openOrdered ? $1 : $0 
} 

Naturalmente la matrice deve avere almeno un elemento per questo funziona. Per evitare il confronto non necessario di gatesOpen[0] con se stesso si può cambiare a (modificato dopo @ commento di Airspeed):

let lastGate = dropFirst(gatesOpen).reduce(gatesOpen[0]) { 
    $0.openOrdered < $1.openOrdered ? $1 : $0 
} 

Answer 2

Utilizzando chiusura con ridurre la funzione,

//////Finding the gate that was Opened the longest//// 
let intitalValue = (Int.min,Int.min) 
let lastGate: (openOrdered: Int, gateNum: Int) = GatesOpen.reduce(intitalValue){ 
     (longestOpenGate: (openOrdered: Int, gateNum: Int), gate) in 
      if(longestOpenGate.openOrdered < gate.openOrdered) { 
        return gate; 
      } else { 
        return longestOpenGate; 
      } 

} 
let lastGateNumber = lastGate.gateNum; 

Oppure,

let lastGate: (openOrdered: Int, gateNum: Int) = GatesOpen.reduce(intitalValue){ 
    $0.openOrdered < $1.openOrdered ? $1 : $0 
} 
let lastGateNumber = lastGate.gateNum;