commit

Author: bryanfks-dev

2. Add Two Numbers.java

@@ -0,0 +1,53 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+        int prev_reminder = 0; // This variable carry the reminder number from previous node
+
+        ListNode rev_out = null;
+
+        while (l1 != null || l2 != null || prev_raeminder != 0) {
+            // Decide digit from linked lists
+            int digit_l1 = (l1 != null) ? l1.val : 0,
+                digit_l2 = (l2 != null) ? l2.val : 0;
+
+            // Sum digits and previous reminder
+            int sum = digit_l1 + digit_l2 + prev_reminder;
+
+            // Update prev_reminder
+            prev_reminder = sum / 10;
+
+            // Append new node
+            ListNode new_node = new ListNode(sum % 10);
+
+            new_node.next = null;
+
+            if (rev_out == null) {
+                rev_out = new_node;
+            }
+            else {
+                ListNode curr_node = rev_out;
+
+                while (curr_node.next != null) {
+                    curr_node = curr_node.next;
+                }
+
+                curr_node.next = new_node;
+            }
+
+            // Update l1 & l2
+            l1 = (l1 != null) ? l1.next : null;
+            l2 = (l2 != null) ? l2.next : null;
+        }
+
+        return rev_out;
+    }
+}

278. First bad Version.c

@@ -0,0 +1,19 @@
+// The API isBadVersion is defined for you.
+// bool isBadVersion(int version);
+
+int firstBadVersion(int n) {
+    // Binary Search algorithm
+    long lowBound = 1,
+        highBound = n;
+
+    while (lowBound <= highBound) {
+        long mid = (lowBound + highBound) / 2;
+
+        bool isBad = isBadVersion(mid);
+        if (isBad && !isBadVersion(mid - 1)) return mid;
+        else if (isBad && isBadVersion(mid - 1)) highBound = mid - 1;
+        else lowBound = mid + 1;
+    }
+
+    return -1;
+}

35. Search Insert Position.c

@@ -0,0 +1,18 @@
+int searchInsert(int* nums, int numsSize, int target){
+    // Use binary search alogirthm
+    int lowBound = 0, 
+        highBound = numsSize - 1;
+
+    while (lowBound <= highBound) {
+        int mid = (lowBound + highBound) / 2;
+
+        if (nums[mid] == target || (mid != 0 && nums[mid] > target && nums[mid - 1] < target)) {
+            return mid;
+        }
+        else if (mid == numsSize - 1 && nums[mid] < target) return mid + 1;
+        else if (nums[mid] > target) highBound = mid - 1;
+        else lowBound = mid + 1;
+    }
+
+    return 0;
+}

50. Pow(x, n).c

@@ -0,0 +1,12 @@
+double myPow(double x, int n){
+    // Use recursive method to find the power result
+    if (x == 1 || n == 0) return 1;
+    
+    // Shorten power
+    if (n % 2 == 0) {
+        x *= x;
+        n /= 2;
+    }
+    
+    return (n < 0) ? myPow(x, n + 1) / x : x * myPow(x, n - 1);
+}

7. Reverse Integer.c

@@ -0,0 +1,15 @@
+int reverse(int x){
+    long temp = x;
+    long reverse = 0;
+
+    // Reverse number algorithm
+    while (temp) {
+        reverse = reverse * 10 + temp % 10;
+        temp /= 10;
+    }
+
+    // Check if the reverse result of x go outside signed 32-bit range
+    if (reverse < -pow(2, 31) || reverse > pow(2, 31) - 1) return 0;
+
+    return reverse;
+}

9. Palindrome Number.c

@@ -0,0 +1,17 @@
+bool isPalindrome(int x){
+    // Check if number bigger or equal to 0
+    if (x >= 0) {
+        long y = 0;
+        int z = x;
+        
+        // Reverse integer algorithm
+        while (z) {
+            y = y * 10 + z % 10;
+            z /= 10;
+        }
+        
+        return x == y;
+    }
+
+    return false;
+}