算法练习--LeetCode--29. Divide Two Integers: 100%

最新推荐文章于 2021-05-18 10:48:44 发布

weixin_33939380

最新推荐文章于 2021-05-18 10:48:44 发布

阅读量167

点赞数

CC 4.0 BY-SA版权

文章标签：数据结构与算法 swift

原文链接：https://juejin.im/post/5c2f8affe51d4539b927a270

本文介绍了一种不使用乘法、除法和取余运算来计算两个整数商的算法，通过批量减法提高效率，确保结果在32位整数范围内，并提供了Swift语言实现及测试案例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Divide Two Integers
Given two integers dividend and divisor, divide two integers without using multiplication, division and mod operator. Return the quotient after dividing dividend by divisor. The integer division should truncate toward zero.

Example 1:

Input: dividend = 10, divisor = 3 Output: 3

Example 2:

Input: dividend = 7, divisor = -3 Output: -2

Note:

Both dividend and divisor will be 32-bit signed integers.
The divisor will never be 0.
Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−2³¹, 2³¹ − 1]. For the purpose of this problem, assume that your function returns 231 − 1 when the division result overflows.

简单来说就是不用***‘乘法’、‘除法’和‘取余’运算***来求两个整数的商，注意结果要在 [−2³¹, 2³¹ − 1]

Round One

~~暴力减法(如下)，我赌5毛，超时（Time Limit Exceeded）！~~

// Swift Code
class Solution {
    func divide(_ dividend: Int, _ divisor: Int) -> Int {
        let sign = (dividend >= 0) == (divisor > 0) ? 1 : -1
        var dividend = abs(dividend)
        let divisor = abs(divisor)
        var result = 0
        while dividend > divisor {
            dividend -= divisor
            result += 1
        }
        if dividend == divisor {
            result += 1
        }
        return sign < 0 ? -result : result
    }
}
复制代码

Round Two

一个一个减肯定是超时了，要是一批一批减呢？

所以就需要先成倍放大被除数，不允许用***‘乘法’、‘除法’和‘取余’*** 还有 ‘<<’、‘>>’

这个方法耗时少于超越了100%的其它Swift提交

// Swift Code
class Solution {
    func divide(_ dividend: Int, _ divisor: Int) -> Int {
        // 除数、被除数符号不一致时候商为负数
        let sign = (dividend >= 0) == (divisor > 0) ? 1 : -1

        // 扩大下数据类型，避免溢出
        var _dividend = Int64(abs(dividend))
        let _divisor = Int64(abs(divisor))

        var result = 0
        var temp = 1
        var _divisor_temp = _divisor

        // 放大被除数
        while _divisor_temp < _dividend {
            _divisor_temp = _divisor_temp << 1
            temp = temp << 1
        }

        // 在合理范围内缩小被放大的被除数
        while _divisor_temp > 0, _divisor_temp > _divisor {
            while _divisor_temp > _dividend {
                _divisor_temp = _divisor_temp >> 1
                temp = temp >> 1
            }
            _dividend -= _divisor_temp
            result += temp
        }

        // 竟然一样大，所以再来一次了
        if _dividend == _divisor {
            result += 1
        }

        // 结果是有范围限制的
        return sign < 0 ? max(-result, Int(Int32.min)) : min(result, Int(Int32.max))
    }
}
复制代码

TestCase

// Swift Code
assert(Solution().divide(10, 3) == 3)
assert(Solution().divide(3, 3) == 1)
assert(Solution().divide(1, 1) == 1)
assert(Solution().divide(2, 3) == 0)
assert(Solution().divide(7, -3) == -2)
assert(Solution().divide(-2147483648, -1) == 2147483647)
assert(Solution().divide(0, 2147483648) == 0)
复制代码

转载于:https://juejin.im/post/5c2f8affe51d4539b927a270