# CodingBat: Java. Update 2013.1

For further help with Coding Bat (Java), please check out my books. I am also available for tutoring.

As I thought I was done with publishing my solutions to the entire Coding Bat: Java library of exercises, with a total of over 200, Nick Parlante updated his website and added some more exercises. Apparently, his aim was to thoroughly prepare students for “FizzBuzz” interview questions.

The first exercise was added to Warmup-1, the others to Logic-1.

All solutions were successfully tested on 28 March 2013.

or35:

```public boolean or35(int n) {
return n % 3 == 0 || n % 5 == 0;
}
```

more20:

```public boolean more20(int n) {
return n % 20 == 1 || n % 20 == 2;
}
```

old35:

```public boolean old35(int n) {
return n % 3 == 0 ^ n % 5 == 0;
}
```

specialEleven:

```public boolean specialEleven(int n) {
return n % 11 == 0 || n % 11 == 1;
}
```

less20:

```public boolean less20(int n) {
return (n + 1) % 20 == 0 || (n + 2) % 20 == 0;
}
```

fizzString:

```public String fizzString(String str) {
boolean fizz = str.charAt(0) == 'f';
boolean buzz = str.charAt(str.length() - 1) == 'b';

if (fizz && buzz) return "FizzBuzz";
if (fizz) return "Fizz";
if (buzz) return "Buzz";
return str;
}
```

fizzString2:

```public String fizzString2(int n) {
boolean fizz = n % 3 == 0;
boolean buzz = n % 5 == 0;

if (fizz && buzz) return "FizzBuzz!";
if (fizz) return "Fizz!";
if (buzz) return "Buzz!";
return n + "!";
}
```

For further help with Coding Bat (Java), please check out my books. I am also available for tutoring.

# CodingBat: Java. Recursion-2

For further help with Coding Bat (Java), please check out my books. I am also available for tutoring.

Finally we’ve reached the last section of Coding Bat: Recursion-2. Those nine exercises are all very similar. Once you’ve figured out one you can probably solve the others immediately.

I’ll just walk you through the general strategy, using the first exercise as an example: The method “groupSum” takes three arguments. The first, “start”, is the index of an array of integers, the second is the array of integers in question, and the third, “target” is the target value. Now, “start” increases by one with each recursive call. If this value is greater than or equal to the length of the array, then the entire array has been processed. At this point, only the evaluation step has to be done, which consists of checking whether the target value is zero.

“Why zero?”, you may ask. If “target” equals zero, then it is possible to pick a group of integers from the array that sum up to the target value. The calculation is done by selecting each value of the array and in one case subtracting it from “target”, while in the other leaving “target” unchanged. Thus, all possible combinations will eventually be checked. Finally, the method returns “true” once one of the results is “true”, which is a property of short-circuit evaluation of logical disjunctions.

All solutions were successfully tested on 28 March 2013.

groupSum:

```public boolean groupSum(int start, int[] nums, int target) {
if (start >= nums.length) return target == 0;
return groupSum(start + 1, nums, target - nums[start])
|| groupSum(start + 1, nums, target);
}
```

groupSum6:

```public boolean groupSum6(int start, int[] nums, int target) {
if (start >= nums.length) return target == 0;
if (nums[start] == 6)
return groupSum6(start + 1, nums, target - nums[start]);
return groupSum6(start + 1, nums, target - nums[start])
|| groupSum6(start + 1, nums, target);
}
```

groupNoAdj:

```public boolean groupNoAdj(int start, int[] nums, int target) {
if (start >= nums.length) return target == 0;
return groupNoAdj(start + 2, nums, target - nums[start])
|| groupNoAdj(start + 1, nums, target);
}
```

groupSum5:

```public boolean groupSum5(int start, int[] nums, int target) {
if (start >= nums.length) return target == 0;
if (nums[start] % 5 == 0) {
if (start < nums.length - 1 && nums&#91;start + 1&#93; == 1)
return groupSum5(start + 2, nums, target - nums&#91;start&#93;);
return groupSum5(start + 1, nums, target - nums&#91;start&#93;);
}
return groupSum5(start + 1, nums, target - nums&#91;start&#93;)
|| groupSum5(start + 1, nums, target);
}
&#91;/sourcecode&#93;

<b>groupSumClump:</b>

public boolean groupSumClump(int start, int[] nums, int target) {
if (start >= nums.length) return target == 0;

int sum = nums[start];
int count = 1;
for (int i = start + 1; i < nums.length; i++)
if (nums&#91;i&#93; == nums&#91;start&#93;) {
sum += nums&#91;i&#93;;
count++;
}
return groupSumClump(start + count, nums, target - sum)
|| groupSumClump(start + count, nums, target);
}
&#91;/sourcecode&#93;

<b>splitArray:</b>

public boolean splitArray(int[] nums) {
return helper(0, nums, 0, 0);
}

private boolean helper(int start, int[] nums, int sum1, int sum2) {
if (start >= nums.length) return sum1 == sum2;
return helper(start + 1, nums, sum1 + nums[start], sum2)
|| helper(start + 1, nums, sum1, sum2 + nums[start]);
}
```

