A) (20 points) Define the method inDogish recursively such that it returns true if the word is in dog-ish and false if it is not. I left a dogish Helper method, which I guarantee you will need to recursively solve dogish. An iterative solution will receive no points. (b) (20 points) Define the method inXish that does the same logic of dog-ish but for some word X. The method returns true if the word contains all the letters in the word X. The solution must be recursive. An iterative solution will receive no points.

/ Main.java

class Main {

     public static void main(String[] args) {

           //System.out.println(inDogish("aplderogad"));

           //System.out.println(inXish("aplderogad", "dog"));

     }

     // returns true if the word is in dog-ish

     // returns false if word is not in dog-ish

     public static boolean inDogish(String word) {

           /**

           * Note: we can use the inXish() method to complete this method in a

           * single line if you want. just write 'return inXish(word,"dog");' and

           * you are done.

           */

           // if word is null or empty, returning false

           if (word == null || word.length() == 0) {

                 return false;

           }

           // converting word to lower case

           word = word.toLowerCase();

           // if 'd' does not exist on the word, returning false

           if (!dogishHelper(word, 'd')) {

                 return false;

           }

           // removing the characters upto first 'd' in word

           word = word.substring(word.indexOf('d') + 1);

           // if 'o' does not exist on the word, returning false

           if (!dogishHelper(word, 'o')) {

                 return false;

           }

           // removing the characters upto first 'o' in word

           word = word.substring(word.indexOf('o') + 1);

           // if 'g' does not exist on the word, returning false, otherwise

           // returning true

           if (!dogishHelper(word, 'g')) {

                 return false;

           } else {

                 return true;

           }

     }

     // necessary to implement inDogish recursively.

     // returns true if letter is in word, else not.

     public static boolean dogishHelper(String word, char letter) {

           // if word is empty, returning -1

           if (word == null || word.length() == 0) {

                 return false;

           }

           // if first character in word is letter, returning 0

           if (word.charAt(0) == letter) {

                 return true;

           }

           return dogishHelper(word.substring(1), letter);

     }

     // the best thing about the above helper method is that we can use it in

     // inXish method also

     // a generalized version of the inDogish method

     public static boolean inXish(String word, String x) {

           // if x is empty, returning true (base case, which means all the letters

           // in x are in word in that order)

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

                 return true;

           }

           // getting first character of x

           char first = x.charAt(0);

           // if first character does not exist on the word, returning false

           if (!dogishHelper(word, first)) {

                 return false;

           }

           // calling and returning inXish recursively, passing the word after

           // removing characters upto first occurrance of char first, and x after

           // removing first character from it

           return inXish(word.substring(word.indexOf(first) + 1), x.substring(1));

     }

}

Explanation:

answer///64-bit architecture and gpt partitioning table;