Finding sum of elements in Swift array


Translate

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.


All Answers
  • Translate

    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.


  • Translate

    Swift 3 / Swift 4 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


  • Translate

    Swift3 has changed to :

    let multiples = [...]
    sum = multiples.reduce(0, +)
    

  • Translate

    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


  • Translate

    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 as follow

    extension Sequence where Element: AdditiveArithmetic {
        func sum() -> Element {
            return reduce(.zero, +)
        }
    }
    

    let numbers = [1,2,3]
    numbers.sum()    // 6
    
    let doubles = [1.5, 2.7, 3.0]
    doubles.sum()    // 7.2
    

  • Translate

    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
    

  • Translate

    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
    }
    

  • Translate

    How about the simple way of

    for (var i = 0; i < n; i++) {
     sum = sum + Int(multiples[i])!
    }
    

    //where n = number of elements in the array


  • Translate

    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)


  • Translate

    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.


  • Translate
    @IBOutlet var valueSource: [MultipleIntBoundSource]!
    
    private var allFieldsCount: Int {
        var sum = 0
        valueSource.forEach { sum += $0.count }
        return sum
    }
    

    used this one for nested parameters


  • Translate

    Swift 3

    From all the options displayed here, this is the one that worked for me.

    let arr = [6,1,2,3,4,10,11]
    
    
    var sumedArr = arr.reduce(0, { ($0 + $1)})
    print(sumedArr)
    

  • Translate

    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


  • Translate

    For sum of elements in array of Objects

    self.rankDataModelArray.flatMap{$0.count}.reduce(0, +)
    

  • Translate

    this is my approach about this. however I believe that the best solution is the answer from the user username tbd

    var i = 0 
    var sum = 0
    let example = 0
    for elements in multiples{
        i = i + 1
        sum = multiples[ (i- 1)]
        example = sum + example
    }