Calculate how many more points to get a set percentage

I'm trying to work out how many more wins are needed to get a certain win/loss ratio, but I can't get my head around how to work it out.

I have the win ratio, and total number of battles

For example, I have 112 battles, and a 50% win rate, how many more wins do I need to get to 70%

So far I have the below, but I'm not getting the values I'm expecting. There's probably an easier way of doing this as well.

    func calculateNeededWins() {
        
        // Convert to Double
        guard let currentRatioDouble = Double(currentRatio) else {return}
        guard var currentBattlesInt = Double(currentBattles) else {return}
        
        NSLog("Current Win Ratio: \(currentRatioDouble)")
        NSLog("Total Battles: \(currentBattlesInt)")
        
        // Convert Ratio to Decimal
        let currentRatioDecimal = (currentRatioDouble / 100)
        NSLog("Current Win Ratio (Decimal): \(currentRatioDecimal)")
        
        var totalWins = currentRatioDecimal * currentBattlesInt
        NSLog("Total Wins: \(totalWins)")
        NSLog("------------")
        let currentWins = totalWins
        guard var currentPercentage = Int(currentRatio) else {return}
        
        let needRatio = neededRatio * 10
        var needWins = 0
        
        NSLog("Loop Start")
        // Add 1 to both wins & total battles until win ratio = required
        while(currentPercentage <= needRatio) {
            NSLog("Current %: \(currentPercentage)")
            NSLog("Wins %: \(totalWins)")
            NSLog("Total %: \(currentBattlesInt)")
            NSLog("------------")
            
            currentBattlesInt += 1
            totalWins += 1
            needWins += 1
            
            let newPercentage = currentBattlesInt * totalWins
            NSLog("New %: \(newPercentage)")
            NSLog("Wins %: \(totalWins)")
            NSLog("Total %: \(currentBattlesInt)")
            
            NSLog("************************************************************")
            
            currentPercentage = Int(newPercentage)
        }
        
        neededWinsString = "\(needWins)"
        
        currentWinsString = "\(currentWins)"
    }

This results with

>Current Win Ratio: 50.0

>Total Battles: 112.0

>Current Win Ratio (Decimal): 0.5

>Total Wins: 56.0

>------------

>Loop Start

>Current : 50

>Wins : 56.0

>Total : 112.0

>------------

>New : 6441.0

>Wins : 57.0

>Total : 113.0

Defining a few variables:

• r_t = target win rate
• r_c = current win rate
• b_c = how many battles thus far
• w_a = how many additional wins are needed

Using a little algebra, we can deduce the solution:

> w_a = ((r_t - r_c) ⨉ b_c) / (1 - r_t)

And, obviously, we then need to round that answer up to the nearest integer.

Thus, given 112 battles with a current run rate of 50%, to get that rate to 70% you’d need 75 straight wins.

Thus, the simple solution in Swift is:

func additionalWins(currentRate: Double, targetRate: Double, battles: Int) -> Int {
    let result = ((targetRate - currentRate) * Double(battles)) / (1 - targetRate)
    return max(0, Int(result.rounded(.up)))
}

You probably should check the preconditions and handle edge case scenarios, perhaps:

func additionalWins(currentRate: Double, targetRate: Double, battles: Int) -> Int {
    precondition(0...1 ~= currentRate)
    precondition(0...1 ~= targetRate)
    precondition(battles >= 0)
    
    if targetRate <= currentRate { 
        return 0
    }
    
    if battles == 0 {
        return targetRate > 0 ? 1 : 0
    }
        
    if targetRate == 1 {
        if currentRate == 1 {
            return 0
        }
        fatalError("There is no way, given current rate of \(currentRate * 100)%, that you can achieve target rate of \(targetRate * 100)%")
    }
        
    let result = ((targetRate - currentRate) * Double(battles)) / (1 - targetRate)
    return max(0, Int(result.rounded(.up)))
}

FWIW, an algorithmic solution might be:

func additionalWins(currentRate: Double, targetRate: Double, battles: Int) -> Int {
    precondition(0...1 ~= currentRate)
    precondition(0...1 ~= targetRate)
    precondition(battles >= 0)
    
    if targetRate <= currentRate { 
        return 0
    }
    
    if battles == 0 {
        return targetRate > 0 ? 1 : 0
    }
        
    if targetRate == 1 {
        if currentRate == 1 {
            return 0
        }
        fatalError("There is no way, given current rate of \(currentRate * 100)%, that you can achieve target rate of \(targetRate * 100)%")
    }

    var i = 0.0
    var currentWins = (Double(battles) * currentRate).rounded()
    var currentBattles = Double(battles)
    
    while ((currentWins + i) / (currentBattles + i)) < targetRate {
        i += 1
    }
    
    return Int(i)
}

But the arithmetic solution is obviously more efficient.