Merge branch 'master' of https://github.com/gavinfish/leetcode-share

Author: gavinfish

java/_257BinaryTreePaths.java

@@ -0,0 +1,41 @@
+import java.util.List;
+
+import javax.management.relation.RelationTypeSupport;
+import javax.swing.tree.TreeNode;
+
+/**
+ * Given a binary tree, return all root-to-leaf paths.
+ * 
+ * For example, given the following binary tree:
+ * 
+ *    1
+ *  /   \
+ * 2     3
+ *  \
+ *   5
+ * All root-to-leaf paths are:
+ * 
+ * ["1->2->5", "1->3"]
+ */
+
+public class _257BinaryTreePaths {
+    public List<String> binaryTreePaths(TreeNode root) {
+        List<String> result = new ArrayList<>();
+        if (root != null) {
+            search(root, "", result);
+        }
+        return result;
+    }
+
+    public void search(TreeNode node, String path, List<String> result) {
+        if (node.left == null && node.right == null) {
+            result.add(path + node.val);
+        }
+        if (node.left != null) {
+            search(node.left, path + node.val + "->", result);
+        }
+        if (node.right != null) {
+            search(node.right, path + node.val + "->", result);
+        }
+    }
+}

java/_258AddDigits.java

@@ -0,0 +1,16 @@
+/**
+ * Given a non-negative integer num, repeatedly add all its digits until the result has only one digit.
+ * 
+ * For example:
+ * 
+ * Given num = 38, the process is like: 3 + 8 = 11, 1 + 1 = 2. Since 2 has only one digit, return it.
+ * 
+ * Follow up:
+ * Could you do it without any loop/recursion in O(1) runtime?
+ */
+public class _258AddDigits {
+    public int addDigits(int num) {
+        int result = num % 9;
+        return (result != 0 || num == 0) ? result : 9;
+    }
+}

java/_283MoveZeroes.java

@@ -0,0 +1,26 @@
+/**
+ * Given an array nums, write a function to move all 0's to the end of it while maintaining the relative order of the non-zero elements.
+ * 
+ * For example, given nums = [0, 1, 0, 3, 12], after calling your function, nums should be [1, 3, 12, 0, 0].
+ * 
+ * Note:
+ * You must do this in-place without making a copy of the array.
+ * Minimize the total number of operations.
+ */
+
+public class _283MoveZeroes {
+    public void moveZeroes(int[] nums) {
+        if (nums == null || nums.length == 0) {
+            return;
+        }
+        int index = 0;
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] != 0) {
+                nums[index++] = nums[i];
+            }
+        }
+        for (int i = index; i < nums.length; i++) {
+            nums[i] = 0;
+        }
+    }
+}

java/_292NimGame.java

@@ -0,0 +1,12 @@
+/**
+ * You are playing the following Nim Game with your friend: There is a heap of stones on the table, each time one of you take turns to remove 1 to 3 stones. The one who removes the last stone will be the winner. You will take the first turn to remove the stones.
+ * 
+ * Both of you are very clever and have optimal strategies for the game. Write a function to determine whether you can win the game given the number of stones in the heap.
+ * 
+ * For example, if there are 4 stones in the heap, then you will never win the game: no matter 1, 2, or 3 stones you remove, the last stone will always be removed by your friend.
+ */
+public class _292NimGame {
+    public boolean canWinNim(int n) {
+        return n % 4 != 0;
+    }
+}