Question

A java program for this question please!

Recursion: A word is considered elfish if it contains the letters: e, l, and f in it, in any order. For example, we would say that the following words are elfish: whiteleaf, tasteful, unfriendly, and waffles, because they each contain those letters. Write a recursive method called elfish(), that, given a word, tells us whether or not that word is elfish. The signature of the method should be: public static boolean elfish(String word) Write a more generalized recursive method called x-ish. That, given two words, returns true if all the letters of the first word are contained in the second. The signature of the method should be: public static boolean xish(String x, String word) Sample Outputs: Suppose the test program is Testish class, the sample outputs are: $ java Testish unfriendly unfriendly is elfish $ java Testish elf unfriendly unfriendly contains elf $ java Testish els unfriendly unfriendly does not contain els $ java Testish Please provide one or two strings Requirements: Files to be submitted: Testish.java. String input: the user provide the strings via command line arguments. If there is no argument provided, your program terminates with a user friendly message informing the user that at least one string is expected (see above sample output). If there is one argument provided, your program will treat it as elfish test and check whether or not the provided string contains e, l, and f. If there are at least two arguments provided, only the first two are used. Your program will perform xish check: whether the second string contains the first string. Make sure method elfish() and xish() are recursive. Any non-recursive() implementation will receive zero credit. String is provided in java.lang package, which is included by default. Your program is not allowed to import any other class in this assignment. Hints: The key to design a recursive method is to (1) have the method call itself and (2) establish a base case. Considering the generic case with two input strings s1 and s2, the basic idea is to linearly scan string s1 one character (starting from the leftmost one) at a time and try to find a matching character in string s2. A failure will indicate a false result. A success then will continue with a recursive method call: move the character pointer of s1 to one position to the right and repeat the above process. Obviously, the base case of this recursion is when the character pointer of s1 is pointing to the end of s1 (you should return true in this case, why?). You are allowed to use any method defined in Java String class. These methods can be found at Java String API. In particular, you may find the following methods useful: charAt(); indexOf(); isEmpty(); length(); substring().

Answer 1

Please let me know if you have any doubts or you want me to modify the answer. And if you find this answer useful then don't forget to rate my answer as thumps up. Thank you! :)

import java.util.*;

public class TreeNode {
    private int val; // The value in the node
    private TreeNode left; // The left subtree (null if empty)
    private TreeNode right; // The right subtree (null if empty)

    // Recursion problem 1. Write the bodies of the following two methods size

    /** Return the size of the tree with this as the root. */
    public int size() {
        return ((left == null) ? 0 : left.size()) +
                ((right == null)? 0 : right.size()) +
                1;
    }

    /** Return the size of the tree whose root is r. */
    public static int size(TreeNode r) {
        return ((r.left == null) ? 0 : size(r.left)) +
                ((r.right == null)? 0 : size(r.right)) +
                1;
    }

    /** Return the number of leaves of this binary tree with
     * its root to be this node. */
    public int getNumOfLeaves() {
        return (left == null && right == null) ? 1 :
                (left == null) ? right.getNumOfLeaves() :
                        (right == null)? left.getNumOfLeaves() :
                                left.getNumOfLeaves() + right.getNumOfLeaves();
    }

    /** Return the number of leaves of this binary tree with
     * its root to be r. */
    public static int getNumOfLeaves(TreeNode r) {
        return (r.left == null && r.right == null) ? 1 :
                (r.left == null) ? getNumOfLeaves(r.right) :
                        (r.right == null)? getNumOfLeaves(r.left) :
                                getNumOfLeaves(r.left) + getNumOfLeaves(r.right);
    }

    /** Return the result of b**c in O(c) time.
     * Precondition: c >= 0. */
    public static double bPowerc(double b, int c) {
        assert c >= 0;

        return (c == 0) ? 1 :
                (c % 2 == 1) ? b * bPowerc(b, c-1) :
                        bPowerc(b*b, c/2);
    }

     /** Return true if all the letters in String x are included in
     * String s and in the same order. */
    public static boolean isXish(String x, String s) {
        return x.equals("") ? true :
                s.indexOf(x.charAt(0)) >= 0 &&
                        isXish(x.substring(1), s.substring(s.indexOf(x.charAt(0))+1));
    }

