payal-kothari
diff --git a/‎src/main/java/com/fishercoder/solutions/_40.java
Lines changed: 20 additions & 20 deletions b/‎src/main/java/com/fishercoder/solutions/_40.java
Lines changed: 20 additions & 20 deletions
diff --git a/‎src/test/java/com/fishercoder/_40Test.java
Lines changed: 32 additions & 0 deletions b/‎src/test/java/com/fishercoder/_40Test.java
Lines changed: 32 additions & 0 deletions
@@ -24,27 +24,27 @@ All numbers (including target) will be positive integers.
 public class _40 {
 
     public static class Solution1 {
-        public List<List<Integer>> combinationSum2(int[] candidates, int target) {
-            List<List<Integer>> result = new ArrayList();
-            Arrays.sort(candidates);
-            backtracking(candidates, target, 0, new ArrayList(), result);
-            return result;
-        }
+      public List<List<Integer>> combinationSum2(int[] candidates, int target) {
+        List<List<Integer>> result = new ArrayList();
+        Arrays.sort(candidates);
+        backtracking(candidates, 0, result, target, new ArrayList());
+        return result;
+      }
 
-        void backtracking(int[] candidates, int target, int start, List<Integer> curr, List<List<Integer>> result) {
-            if (target > 0) {
-                for (int i = start; i < candidates.length && target >= candidates[i]; i++) {
-                    if (i > start && candidates[i] == candidates[i - 1]) {
-                        continue;//skip duplicates, this is one difference from Combination Sum I
-                    }
-                    curr.add(candidates[i]);
-                    backtracking(candidates, target - candidates[i], i + 1, curr, result);//i+1 is the other difference from Combination Sum I
-                    curr.remove(curr.size() - 1);
-                }
-            } else if (target == 0) {
-                result.add(new ArrayList(curr));
+      void backtracking(int[] candidates, int start, List<List<Integer>> result, int target,
+          List<Integer> curr) {
+        if (target > 0) {
+          for (int i = start; i < candidates.length; i++) {
+            if (candidates[i] > target || (i > start && candidates[i - 1] == candidates[i])) {
+              continue;
             }
+            curr.add(candidates[i]);
+            backtracking(candidates, i + 1, result, target - candidates[i], curr);
+            curr.remove(curr.size() - 1);
+          }
+        } else if (target == 0) {
+          result.add(new ArrayList(curr));
         }
+      }
     }
-
-}
+}
@@ -0,0 +1,32 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._40;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _40Test {
+  private static _40.Solution1 solution1;
+  private static int[] candidates;
+  private static List<List<Integer>> expected;
+
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _40.Solution1();
+  }
+
+  @Test
+  public void test1() {
+    candidates = new int[] {10, 1, 2, 7, 6, 1, 5};
+    expected = new ArrayList<>();
+    expected.add(Arrays.asList(1, 1, 6));
+    expected.add(Arrays.asList(1, 2, 5));
+    expected.add(Arrays.asList(1, 7));
+    expected.add(Arrays.asList(2, 6));
+    assertEquals(expected, solution1.combinationSum2(candidates, 8));
+  }
+}