You are required to write an interactive C program that prompts the .pdf

You are required to write an interactive C program that prompts the user for commands, accepts
commands from the keyboard (stdin) and executes those commands. When a command requires
output, it must be written to stdout. The program must continue to accept and process commands
until the user types the end command.
The program deals with linked lists. Each node of such a list contains a string of length at most
10, a positive integer (i.e., an integer value 1) and a pointer to the next node of the list. For any
node, the string and the integer stored in that node will be referred to as the symbol and count for
that node respectively. At all times, the list must satisfy the following two important properties.
1. The symbols appearing in the list are all distinct; that is, no two nodes have the same symbol.
2. When the list is scanned from left to right, the counts must be in non-increasing order.
Initially, we have an empty list. Some commands require your program to modify the list while
others involve traversing the list to gather and print information about the list. The commands
and their interpretations are as follows. (You should bear in mind that different parts of a
command are separated by one or more spaces.)
(a)Insert Command: The syntax for this command is as follows: ins str
Here, ins represents the name of the command and str represents a string. The interpretation of
this command is as follows.
(i) If the list contains a node whose symbol is identical to the string specified in the command,
then the count stored in the node must be incremented by 1. After this increment, if necessary,
the node must be moved to an appropriate position in the list to ensure that the counts are in non-
increasing order.
(ii) If the list does not contain a node whose symbol is identical to the string specified in the
command, then a new node must be created. The symbol stored in the new node is the string
specified in the command and the count stored in the new node must be 1. The new node must be
inserted at the end of the list.
Note that the ins command does not produce any output.
(b)Delete Command: The syntax for this command is as follows:
del str
Here, del represents the name of the command and str represents a string. The interpretation of
this command is as follows.
(i) If the list contains a node whose symbol is identical to the string specified in the command,
then the count stored in the node must be decremented by 1. If the new count becomes 0, then
the node must be removed from the list. If the new count is at least 1, the node must be moved, if
necessary, to an appropriate position in the list to ensure that the counts are in non-increasing
order.

(ii) If the list does not contain a node whose symbol is identical to the string specified in the
command, then your program must leave the list unchanged.
Note that the del command does not produce any output.
(c)Forced Delete Command: The syntax for this command is as follows:
fde val
Here, fde represents the name of the command and val represents a positive integer value. The
command must remove from the list, each node whose count is less than or equal to the integer
value specified by val. If the list is empty or the count stored in each node is greater than the
value
2
specified by val, then your program must leave the list unchanged. Note that the fde command
does not produce any output.
(d)Print Statistics Command: The syntax for this command is as follows: pst
Here, pst represents the name of the command. If the list is empty, your program should simply
print the message “The list is empty.”. Otherwise (i.e., the list is non-empty), your program must
compute and print the following quantities.
(a) The number of nodes in the list.
(b) The maximum count in the list.
(c) The minimum count in the list.
(d) The average count in the list. (Bear in mind that, in general, the average count is a real
number.)
(e)Print List Command: The syntax for this command is as follows: prl
Here, prl represents the name of the command. If the list is empty, your program should print the
message “The list is empty.”. Otherwise, your program should traverse the list (from left to right)
and print each symbol and the corresponding count on a line by itself. (Thus, when the list is
non-empty, the number of lines printed is the number of nodes in the list.)
(f)Print using Count Range Command: The syntax for this command is as follows: pcr v1 v2
Here, pcr represents the name of the command and v1 and v2 are non-negative integer values
such that the value specified by v1 is less than or equal to that specified by v2. If the list is
empty, your program should simply print the message “The list is empty.”. Otherwise, your
program should traverse the list (from left to right); for each node whose count is in the integer
range specified by v1 and v2 (i.e., the count is greater than or equal to the value specified by v1
and less than or equal to the value specified by v2 ), the program must print the symbol and the
count for that node on a line by itself. (Thus, when the list is non-empty, the number of lines
printed is the number of nodes in the list whose counts are in the integer range specified by v1
and v2.)