    /** Return true if the given word String s contains the letters e,
     * l and f without considering the order. */
    public static boolean isElfish(String s) {
        return s.contains("e") && s.contains("l") && s.contains("f");
    }

  
    /** Return a set of all permutations of s.
     * Precondition: s contains no duplicates --all chars are different*/
    public static Set<String> permutations(String s) {
        if (s.length() == 0)
            return new HashSet<String>();
        else if (s.length() == 1) {
            Set<String> permutationSet = new HashSet<String>();
            permutationSet.add(s);
            return permutationSet;
        }
        else {
            Set<String> permutationSetLesser = permutations(s.substring(1));
            Set<String> permutationSet = new HashSet<String>();
            for (String permutationLesser: permutationSetLesser)
                for (int offset = 0; offset <= permutationLesser.length(); offset++)
                    permutationSet.add(new StringBuilder(permutationLesser).insert(offset, s.charAt(0)).toString());
            return permutationSet;
        }
    }

    // Write your coin-game stuff here (it is optional)
    public enum Player {
        Alice, Bob;

        /** Return the opponent of this player. */
        public Player opponent() {
            return this == Alice ? Bob : Alice;
        }

        /** Return the player as a String. */
        public String toString() {
            return this == Alice ? "Alice" : "Bob";
        }
    }

    public static class PickCoinResult {
        private Player winner;
        private int NumOfStrategies;

        /** Constructor. */
        public PickCoinResult(Player win, int NOS) {
            winner = win;
            NumOfStrategies = NOS;
        }

        /** Get the value of fields. */
        public Player getWinner() {
            return winner;
        }

        public int getNOS() {
            return NumOfStrategies;
        }
    }

    /** Return the winner of the pick coin game and the number of strategies. */
    public static PickCoinResult pickCoin(int NumOfCoins, Player first, Player second) {
        assert NumOfCoins > 0;

        if (NumOfCoins == 1 || NumOfCoins == 2)
            return new PickCoinResult(first, 1);
        else if (NumOfCoins == 3)
            return new PickCoinResult(second, 2);
        else if (NumOfCoins == 4)
            return new PickCoinResult(first, 3);
        else {
            // NumOfCoins > 4
            if (NumOfCoins % 3 == 0) {
                int NumOfStrategies = pickCoin(NumOfCoins - 1, second, first).getNOS() +
                        pickCoin(NumOfCoins - 2, second, first).getNOS() +
                        pickCoin(NumOfCoins - 4, second, first).getNOS();
                return new PickCoinResult(second, NumOfStrategies);
            }
            else {
                int NumOfStrategies = ((NumOfCoins - 1) % 3 == 0) ?
                        (pickCoin(NumOfCoins - 1, second, first).getNOS() +
                                pickCoin(NumOfCoins - 4, second, first).getNOS()) :
                        pickCoin(NumOfCoins - 2, second, first).getNOS();
                return new PickCoinResult(first, NumOfStrategies);
            }
        }
    }

    /** Constructor: a one-node tree with value v */
    public TreeNode(int v) {
        val= v;
    }

    /**Constructor: a treee with value v, left subtree left, and right subtee right */
    public TreeNode(int v, TreeNode left, TreeNode right) {
        val= v;
        this.left= left;
        this.right= right;
    }

    public @Override String toString() {
        return toString("");
    }

    /** Like toString() except that everything is indented by sp (assumed to be
     * a string with blanks in it) */
    public String toString(String sp) {
        if (left == null && right == null) {
            return sp + val;
        }
        return sp + val +
                " " + (left == null ? sp + " " + null : left.toString(sp + " ")) +
                " " + (right == null ? sp + " " + null : right.toString(sp + " "));
    }

    /** = a tree (1 2 (3 (4 5 6) null)) */
    public static TreeNode tree1() {
        TreeNode t1= new TreeNode(1);
        TreeNode t2= new TreeNode(2);
        TreeNode t3= new TreeNode(3);
        TreeNode t4= new TreeNode(4);
        TreeNode t5= new TreeNode(5);
        TreeNode t6= new TreeNode(6);
        return new TreeNode(1, t2, new TreeNode(3, new TreeNode(4, t5, t6), null));
    }

}
--------------------------------------------------------------------------------------------------------------------
import static org.junit.Assert.*;

import org.junit.Test;
import java.util.*;

public class TreeNodeTest {

    @Test
    public void sizeleavesTest() {
        TreeNode tree1 = TreeNode.tree1();
        assertEquals(6, tree1.size());
        assertEquals(6, TreeNode.size(tree1));
        assertEquals(3, tree1.getNumOfLeaves());
        assertEquals(3, TreeNode.getNumOfLeaves(tree1));
    }

