LeetCode Medium Math Solutions

Author: ashwanisharma3

166. Fraction to Recurring Decimal.cpp

@@ -0,0 +1,66 @@
+/*
+Link: https://leetcode.com/problems/fraction-to-recurring-decimal/
+
+Given two integers representing the numerator and denominator of a fraction, return the fraction in string format.
+
+If the fractional part is repeating, enclose the repeating part in parentheses.
+
+Example 1:
+
+Input: numerator = 1, denominator = 2
+Output: "0.5"
+Example 2:
+
+Input: numerator = 2, denominator = 1
+Output: "2"
+Example 3:
+
+Input: numerator = 2, denominator = 3
+Output: "0.(6)"
+*/
+
+// Solution
+// Uses the approach of long division method.
+
+/*
+TC = O(n)
+SC = O(n)
+*/
+
+class Solution {
+public:
+    string fractionToDecimal(long long int num, long long int den) {
+        if(num == 0)
+            return "0";
+        map<int, int> mp;
+        string ans = "";
+        if ((num < 0) ^ (den < 0))
+            ans.push_back('-');
+        
+        ans += to_string(abs(num / den));
+        
+        num = num % den;
+        
+        long long int deno = abs(den);
+        long long int nume = abs(num);
+        
+        if (num == 0)
+            return ans;
+        
+        ans += '.';
+        
+        while (nume != 0) {
+            if (mp.find(nume) !=mp.end()) {
+                ans.insert(mp[nume], "(");
+                ans.push_back(')');
+                break;
+            }
+            mp[nume] = ans.size();
+            nume *= 10;
+            ans += to_string(nume / deno);
+            
+            nume %= deno;
+        }        
+        return ans;
+    }
+};

171. Excel Sheet Column Number.cpp

@@ -0,0 +1,52 @@
+/*
+Link: https://leetcode.com/problems/excel-sheet-column-number/
+
+Given a column title as appear in an Excel sheet, return its corresponding column number.
+
+For example:
+
+    A -> 1
+    B -> 2
+    C -> 3
+    ...
+    Z -> 26
+    AA -> 27
+    AB -> 28 
+    ...
+Example 1:
+
+Input: "A"
+Output: 1
+Example 2:
+
+Input: "AB"
+Output: 28
+Example 3:
+
+Input: "ZY"
+Output: 701
+*/
+
+// Solution
+
+
+/*
+TC = O(n)
+SC = O(1)
+*/
+
+class Solution {
+public:
+    int titleToNumber(string s) {
+        int i, j, len = s.size();
+        int k = 0, ans = 0;
+        char ch;
+        while (s.size()) {
+            ch = s[s.size() - 1];
+            ans += pow (26, k) * int(ch -'A' + 1);
+            k++;
+            s.pop_back();
+        }
+        return ans;
+    }
+};

172. Factorial Trailing Zeroes.cpp

@@ -0,0 +1,43 @@
+/*
+Link: https://leetcode.com/problems/factorial-trailing-zeroes/
+
+Given an integer n, return the number of trailing zeroes in n!.
+
+Example 1:
+
+Input: 3
+Output: 0
+Explanation: 3! = 6, no trailing zero.
+Example 2:
+
+Input: 5
+Output: 1
+Explanation: 5! = 120, one trailing zero.
+Note: Your solution should be in logarithmic time complexity.
+*/
+
+// Solution
+
+
+/*
+TC = O(log n base 5)
+SC = O(1) in iterative; recursion uses extra memory for execution, here it is O(log n base 5)
+*/
+
+class Solution {
+public:
+    int trailingZeroes(int n) {
+        // This line is solution using recursion
+        // return n == 0 ? 0 : n / 5 + trailingZeroes(n / 5);
+
+        // Iterative
+        int i = 1, ans = 0;
+        while (1) {
+            if (n / pow(5, i) < 1)
+                break;
+            ans += n / pow(5, i++);
+        }
+        
+        return ans;
+    }
+};

29. Divide Two Integers.cpp

