What is the easiest (best) way to find the sum of an array of integers in swift? I have an array called multiples and I would like to know the sum of the multiples.
16 Answers
This is the easiest/shortest method I can find.
Swift 3 and Swift 4:
let multiples = [...]
let sum = multiples.reduce(0, +)
print("Sum of Array is : ", sum)
Swift 2:
let multiples = [...]
sum = multiples.reduce(0, combine: +)
Some more info:
This uses Array's reduce method (documentation here), which allows you to "reduce a collection of elements down to a single value by recursively applying the provided closure". We give it 0 as the initial value, and then, essentially, the closure { $0 + $1 }. Of course, we can simplify that to a single plus sign, because that's how Swift rolls.
6 Comments
Libor Zapletal
Thanks for this answer. It works great and I just want to add my example code with array of custom classes:
let totalSum = self.cheques.reduce(0) { $0 + $1.amount}
Evgenii
Great answer but missing parameter name
combine. Should be multiples.reduce(0, combine: +).
lorenzo
Is it faster than a for loop?
Samah
@SwiftMatt Try using a
flatMap on it first to flatten it to a single dimension array. multiArray.flatMap{$0}.reduce(0, combine: +)
Tom Dibble
@lorenzo - Testing on an iPhone 7 with latest Swift and XCode (a simple array filled with 1,000,000 UInt32 random values capped at 256 to prevent UInt32 overflow) interestingly shows the 'for' loop being just a hair faster (1.941 seconds versus 2.137 seconds), although that advantage is not present at 100,000 values (0.23 seconds each). IMHO, code clarity is worth any very minor performance cost here even when dealing with 32MB arrays.
|
Swift 3+ one liner to sum properties of objects
var totalSum = scaleData.map({$0.points}).reduce(0, +)
Where points is the property in my custom object scaleData that I am trying to reduce
2 Comments
Leo Dabus
This will unnecessarily iterate the whole collection twice
Climbatize
you can achieve this with
scaleData.reduce(0) { $0 + $1.points }In Swift 4 You can also constrain the sequence elements to Numeric protocol to return the sum of all elements in the sequence as follow
extension Sequence where Element: Numeric {
/// Returns the sum of all elements in the collection
func sum() -> Element { return reduce(0, +) }
}
edit/update:
Xcode 10.2 • Swift 5 or later
We can simply constrain the sequence elements to the new AdditiveArithmetic protocol to return the sum of all elements in the collection
extension Sequence where Element: AdditiveArithmetic {
func sum() -> Element {
return reduce(.zero, +)
}
}
Xcode 11 • Swift 5.1 or later
extension Sequence where Element: AdditiveArithmetic {
func sum() -> Element { reduce(.zero, +) }
}
let numbers = [1,2,3]
numbers.sum() // 6
let doubles = [1.5, 2.7, 3.0]
doubles.sum() // 7.2
To sum a property of a custom object we can extend Sequence to take a predicate to return a value that conforms to AdditiveArithmetic:
extension Sequence {
func sum<T: AdditiveArithmetic>(_ predicate: (Element) -> T) -> T { reduce(.zero) { $0 + predicate($1) } }
}
Usage:
struct Product {
let id: String
let price: Decimal
}
let products: [Product] = [
.init(id: "abc", price: 21.9),
.init(id: "xyz", price: 19.7),
.init(id: "jkl", price: 2.9)
]
products.sum(\.price) // 44.5
3 Comments
sabiland
Great, nice solution!
FrugalResolution
Best answer for me! 👌🏻
elemento
Finally found it. Probably the hardest shit I had to find on the internet so far. Works like a charm ✨
Swift3 has changed to :
let multiples = [...]
sum = multiples.reduce(0, +)
Comments
Swift 4 example
class Employee {
var salary: Int = 0
init (_ salary: Int){
self.salary = salary
}
}
let employees = [Employee(100),Employee(300),Employee(600)]
var sumSalary = employees.reduce(0, {$0 + $1.salary}) //1000
1 Comment
Carl Smith
Very helpful because it includes an example of totaling an arithmetic property for an array of objects, which is what I needed to do.
This also works:
let arr = [1,2,3,4,5,6,7,8,9,10]
var sumedArr = arr.reduce(0, combine: {$0 + $1})
print(sumedArr)
The result will be: 55
Comments
Swift 3
If you have an array of generic objects and you want to sum some object property then:
class A: NSObject {
var value = 0
init(value: Int) {
self.value = value
}
}
let array = [A(value: 2), A(value: 4)]
let sum = array.reduce(0, { $0 + $1.value })
// ^ ^
// $0=result $1=next A object
print(sum) // 6
Despite of the shorter form, many times you may prefer the classic for-cycle:
let array = [A(value: 2), A(value: 4)]
var sum = 0
array.forEach({ sum += $0.value})
// or
for element in array {
sum += element.value
}
2 Comments
Ivailo Kanev
ciao Luca, here is my solution: array.map({$0.value}).reduce(0, +)
Luca Davanzo
In this way you write more code and increment complexity.. so, why?
Swift 3, 4, and 5
Using reduce:
let totalAmount = yourTransactionsModelArray.reduce(0) { $0 + $1.amount}
Old fashioned way for understanding purposes:
for (var i = 0; i < n; i++) {
sum = sum + Int(multiples[i])!
}
//where n = number of elements in the array
4 Comments
donarb
Note that in Swift 3 this is no longer valid because the C style for loops have been removed from the language. Use for-in loops instead, Swift keeps track internally of the index.
MarkAurelius
That wouldn't work as it. You have to initialise sum to 0 first. The beauty of reduce is that it reminds you to think of the initial value.
JeremyP
var sum = 0 ; for n in multiples { sum += n } although I would use reduce.
Anand
@naishta already mentioned that it the for loo she wrote is only for understanding purpose
If your array contains nil then following solution will work for you
var array = [1,2,3,5,6,nil]
let sum = array.compactMap{$0}.reduce(0, +)
Comments
A possible solution: define a prefix operator for it. Like the reduce "+/" operator as in APL (e.g. GNU APL)
A bit of a different approach here.
Using a protocol en generic type allows us to to use this operator on Double, Float and Int array types
protocol Number
{
func +(l: Self, r: Self) -> Self
func -(l: Self, r: Self) -> Self
func >(l: Self, r: Self) -> Bool
func <(l: Self, r: Self) -> Bool
}
extension Double : Number {}
extension Float : Number {}
extension Int : Number {}
infix operator += {}
func += <T:Number> (inout left: T, right: T)
{
left = left + right
}
prefix operator +/ {}
prefix func +/ <T:Number>(ar:[T]?) -> T?
{
switch true
{
case ar == nil:
return nil
case ar!.isEmpty:
return nil
default:
var result = ar![0]
for n in 1..<ar!.count
{
result += ar![n]
}
return result
}
}
use like so:
let nmbrs = [ 12.4, 35.6, 456.65, 43.45 ]
let intarr = [1, 34, 23, 54, 56, -67, 0, 44]
+/nmbrs // 548.1
+/intarr // 145
(updated for Swift 2.2, tested in Xcode Version 7.3)
1 Comment
Tom Dibble
One issue with this is that often (at least, when dealing with large arrays) you will need the sum to be a different type than the components. For instance, if you have a million UInt32s running the gamut from 0 to 2^32-1 (ex, populated by arc4random()), adding those up will overflow your UInt32 "sum" value every time.
Swift 3.0
i had the same problem, i found on the documentation Apple this solution.
let numbers = [1, 2, 3, 4]
let addTwo: (Int, Int) -> Int = { x, y in x + y }
let numberSum = numbers.reduce(0, addTwo)
// 'numberSum' == 10
But, in my case i had a list of object, then i needed transform my value of my list:
let numberSum = self.list.map({$0.number_here}).reduce(0, { x, y in x + y })
this work for me.
Comments
another easy way of getting it done:
let sumOfMultiples = ar.reduce(0) { x, y in x + y }
print(sumOfMultiples)
Comments
Keep it simple...
var array = [1, 2, 3, 4, 5, 6, 7, 9, 0]
var n = 0
for i in array {
n += i
}
print("My sum of elements is: \(n)")
Output:
My sum of elements is: 37
Comments
For me, it was like this using property
let blueKills = match.blueTeam.participants.reduce(0, { (result, participant) -> Int in
result + participant.kills
})
Comments
@IBOutlet var valueSource: [MultipleIntBoundSource]!
private var allFieldsCount: Int {
var sum = 0
valueSource.forEach { sum += $0.count }
return sum
}
used this one for nested parameters
Comments
For sum of elements in array of Objects
self.rankDataModelArray.flatMap{$0.count}.reduce(0, +)
.sum()method to sum numeric arrays