(g)Print Prefix Command: To discuss this command, we first note that a prefix is a substring that
occurs at the beginning of a string. For example, the string “val” is a prefix of the symbol
“value” and the string “On” is a prefix of the symbol “Only”. (Note also that each string is a
prefix of itself.) However, the string “alu” is not a prefix of the symbol “value” and the string
“ly” is not a prefix of the symbol “Only”.
3
The syntax for the print prefix command is as follows:
ppr str
Here, ppr represents the name of the command and str represents a string. If the list is empty,
your program should simply print the message “The list is empty.”. Otherwise, your program
should traverse the list (from left to right); if the given string str is a prefix of the symbol stored
in a node, then the command must print the symbol and the corresponding count on a line by
itself. (Thus, when the list is non-empty, the number of lines printed is the number of symbols
which have the string specified by str as a prefix.)
(h)Print Suffix Command: To discuss this command, we first note that a suffix is a substring that
occurs at the end of a string. For example, the string “ue” is a suffix of the symbol “value” and
the string “y” is a suffix of the symbol “Only”. (Note also that each string is a suffix of itself.)
However, the string “va” is not a suffix of the symbol “value” and the string “nl” is not a suffix
of the symbol “Only”.
The syntax for the command is as follows:
psu str
Here, psu represents the name of the command and str represents a string. If the list is empty,
your program should print the message “The list is empty.”. Otherwise, your program should
traverse the list (from left to right); if the given string str is a suffix of the symbol stored in a
node, then the command must print the symbol and the corresponding count on a line by itself.
(Thus, when the list is non-empty, the number of lines printed is the number of symbols which
have the string specified by str as a suffix.)
(i)End Command: The syntax for this command is as follows: end
In response to this command, your program must stop.
Assumptions: In writing this program, you may assume the following.
(a) Symbols, prefixes, suffixes are all case sensitive. (Thus, the symbols “value” and “Value” are
distinct. The string “val” is a prefix of the symbol “value” but not a prefix of the symbol
“Value”. Similar considerations apply to suffixes.)
(b) The command given by the user will be one of ins, del, fde, pst, prl, pcr, ppr, psu or end. (The
command names are also case sensitive.)
(c) Each command will contain all and only the necessary arguments. (Thus, commands won’t

have missing or extraneous arguments.) Further, when a command has one or more arguments,
the command name and the successive arguments will be separated by one or more spaces.
(d) Each string specified in a command will have a length of at least 1 and at most 10; further,
the string won’t include any whitespace characters.
4
(e) Integer values specified in commands will be non-negative; further, in the pcr command, the
value specified by v1 will be less than or equal to that specified by v2.
Thus, there is no need to deal with any erroneous commands. Your program should continue to
prompt the user and process commands until the user types the end command.
Here is a snippet of the code
//char declerations for all commands
//str1 //= to input command
#include
struct node
{
int data;
struct node *next;
}*head;
void main(void){
char ins[3]="ins";
char del[3]="del";
char fde[3]="fde";
char pst[3]="pst";
char prl[3]="prl";
char pcr[3]="pcr";
char ppr[3]="ppr";
char psu[3]="psu";
char end[3]="end";
char str1[10];
char secondarycommand[10];
//accept first input here
printf("Enter command: ");
scanf("%c %c", &str1, &secondarycommand);
//accepts input as two strings, can parse to int later depending on the command

int tester;
int end1=0;
while(end1 !=1){
tester = strcmp(str1, ins);
if (tester ==0){
// insert
}
tester = strcmp(str1, del);
if (tester ==0){
// delete
}
tester = strcmp(str1, fde);
if (tester ==0){
// force delete
}
tester = strcmp(str1, pst);
if (tester ==0){
//print statistics
}
tester = strcmp(str1, prl);
if (tester ==0){
// print list
}
tester = strcmp(str1, pcr);
if (tester ==0){
// Print Count Range
}
tester = strcmp(str1, ppr);
if (tester ==0){
// Print Prefix
}
tester = strcmp(str1, psu);
if (tester ==0){
//Print Suffix
}
tester = strcmp(str1, end);

if (tester ==0){
end1=1;
exit(0);
//end
}
else{
printf("unknown command ");
end1=1;
exit(0);
}
//accept next input here
printf("Enter next command: ");
scanf("%c %d", &str1, &secondarycommand);
//accepts input as two strings, can parse to int later depending on the command
}
return 0;
}
Solution
#include
#include
#include
#define STRING_SIZE 11
/* Size of char array for the string */
#define COMMAND_SIZE 4
/* Size of char array for the command*/
#define PREFIX_SIZE 11
/* Size of char array for prefix */
#define SUFFIX_SIZE 11
/* Size of char array for suffix */
#define COMPARE_TO 3
/* Number of spots to compare command up until */
#define FIRST_COUNT 1

