Input two sequences of integers (as Strings and then use String Tokenizer to extract the individual integers) and use a hash table to determine whether the relationship between the second integer sequence and the first integer sequence is one of the following: (i) the second integer sequence is a proper subset of the first integer sequence (ii) the second integer sequence is a permutation of the first integer sequence (iii) the second integer sequence is neither a permutation nor a proper subset of the first integer sequence.

Note that an integer sequence S2 is a "proper subset" of integer sequence S1 if every element of S2 is in S1, but S1 has at least one element that is not in S2.

You are given the code for the Hash table permutation check that we discussed in class. Modify this code to identify the relationship between two input integer sequences as mentioned above.

Test your code with three different inputs for the two integer sequences such that one of the above three relationships are printed (i.e., the output is (i) for one pair of inputs, (ii) for another pair of inputs and (iii) for the third pair of inputs). Take screenshots of the outputs obtained for all the three pairs of input integer sequences.

You could choose the hash table size of your choice.

The code which is given is:

import java.util.*;

// implementing hash tables as an array of linked lists

class Node{

private int data;

private Node nextNodePtr;

public Node(){}

public void setData(int d){

data = d;

}

public int getData(){

return data;

}

public void setNextNodePtr(Node nodePtr){

nextNodePtr = nodePtr;

}

public Node getNextNodePtr(){

return nextNodePtr;

}

}

class List{

private Node headPtr;

public List(){

headPtr = new Node();

headPtr.setNextNodePtr(null);

}

public Node getHeadPtr(){

return headPtr;

}

public boolean isEmpty(){

if (headPtr.getNextNodePtr() == null)

return true;

return false;

}

public void insert(int data){

Node currentNodePtr = headPtr.getNextNodePtr();

Node prevNodePtr = headPtr;

while (currentNodePtr != null){

prevNodePtr = currentNodePtr;

currentNodePtr = currentNodePtr.getNextNodePtr();

}

Node newNodePtr = new Node();

newNodePtr.setData(data);

newNodePtr.setNextNodePtr(null);

prevNodePtr.setNextNodePtr(newNodePtr);

}

public void insertAtIndex(int insertIndex, int data){

Node currentNodePtr = headPtr.getNextNodePtr();

Node prevNodePtr = headPtr;

int index = 0;

while (currentNodePtr != null){

if (index == insertIndex)

break;

prevNodePtr = currentNodePtr;

currentNodePtr = currentNodePtr.getNextNodePtr();

index++;

}

Node newNodePtr = new Node();

newNodePtr.setData(data);

newNodePtr.setNextNodePtr(currentNodePtr);

prevNodePtr.setNextNodePtr(newNodePtr);

}

public int read(int readIndex){

Node currentNodePtr = headPtr.getNextNodePtr();

Node prevNodePtr = headPtr;

int index = 0;

while (currentNodePtr != null){

if (index == readIndex)

return currentNodePtr.getData();

prevNodePtr = currentNodePtr;

currentNodePtr = currentNodePtr.getNextNodePtr();

index++;

}

return -1; // an invalid value indicating

// index is out of range

}

public void modifyElement(int modifyIndex, int data){

Node currentNodePtr = headPtr.getNextNodePtr();

Node prevNodePtr = headPtr;

int index = 0;

while (currentNodePtr != null){

if (index == modifyIndex){

currentNodePtr.setData(data);

return;

}

prevNodePtr = currentNodePtr;

currentNodePtr = currentNodePtr.getNextNodePtr();

index++;

}

}

public boolean deleteElement(int data){

Node currentNodePtr = headPtr.getNextNodePtr();

Node prevNodePtr = headPtr;

Node nextNodePtr = headPtr;

while (currentNodePtr != null){

if (currentNodePtr.getData() == data){

nextNodePtr = currentNodePtr.getNextNodePtr();

prevNodePtr.setNextNodePtr(nextNodePtr);

return true;

}

prevNodePtr = currentNodePtr;

currentNodePtr = currentNodePtr.getNextNodePtr();

}

return false;

}

public int countList(){

Node currentNodePtr = headPtr.getNextNodePtr();

int numElements = 0;

while (currentNodePtr != null){

numElements++;

currentNodePtr = currentNodePtr.getNextNodePtr();

}

return numElements;

}

public void IterativePrint(){

Node currentNodePtr = headPtr.getNextNodePtr();

while (currentNodePtr != null){

System.out.print(currentNodePtr.getData()+" ");

currentNodePtr = currentNodePtr.getNextNodePtr();

}

System.out.println();

}

public boolean containsElement(int data){

Node currentNodePtr = headPtr.getNextNodePtr();

while (currentNodePtr != null){

if (currentNodePtr.getData() == data)

return true;

currentNodePtr = currentNodePtr.getNextNodePtr();

}

return false;

}

}

class Hashtable{

private List[] listArray;

private int tableSize;

public Hashtable(int size){

tableSize = size;

listArray = new List[size];

for (int index = 0; index < size; index++)

listArray[index] = new List();

}

public int getTableSize(){

return tableSize;

}

public void insert(int data){

int hashIndex = data % tableSize;

listArray[hashIndex].insert(data);

}

public void deleteElement(int data){

int hashIndex = data % tableSize;

while (listArray[hashIndex].deleteElement(data));

}

public boolean hasElement(int data){

int hashIndex = data % tableSize;

return listArray[hashIndex].containsElement(data);

}

public void printHashTable(){

for (int hashIndex = 0; hashIndex < tableSize; hashIndex++){

System.out.print("Hash Index: " + hashIndex + " : ");

listArray[hashIndex].IterativePrint();

}

}

public boolean isEmpty(){

for (int hashIndex = 0; hashIndex < tableSize; hashIndex++){

if (!listArray[hashIndex].isEmpty())

return false;

}

return true;

}

}

class HashTableLinkedList{

public static void main(String[] args){

Scanner input = new Scanner(System.in);

String FirstIntegerSequence;

System.out.print("Enter the first integer sequence: ");

FirstIntegerSequence = input.nextLine();

String SecondIntegerSequence;

System.out.print("Enter the second integer sequence: ");

SecondIntegerSequence = input.nextLine();

int hashTableSize;

System.out.print("Enter the size of the hash table: ");

hashTableSize = input.nextInt();

Hashtable hashTable = new Hashtable(hashTableSize);

StringTokenizer stk = new StringTokenizer(FirstIntegerSequence, ", ");

while (stk.hasMoreTokens()){

int value = Integer.parseInt(stk.nextToken());

hashTable.insert(value);

}

stk = new StringTokenizer(SecondIntegerSequence, ", ");

while (stk.hasMoreTokens()){

int value = Integer.parseInt(stk.nextToken());

if (hashTable.hasElement(value))

hashTable.deleteElement(value);

else{

System.out.println(SecondIntegerSequence + " is not a permutation of " + FirstIntegerSequence);

return;

}

}

if (hashTable.isEmpty())

System.out.println(SecondIntegerSequence +" is a permutation of " + FirstIntegerSequence);

else

System.out.println(SecondIntegerSequence +" is not a permutation of " + FirstIntegerSequence);

}

}