Day19 兩數相除

阿新 • • 發佈：2021-02-14

技術標籤：筆記

給定兩個整數，被除數 dividend 和除數 divisor。將兩數相除，要求不使用乘法、除法和 mod 運算子

返回被除數 dividend 除以除數 divisor 得到的商。

整數除法的結果應當截去（truncate）其小數部分，例如：truncate(8.345) = 8 以及 truncate(-2.7335) = -2

https://leetcode-cn.com/problems/divide-two-integers/

示例1：

輸入: dividend = 10, divisor = 3
輸出: 3
解釋: 10/3 = truncate(3.33333…) = truncate(3) = 3

示例2：

輸入: dividend = 7, divisor = -3
輸出: -2
解釋: 7/-3 = truncate(-2.33333…) = -2

提示：

被除數和除數均為 32 位有符號整數。
除數不為 0。
假設我們的環境只能儲存 32 位有符號整數，其數值範圍是 [−2^31, 2^31 − 1]。本題中，如果除法結果溢位，則返回 2^31 − 1。

Java解法

思路：

Emmm 知識盲區，沒有思路，看下大佬們的解法
沒有啥官方解，參考了下大佬們的解法，主要兩個步驟
轉換為減法，不斷減值逼近結果，優化查詢提高效率
處理邊界符號問題，符號問題有特殊處理及轉long型處理的方式，這邊嘗試下特殊處理

運算正常，但是超時

public static int divide(int dividend, int divisor) {
    if (divisor==0) {
        return 0;
    }
    //dividend =  divisor * result
    int result = 0;
    if (dividend > 0 && divisor > 0) {
        while (dividend -divisor >= 0) {
            result++;
            dividend = 
 dividend - divisor;
        }
    } else if (dividend > 0 && divisor < 0) {
        while (dividend + divisor>=0) {
            result++;
            dividend = dividend + divisor;
        }
        result = -result;
    }else if (dividend < 0 && divisor < 0) {
        //邊界溢位發生在 -2^31 / -1 的時候
        if (dividend== Integer.MIN_VALUE&&divisor==-1) {
            return Integer.MAX_VALUE;
        }
        while (dividend - divisor<=0) {
            result++;
            dividend = dividend - divisor;
        }
    }else if (dividend < 0 && divisor > 0) {
        while (dividend + divisor<=0) {
            result++;
            dividend = dividend + divisor;
        }
        result = -result;
    }
    return result;
}

後續優化太難處理，決定將int轉為lon型，修復邊界問題，方便對演算法統一

package sj.shimmer.algorithm.ten_2;

import sj.shimmer.algorithm.Utils;

/**
 * Created by SJ on 2021/2/12.
 */

class D19 {
    public static void main(String[] args) {
        Utils.logTime();
        System.out.println(divide(-2147483648, -3));
        Utils.logTime();
//        System.out.println(divide(-1,-1));
//        System.out.println(divide(10,3));
//        System.out.println(divide(7,-3));
    }

    public static int divide(int dividend, int divisor) {
        if (divisor == 0) {
            return 0;
        }
        if (divisor == 1) {
            return dividend;
        }
        if (divisor == -1) {
            //邊界溢位發生在 -2^31 / -1 的時候
            if (dividend == Integer.MIN_VALUE) {
                return Integer.MAX_VALUE;
            }
            return -dividend;
        }
        long dd = dividend;
        long dr = divisor;

        if (dividend > 0 && divisor > 0) {
            return get(dd, dr);
        } else if (dividend < 0 && divisor < 0) {
            return get(-dd, -dr);
        } else if (dividend > 0 && divisor < 0) {
            return -get(dd, -dr);
        } else if (dividend < 0 && divisor > 0) {
            return -get(-dd, dr);
        }
        return 0;
    }

    private static int get(long dd, long dr) {
        if (dd<dr) {
            return 0;
        }
        int result = 1;
        long temp = dr;
        while (dd > dr+dr) {
            dr+=dr;
            result+=result;
        }

        return result+get(dd-dr,temp);
    }
}