15.14. Mixed-Up Code Exercises¶

Arrange the following Mixed-Up Code exercises to assess what you have learned in this chapter.

15.14.1. Parsons exercises¶

Write a program that prompts a user for the name of an input file and for an integer n. Then open the file and output the first n lines of the file with each line reversed. For example, if you read in the line "hello world" you should print out "dlrow olleh" to the terminal. Include proper file error checking. Use the lines to construct the code, then complete the code in the correct order.

```
for (std::size_t i = 0; i < n; i++) {
```

if (in_file.good() == false) {
   std::cout << "Unable to open the file named " << file_in << " and output " << n << " lines." << '\n';
   std::exit(1);
}

```
int main () {
```

std::cout << "Enter an integer: ";
std::cin >> n;
std::cout << n << '\n';

std::cout << "Enter the name of the file: ";
std::cin >> file_in;
std::cout << file_in << '\n';

```
std::cout << line << '\n';
```
```
std::getline(in_file, line);
```
```
std::ifstream in_file(file_in);
```
```
std::size_t n = 0;
```
```
std::string file_in;
```
```
std::string line;
```
```
}
```
```
}
```

Write a program that prompts a user for an integer n and print the first n powers of 2 to an output file called powers.txt. Include proper file error checking. To simulate what your output file would look like, the contents of your output file will be displayed on the terminal. Use the lines to construct the code, then go back to complete the code tab.

```
for (std::size_t i = 0; i < n; i++) {
```

if (!student_output.good()) {
   std::cout << "Error opening student's output." << '\n';
}

if (outfile.good() == false) {
   std::cout << "Unable to open output file." << '\n';
   std::exit (1);
}

```
int main() {
```
```
outfile << std::pow(2,i) << '\n';
```
```
std::cin >> n;
```
```
std::cout << "Enter an integer: ";
```
```
std::cout << n << '\n';
```

std::ifstream student_output("powers.txt");

```
std::ofstream outfile ("powers.txt");
```
```
std::size_t n = 0;
```
```
std::string answer;
```

while (std::getline(student_output, answer)) {
   std::cout << answer << '\n';
}

```
while (true) {
```
```
}
```
```
}
```
```
}
```

Write a program that takes an input file called "dream.txt" and outputs the number of times the string "you" appears in the file to the terminal. Include proper file error checking. Use the lines to construct the code, then complete the code in the correct order.

```
char w[ ] = {'y', 'o', 'u'};
```
```
count++;
```