splitOdd10:

```public boolean splitOdd10(int[] nums) {
return helper(0, nums, 0, 0);
}

private boolean helper(int start, int[] nums, int sum1, int sum2) {
if (start >= nums.length)
return sum1 % 10 == 0 && sum2 % 2 == 1 || sum1 % 2 == 1
&& sum2 % 10 == 0;
return helper(start + 1, nums, sum1 + nums[start], sum2)
|| helper(start + 1, nums, sum1, sum2 + nums[start]);
}
```

split53:

```public boolean split53(int[] nums) {
return helper(0, nums, 0, 0);
}

private boolean helper(int start, int[] nums, int sum1, int sum2) {
if (start >= nums.length) return sum1 == sum2;
if (nums[start] % 5 == 0)
return helper(start + 1, nums, sum1 + nums[start], sum2);
if (nums[start] % 3 == 0)
return helper(start + 1, nums, sum1, sum2 + nums[start]);

return helper(start + 1, nums, sum1 + nums[start], sum2)
|| helper(start + 1, nums, sum1, sum2 + nums[start]);
}
```

For further help with Coding Bat (Java), please check out my books. I am also available for tutoring.

# CodingBat: Java. Recursion-1, Part III

For further help with Coding Bat (Java), please check out my books. I am also available for tutoring.

countPairs:

```public int countPairs(String str) {
if (str.length() < 3) return 0;
if (str.charAt(0) == str.charAt(2))
return 1 + countPairs(str.substring(1));
return countPairs(str.substring(1));
}
```

countAbc:

```public int countAbc(String str) {
if (str.length() < 3) return 0;
if (str.substring(0, 3).equals("abc")
|| str.substring(0, 3).equals("aba"))
return 1 + countAbc(str.substring(1));
return countAbc(str.substring(1));
}
```

count11:

```public int count11(String str) {
if (str.length() < 2) return 0;
if (str.substring(0, 2).equals("11"))
return 1 + count11(str.substring(2));
return count11(str.substring(1));
}
```

stringClean:

```public String stringClean(String str) {
if (str.length() < 2) return str;
if (str.charAt(0) == str.charAt(1))
return stringClean(str.substring(1));
return str.charAt(0) + stringClean(str.substring(1));
}
```

countHi2:

```public int countHi2(String str) {
if (str.length() < 2) return 0;
if (str.substring(0, 2).equals("hi"))
return 1 + countHi2(str.substring(2));
if (str.charAt(0) == 'x' && str.length() >= 3) {
if (str.substring(1, 3).equals("hi"))
return countHi2(str.substring(3));
return countHi2(str.substring(1));
}
return countHi2(str.substring(1));
}
```

parenBit:

```public String parenBit(String str) {
if (!str.substring(0, 1).equals("("))
return parenBit(str.substring(1));
return (str.substring(0, str.indexOf(")") + 1));
}
```

nestParen:

```public boolean nestParen(String str) {
if (str.equals("") || str.equals("()")) return true;
if (str.charAt(0) == '(' && str.charAt(str.length() - 1) == ')')
return nestParen(str.substring(1, str.length() - 1));
return false;
}
```

strCount:

```public int strCount(String str, String sub) {
if (str.length() < sub.length()) return 0;
if (str.substring(0, sub.length()).equals(sub))
return 1 + strCount(str.substring(sub.length()), sub);
return strCount(str.substring(1), sub);
}
```

strCopies:

```public boolean strCopies(String str, String sub, int n) {
if (str.length() < sub.length()) return (n <= 0);
if (str.substring(0, sub.length()).equals(sub))
return strCopies(str.substring(1), sub, n - 1);
return strCopies(str.substring(1), sub, n);
}
```

strDist:

```public int strDist(String str, String sub) {
if (str.indexOf(sub) == -1) return 0;
if (str.substring(0, sub.length()).equals(sub)
&& str.substring(str.length() - sub.length())
.equals(sub))
return str.length();
if (!str.substring(0, sub.length()).equals(sub))
return strDist(str.substring(1), sub);
// case: (!str.substring(str.length()-sub.length()).equals(sub))
return strDist(str.substring(0, str.length() - 1), sub);
}
```

For further help with Coding Bat (Java), please check out my books. I am also available for tutoring.

# CodingBat: Java. Recursion-1, Part II

For further help with Coding Bat (Java), please check out my books. I am also available for tutoring.

countHi:

```public int countHi(String str) {
if (str.length() < 2) return 0;
if (str.substring(0, 2).equals("hi"))
return 1 + countHi(str.substring(2));
return countHi(str.substring(1));
}
```