/* Sets count to 1 */
#define SORT 1
/* Used to determine whether to sort list or not */
#define DONT_SORT 0
/* Used to determine whether to sort list or not */
#define LARGE_NUM 100000
/* Array size for int array for count in printStats */
#define ONE 1
/* Used in calculations */
/* Function Prototypes */
void insert(char[STRING_SIZE]);
void createNewList(char[STRING_SIZE]);
void delete(char[STRING_SIZE], int);
void forcedDelete(int);
void sortList();
int printStats();
void printList();
int printByCount(int, int);
void printPrefix(char[PREFIX_SIZE]);
void printSuffix(char[SUFFIX_SIZE]);
/* Function Prototypes */
/* Explainations are within the function themselves */
typedef struct LinkedList
/* Structrure definition for the linked list nodes */
{
char symbol[STRING_SIZE]; /* String in node */
int count; /* Count of node */
struct LinkedList *next;
} Node;
/* Struct for nodes of the linked list */
Node *pHead = NULL;
/* Pointer to head node */
Node *pTail = NULL;
/* Pointer to tail node */
/* Pointers to the node */

int main(void)
/* Main function */
{
char command[COMMAND_SIZE];
/* char array to store command */
char string[STRING_SIZE];
/* char array to store string */
char ins[] = "ins";
/* string command ins to commpare */
char del[] = "del";
/* string command del to commpare */
char fde[] = "fde";
/* string command fde to commpare */
char prl[] = "prl";
/* string command prl to commpare */
char end[] = "end";
/* string command end to commpare */
char pcr[] = "pcr";
/* string command pcr to commpare */
char pst[] = "pst";
/* string command pst to commpare */
char ppr[] = "ppr";
/* string command ppr to commpare */
char psu[] = "psu";
/* string command psu to commpare */
char pre[PREFIX_SIZE];
/* char array for user entered prefix */
char suf[SUFFIX_SIZE];
/* char array for user entered suffix */
int val;
/* value to print range */
int val2;
/* value to print range */
printf("Enter a command: "); fflush(stdout);
scanf("%s", command);

while (strcmp(command, end) != 0)
/* Run while command doesn't equal "end" */
{
if (strcmp(command, ins) == 0)
/* Do this if user enters ins for insert */
{
scanf("%s", string);
/* input string */
insert(string);
/* call insert function */
}
else if (strcmp(command, del) == 0)
/* Do this if user enters del */
{
scanf("%s", string);
/* input string */
delete(string, SORT);
/* call delete function */
}
else if (strcmp(command, fde) == 0)
/* Do this if user enters fde */
{
scanf("%d", &val);
/* input int to force delete from */
forcedDelete(val);
/* call forcedelete function */
}
else if (strcmp(command, prl) == 0)
/* Do this if user enters prl */
{
printList();
/* call printList function */

}
else if (strcmp(command, pcr) == 0)
/* Do this if user enters pcr */
{
scanf("%d", &val);
/* input int to print count from */
scanf("%d", &val2);
/* input int to print count up until */
printByCount(val, val2);
/* call printByCount function */
}
else if (strcmp(command, pst) == 0)
/* Do this if users enters pst */
{
printStats();
/* Call printStats function */
}
else if (strcmp(command, ppr) == 0)
/* Do this if user enters ppr */
{
scanf("%s", pre);
/* input string into prefix variable */
printPrefix(pre);
/* call printPrefix function */
}
else if (strcmp(command, psu) == 0)
/* Do this if user enters psu */
{
scanf("%s", suf);
/* input string into suffix variable */
printSuffix(suf);
/* call printSuffix function */

}
printf(" Enter a command: "); fflush(stdout);
scanf("%s", command);
/* Prompt user to enter a command and
* input command into string
*/
}
if (strcmp(command, end) == 0)
/* Do this if user inputs "end" */
{
printf(" Program Closing "); fflush(stdout);
}
}
void insert(char string[STRING_SIZE])
{
Node *pNewNode = malloc(sizeof(Node));
Node *pLoop = pHead;
if (pHead == NULL)
{
createNewList(string);
/* Call create newList function */
}
else
{
strcpy(pNewNode -> symbol, string);
if (pHead == pTail)
{
if (strcmp(pHead -> symbol, pNewNode -> symbol) == 0)
/* Do this if the second node being input equals head node */
{
pHead -> count++;

/* Increment head count by one */
}
else
{
pNewNode -> count = FIRST_COUNT;
pHead -> next = pNewNode;
/* Have the head node point to the new node */
pTail = pNewNode;
/* Insert the new node into tail */
pNewNode -> next = NULL;
/* Remove the new from the list */
}
}
else
{
while (pLoop != NULL)
/* run while node does not equal null */
{
if (strcmp(pLoop -> symbol, pNewNode -> symbol) == 0)
/* Do this if new node symbol equals current node symbol */
{
pLoop -> count++;
/* Increment current node count by one */
break;
/* break out of loop */
}
else if (pLoop -> next == NULL)
/* Do this if next node equals null */
{
pTail -> next = pNewNode;
/* Point the tail node to the new node */

/* Remove the new node frome the list */
pTail = pNewNode;
/* Insert the new node into tail */
break;
}
pLoop = pLoop -> next;
/* increment linked list */
}
}
sortList();
/* call sortList function */
}
}
void createNewList(char string[STRING_SIZE])
/* Function to create a new list */
{
Node *pNewNode = malloc(sizeof(Node));
strcpy(pNewNode -> symbol, string);
/* Insert user's string into node */
pHead = pTail = pNewNode;
}
void delete(char string[STRING_SIZE], int sort)
/* Function to delete a node */
{
Node *pCurr = pHead;
Node *pPrev = NULL;
if (pHead == NULL)
{
printf("This List Is Empty "); fflush(stdout);

}
while (pCurr != NULL)
{
if (strcmp(pCurr -> symbol, string) == 0)
/* Do this if the current nodes symbol equals user inputed string */
{
if (pCurr -> count > 1)
/* If current node has a count greater than one*/
{
pCurr -> count--;
/* Decrement current node count by one */
}
else
{
if (pCurr == pHead)
{
pHead = pCurr -> next;
free(pCurr);
/*
* Free original head node from memory.
*/
}
else
{
if ((pPrev == pHead) && (pCurr -> next == NULL))
{
pTail = pHead;
pHead -> next = NULL;
}
else if (pCurr -> next == NULL)
/* If the next node equals null */
{

pTail = pPrev;
/* Make tail node the previous node */
pTail -> next = NULL;
/* Have tail reference null */
free(pCurr);
/* free current node from memory */
}
else
{
pPrev -> next = pCurr -> next;
free(pCurr);
/*
* Free removed node from memory.
*/
}
}
}
}
pPrev = pCurr;
/* have the current node equal previous node */
pCurr = pCurr -> next;
/* Increment current node */
}
if (sort == 1)
{
sortList();
/* Call sortList function */
}
}
void printList()
/* printList function */
{

if (pHead == NULL)
/* If head node equals null */
{
printf("The list is empty. "); fflush(stdout);
}
else
{
printf(" Strings Entered: "); fflush(stdout);
printf(" "); fflush(stdout);
/* run while current node isn't null */
{
printf("%s", pCurr -> symbol); fflush(stdout);
printf(" %d ", pCurr -> count); fflush(stdout);
/* Print symbol and count from current node */
/* Move to next node */
}
}
}
void forcedDelete(int min)
/* function to delete nodes based on count */
{
int nodeCount;
if (pHead == NULL)
{

printf("This List Is Empty "); fflush(stdout);
}
while(pCurr != NULL)
/* run while current node isn't null */
{
nodeCount = pCurr -> count;
/* insert current nodes count into int variable */
if (nodeCount <= min)
/* if nodeCount is less than min */
{
while(nodeCount > 0)
/* Run while nodeCount is greater than zero */
{
nodeCount--;
/* decrement nodeCount by one */
delete(pCurr -> symbol, DONT_SORT);
/* Call delete function with current symbol and don't sort list */
}
}
/* move to next node */
}
}
void sortList()
/* Function to sort the list */
{
Node *pNext = NULL;
Node *pPrev = NULL;
/* Run while current node isn't null */
{
pNext = pCurr -> next;

/* set the next node */
if (pPrev == NULL)
/* Check to see if it the head node */
{
if (pNext == NULL);
/* if next equals null, */
else if (pCurr -> count < pNext -> count)
{
if (pNext -> next == NULL)
/*
* If there are only 2 nodes in the linked list
*/
{
pCurr -> next = pNext -> next;
/* Set current reference to next reference */
pHead = pNext;
/* Set next node equal to head */
pTail = pCurr;
/* Set current equal to tail */
pHead -> next = pTail;
/* have head node reference tail */
}
else
/*
* If there are more than 2 nodes in the linked list
*/
{
/* Set current reference to next referenec */
pHead = pNext;
/* Set next node equal to head */
pHead -> next = pCurr;
/* have head equal current node */
sortList();

/* call sortList again to continue sorting */
}
}
}
else if (pNext == NULL)
/* Do this if next node equals null */
{
break;
/* break out of loop */
}
else if (pCurr -> count < pNext -> count)
/* do this if current count is less than next count */
{
if (pNext -> next == NULL)
/*
* If there are only 2 nodes in the linked list
*/
{
/* have current node reference the node next is pointing to */
pPrev -> next = pNext;
/* have previous node reference the next node */
pTail = pCurr;
/* insert current node into tail node */
pNext -> next = pCurr;
/* have next node reference current node */
sortList();
/* call sortList function to continue sorting list */
}
else
{
pPrev -> next = pNext;

/* have previous node reference next node */
/* have current node reference node the next node is referencing */
pNext -> next = pCurr;
/* have next node reference the current node */
sortList();
/* call sortList function to continue sorting list */
}
}
pPrev = pCurr;
/* have previous node equal current node */
}
}
int printByCount(int v1, int v2)
/* function to print out nodes between the range of the inputed count values */
{
Node *pCurr;
/* node pointer for current node */
int nodeCount;
/* int variable for node count */
if(pHead == NULL)
/* do this if head is null */
{
printf("%s ","The list is empty"); fflush(stdout);
return 0;
/* leave function */
}
pCurr = pHead;

/* loop through list while current doesn't equal null */
{
/* insert current node count into nodeCount variables */
if(nodeCount >= v1 && nodeCount <= v2)
{
printf("%s",pCurr -> symbol); fflush(stdout);
/* print node */
}
}
return 0;
}
int printStats()
/* function to print stats of nodes */
{
Node *pCurr;
/* pointer to current node */
int min = LARGE_NUM;
/* minimum value */
int max = 0;
/* max value */
double mean = 0;
/* mean value */
int numCount = 0;
/* count value */
int nodeCount;
/* count value */
int numCount2;
/* count value */

int allCounts[LARGE_NUM];
/* array of all counts */
if(pHead == NULL)
/* if list is empty */
{
printf("%s ","The list is empty."); fflush(stdout);
return 0;
/* leave function */
}
pCurr = pHead;
/* insert head node into current */
/* run while there are nodes in the linked list */
{
/* set nodeCount to current count */
numCount++;
/* increment numCount by one */
if(nodeCount > max)
/* if nodeCount is greater than the max value */
{
max = nodeCount;
/* Set max value to current nodeCount */
}
if(nodeCount < min)
/* If nodeCount is less than the max value */
{
min = nodeCount;
/* Set min value to current nodeCount */
}

allCounts[numCount - ONE] = nodeCount;
/* Insert nodeCount into allCounts array at next available position */
/* Set current node to next node */
}
numCount2 = numCount;
/* Insert numCount into numCount2 */
while(numCount2 > -ONE)
/* run while numCount2 is greater than negative one */
{
mean = mean + allCounts[numCount2 - ONE];
/* adds total count to mean to be calculated */
numCount2--;
/* decrement numCount2 by one */
}
mean = mean / numCount;
/* Calculates mean */
printf("%s","The number of nodes in the list: "); fflush(stdout);
printf("%d ",numCount); fflush(stdout);
/* Prints the number of nodes in the list */
printf("%s","The maximum count in the list: "); fflush(stdout);
printf("%d ",max); fflush(stdout);
/* Prints the maximum count in the list */
printf("%s","The minimum count in the list: "); fflush(stdout);
printf("%d ",min); fflush(stdout);
/* prints the minimum count in the list */
printf("%s","The mean of the list's count values: "); fflush(stdout);

printf("%f ",mean); fflush(stdout);
/* prints the mean of all the counts in the list */
return 0;
/* return to main function */
}
void printPrefix(char pre[PREFIX_SIZE])
/* Function to print prefix */
{
if (pHead == NULL)
/* Run if the list is empty */
{
printf("The List Is Empty "); fflush(stdout);
}
else
{
{
if (strstr(pCurr -> symbol, pre) != NULL)
/* Runs if the prefix the user inputs is in the current node */
{
if ((strcspn(pCurr -> symbol, pre) == 0) || (strncmp(pCurr -> symbol, pre, 3) == 0))
{
printf("%s", pCurr -> symbol); fflush(stdout);
/* Print string and count of string */
}
}
}
}
}

