缺了什么就惡補一下??

由于數(shù)字類型長度有限，超大數(shù)字相乘會造成溢出。這估計就是該算法的背景由來吧？（猜的哈哈哈??）

好吧，進入正題啦～

先舉個簡單的例子： 789 * 456

1. 第一步，把數(shù)字逐個放到數(shù)組里，組成

【7,8,9】 和 【4,5,6】

2. 第二步，從低位向高位逐位相乘（右往左??）

9 * 6
9 * 5
9 * 4
8 * 6
8 * 5

3.png

3.第三步，從低位向高位進位（右往左??）

規(guī)則：個位數(shù)原地保留，十位數(shù)以上的數(shù)字向左移動一位

步驟4.png

4. 最后把第一位的0舍棄，然后把數(shù)字串起來，就完成啦?。?！??????????

最后上個完整代碼

let result:String = getsTheResultOfMultiplyingTwoLargeNumbers(numberA: "789",
                                                              numberB: "456")

print("大數(shù)相乘結果-->\(result)")



//MARK:  - -------- 兩個大數(shù)相乘 算法 ---------

private func getsTheResultOfMultiplyingTwoLargeNumbers(numberA:String = "0" ,
                                                       numberB:String = "0") -> String {
    
    guard numberA != "0" && numberB != "0" else {
        return "0"
    }
    
    if numberA == "1" {
        return numberB
    }
    
    if numberB == "1" {
        return numberA
    }
    
    
    
    
    
    let numCountA:Int = numberA.count
    
    let numCountB:Int = numberB.count
    
    var resultArray:[Int] = Array.init(repeating: 0,
                                       count: numCountA + numCountB)
    
    
    var number1Array:[Int] = Array.init(repeating: 0,
                                        count: numCountA)

    var number2Array:[Int] = Array.init(repeating: 0,
                                        count: numCountB)


    //1. 把A數(shù)的每個數(shù)字遍歷出來放到數(shù)組
    for (index,charObject) in numberA.enumerated() {

        let numberString:String = String.init(charObject)

        number1Array[index] = Int(numberString) ?? 0
    }


    //2. 把B數(shù)的每個數(shù)字遍歷出來放到數(shù)組
    for (index,charObject) in numberB.enumerated() {

        let numberString:String = String.init(charObject)

        number2Array[index] = Int(numberString) ?? 0
    }
    
    
    //3.從右到左開始逐個數(shù)字相乘
    // 789
    // 456
    //
    for valueA in 0...numCountA - 1 {
        
        let locationA = numCountA - 1 - valueA
        
        for valueB in 0...numCountB - 1 {
            
            let locationB = numCountB - 1 - valueB
            
            /// 結果數(shù)組下標
            let resultIndex:Int = locationA + locationB + 1
            
            ///相乘結果
            let numberResult:Int = number1Array[locationA] * number2Array[locationB]
            
            resultArray[resultIndex] += numberResult
            
            print("循環(huán)數(shù)組A的下標-->\(valueA),循環(huán)數(shù)組B的下標-->\(valueB),結果數(shù)組下標-->\(resultIndex),相乘結果-->\(numberResult)")
        }
        
    }
   
    
    //4. 計算每個數(shù)字的進位
    var index:Int = numCountA + numCountB - 1
    
    while index > 0 {
        
        resultArray[index - 1] += resultArray[index] / 10
        
        resultArray[index] %= 10
        
        index -= 1
    }
    
    
    //5. 如果首位為0，則刪除不要
    if resultArray.first == 0 {
        
        resultArray.removeFirst()
    }
    
    
    //6. 拼接數(shù)組成為最終結果
    var resultString:String = ""
    
    for (_,number) in resultArray.enumerated() {
        
        resultString += "\(number)"
    }
    
    return resultString
}