    @Test
    public void bPowercTest() {
        double[] bArray = {2, 3, 3.5, 4};
        int[] cArray = {2, 3, 4, 5};
        double[] expected = {4, 27, 150.0625, 1024};
        double actual;

        for (int i = 0; i < bArray.length; i++) {
            actual = TreeNode.bPowerc(bArray[i], cArray[i]);
            assert expected[i] == actual;
        }
    }

    @Test
    public void isXishTest() {
        String[][] testCases = {{"ab", "abc"}, {"ba", "abc"}, {"ab", ""}};
        boolean[] expected = {true, false, false};
        boolean actual = false;

        for (int i = 0; i < testCases.length; i++) {
            actual = TreeNode.isXish(testCases[i][0], testCases[i][1]);
            assertEquals(expected[i], actual);
        }
    }

    @Test
    public void permutationsTest() {
        String[] testCases = {"", "a", "ab", "abc", "abcd"};
        Set<String> actual = null;

        for (int i = 0; i< testCases.length; i++) {
            System.out.println("Test Case " + (i+1) + ":");
            actual = TreeNode.permutations(testCases[i]);
            for (String permutation: actual)
                System.out.print(permutation + ' ');
            System.out.println();
        }
    }

    @Test
    public void pickCoinTest() {
        int[] numOfCoinsCases = {1, 2, 3, 10, 25, 30};
        TreeNode.Player[][] PlayerCases = {{TreeNode.Player.Alice, TreeNode.Player.Bob},
                {TreeNode.Player.Bob, TreeNode.Player.Alice},
                {TreeNode.Player.Alice, TreeNode.Player.Bob},
                {TreeNode.Player.Alice, TreeNode.Player.Bob},
                {TreeNode.Player.Alice, TreeNode.Player.Bob},
                {TreeNode.Player.Alice, TreeNode.Player.Bob}};

        TreeNode.Player[] expectedWinner = {TreeNode.Player.Alice,
                TreeNode.Player.Bob,
                TreeNode.Player.Bob,
                TreeNode.Player.Alice,
                TreeNode.Player.Alice,
                TreeNode.Player.Bob};

        int[] expectedNOS = {1, 1, 2, 22, 3344, 18272};

        TreeNode.PickCoinResult actualResult = null;

        for (int i = 0; i < numOfCoinsCases.length; i++) {
            actualResult = TreeNode.pickCoin(numOfCoinsCases[i], PlayerCases[i][0], PlayerCases[i][1]);
            assertEquals(expectedWinner[i], actualResult.getWinner());
            assertEquals(expectedNOS[i], actualResult.getNOS());
        }
    }

}

Elfish [-fldeaProjects/Elfish] - ./src/TreeNodeTest.java [Elfish Project *증 *一 eTreeNodejava GTreeNodeTest.java import static org.junit.Assert. Elfish ideaProjects/Elfish idea import org.junit.Test; 4 中import java.util.*; G TreeNode TreeNodeTest public class TreeNodeTest Elfish.im l External Libraries Test public void sizeleavesTest() Scratches and Consoles 10D TreeNode tree1 TreeNode. treel0 assertEquatst expected: 6, treel.size)); assertEquals( expected: 6, TreeNode.size(tree1)); assertEquals( expected: 3, treel.getNumOfLeaves()) assertEquals( expected: 3, TreeNode.getNumOfLeaves(tree1)) 15 16 17 18 19 Test public void bPowercTest) doublell bArray 12, 3, 3.5, 4 int I1 cArray12, 3, 4, 5); doublell expected-14, 27, 150.0625, 1824); double actual; 23 for (int 1-0; ¡<bArray.Length; i++) { 26 27 actual TreeNode.bPowerc(bArraylil, cArrayli): assert expectedlil-actual; 29 @Test 2public void isXishTest) Stringl1Il testcases-f'ab", "abc")ba","abe"),"ab" boolean[I expected true, false, false); 35 36 boolean actual false for (int į=0; į< testcases.Length; i++) { actual TreeNode.isXish(testCases (il 101, testCases lil [11); assertEquals (expected[i], actual); 38 41 Test public void permutationsTest) f Stringll testCases-(a" "ab", "abc", "absd" SeteStrino> actual null: 46 TreeNodeTest bPowercTest) Terminal:TODo Q Event Log 26:31 LF UTF-8# 4spaces: -t