├── Recursion.java
└── RecursionTestClass.java


/Recursion.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * There is no requirement for a file header comment for this 
  3 |  * assignment. Spend your time writing good testcases instead!
  4 |  */
  5 | import java.util.Queue;
  6 | import java.util.Stack;
  7 | 
  8 | public class Recursion {
  9 | 
 10 | 	/**
 11 | 	 * Write a recursive function that finds the index of s2 in s1. Do not use any
 12 | 	 * string functions except for .length(), .equals(), and .substring(). Do not use
 13 | 	 * any loops, or any data structures.
 14 | 	 * @param s1
 15 | 	 * @param s2
 16 | 	 * @return Returns the index of the first time that
 17 | 	 * 			s2 appears in s1 or -1 if s2 is not contained
 18 | 	 * 			in s1.
 19 | 	 */
 20 | 	public static int indexOf(String s1, String s2) {
 21 | 		if (s1.length() == 0 || s2.length() == 0 ||
 22 | 				s1.length() < s2.length()) {
 23 | 			return -1;
 24 | 		}
 25 | 		else {
 26 | 			String check = s1.substring(0, s2.length());
 27 | 			if (check.equals(s2)) {
 28 | 				return 0;
 29 | 			}
 30 | 			else if (indexOf(s1.substring(1), s2) != -1) {
 31 | 				return 1 + indexOf(s1.substring(1), s2);
 32 | 			}
 33 | 		}
 34 | 		return -1;
 35 | 	}
 36 | 
 37 | 	/**
 38 | 	 * Write a recursive function that removes the first k even numbers
 39 | 	 * from the stack. If there are less than k even elements in the stack,
 40 | 	 * just remove all even elements. Do not use any loops or data structures
 41 | 	 * other than the stack passed in as a parameter.
 42 | 	 * @param stack
 43 | 	 * @param k
 44 | 	 * @return Returns the number of elements removed from the stack.
 45 | 	 */
 46 | 	public static int removeEvenNumbers(Stack<Integer> stack, int k) {
 47 | 		if (stack.isEmpty() || k <= 0) {
 48 | 			return 0;
 49 | 		}
 50 | 		else {
 51 | 			if (stack.peek() % 2 == 0) {
 52 | 				stack.pop();
 53 | 				return 1 + removeEvenNumbers(stack, k - 1);
 54 | 			}
 55 | 			else {
 56 | 				int temp = stack.pop();
 57 | 				int count = removeEvenNumbers(stack, k);
 58 | 				stack.push(temp);
 59 | 				return count;
 60 | 			}
 61 | 		}
 62 | 	}
 63 | 
 64 | 	/**
 65 | 	 * Write a recursive function that accepts an integer and
 66 | 	 * returns a new number containing only the even digits, in the same
 67 | 	 * order. If there are no even digits, return 0. Your function should
 68 | 	 * work for positive or negative numbers. You are NOT allowed
 69 | 	 * to use any data structures. You are not allowed to use Strings to
 70 | 	 * solve this problem either.
 71 | 	 * @param n
 72 | 	 * @return The input with only the even digits remaining in the same
 73 | 	 * order.
 74 | 	 */
 75 | 	public static int evenDigits(int n) {
 76 | 		if (n < 0) {
 77 | 			n = Math.abs(n);
 78 | 		}
 79 | 		if (n < 10) {
 80 | 			if (n % 2 == 0) {
 81 | 				return n;
 82 | 			}
 83 | 			else {
 84 | 				return 0;
 85 | 			}
 86 | 		}
 87 | 		else {
 88 | 			int check = n % 10;
 89 | 			if (check % 2 == 0) {
 90 | 				return evenDigits(n / 10) * 10 + check;
 91 | 			}
 92 | 			else {
 93 | 				return evenDigits(n / 10);
 94 | 			}
 95 | 		}
 96 | 	}
 97 | 
 98 | 	/**
 99 | 	 * Write a recursive function that evaluates a Queue<Character> as a mathematical
100 | 	 * expression. This queue can have any of the following characters:
101 | 	 * { '(', ')', '+', '*'} or any single digit number. Evaluate this expression and
102 | 	 * return the result. For example, for the expression:
103 | 	 * "(((1+2)*(3+1))+(1*(2+2)))", each of these characters would be in the
104 | 	 * q. As you recursively evaluate characters from the expression, you will
105 | 	 * remove the characters from the q. After evaluating the above expression,
106 | 	 * you should return 16. You are guaranteed that there are NO two digit numbers,
107 | 	 * and that the expression is well formed (parenthesis match, etc...). Do not use any
108 | 	 * loops. Do not use any data structures besides the q passed in as a parameter.
109 | 	 * @param q
110 | 	 * @return The result of the mathematical expression.
111 | 	 */
112 | 	public static int evaluate(Queue<Character> q) {
113 | 		if (q.isEmpty()) {
114 | 			return 0;
115 | 		}
116 | 		else if ((int) q.peek() < 40 || (int) q.peek() > 57) {
117 | 			return 0;
118 | 		}
119 | 		else if (q.size() == 1) {
120 | 			if (Character.isDigit(q.peek())) {
121 | 				return Character.getNumericValue(q.remove());
122 | 			}
123 | 			else {
124 | 				return 0;
125 | 			}
126 | 		}
127 | 		else {
128 | 			if (q.peek() == '(') {
129 | 				q.remove();
130 | 				int left = evaluate(q);
131 | 				char operator = q.remove();
132 | 				int right = evaluate(q);
133 | 				q.remove();
134 | 				if (operator == '+') {
135 | 					return left + right;
136 | 				}
137 | 				else if (operator == '*') {
138 | 					return left * right;
139 | 				}
140 | 			}
141 | 			return Character.getNumericValue(q.remove());
142 | 		}
143 | 	}
144 | 
145 | 	/**
146 | 	 * Write a recursive function that accepts a stack of integers and
147 | 	 * replaces each int with two copies of that integer. For example,
148 | 	 * calling repeatStack and passing in a stack of { 1, 2, 3} would change
149 | 	 * the stack to hold { 1, 1, 2, 2, 3, 3}. Do not use any loops. Do not use
150 | 	 * any data structures other than the stack passed in as a parameter.
151 | 	 * @param stack
152 | 	 */
153 | 	public static void repeatStack(Stack<Integer> stack) {
154 | 		if (!stack.empty()) {
155 | 			int temp = stack.pop();
156 | 			repeatStack(stack);
157 | 			stack.push(temp);
158 | 			stack.push(temp);
159 | 		}
160 | 	}
161 | 
162 | 	/**
163 | 	 * Write a recursive function that accepts a Queue<Integer>. It
164 | 	 * should change every int in this queue to be double its original
165 | 	 * value. You may NOT use loops or any other data structures besides
166 | 	 * the queue passed in as a parameter. You may use a helper function.
167 | 	 * @param q
168 | 	 */
169 | 	public static void doubleElements(Queue<Integer> q) {
170 | 		if (!q.isEmpty()) {
171 | 			int length = q.size();
172 | 			doubleElementsHelper(q, length - 1);
173 | 		}
174 | 	}
175 | 	
176 | 	private static void doubleElementsHelper(Queue<Integer> q, int index) {
177 | 		if (index < 0) {
178 | 			return;
179 | 		}
180 | 		else {
181 | 			int doubleNum = q.remove() * 2;
182 | 			q.add(doubleNum);
183 | 			doubleElementsHelper(q, index - 1);
184 | 		}
185 | 	}
186 | 
187 | }
188 | 


