Question

我想弄清楚递归操作。我正在尝试编写一个函数，它将乘以2个整数而不使用“*”运算符。我理解它必须基本上Int1添加到自己Int2次，但我发现的一切都是C，C ++或Java。

有些事情：

var num1: Int
var num2: Int
var result: Int

func mult() -> Int {


}

再次，我知道它必须是简单的事情，但是，我可能过于复杂化了（我倾向于这样做）

Answer 1

尝试一下（Swift 3）：

func mult(x: Int, y: Int) -> Int {
    if x == 0 || y == 0 {
        return 0
    }

    return x + mult(x: x, y: y - 1)
}

print(mult(x: 5, y: 10))

仅当x和y都大于或等于0时才有效。

Answer 2

通过处理负面输入来扩展@ Jenny的答案：

func times(_ a: Int, _ b: Int) -> Int {
    var a = a
    var b = b
    var sign = 1

    // base case for recursion
    if a == 0 || b == 0 {
        return 0
    }

    // make "a" positive and keep track of sign of result
    if a < 0 {
        a = -a
        sign = -sign
    }

    // make "b" positive and keep track of sign of result
    if b < 0 {
        b = -b
        sign = -sign
    }

    // make sure "a" is the smallest so that it finishes faster
    // by recursing fewer times
    if a > b {
        (a, b) = (b, a)
    }

    // recursive step
    // note that a * b = (1 + (a - 1)) * b = b + times(a - 1, b)
    let result = b + times(a - 1, b)

    // return result adjusting for sign
    return sign == 1 ? result : -result
}

测试案例：

print(times(3, -7))     // -21
print(times(-3, 7))     // -21
print(times(-3, -7))    // 21
print(times(3, 7))      // 21
print(times(0, 8))      // 0
print(times(8, 0))      // 0
print(times(10000, 3))  // 30000
print(times(-3, 10000)) // -30000

Answer 3

对于 a 和 b 整数，＆＃34; a 次 b ＆＃34;基本上意味着＆＃34;将 a 添加到自己 b 次＆＃34; （或反之亦然）。

为简单起见，这两个数字都不是负数，这段代码就应该这样做：

func multiply(a:Int, b:Int) -> Int {

    guard a != 0 else { return 0 }
    guard b != 0 else { return 0 }

    var result = 0

    for index in 0 ..< b { 
        result += a
    }

    return result
}

使用递归的解决方案乍一看看起来很聪明和聪明，但除非绝对必要，否则我不会使用递归。在我看来，直截了当，非复杂的代码是最好的。

如何在不使用*运算符

3 个答案: