Swift 배열에서 요소의 합계를 찾는 중

Swift 배열에서 요소의 합계를 찾는 중

정수 배열의 합을 빠르게 구하는 가장 쉬운 방법은 무엇입니까?저는 배수라는 배열을 가지고 있는데 그 배수의 합을 알고 싶습니다.

이것이 제가 찾을 수 있는 가장 쉽고 간단한 방법입니다.

Swift 3 및 Swift 4:

let multiples = [...]
let sum = multiples.reduce(0, +)
print("Sum of Array is : ", sum)

스위프트 2:

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

---

기타 정보:

이 방법에서는 Array의 축소 방법(여기서 설명)을 사용합니다.이 방법을 사용하면 "제공된 닫힘을 재귀적으로 적용함으로써 요소 집합을 단일 값으로 줄일 수 있습니다."초기값으로 0을 부여하고, 그 다음, 기본적으로, 닫힘을 부여합니다.{ $0 + $1 }물론 Swift가 그렇게 굴러가기 때문에 단일 플러스 기호로 단순화할 수 있습니다.

3+1개의 라이너로 물체의 속성을 합산합니다.

var totalSum = scaleData.map({$0.points}).reduce(0, +)

여기서 points는 사용자 지정 개체 scaleData에서 축소하려는 속성입니다.

Swift 4에서는 시퀀스 요소를 숫자 프로토콜로 제한하여 다음과 같이 시퀀스 내의 모든 요소의 합계를 반환할 수도 있습니다.

extension Sequence where Element: Numeric {
    /// Returns the sum of all elements in the collection
    func sum() -> Element { return reduce(0, +) }
}

---

편집/갱신:

Xcode 10.2 • Swift 5 이후

우리는 단순히 시퀀스 요소를 새로운 AdditionAssmetic 프로토콜로 제한하여 컬렉션의 모든 요소의 합계를 반환할 수 있다.

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

---

Xcode 11 • Swift 5.1 이후

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

커스텀 객체의 속성을 요약하기 위해 Sequence를 확장하여 다음과 같은 값을 반환하는 술어를 사용할 수 있습니다.AdditiveArithmetic:

extension Sequence  {
    func sum<T: AdditiveArithmetic>(_ predicate: (Element) -> T) -> T { reduce(.zero) { $0 + predicate($1) } }
}

---

사용방법:

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

Swift3가 다음과 같이 변경되었습니다.

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

Swift 4의 예

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

이것도 동작합니다.

let arr = [1,2,3,4,5,6,7,8,9,10]
var sumedArr = arr.reduce(0, combine: {$0 + $1})
print(sumedArr)

결과는 55 입니다.

스위프트 3

일반 개체 배열이 있고 일부 개체 속성을 합산하려면 다음과 같이 하십시오.

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 

짧은 형태에도 불구하고 많은 경우 고전적인 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
}

스위프트 3, 4, 5

감소 사용:

let totalAmount = yourTransactionsModelArray.reduce(0) { $0 + $1.amount}

이해하기 위한 구식 방법:

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

//여기서 n = 배열 내의 요소 수

생각할 수 있는 해결책: 프레픽스 연산자를 정의합니다.APL(예: GNU APL)에서와 같이 "+/" 축소 연산자와 유사합니다.

여기에서는 조금 다른 접근법이 있습니다.

protocol engeneric type을 사용하면 Double, Float 및 Int 어레이 타입에서 이 연산자를 사용할 수 있습니다.

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
   }
}

다음과 같이 사용:

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

(Swift 2.2용으로 업데이트, Xcode 버전 7.3에서 테스트 완료)

Swift 3.0

나도 같은 문제가 있었어. 애플 문서에서도 이 해결책을 찾았어.

let numbers = [1, 2, 3, 4]
let addTwo: (Int, Int) -> Int = { x, y in x + y }
let numberSum = numbers.reduce(0, addTwo)
// 'numberSum' == 10

그러나 내 경우에는 객체 목록이 있었고, 내 목록의 가치를 변환해야 했습니다.

let numberSum = self.list.map({$0.number_here}).reduce(0, { x, y in x + y })

난 이게 좋아.

또 다른 간단한 방법:

let sumOfMultiples = ar.reduce(0) { x, y in x + y }          
print(sumOfMultiples)

심플하게...

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)")

출력:

요소의 합계는 37입니다.

나에겐 재산을 이용해서 이런 식이었어.

    let blueKills = match.blueTeam.participants.reduce(0, { (result, participant) -> Int in
        result + participant.kills
    })

@IBOutlet var valueSource: [MultipleIntBoundSource]!

private var allFieldsCount: Int {
    var sum = 0
    valueSource.forEach { sum += $0.count }
    return sum
}

중첩된 매개 변수에 이 매개 변수

객체 배열의 요소 합계의 경우

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

언급URL : https://stackoverflow.com/questions/24795130/finding-sum-of-elements-in-swift-array