You create a suffix trie out of the string MISSISSIPPI$. Assume that the root is at depth 0, its children are at depth 1, and their children are at depth 2, and so on. Fill in the following (just write numbers): The number of children of the root is The number of leaves in the suffix trie is  . You search for the pattern ISS in the suffix trie. After the pattern is completely matched, the node reached is at depth  . The number of leaves where a match for the pattern ISS is found is You search for the pattern IPS in the suffix trie. The depth of the node reached right before a mismatch occurs is

Consider the set A = {1, 2, 11, {121}, 22, 1212, (111, 212, 112}} Enter the value of Al. (Note: Enter a number).

Please fill in the code gaps if possible. This problem has been giving me trouble. Any help is appreciated.  public class Node {       private String element; // we assume elements are character strings         private Node next;  /* Creates a node with the given element and next node. */ public Node(String s, Node n) {  //fill in body  }  /* Returns the element of this node. */ public String getElement() {  //fill in body  }  /* Returns the next node of this node. */ public Node getNext() {  //fill in body  }  // Modifier methods:  /* Sets the element of this node. */ public void setElement(String newElem) {  //fill in body  }  /* Sets the next node of this node. */ public void setNext(Node newNext) {  //fill in body  } }

Java Programming:  Make AST Nodes: IfNode, WhileNode, RepeatNode. All will have BooleanCompare for a condition and a collection of StatementNode. ForNode will have a Node for from and a node for to. This will have to be of type Node because it could be any expression. For example: for a from 1+1 to c-6  Make parsing functions for each. Java won't let you create methods called if(), etc. parseIf() is an example of a way around that; use whatever you like but use good sense in your names.  Next let's look at function calls. Each function has a name and a collection of parameters. A parameter can be a VAR variable  or something that came from booleanCompare (IntegerNode, VariableReferenceNode, etc). It would be reasonable to make 2 objects - ParameterVariableNode and ParameterExpressionNode. But for this very simple and well-defined case, we can do something simple: ParameterNode has a VariableReferenceNode (for VAR IDENTIFIER) and a Node for the case where the parameter is not a VAR.…