Блог

 var a = [32,37,68,66,97,38,16,86,35,58]
  

Я хочу знать,
как напечатать сумму и среднее значение четного числа, сумму и среднее значение нечетного числа

O (n)

Вы можете сделать это за один раз :

 let (oddsSum, oddsCount, evensSum, evensCount) = a.reduce(into:(0, 0, 0, 0)) { tuple, element in
    if element % 2 != 0 {
        tuple.0  = element
        tuple.1  = 1
    } else {
        tuple.2  = element
        tuple.3  = 1
    }
}

let oddsAverage = oddsCount == 0 ? 0.0 : Double(oddsSum) / Double(oddsCount)
let evensAverage = evensCount == 0 ? 0.0 : Double(evensSum) / Double(evensCount) 
  

Что даст следующие результаты :

oddsSum // 169
oddsAverage // 56.33333333333334 
Четная сумма //364 
evensAverage // 52

Два массива

Вы можете создать два массива коэффициентов и четных чисел следующим образом :

 let a = [32, 37, 68, 66, 97, 38, 16, 86, 35, 58]

let (odds, evens) = a.reduce(into:([Int](), [Int]())) { tuple, element in
    if element % 2 != 0 {
        tuple.0.append(element)
    } else {
        tuple.1.append(element)
    }
}
  

odds и evens два массива целых чисел : [Int] .

Суммы

Для вычисления сумм :

 let oddsSum = odds.reduce(0,  )           //169
let evensSum = odds.reduce(0,  )          //364
  

Вы также можете использовать cblas_dasum(_:_:_:) фреймворк Accelerate, который быстрее, чем reduce :

 import Accelerate

var (odds, evens) = a.reduce(into:([Double](), [Double]())) { tuple, element in
    if element % 2 != 0 {
        tuple.0.append(Double(element))
    } else {
        tuple.1.append(Double(element))
    }
}

var oddSum = Int(cblas_dasum(Int32(odds.count), amp;odds, 1))
print(oddSum)     //169

var evenSum = Int(cblas_dasum(Int32(evens.count), amp;evens, 1))
print(evenSum)    //364
  

Средние значения

Средние значения — это суммы, деленные на количество элементов в каждом массиве.

 let oddsAverage = odds.isEmpty ? 0.0 : Double(oddsSum) / Double(odds.count)    //56.33333333333334
let evensAverage = evens.isEmpty ? 0.0 : Double(evensSum) / Double(evens.count) //52
  

Или вы можете использовать vDSP_meanvD(_:_:_:_:) из Accelerate framework, что быстрее, чем вычисление суммы и последующее деление на количество :

 import Accelerate

var (odds, evens) = a.reduce(into:([Double](), [Double]())) { tuple, element in
    if element % 2 != 0 {
        tuple.0.append(Double(element))
    } else {
        tuple.1.append(Double(element))
    }
}

var oddAvg = 0.0
vDSP_meanvD(amp;odds, 1, amp;oddAvg, vDSP_Length(odds.count))
print(oddAvg)     //56.333333333333336

var evenAvg = 0.0
vDSP_meanvD(amp;evens, 1, amp;evenAvg, vDSP_Length(evens.count))
print(evenAvg)    //52.0
  

Добавьте расширение, подобное этому

 extension Sequence where Self.Element == Int {
    var sum: Int {
        return self.reduce(0, { $0   $1 })
    }
}
  

затем сделайте это:

 var a = [38,97,25,66,90,31,16,86,33,59]
var evens = a.filter({ ($0 % 2) == 0 })
var odds = a.filter({ ($0 % 2) != 0 })

print(evens.sum)
print(odds.sum)
  

Без расширения, так что, возможно, новичкам будет проще понять, вот как я бы это сделал:

 let oddElements = a.filter{$0 % 2 == 0}
let evenElements = a.filter{$0 % 2 != 0}

let oddElementsSum = oddElements.reduce(0, {$0   $1})
let oddElementsAverage = oddElementsSum / oddElements.count

let evenElementsSum = evenElements.reduce(0, {$0   $1})
let evenElementsAverage = evenElementsSum / evenElements.count
  

Можно сделать операторы сокращения немного короче с помощью

 let oddElementsSum = oddElements.reduce(0, { })
let evenElementsSum = evenElements.reduce(0, { })
  

Затем вы можете печатать через

 print (oddElementsSum)
print (oddElementsAverage)
print (evenElementsSum)
print (evenElementsAverage)