Add recursion algorithm code

Author: jbee37142

src/test/java/algorithm/recursion/BraceCombination.java

@@ -0,0 +1,23 @@
+package algorithm.recursion;
+
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+public class BraceCombination {
+
+    /*
+        TASK
+        N개 괄호로 만들 수 있는 모든 조합 출력하기.
+     */
+
+    @Test
+    public void test() {
+        assertThat("", is(testFunction()));
+    }
+
+    public String testFunction() {
+        return "";
+    }
+}

src/test/java/algorithm/recursion/Dice.java

@@ -0,0 +1,32 @@
+package algorithm.recursion;
+
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+public class Dice {
+
+    /*
+        TASK
+        주사위로 이동 가능한 경우의 수를 모두 구한다.
+     */
+
+    @Test
+    public void test() {
+        assertThat(4, is(calcDiceCase(3)));
+        assertThat(8, is(calcDiceCase(4)));
+        assertThat(16, is(calcDiceCase(5)));
+    }
+
+    public int calcDiceCase(int n) {
+        if (n < 0) return 0;
+        if (n == 0) return 1;
+        return calcDiceCase(n - 1)
+                + calcDiceCase(n - 2)
+                + calcDiceCase(n - 3)
+                + calcDiceCase(n - 4)
+                + calcDiceCase(n - 5)
+                + calcDiceCase(n - 6);
+    }
+}

src/test/java/algorithm/recursion/Fibonacci.java

@@ -0,0 +1,27 @@
+package algorithm.recursion;
+
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+public class Fibonacci {
+
+    /*
+        TASK
+        Fibonacci 를 계산하는 함수를 작성한다.
+     */
+    @Test
+    public void test() {
+        assertThat(5, is(calcFibo(5)));
+        assertThat(8, is(calcFibo(6)));
+        assertThat(13, is(calcFibo(7)));
+    }
+
+    public int calcFibo(int num) {
+        if (num < 2) {
+            return num;
+        }
+        return calcFibo(num - 1) + calcFibo(num - 2);
+    }
+}

src/test/java/algorithm/recursion/NBitWays.java

@@ -0,0 +1,52 @@
+package algorithm.recursion;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+public class NBitWays {
+
+    /*
+        TASK
+        n비트의 모든 경우의 수를 출력한다.
+     */
+
+    @Test
+    public void test() {
+        List<String> actual1 = new ArrayList<>();
+        actual1.add("00");
+        actual1.add("01");
+        actual1.add("10");
+        actual1.add("11");
+        assertThat(actual1, is(calcBitCombination(2)));
+
+        List<String> actual2 = new ArrayList<>();
+        actual2.add("000");
+        actual2.add("001");
+        actual2.add("010");
+        actual2.add("011");
+        actual2.add("100");
+        actual2.add("101");
+        actual2.add("110");
+        actual2.add("111");
+        assertThat(actual2, is(calcBitCombination(3)));
+    }
+
+    public List<String> calcBitCombination(int n) {
+        return bitCombination(n, "", new ArrayList<>());
+    }
+
+    private List<String> bitCombination(int n, String str, List<String> list) {
+        if (n == str.length()) {
+            list.add(str);
+            return list;
+        }
+        bitCombination(n, str + "0", list);
+        bitCombination(n, str + "1", list);
+        return list;
+    }
+}

src/test/java/algorithm/recursion/Permutation.java

@@ -0,0 +1,54 @@
+package algorithm.recursion;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+
+public class Permutation {
+
+    /*
+        TASK
+        순열을 구한다.
+     */
+
+    @Test
+    public void test() {
+        List<String> actual = new ArrayList<>();
+        actual.add("123");
+        actual.add("132");
+        actual.add("213");
+        actual.add("231");
+        actual.add("312");
+        actual.add("321");
+        assertThat(actual, is(calcPermutation("123")));
+    }
+
+    public List<String> calcPermutation(String str) {
+        if (str == null) return null;
+        return permutation(str, new boolean[str.length()],
+                            "", new ArrayList<>());
+    }
+
+    private List<String> permutation(String str, boolean[] isPick,
+                                     String perm, List<String> result) {
+        if (str.length() == perm.length()) {
+            result.add(perm);
+            return result;
+        }
+
+        for (int i = 0; i < str.length(); i++) {
+            if (isPick[i]) {
+                continue;
+            }
+            isPick[i] = true;
+            permutation(str, isPick, perm + str.charAt(i), result);
+            isPick[i] = false;
+        }
+        return result;
+    }
+}