changeXY:

```public String changeXY(String str) {
if (str.length() == 0) return str;
if (str.charAt(0) == 'x') return "y" + changeXY(str.substring(1));
return str.charAt(0) + changeXY(str.substring(1));
}
```

changePi:

```public String changePi(String str) {
if (str.length() < 2) return str;
if (str.substring(0, 2).equals("pi"))
return "3.14" + changePi(str.substring(2));
return str.charAt(0) + changePi(str.substring(1));
}
```

noX:

```public String noX(String str) {
if (str.length() == 0) return "";
if (str.charAt(0) == 'x') return noX(str.substring(1));
return str.charAt(0) + noX(str.substring(1));
}
```

array6:

```public boolean array6(int[] nums, int index) {
if (nums.length == 0) return false;
if (index == nums.length - 1) return nums[index] == 6;
if (nums[index] == 6) return true;
return array6(nums, index + 1);
}
```

array11:

```public int array11(int[] nums, int index) {
if (index == nums.length) return 0;
if (nums[index] == 11) return 1 + array11(nums, index + 1);
return array11(nums, index + 1);
}
```

array220:

```public boolean array220(int[] nums, int index) {
if (nums.length < 2 || index == nums.length - 1) return false;
if (nums[index + 1] == nums[index] * 10) return true;
return array220(nums, index + 1);
}
```

allStar:

```public String allStar(String str) {
if (str.length() <= 1) return str;
return str.charAt(0) + "*" + allStar(str.substring(1));
}
```

pairStar:

```public String pairStar(String str) {
if (str.length() < 2) return str;
if (str.charAt(0) == str.charAt(1))
return str.charAt(0) + "*" + pairStar(str.substring(1));
return str.charAt(0) + pairStar(str.substring(1));
}
```

endX:

```public String endX(String str) {
if (str.length() == 0) return str;
if (str.charAt(0) == 'x')
return endX(str.substring(1)) + "x";
return str.charAt(0) + endX(str.substring(1));
}
```

For further help with Coding Bat (Java), please check out my books. I am also available for tutoring.

# CodingBat: Java. Recursion-1, Part I

For further help with Coding Bat (Java), please check out my books. I am also available for tutoring.

Recursion is neat in theory and commonly leads to very clean code. Some people have a hard time understanding it, though. If you’ve ever encountered a recurrence relation in mathematics, then you already know everything there is to know about the “mind-bending” nature of recursive problems.

Otherwise, try this simple strategy. First, you may be tempted to think recursively about recursive functions. This may work with factorials, but for something more complex like, say, the Ackermann function, it’s a recipe for disaster. So, don’t do it! Instead, figure out what the base case consists of. The base case immediately returns a result. All other conditions eventually have to revert to the base case, which means that you’ll return “something” in addition to recursively calling the function, but with an input that brings you closer to the base case.

The first example, factorial, of CodingBat’s Recursion-1 section illustrates this strategy very well. All subsequent problems are rather similar.

All solutions were successfully tested on 24 March 2013.

factorial:

```public int factorial(int n) {
if (n <= 1) return 1;
return n * factorial(n - 1);
}
```

bunnyEars:

```public int bunnyEars(int bunnies) {
if (bunnies == 0) return 0;
return 2 + bunnyEars(bunnies - 1);
}
```

fibonacci:

```public int fibonacci(int n) {
if (n <= 1) return n;
return fibonacci(n - 2) + fibonacci(n - 1);
}
```

bunnyEars2:

```public int bunnyEars2(int bunnies) {
if (bunnies == 0) return 0;
if (bunnies % 2 == 1) return 2 + bunnyEars2(bunnies - 1);
return 3 + bunnyEars2(bunnies - 1);
}
```

triangle:

```public int triangle(int rows) {
if (rows == 0) return 0;
return rows + triangle(rows - 1);
}
```

sumDigits:

```public int sumDigits(int n) {
if (n == 0) return 0;
return n % 10 + sumDigits(n / 10);
}
```

count7:

```public int count7(int n) {
if (n == 0) return 0;
if (n % 10 == 7) return 1 + count7(n / 10);
return count7(n / 10);
}
```

count8:

```public int count8(int n) {
if (n == 0) return 0;
if (n >= 88 && n % 100 == 88) return 2 + count8(n / 10);
if (n % 10 == 8) return 1 + count8(n / 10);
return count8(n / 10);
}
```

powerN:

```public int powerN(int base, int n) {
if (n == 0) return 1;
return base * powerN(base, n - 1);
}
```

countX:

```public int countX(String str) {
if (str.length() == 0) return 0;
if (str.charAt(0) == 'x') return 1 + countX(str.substring(1));
return countX(str.substring(1));
}
```

For further help with Coding Bat (Java), please check out my books. I am also available for tutoring.