Through this programming assignment, the students will learn to do the following: Practice processing command line arguments. Perform basic file I/O. Use structs, pointers, and strings. Use dynamic memory. This assignment asks you to sort the letters in an input file and print the sorted letters to an output file (or standard output) which will be the solution. Your program, called codesolve, will take the following command line arguments: % codesolve [-o output_file_name] input_file_name Read the letters in from the input file and convert them to upper case if they are not already in uppercase. If the output_file_name is given with the -o option, the program will output the sorted letters to the given output file; otherwise, the output shall be to standard output. In addition to parsing and processing the command line arguments, your program needs to do the following: You need to construct a doubly linked list as you read from input. Each node in the list will link to the one in front of it and the one behind it if they exist. They will have NULL for the previous pointer if they are first in the list. They will have NULL for the next pointer if they are last in the list. You can look up doubly linked lists in your Data Structure textbook. Initially the list is empty. The program reads from the input file one letter at a time and converts it to upper case. Create a node with the letter and 2 pointers to nodes, previous and next. Initially the previous and next pointers should be NULL. As long as you continue reading letters, if the letter is not already in the list, create a new node and place the node into the list in the proper Alphabetical order. If there is a node in front of it, the previous pointer should point to it. If there is a node after it then the next pointer should point to it. All duplicate letters are ignored. An end of file would indicate the end of input from the input file. Once the program has read all the input, the program then performs a traversal of the doubly linked list first to last to print out all the strings one letter at a time to the output file or stdout. The output would be all letters on the same line. Before the program ends, it must reclaim the list! You can do this by going through the list and freeing all nodes. This can be done in either direction. It is required that you use getopt for processing the command line and use malloc or calloc and free functions for dynamically allocating and deallocating nodes and the buffers for the strings.

Through this programming assignment, the students will learn to do the following: Practice processing command line arguments. Perform basic file I/O. Use structs, pointers, and strings. Use dynamic memory. This assignment asks you to sort the letters in an input file and print the sorted letters to an output file (or standard output) which will be the solution. Your program, called codesolve, will take the following command line arguments: % codesolve [-o output_file_name] input_file_name Read the letters in from the input file and convert them to upper case if they are not already in uppercase. If the output_file_name is given with the -o option, the program will output the sorted letters to the given output file; otherwise, the output shall be to standard output. In addition to parsing and processing the command line arguments, your program needs to do the following: You need to construct a doubly linked list as you read from input. Each node in the list will link to the one in front of it and the one behind it if they exist. They will have NULL for the previous pointer if they are first in the list. They will have NULL for the next pointer if they are last in the list. You can look up doubly linked lists in your Data Structure textbook. Initially the list is empty. The program reads from the input file one letter at a time and converts it to upper case. Create a node with the letter and 2 pointers to nodes, previous and next. Initially the previous and next pointers should be NULL. As long as you continue reading letters, if the letter is not already in the list, create a new node and place the node into the list in the proper Alphabetical order. If there is a node in front of it, the previous pointer should point to it. If there is a node after it then the next pointer should point to it. All duplicate letters are ignored. An end of file would indicate the end of input from the input file. Once the program has read all the input, the program then performs a traversal of the doubly linked list first to last to print out all the strings one letter at a time to the output file or stdout. The output would be all letters on the same line. Before the program ends, it must reclaim the list! You can do this by going through the list and freeing all nodes. This can be done in either direction. It is required that you use getopt for processing the command line and use malloc or calloc and free functions for dynamically allocating and deallocating nodes and the buffers for the strings.

C++ for Engineers and Scientists

4th Edition

ISBN:9781133187844

Author:Bronson, Gary J.

Publisher:Bronson, Gary J.

Chapter7: Arrays

Section7.5: Case Studies

Problem 8E

See similar textbooks

Related questions

Question

Through this programming assignment, the students will learn to do the following:

Practice processing command line arguments.
Perform basic file I/O.
Use structs, pointers, and strings.
Use dynamic memory.

This assignment asks you to sort the letters in an input file and print the sorted letters to an output file (or standard output) which will be the solution. Your program, called codesolve, will take the following command line arguments:

% codesolve [-o output_file_name] input_file_name

Read the letters in from the input file and convert them to upper case if they are not already in uppercase. If the output_file_name is given with the -o option, the program will output the sorted letters to the given output file; otherwise, the output shall be to standard output.

In addition to parsing and processing the command line arguments, your program needs to do the following:

You need to construct a doubly linked list as you read from input. Each node in the list will link to the one in front of it and the one behind it if they exist. They will have NULL for the previous pointer if they are first in the list. They will have NULL for the next pointer if they are last in the list. You can look up doubly linked lists in your Data Structure textbook.
Initially the list is empty. The program reads from the input file one letter at a time and converts it to upper case. Create a node with the letter and 2 pointers to nodes, previous and next. Initially the previous and next pointers should be NULL.
As long as you continue reading letters, if the letter is not already in the list, create a new node and place the node into the list in the proper Alphabetical order. If there is a node in front of it, the previous pointer should point to it. If there is a node after it then the next pointer should point to it. All duplicate letters are ignored.
An end of file would indicate the end of input from the input file.
Once the program has read all the input, the program then performs a traversal of the doubly linked list first to last to print out all the strings one letter at a time to the output file or stdout. The output would be all letters on the same line.
Before the program ends, it must reclaim the list! You can do this by going through the list and freeing all nodes. This can be done in either direction.
It is required that you use getopt for processing the command line and use malloc or calloc and free functions for dynamically allocating and deallocating nodes and the buffers for the strings.

Expert Solution

Trending now

This is a popular solution!

Step by step

Solved in 4 steps with 8 images

SEE SOLUTION Check out a sample Q&A here

Knowledge Booster

Learn more about

Need a deep-dive on the concept behind this application? Look no further. Learn more about this topic, computer-science and related others by exploring similar questions and additional content below.