Question

Neo needs to break into the server room, but he has only partial information about the code that opens the door. Parts of the code are known, and other parts have been narrowed down to several options, which are listed inside parentheses. He also knows the sum of all of the digits in the code. Write a recursive method that will find the correct code.

If the given pattern was “1(2,34)5(3,2)”, then the code must start with 1 and have a 5 in the middle. The numbers in parentheses are different choices for those parts of the code. The possible codes in this case would be 1253, 1252, 13453, and 13452. If the target sum was 11, then the answer would be 1253. Some possible inputs would not lead to a unique code. In that case, return any code that adds up to the correct total.

Hints:

1. Assume that the input is well-formed. You don’t need to worry about patterns where the parentheses don’t match up, for example.
2. Since the characters for 0-9 are in order in the ASCII standard, you can easily get the value of a character as an int by doing this: achar - ‘0’
3. To approach this problem recursively, your code needs to make a decision, and then attempt to solve the rest of the problem. There are two key questions: How can you make the problem smaller? How can you backtrack to change your decision if it turns out to be wrong?

public class CodeBreaker {
public String breakCode(String pattern, int target) {
return null;
}
}

Answer 1

Here is the completed code for this problem. Comments are included, go through it, learn how things work and let me know if you have any doubts or if you need anything to change. If you are satisfied with the solution, please rate the answer. If not, PLEASE let me know before you rate, I’ll help you fix whatever issues. Thanks

// CodeBreaker.java

public class CodeBreaker {

      // required method, returns the pattern in which sum of digits equals

      // target, or null if no such patterns exist

      public String breakCode(String pattern, int target) {

            // checking if pattern contains "("

            if (pattern.contains("(")) {

                  // finding the first indices of ( and )

                  int index1 = pattern.indexOf("(");

                  int index2 = pattern.indexOf(")");

                  // taking String before ( from pattern

                  String before = pattern.substring(0, index1);

                  // taking String after )

                  String after = pattern.substring(index2 + 1);

                  // taking String between ( and ), splitting by comma to get an array

                  // of values containing choices that can be used

                  String values[] = pattern.substring(index1 + 1, index2).split(",");

                  // looping through each value in the array

                  for (int i = 0; i < values.length; i++) {

                        // calling breakCode method recursively, using values[i] as

                        // subsititute (i.e concatenated before,values[i] and after)

                        String str = breakCode(before + values[i] + after, target);

                        //if the resultant string is non null, returning it

                        if (str != null) {

                              return str;

                        }

                  }

            }

            //if string does not contain "(", checking if sum of digits equals target

            else if (sumDigits(pattern) == target) {

                  //found, returning pattern

                  return pattern;

            }

            //not found, returning null

            return null;

      }

      // private helper method to find the sum of digits in a string, assuming str

      // consist of digits only

      private int sumDigits(String str) {

            if (str.length() == 0) {

                  // base case, returning 0

                  return 0;

            }

            // finding digit at first index

            int i = str.charAt(0) - '0';

            // adding to the sum of digits of remaining String, after taking a

            // substring ignoring the first character

            return i + sumDigits(str.substring(1));

      }

}