Some additions

Author: gpitois

src/com/leetcode/Combinations.java

@@ -0,0 +1,46 @@
+package com.leetcode;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/*
+Given two integers n and k, return all possible combinations of k numbers out of 1 ... n.
+Example:
+Input: n = 4, k = 2
+Output:
+[
+  [2,4],
+  [3,4],
+  [2,3],
+  [1,2],
+  [1,3],
+  [1,4],
+]
+ */
+public class Combinations {
+    public static List<List<Integer>> combine(int n, int k) {
+        List<List<Integer>> output = new ArrayList<>();
+        List<Integer> current = new ArrayList<>();
+        addNumber(output, current, k, n, 1);
+        return output;
+    }
+
+    private static void addNumber(List<List<Integer>> output, List<Integer> current, int k, int n, int ni) {
+        if (k == 0) {
+            output.add(new ArrayList<>(current));
+            return;
+        }
+        for (int skip = 0; skip <= n - ni; ++skip) {
+            current.add(ni + skip);
+            addNumber(output, current, k - 1, n, ni + skip + 1);
+            current.remove(current.size() - 1);
+        }
+    }
+
+    @Test
+    public void testCase1() {
+        System.out.println(combine(4, 2));
+    }
+}

src/com/leetcode/SetMatrixZeros.java

@@ -46,8 +46,8 @@ public static void setZeroes(int[][] matrix) {
         for (int i = 0; i < n; ++i) {
             for (int j = 0; j < m; ++j) {
                 if (matrix[i][j] == 0) {
-                    if (i == 0) firstCol = true;
-                    if (j == 0) firstRow = true;
+                    if (i == 0) firstRow = true;
+                    if (j == 0) firstCol = true;
                     matrix[0][j] = 0;
                     matrix[i][0] = 0;
                 }
@@ -86,6 +86,12 @@ public void testCase2() {
         setZeroes(m);
     }
 
+    @Test
+    public void testCase3() {
+        int[][] m = {{1, 0, 3}};
+        setZeroes(m);
+    }
+
     private static String printMat(int[][] mat) {
         int n = mat.length;
         int m = mat[0].length;

src/com/leetcode/SortColors.java

@@ -0,0 +1,64 @@
+package com.leetcode;
+
+import org.junit.Test;
+
+/*
+Given an array with n objects colored red, white or blue, sort them in-place so that objects of the same color are
+adjacent, with the colors in the order red, white and blue.
+Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.
+Note: You are not suppose to use the library's sort function for this problem.
+
+Example:
+
+Input: [2,0,2,1,1,0]
+Output: [0,0,1,1,2,2]
+Follow up:
+
+A rather straight forward solution is a two-pass algorithm using counting sort.
+First, iterate the array counting number of 0's, 1's, and 2's, then overwrite array with total number of 0's,
+then 1's and followed by 2's.
+Could you come up with a one-pass algorithm using only constant space?
+*/
+public class SortColors {
+    public static void sortColors(int[] nums) {
+        int n = nums.length;
+        int left = 0, right = n - 1;
+        int i = 0;
+        while (i <= right) {
+            if (nums[i] < 1) {
+                // Exchange with current left pointer
+                nums[i] = nums[left];
+                nums[left] = 0;
+                ++left;
+            }
+            if (nums[i] > 1) {
+                // Exchange with right
+                nums[i] = nums[right];
+                nums[right] = 2;
+                --right;
+                --i;
+            }
+            ++i;
+        }
+        System.out.println(matToString(nums));
+    }
+
+    @Test
+    public void testCase1() {
+        int[] m = {2, 0, 2, 1, 1, 0};
+        sortColors(m);
+    }
+
+    private static String matToString(int[] mat) {
+        int n = mat.length;
+        StringBuilder sb = new StringBuilder();
+        sb.append("[");
+        for (int j = 0; j < n; ++j) {
+            sb.append(mat[j]);
+            if (j < n - 1) sb.append(",");
+        }
+        sb.append("]");
+        return sb.toString();
+    }
+
+}