void printSuffix(char suf[SUFFIX_SIZE])
{
int sufLen = 0;
int symLen = 0;
int index = 0;
int nineNineK;
/* integers used for string manipulations */
char endSym[LARGE_NUM];
Node *pCurr;
/* pointer to a node; this is used to walk across the list */
if(pHead == NULL)
/* prints "the list is empty if the first node in the list is NULL */
{
printf("%s ", "The list is empty"); fflush(stdout);
}
else
{
pCurr = pHead;
/* sets node to first node in list */
printf(" ");
/* loops while nodes remain */
{
index = 0;
nineNineK = LARGE_NUM - ONE;
/* resetting variables used to keep track of positions in arrays */
while(nineNineK > - ONE)
/* this loop sets every position of char array to '0' */
{
endSym[nineNineK] = '0';
nineNineK = nineNineK - ONE;

}
symLen = (int)(strlen(pCurr -> symbol));
sufLen = (int)strlen(suf);
/* gets length of symbol and passed string */
while(sufLen > 0)
/* adds last n characters to new array to compare */
{
endSym[index] = pCurr->symbol[symLen-sufLen];
sufLen = sufLen - 1;
index = index + 1;
}
if(strstr(endSym, suf) != NULL)
{
printf("%s",pCurr-> symbol); fflush(stdout);
printf(" %d ", pCurr-> count); fflush(stdout);
}
pCurr = pCurr-> next;
/* moves to next node in list */
}
}
}

You are required to write an interactive C program that prompts the .pdf

More Related Content

Similar to You are required to write an interactive C program that prompts the .pdf (20)

More from arrowcomputers8700 (20)

Recently uploaded (20)

You are required to write an interactive C program that prompts the .pdf