for (std::size_t i = 0; i < line.size(); i++) {

if (!in_file.good()) {
   std::cout << "Unable to open file." << '\n';
   std::exit(1);
}

```
if (line.at (i+2) == w[2]) {
```
```
if (line.at(i) == w[0]) {
```
```
if (line.at(i+1) == w[1]) {
```
```
int main() {
```
```
std::cout << count << '\n';
```
```
std::ifstream in_file("dream.txt");
```
```
std::size_t count = 0;
```
```
std::string line;
```
```
while (std::getline(in_file,line)) {
```
```
}
```
```
}
```
```
}
```
```
}
```
```
}
```
```
}
```

Write a program that takes an input file called "shrimp.txt" and outputs the quote with "shrimp" replaced by a word that the user inputs to the terminal. Include proper file error checking. Use the lines to construct the code, then complete the code in the correct order.

```
for (std::size_t i = 0; i < 4; i++) {
```

for (std::size_t j = 0; j < line.size(); j++) {

```
if (pos != std::string::npos) {
```
```
int main() {
```

line.replace(pos,replace.length(),word);

```
std::cin >> word;
```

std::cout << "Enter word to replace 'shrimp': ";

```
std::cout << line<< '\n';
```
```
std::cout << word << '\n';
```
```
std::getline(in_file,line);
```
```
std::ifstream in_file("shrimp.txt");
```
```
std::size_t pos = line.find(replace);
```
```
std::string line;
```
```
std::string replace = "shrimp";
```
```
std::string word;
```
```
}
```
```
}
```
```
}
```
```
}
```

Construct the multiplication program. Include the array, cstddef, and iostream headers. The result should be 58 64 on the first row and 139 154 on the second row.

```
for (const auto& row : product) {
```

for (int value : row) { std::cout << value << ' '; }

for (std::size_t col = 0; col < b[0].size(); ++col) {

for (std::size_t k = 0; k < b.size(); ++k) {

for (std::size_t row = 0; row < a.size(); ++row) {

```
int main() {
```

product[row][col] += a[row][k] * b[k][col];

std::array<std::array<int, 2>, 2> product{};

std::array<std::array<int, 2>, 3> b{{{7, 8}, {9, 10}, {11, 12}}};

std::array<std::array<int, 3>, 2> a{{{1, 2, 3}, {4, 5, 6}}};

```
std::cout << '\n';
```
```
}
```
```
}
```
```
}
```
```
}
```
```
}
```

We have a file called "locations.txt" that we want to read data from. Check to make sure that the file was opened properly; if it wasn't, display an error message and exit with a status of 1. Put the necessary blocks of code in the correct order.

```
if (infile.good() == false) {
```
```
if (infile.good()) {
```
```
int main() {
```
```
return 1;
```

std::cout << "Unable to open the file." << '\n';

```
std::exit(1);
```
```
std::ifstream infile("locations.txt");
```
```
std::ifstream infile(locations.txt);
```
```
}
```
```
}
```

Let's write a program that prompts the user for a filename and opens that file. Put the necessary blocks of code in the correct order.

```
if (infile.good() == false) {
```
```
int main() {
```
```
std::cin >> filename;
```

std::cout << "Enter the name of the file: ";

std::cout << "Unable to open the file." << '\n';

```
std::exit(1);
```
```
std::ifstream filename;
```
```
std::ifstream infile(filename);
```
```
std::ofstream infile(filename);
```
```
std::string filename;
```
```
}
```
```
}
```

Now let's write some output to a file. Write a program that prompts a user for a list of 5 integers separated by spaces, calculates the average of those integers, and outputs "The average is average" to an output file called "average.txt". Put the necessary blocks of code in the correct order. Declare the output file first and check that it is opened correctly.

if (outfile.good() == false) {
   std::cout << "Unable to open the file." << '\n';
   std::exit(1);
}

```
int main() {
```
```
int n1, n2, n3, n4, n5;
```
```
int sum = 0;
```

outfile << "The average is " << sum / 5.0 << '\n';

```
std::cin >> n1 >> n2 >> n3 >> n4 >> n5;
```

std::cout << "Enter five integers separated by spaces: ";

std::cout << "The average is " << sum / 5.0 << '\n';

```
std::ofstream outfile("average.txt");
```
```
std::vector<int> list;  #distractor
```
```
sum = n1 + n2 + n3 + n4 + n5;
```
```
}
```

We are given a file called "data.txt" with an unknown number of double values. Write a program that finds the minimum, maximum, and number of data and outputs these values to a file called "summary.txt". Put the necessary blocks of code in the correct order. Declare the input and output files first, and check to see that both are opened correctly before dealing with data. Increment the number of data points before checking for the min and max.

```
++num_data;
```
```
double min, max, value;
```
```
if (!(infile >> value)) { return 1; }
```

if (infile.good() == false || outfile.good() == false) {
   std::cout << "Unable to open a file." << '\n';
   std::exit(1);
}

```
if (value < min) { min = value; }
```
```
if (value > max) { max = value; }
```
```
int main() {
```
```
max = value;
```
```
min = value;
```

outfile << "Number of data: " << num_data << ", min: " << min << ", max: " << max << '\n';

```
std::ifstream infile("data.txt");
```
```
std::ofstream outfile("summary.txt");
```
```
std::size_t num_data = 1;
```
```
std::vector<int> data;  #distractor
```
```
while (infile >> value) {
```
```
}
```
```
}
```

You are given a file called "employee_data.txt" and you want to store the information from that file into a vector of data. The file contains information about an employee's first and last name, age, phone number, and email. Write the definition of an employee before you write your main function. Open and check the file before working with the data. Put the necessary blocks of code in the correct order.

```
data.push_back(e);
```

employee e(fname, lname, age, phone, email);

employee(std::string f, std::string l, int a, int p, std::string e) {
   fname = f;
   lname = l;
   age = a;
   phone = p;
   email = e;
}

if (infile.good() == false) {
   std::cout << "Unable to open the file." << '\n';
   std::exit(1);
}

```
int age, phone;
```
```
int main() {
```

std::ifstream infile("employee_data.txt");

```
std::string fname, lname, email;
```
```
std::vector<employee> data;
```

struct employee {
   std::string fname;
   std::string lname;
   int age;
   int phone;
   std::string email;

while (infile >> fname >> lname >> age >> phone >> email) {

```
while (infile) {
```
```
}
```
```
}
```
```
};
```

You are given a file but it appears that someone's capslock key was stuck because everything is in uppercase. Write a program that takes the input from the file "UPPER.txt" and converts all the words to lowercase and prints out the modified message to a file called "lower.txt". Write the definition of the function to_lower first. Separate the words with spaces. Put the necessary blocks of code in the correct order.

```
   }
   return upper;
}
```

if (infile.good() == false || outfile.good() == false) {
   std::cout << "Unable to open a file." << '\n';
   std::exit(1);
}

```
int main() {
```
```
outfile << upper << ' ';
```
```
std::ifstream infile("UPPER.txt");
```
```
std::ofstream outfile("lower.txt");
```

std::string upper = upper_to_lower(word);

std::string upper_to_lower(std::string upper) {
   for (std::size_t i = 0; i < upper.length(); ++i) {

```
std::string word;
```
```
std::tolower(upper[i]);
```

upper[i] = static_cast<char>(std::tolower(static_cast<unsigned char>(upper[i])));

```
upper_to_lower(word);
```
```
while (infile >> word) {
```
```
}
```
```
}
```

Nobody ever put a limit on how many files we can work with. Does this mean we can open two or more files at once? Yes we can! Write a program that combines two files "odds.txt" and "evens.txt" into one output file "numbers.txt". You should combine them in a way such that "numbers.txt" contains the first odd number then the first even number then the second odd number and so on. You are guaranteed that there are equal amounts of odd and even numbers. Put the necessary blocks of code in the correct order.

if (!odds.good() || !evens.good() || !outfile.good()) {
   std::cout << "Unable to open a file." << '\n';
   std::exit(1);
}

```
int main() {
```
```
int odd, even;
```
```
outfile << odd << ' ' << even << ' ';
```
```
std::ifstream evens("evens.txt");
```
```
std::ifstream odds("odds.txt");
```
```
std::ofstream outfile("numbers.txt");
```
```
while (odds >> odd && evens >> even) {
```
```
}
```
```
}
```

Convert a vector of names to a set of unique names. Assume the necessary standard-library headers are included.

```
for (const auto& name : data) {
```
```
names.insert(name);
```
```
return names;
```
```
std::set<std::string> names;
```

std::set<std::string> vector_to_set(const std::vector<std::string>& data) {

```
}
```
```
}
```

Create a rectangular table with rows and columns supplied at run time. Initialize all entries to zero. Assume the necessary standard-library headers are included.

return std::vector<std::vector<int>>(rows, std::vector<int>(columns, 0));

std::vector<std::vector<int>> make_table(std::size_t rows, std::size_t columns) {

```
}
```

Count repeated city names with a map. Return the frequency of each name. Assume the necessary standard-library headers are included.

```
++counts[name];
```
```
for (const auto& name : names) {
```
```
return counts;
```

std::map<std::string, std::size_t> count_cities(const std::vector<std::string>& names) {

std::map<std::string, std::size_t> counts;

```
}
```
```
}
```