@@ -0,0 +1,71 @@
+/*
+Link: https://leetcode.com/problems/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, which means losing its fractional part. For example, truncate(8.345) = 8 and truncate(-2.7335) = -2.
+
+Example 1:
+
+Input: dividend = 10, divisor = 3
+Output: 3
+Explanation: 10/3 = truncate(3.33333..) = 3.
+Example 2:
+
+Input: dividend = 7, divisor = -3
+Output: -2
+Explanation: 7/-3 = truncate(-2.33333..) = -2.
+Note:
+
+Both dividend and divisor will be 32-bit signed integers.
+The divisor will never be 0.
+*/
+
+// Solution
+// We subtract the sum of all powers of two less than the current dividend from it.
+// and repeat the process untill dividend is less than divisor.
+
+/*
+TC = O(1)
+SC = O(1)
+*/
+
+class Solution {
+public:
+    int divide(long long int dividend, long long int divisor) {
+        
+        long long ans = 0, temp = 1;
+        
+        int flag = (divisor < 0 ^ dividend < 0);
+        
+        if (dividend == INT_MIN && divisor == -1)
+            return INT_MAX;
+        
+        if (dividend == INT_MIN && divisor == 1)
+            return INT_MIN;
+        
+        dividend = abs(dividend);
+        divisor = abs(divisor);
+        
+        while (dividend >= divisor) {
+            long long int temp = 1;
+            ans += temp;
+            long long int div = divisor;   
+            dividend -= divisor;
+            while (dividend >= divisor << 1) {
+                divisor <<= 1;
+                dividend = dividend - divisor;
+                temp <<= 1;
+                
+                ans += temp;
+            }
+            
+            divisor = div;
+        }
+        if (flag)
+            return -ans;
+        return ans;
+    }
+};

50. Pow(x, n).cpp

@@ -0,0 +1,50 @@
+/*
+Link: https://leetcode.com/problems/powx-n/
+Implement pow(x, n), which calculates x raised to the power n (xn).
+
+Example 1:
+
+Input: 2.00000, 10
+Output: 1024.00000
+Example 2:
+
+Input: 2.10000, 3
+Output: 9.26100
+Example 3:
+
+Input: 2.00000, -2
+Output: 0.25000
+Explanation: 2-2 = 1/22 = 1/4 = 0.25
+Note:
+
+-100.0 < x < 100.0
+n is a 32-bit signed integer, within the range [−231, 231 − 1]
+
+*/
+
+// Solution
+//Attempt is to reduce the number of calls to pow function
+// and that is being done by call the pow function recursively on sqaure of the number.
+
+/*
+TC = O(log n)
+SC = O(log n) for stack
+*/
+
+class Solution {
+public:
+    double myPow(double x, int n) {
+        if (n == 0)
+            return 1;
+        if(n == INT_MIN){
+            x = x * x;
+            n = n/2;
+        }
+        if (n < 0) {
+            n = -n;
+            x = 1 / x;
+        }
+        
+        return (n%2) ? x * pow (x * x, n / 2) : pow (x * x, n / 2);
+    }
+};

69. Sqrt(x).cpp

@@ -0,0 +1,55 @@
+/*
+Link: https://leetcode.com/problems/sqrtx/
+
+Implement int sqrt(int x).
+
+Compute and return the square root of x, where x is guaranteed to be a non-negative integer.
+
+Since the return type is an integer, the decimal digits are truncated and only the integer part of the result is returned.
+
+Example 1:
+
+Input: 4
+Output: 2
+Example 2:
+
+Input: 8
+Output: 2
+Explanation: The square root of 8 is 2.82842..., and since 
+             the decimal part is truncated, 2 is returned.
+*/
+
+// Solution
+
+
+/*
+TC = O(log n)
+SC = O(1)
+*/
+
+class Solution {
+public:
+    int mySqrt(int x) {
+        if (!x)
+            return x;
+        
+        int ans, low = 1, high = x;
+        int mid;
+        // binary search
+        while (1) {
+            mid = low + (high - low) / 2;
+            
+            if (mid == x / mid)
+                break;
+            
+            if (mid > x / mid)
+                high = mid - 1;
+            else {
+                if (mid + 1 > x / (mid + 1))
+                    return mid;
+                low = mid + 1;
+            }
+        }
+        return mid;
+    }
+};