some easy questions

Author: metanet

src/problems/leetcode/FindTheWinnerOfTheCircularGame.java

@@ -0,0 +1,70 @@
+package problems.leetcode;
+
+// https://leetcode.com/problems/find-the-winner-of-the-circular-game/
+public class FindTheWinnerOfTheCircularGame {
+
+
+    // 0, 1, 2, 3, 4, 5
+    // 1, 2, 3, 4, 5, 6
+
+    // n = 6, k = 3
+    // 1, 2, 3, 4, 5, 6
+    // 1, 2, -, 4, 5, 6
+    // 1, 2, -, 4, 5, -
+    // 1, 2, -, -, 5, -
+    // 1, -, -, -, 5, -
+    // 1, -, -, -, -, -
+    //
+    // n = 6, k = 4
+    // 1, 2, 3, 4, 5, 6
+    // 1, 2, 3, -, 5, 6
+    // 1, -, 3, -, 5, 6
+    // -, -, 3, -, 5, 6
+    // -, -, -, -, 5, 6
+    // -, -, -, -, 5, -
+    //
+    // n = 7, k = 2
+    // 1, 2, 3, 4, 5, 6, 7
+    // 1, -, 3, 4, 5, 6, 7
+    // 1, -, 3, -, 5, 6, 7
+    // 1, -, 3, -, 6, -, 7
+    // -, -, 3, -, 6, -, 7
+    // -, -, 3, -, -, -, 7
+    // -, -, -, -, -, -, 7
+
+    public static int findTheWinner(int n, int k) {
+        int[] players = new int[n];
+        for (int i = 0; i < n; i++) {
+            players[i] = i + 1;
+        }
+
+        int current = 0;
+        for (int remaining = n - 1; remaining > 0; remaining--) {
+            for (int move = k; move > 0;) {
+                if (players[current++] != 0) {
+                    move--;
+                }
+                if (current == n) {
+                    current = 0;
+                }
+            }
+            players[((current - 1) + n) % n] = 0;
+        }
+
+        for (int i = 0; i < n; i++) {
+            if (players[i] != 0) {
+                return players[i];
+            }
+        } 
+
+        return -1;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(findTheWinner(5, 2));
+        System.out.println(findTheWinner(6, 3));
+        System.out.println(findTheWinner(6, 4));
+        System.out.println(findTheWinner(7, 2));
+    }
+
+}

src/problems/leetcode/HeapSort.java

@@ -0,0 +1,73 @@
+package problems.leetcode;
+
+import java.util.Arrays;
+
+public class HeapSort {
+    
+    /**
+     * runtime: O(NlgN)
+     * space: O(1)
+     * 
+     * HEAPSORT(A)
+     *   BUILD-MAX-HEAP(A)
+     *   for i = A.length..2
+     *     exch A[1], A[i]
+     *     A.heap-size--
+     *     MAX-HEAPIFY(A, 1)
+     */
+    public static void sort(int[] vals) {
+        maxHeapify(vals, vals.length);
+
+        for (int size = vals.length, i = size - 1; i >= 1; i--) {
+            swap(vals, 0, i);
+            maxHeapify(vals, --size, 0);
+        }
+
+        System.out.println(Arrays.toString(vals));
+    }
+
+    private static void maxHeapify(int[] heap, int size) {
+        // heap[size/2..1] are leaves, which are heap themselves.
+        for (int i = size / 2; i >= 0; i--) {
+            maxHeapify(heap, size, i);
+        }
+    }
+
+    private static void maxHeapify(int[] heap, int size, int i) {
+        int l = leftChild(i);
+        int r = rightChild(i);
+        int largest = i;
+        if (l < size && heap[l] > heap[i]) {
+            largest = l;
+        }
+        if (r < size && heap[r] > heap[largest]) {
+            largest = r;
+        }
+        if (largest != i) {
+            swap(heap, i, largest);
+            maxHeapify(heap, size, largest);
+        }
+    }
+
+    private static int leftChild(int i) {
+        return (i + 1) * 2 - 1;
+    }
+
+    private static int rightChild(int i) {
+        return (i + 1) * 2;
+    }
+
+    private static void swap(int[] heap, int l, int r) {
+        int tmp;
+        tmp = heap[l];
+        heap[l] = heap[r];
+        heap[r] = tmp;
+    }
+
+    public static void main(String[] args) {
+        sort(new int[] { 1, 2, 3, 4, 5 });
+        sort(new int[] { 5, 4, 3, 2, 1 });
+        sort(new int[] { 1, 2, 3, 4, 5, 4, 3, 2, 1 });
+    }
+
+}

src/problems/leetcode/PalindromeNumber.java

@@ -0,0 +1,46 @@
+package problems.leetcode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+// https://leetcode.com/problems/palindrome-number/
+public class PalindromeNumber {
+    
+    public static boolean isPalindrome(int x) {
+        if (x < 0) {
+            return false;
+        }
+
+        List<Integer> digits = new ArrayList<>(10);
+        int j = 0;
+        for (int i = 1, k = 0;i <= 1_000_000_000; i *= 10, k++) {
+            long d = i;
+            int digit = (int) ((((long) x) % (d * 10)) / d);
+            digits.add(digit);
+            if (digit > 0) {
+                j = k;
+            }
+        }
+
+        // System.out.println(digits);
+        int i = 0;
+        while (i < j) {
+            if (digits.get(i) != digits.get(j)) {
+                return false;
+            }
+            i++;
+            j--;
+        }
+     
+        return true;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(isPalindrome(121));
+        System.out.println(isPalindrome(4325));
+        System.out.println(isPalindrome(43234));
+        System.out.println(isPalindrome(1111111111));
+        System.out.println(isPalindrome(1410110141));
+    }
+
+}

src/problems/leetcode/RemoveElement.java

@@ -0,0 +1,33 @@
+package problems.leetcode;
+
+import java.util.AbstractList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+// https://leetcode.com/problems/remove-element/
+public class RemoveElement {
+
+    public static void main(String[] args) {
+        int[] nums = new int[] {3,2,5,2,3};
+        System.out.println(removeElement(nums, 2));
+    }
+
+    public static int removeElement(int[] nums, int val) {
+        int i = 0;
+        for (int j = 0; j < nums.length; j++) {
+            if (nums[j] != val) {
+                int temp = nums[i];
+                nums[i] = nums[j];
+                nums[j] = temp;
+                i++;
+            }
+        }
+        
+        System.out.println(Arrays.toString(nums));
+
+        return i;
+    }
+    
+}