--------------------------------------------------------------------------------
/RecursionTestClass.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * This file will hold all of your testcases. Remember, to run all
  3 |  * of your tests, right-click on 'RunTests.java' and select 'Run As' ->
  4 |  * JUnit Test.
  5 |  */
  6 | import static org.junit.Assert.assertEquals;
  7 | 
  8 | import java.util.Arrays;
  9 | import java.util.LinkedList;
 10 | import java.util.Queue;
 11 | import java.util.Stack;
 12 | 
 13 | import org.junit.Test;
 14 | 
 15 | public class RecursionTestClass {
 16 | 	
 17 | 	/*
 18 | 	 * Here I have provided an example of one of the tests that I
 19 | 	 * would write. For each of your tests, leave a brief comment
 20 | 	 * above the test specifying its purpose. For example, for this
 21 | 	 * test, I might write, "indexOf_test1 tests when s2 is not a 
 22 | 	 * substring of s1. This should return -1."
 23 | 	 */
 24 |     @Test
 25 |     public void test_indexOf_test1() {
 26 |         int result = Recursion.indexOf("Hello", "World");
 27 |         System.out.println("indexOf(Hello, World), got " + result);
 28 |         assertEquals(-1, result);
 29 |     }
 30 |     //test when s1 is empty
 31 |     @Test
 32 |     public void test_indexOf_test2() {
 33 |         int result = Recursion.indexOf("", "World");
 34 |         System.out.println("indexOf(, World), got " + result);
 35 |         assertEquals(-1, result);
 36 |     }
 37 |     //test when s2 is empty
 38 |     @Test
 39 |     public void test_indexOf_test3() {
 40 |         int result = Recursion.indexOf("Hello", "");
 41 |         System.out.println("indexOf(Hello, ), got " + result);
 42 |         assertEquals(-1, result);
 43 |     }
 44 |     //test when both are empty
 45 |     @Test
 46 |     public void test_indexOf_test4() {
 47 |         int result = Recursion.indexOf("", "");
 48 |         System.out.println("indexOf(, ), got " + result);
 49 |         assertEquals(-1, result);
 50 |     }
 51 |     //test when s2 longer than s1
 52 |     @Test
 53 |     public void test_indexOf_test5() {
 54 |         int result = Recursion.indexOf("Hello", "HelloWorld");
 55 |         System.out.println("indexOf(Hello, HelloWorld), got " + result);
 56 |         assertEquals(-1, result);
 57 |     }
 58 |     //test when s1 == s2
 59 |     @Test
 60 |     public void test_indexOf_test6() {
 61 |         int result = Recursion.indexOf("Hello", "Hello");
 62 |         System.out.println("indexOf(Hello, Hello), got " + result);
 63 |         assertEquals(0, result);
 64 |     }
 65 |     //test when s1 contains s2
 66 |     @Test
 67 |     public void test_indexOf_test7() {
 68 |         int result = Recursion.indexOf("HelloWorld", "World");
 69 |         System.out.println("indexOf(HelloWorld, World), got " + result);
 70 |         assertEquals(5, result);
 71 |     }
 72 |     
 73 |     //test when k < 0
 74 |     @Test
 75 |     public void test_removeEvenNumbers_test1() {
 76 |     	Stack<Integer> stack = new Stack<Integer>();
 77 |     	stack.push(1); stack.push(2); stack.push(2); stack.push(1); stack.push(2);
 78 |         int result = Recursion.removeEvenNumbers(stack, -1);
 79 |         System.out.println("removeEvenNumbers([1,2,2,1,2], -1), got " + result);
 80 |         System.out.println("Current stack: " + stack);
 81 |         assertEquals(0, result);
 82 |     }
 83 |     //test remove 1 even number
 84 |     @Test
 85 |     public void test_removeEvenNumbers_test2() {
 86 |     	Stack<Integer> stack = new Stack<Integer>();
 87 |     	stack.push(1); stack.push(2); stack.push(2); stack.push(1); stack.push(2);
 88 |         int result = Recursion.removeEvenNumbers(stack, 1);
 89 |         System.out.println("removeEvenNumbers([1,2,2,1,2], 1), got " + result);
 90 |         System.out.println("Current stack: " + stack);
 91 |         assertEquals(1, result);
 92 |     }
 93 |     //test remove 4 even numbers when there's only 3 even numbers
 94 |     @Test
 95 |     public void test_removeEvenNumbers_test3() {
 96 |     	Stack<Integer> stack = new Stack<Integer>();
 97 |     	stack.push(1); stack.push(2); stack.push(2); stack.push(1); stack.push(2);
 98 |         int result = Recursion.removeEvenNumbers(stack, 4);
 99 |         System.out.println("removeEvenNumbers([1,2,2,1,2], 4), got " + result);
100 |         System.out.println("Current stack: " + stack);
101 |         assertEquals(3, result);
102 |     }
103 |     //test empty stack
104 |     @Test
105 |     public void test_removeEvenNumbers_test4() {
106 |     	Stack<Integer> stack = new Stack<Integer>();
107 |         int result = Recursion.removeEvenNumbers(stack, 10);
108 |         System.out.println("removeEvenNumbers([], 10), got " + result);
109 |         System.out.println("Current stack: " + stack);
110 |         assertEquals(0, result);
111 |     }
112 |     
113 |     //test input only contains 1s and 0s
114 |     @Test
115 |     public void test_evenDigits_test1() {
116 |         int result = Recursion.evenDigits(101010);
117 |         System.out.println("evenDigits(101010), got " + result);
118 |         assertEquals(0, result);
119 |     }
120 |     //test input is negative
121 |     @Test
122 |     public void test_evenDigits_test2() {
123 |         int result = Recursion.evenDigits(-246);
124 |         System.out.println("evenDigits(-246), got " + result);
125 |         assertEquals(246, result);
126 |     }
127 |     //test input is positive
128 |     @Test
129 |     public void test_evenDigits_test3() {
130 |         int result = Recursion.evenDigits(123456);
131 |         System.out.println("evenDigits(123456), got " + result);
132 |         assertEquals(246, result);
133 |     }
134 |     //test input is 0
135 |     @Test
136 |     public void test_evenDigits_test4() {
137 |         int result = Recursion.evenDigits(0);
138 |         System.out.println("evenDigits(0), got " + result);
139 |         assertEquals(0, result);
140 |     }
141 |     
142 |     //test empty queue
143 |     @Test
144 |     public void test_evaluate_test1() {
145 |     	Queue<Character> queue = new LinkedList<Character>();
146 |         int result = Recursion.evaluate(queue);
147 |         System.out.println("evaluate([]), got " + result);
148 |         System.out.println("Current queue: " + queue);
149 |         assertEquals(0, result);
150 |     }
151 |     //test queue contains other characters
152 |     @Test
153 |     public void test_evaluate_test2() {
154 |     	Queue<Character> queue = new LinkedList<Character>();
155 |     	queue.add('a'); queue.add('b'); queue.add('c');
156 |         int result = Recursion.evaluate(queue);
157 |         System.out.println("evaluate([a,b,c]), got " + result);
158 |         System.out.println("Current queue: " + queue);
159 |         assertEquals(0, result);
160 |     }
161 |     //test queue only contains operators
162 |     @Test
163 |     public void test_evaluate_test3() {
164 |     	Queue<Character> queue = new LinkedList<Character>();
165 |     	queue.add('+');
166 |         int result = Recursion.evaluate(queue);
167 |         System.out.println("evaluate([+]), got " + result);
168 |         System.out.println("Current queue: " + queue);
169 |         assertEquals(0, result);
170 |     }
171 |     //test queue only contains number
172 |     @Test
173 |     public void test_evaluate_test4() {
174 |     	Queue<Character> queue = new LinkedList<Character>();
175 |     	queue.add('3');
176 |         int result = Recursion.evaluate(queue);
177 |         System.out.println("evaluate([3]), got " + result);
178 |         System.out.println("Current queue: " + queue);
179 |         assertEquals(3, result);
180 |     }
181 |     //test given example
182 |     @Test
183 |     public void test_evaluate_test5() {
184 |     	Queue<Character> queue = new LinkedList<Character>();
185 |     	String testcase = "(((1+2)*(3+1))+(1*(2+2)))";
186 |     	for (int i = 0; i < testcase.length(); i++) {
187 |     		queue.add(testcase.charAt(i));
188 |     	}
189 |         int result = Recursion.evaluate(queue);
190 |         System.out.println("evaluate([(((1+2)*(3+1))+(1*(2+2)))]), got " + result);
191 |         System.out.println("Current queue: " + queue);
192 |         assertEquals(16, result);
193 |     }
194 |     
195 |     //test empty stack
196 |     @Test
197 |     public void test_repeatStack_test1() {
198 |     	Stack<Integer> stack = new Stack<Integer>();
199 |         Recursion.repeatStack(stack);
200 |         System.out.println("repeatStack([]), got " + stack);
201 |         assertEquals(0, stack.size());
202 |     }
203 |     //normal test
204 |     @Test
205 |     public void test_repeatStack_test2() {
206 |     	Stack<Integer> stack = new Stack<Integer>();
207 |     	stack.push(1); stack.push(2); stack.push(3);
208 |         Recursion.repeatStack(stack);
209 |         System.out.println("repeatStack([1,2,3]), got " + stack);
210 |         assertEquals(6, stack.size());
211 |     }
212 |     
213 |     //normal test
214 |     @Test
215 |     public void test_doubleElements_test1() {
216 |     	Queue<Integer> queue = new LinkedList<Integer>();
217 |     	queue.add(1); queue.add(2); queue.add(3);
218 |         Recursion.doubleElements(queue);
219 |         System.out.println("doubleElements([1,2,3]), got " + queue);
220 |         assertEquals(3, queue.size());
221 |     }
222 |     //test empty queue
223 |     @Test
224 |     public void test_doubleElements_test2() {
225 |     	Queue<Integer> queue = new LinkedList<Integer>();
226 |         Recursion.doubleElements(queue);
227 |         System.out.println("doubleElements([]), got " + queue);
228 |         assertEquals(0, queue.size());
229 |     }
230 |     //test queue only contains 0s and 1s
231 |     @Test
232 |     public void test_doubleElements_test3() {
233 |     	Queue<Integer> queue = new LinkedList<Integer>();
234 |     	queue.add(0); queue.add(0); queue.add(1); queue.add(1);
235 |         Recursion.doubleElements(queue);
236 |         System.out.println("doubleElements([0,0,1,1]), got " + queue);
237 |         assertEquals(4, queue.size());
238 |     }
239 | }
240 | 


--------------------------------------------------------------------------------