Leetcode -- Day 14&Day15&Day16&Day17

Add / Divide / Multiply / Power / Plus / Sqrt

Question 1

Add Two Numbers

You are given two linked lists representing two non-negative numbers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.

Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 0 -> 8

Remember to use a carry and check carry in the very last part. And initiate a -1 result listNode is very clear. 

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        if (l1 == null)
            return l2;
        if (l2 == null)
            return l1;
        
        int carry = 0;
        ListNode res = new ListNode(-1);
        ListNode head = res;
        while (l1!=null || l2 != null){
            int sum = carry;
            if (l1 != null){
                sum += l1.val;
                l1 = l1.next;
            }
            if (l2 != null){
                sum += l2.val;
                l2 = l2.next;
            }
            carry = sum/10;
            res.next = new ListNode(carry==1 ? sum%10 : sum);
            res = res.next;
        }
        if (carry == 1)
            res.next = new ListNode(carry);
        return head.next;
    }
}

Question 2

Add Binary

Given two binary strings, return their sum (also a binary string).

For example,
a = "11"
b = "1"
Return "100".

We can use stringBuffer here too with append() and reverse(), which can save time as string + is copy first then add. 

public String addBinary(String a, String b) {
        if (a==null)
            return b;
        if (b==null)
            return a;
        
        int carry = 0;
        int sum = 0;
        String res = "";
        int i = a.length()-1;
        int j = b.length()-1;
        
        while (i >= 0 || j >=0){
            sum = carry;
            if (i >= 0){
                sum += a.charAt(i) - '0';
                i --;
            }
            if (j >= 0){
                sum += b.charAt(j) - '0';
                j --;
            }
            carry = sum/2;
            sum = sum%2;
            res = sum + res;
        }
        if (carry == 1)
            res = "1" + res;
        return res;
    }

Question 3

Divide Two Integers

Divide two integers without using multiplication, division and mod operator.

If it is overflow, return MAX_INT.

If we cannot use * / %, we can consider using +. Remember to deal with overflow problem. 

public int divide(int dividend, int divisor) {
        if (dividend == 0 || divisor == 0) {  
            return 0;  
        }  
        boolean isNeg = (dividend > 0 && divisor < 0)  
                || (dividend < 0 && divisor > 0);  
        long a = Math.abs((long) dividend);  
        long b = Math.abs((long) divisor);  
        if (b > a) {  
            return 0;  
        }  
  
        long sum = 0;  
        long pow = 0;  
        long result = 0;  
        while (a >= b) {  
            pow = 1;  
            sum = b;  
            while (sum + sum <= a) {  
                sum += sum;  
                pow += pow;  
            }  
            a -= sum;  
            result += pow;  
        }  
        
        if (isNeg){
            if (-result < Integer.MIN_VALUE){
                return Integer.MAX_VALUE;
            }
        }
        else {
            if (result > Integer.MAX_VALUE){
                return Integer.MAX_VALUE;
            }
        }
        
        return isNeg ? -(int)result : (int)result;  
    } 

Question 4

Multiply Strings

Given two numbers represented as strings, return multiplication of the numbers as a string.

Note: The numbers can be arbitrarily large and are non-negative.

A very important trick here is use another int[] array to record each digit's multiply result. And the int length is the i + j length. Althoughghtit may larger thatn the actual length of the result, the result stringBuilder we use will delete all the zero value at the begining of the string. 

And the stringBuilder has insert() and delete(), and can insert a digit before all result, which is very convenient. 

public String multiply(String num1, String num2) {
        if (num1 == null || num2 == null)
            return null;
        if (num1.equals("0") || num2.equals("0"))
            return "0";
        
        String n1 = new StringBuilder(num1).reverse().toString();
        String n2 = new StringBuilder(num2).reverse().toString();
        
        int[] d = new int[n1.length() + n2.length()];
        
        for (int i = 0; i < n1.length(); i ++){
            for (int j = 0; j < n2.length(); j ++){
                int a = n1.charAt(i)-'0', b = n2.charAt(j)-'0';
                d[i+j] += a*b;
            }
        }
        
        StringBuilder res = new StringBuilder();
        int carry = 0;
        int digit = 0;
        for (int i : d){
            digit = (i + carry)%10;
            carry = (i+carry) / 10;
            res.insert(0,digit);
        }
        if (carry != 0)
            res.insert(0,carry);
        
        while (res.length() > 0 && res.charAt(0) == '0')
            res.deleteCharAt(0);
        
        return res.toString();
    } 

Question 5

Pow(x, n)

Implement pow(x, n).

It is very clear use the binary search to reduce the calculation complex and use half/x*half to deal with the negative power. So if the n < 0, it will let it divide the x instead of mutiply, but it also equals to * 1/x;

public double myPow(double x, int n) {
        if (n==0)
            return 1;
        double half = myPow(x,n/2);
        if (n % 2 == 0)
            return half * half;
        else if (n > 0)
            return half * half * x;
        else
            return half/x*half;
    }

Question 6

Plus One

Given a non-negative number represented as an array of digits, plus one to the number.

The digits are stored such that the most significant digit is at the head of the list.

A trick here is if the carry remains 1 till the end, only the most significant bit is 1, while others are all 0. Because it only adds one not other value.

public int[] plusOne(int[] digits) {
        if (digits == null || digits.length == 0)
            return digits;
        
        int carry = 1;
        int sum = 0;
        for (int i = digits.length-1; i >= 0; i --){
            sum = carry + digits[i];
            carry = sum/10;
            digits[i] = sum%10;
        }
        if (carry == 0)
            return digits;
        
        int[] res = new int[digits.length+1];
        res[0] = 1;
        return res;
    }

Go to have dinner with xl, so did not finish it at time.

Question 7

Sqrt(x)

Implement int sqrt(int x).

Compute and return the square root of x.

Be careful you may met a /zero error here if you start by left = 0; 

while you set left = 1, and right >=left, so right >=1, (left + right)/2 >=1 will not be zero.

public int mySqrt(int x) {
        if (x == 0)
            return x;
        
        int left = 1;
        int right = x;
        int mid;
        int res = 0;
        while (left <= right){
            mid = (left + right)/2;
            if(x/mid>=mid){
                left = mid +1 ;
                res = mid;
            }
            else 
                right = mid -1;
        }
        return res;
    }