计算函数返回的最高 2 和 3 个值

Question

在一个类中，我有 4 个返回单个值的函数（参见下面的代码）。

我需要添加 2 个额外的函数来计算以下总和：-

两个最高数字的总和

3 个最高数字的总和

这些总数随后将用于应用程序中的其他计算。

以下应注意，因为超过 1 个数字可能具有相同的值，但只有相关数字需要包含在总数中。以下是所需内容的示例：

两个最大值

如果返回值为 3、3、2、1，则返回值应为 6 (3 + 3)

如果返回值为 3、3、3、2，则返回值应为 6 (3 + 3)

如果返回值是 4、3、3、1，那么返回值应该是 7 (4 + 3)

三个最高值

如果返回是 3、3、2、2，那么返回应该是 8 (3 + 3 + 2)

如果返回是 4、3、3、3，那么返回应该是 10 (4 + 3 + 3)

如果返回值是 3、3、3、3，那么返回值应该是 9 (3 + 3 + 3)

我查看了许多搜索如下：-

1. 能够对返回的 4 个值应用排名，以便使用它来返回最高的 2 个或 3 个值，但找不到任何 SwiftUI 代码来实现这一点。

2. 我找到了可以应用简单排序的代码，但没有任何代码可以让我选择最高的 2 或 3 个值。

3. 我可以为每个值使用多个嵌套的 if 函数来将值与其他值进行比较并确定最高的 2 或 3 个值，但这将是很多代码来实现在 Excel 等中相对简单的计算。

SwiftUI 中是否有任何“标准”功能可以让我实现他的功能，或者上面 3 的冗长方式是唯一可以实现的方式？

希望这有意义吗？

func p1h1points(hole1par: Int16, hole1index: Int16) -> Int16 {

    let gross = p1hole1gross
    let par = hole1par
    let shot = p1h1shots(hole1index: hole1index)
    
    
    let net = Int16(gross) - Int16(shot)
    let points = par - net
    
    if p1hole1gross == 0 {
        return 0
    }
    
    if points < -1 {
        return 0
    }
    if points == -1 {
        return 1
    }
    if points == 0 {
        return 2
    }
    if points == 1 {
        return 3
    }
    if points == 2 {
        return 4
    }
    if points == 3 {
        return 5
    }
    if points == 4 {
        return 6
    }
    if points == 5 {
        return 7
    }
    if points == 6 {
        return 8
    }
    if points == 7 {
        return 9
    }
    return 0
    }



func p2h1points(hole1par: Int16, hole1index: Int16) -> Int16 {

    let gross = p2hole1gross
    let par = hole1par
    let shot = p2h1shots(hole1index: hole1index)
    
    
    let net = Int16(gross) - Int16(shot)
    let points = par - net
    
    if p2hole1gross == 0 {
        return 0
    }
    
    if points < -1 {
        return 0
    }
    if points == -1 {
        return 1
    }
    if points == 0 {
        return 2
    }
    if points == 1 {
        return 3
    }
    if points == 2 {
        return 4
    }
    if points == 3 {
        return 5
    }
    if points == 4 {
        return 6
    }
    if points == 5 {
        return 7
    }
    if points == 6 {
        return 8
    }
    if points == 7 {
        return 9
    }
    return 0
    }

func p3h1points(hole1par: Int16, hole1index: Int16) -> Int16 {

    let gross = p3hole1gross
    let par = hole1par
    let shot = p3h1shots(hole1index: hole1index)
    
    
    let net = Int16(gross) - Int16(shot)
    let points = par - net
    
    if p3hole1gross == 0 {
        return 0
    }
    
    if points < -1 {
        return 0
    }
    if points == -1 {
        return 1
    }
    if points == 0 {
        return 2
    }
    if points == 1 {
        return 3
    }
    if points == 2 {
        return 4
    }
    if points == 3 {
        return 5
    }
    if points == 4 {
        return 6
    }
    if points == 5 {
        return 7
    }
    if points == 6 {
        return 8
    }
    if points == 7 {
        return 9
    }
    return 0
    }

func p4h1points(hole1par: Int16, hole1index: Int16) -> Int16 {

    let gross = p4hole1gross
    let par = hole1par
    let shot = p4h1shots(hole1index: hole1index)
    
    
    let net = Int16(gross) - Int16(shot)
    let points = par - net
    
    if p4hole1gross == 0 {
        return 0
    }
    
    if points < -1 {
        return 0
    }
    if points == -1 {
        return 1
    }
    if points == 0 {
        return 2
    }
    if points == 1 {
        return 3
    }
    if points == 2 {
        return 4
    }
    if points == 3 {
        return 5
    }
    if points == 4 {
        return 6
    }
    if points == 5 {
        return 7
    }
    if points == 6 {
        return 8
    }
    if points == 7 {
        return 9
    }
    return 0
    }

Answer 1

在实现这样的新功能时，将其放入新的自定义类型通常是一个好主意，这样该类型只负责这个新部分，而旧代码不会因为更多的职责而变得混乱。

此外，这将使更改逻辑或在需要时扩展它变得更容易。

所以这是一个用于计算点的结构，您可以从现有代码中使用它

struct PointsCalculator {
    private var playerPoints: [Int]

    init(points: [Int]) {
        playerPoints = points
    }

    var sum2Highest: Int {
        sum(for: 2)
    }

    var sum3Highest: Int {
        sum(for: 3)
    }

    private func sum(for count: Int) -> Int {
        playerPoints.sorted().suffix(count).reduce(0, +)
    }
}

这将所有玩家的分数作为一个数组，如果同时计算每个玩家的分数，则效果很好。如果另一方面和点是单独计算的，那么下面的函数可能更合适

extension PointsCalculator {
    init() {
        playerPoints = Array(repeating: 0, count: 4)
    }

    mutating func add(_ points: Int, player: Int) {
        guard 1...4 ~= player else {
            fatalError("Player must be between 1 and 4")
        }

        playerPoints[player-1] = points
    }
}

Answer 2

假设你有一个数字数组，我会这样做

let highestNumbersToAdd = 2
arrayWithPoints.sort
let total = arrayWithPoints[...highestNumbersToAdd].reduce(0, +)