Solutions to Final Exam Practice Questions¶

Vectors and Strings¶

Write a boolean function called all_same(v), where v is a vector<string>, that returns true if all the elements in v are the same, and false otherwise. If v is empty, then return true.

For example:

all_same({"cat", "cat", "cat"}) returns true

all_same({"mustard"}) returns true

all_same({"cat", "cat", "dog"}) returns false

all_same({}) returns true

Sample solution:

bool all_same(const vector<string>& v) {
   if (v.size() < 2) return true;

   // at this point we know v must have at least
   // 2 elements
   for(int i = 1; i < v.size(); ++i) {  // note i starts at 1
      if (v[i] != v[0]) {
         return false;
      }
   }
   return true;
}

Write a void function called constrain(v), where v is a vector<int>, that modifies the elements of v as follows:

If the element is less than 0, replace it with 0.
If the element is greater than 100, replace it with 100.
Otherwise, don’t change the element.

For example:

vector<int> a = {6, -10, 0, 100, 44, 101};
constrain(a);
// now a == {6, 0, 0, 100, 44, 100}

Sample solution:

void constrain(vector<int>& v) {
    for(int i = 0; i < v.size(); ++i) {
       if (v[i] < 0) {
          v[i] = 0;
       } else if (v[i] > 100) {
          v[i] = 100;
       }
    }
}

Write a function just_digits(s) that returns a string that is the same as s except all non-digit characters have been removed. For example:

just_digits("Route 7.2, highway56") returns "7256"
just_digits(" moose") returns ""

Sample solution:

bool is_digit(char c) {
    return '0' <= c && c <= '9';
}

string just_digits(const string& s) {
    string result;
    for(char c : s) {
        if (is_digit(c)) {
            result += c;
        }
    }
    return result;
}

RGB Structures¶

RGB color is a popular way to represent colors. In RGB, a color is represented as a mixture of red (r), green (g), and blue (b). Each RGB color has the form (r, g, b), where r, g, and b are integers. We will refer to (r, g, b) as an RGB triple, or just a triple for short.

For example, the triple (255, 140, 0) is dark orange, and (147, 112, 219) is medium purple.

A triple (r, g, b) is valid if each of r, g, and b is greater than, or equal to 0, and less than, or equal to 255. Otherwise, the triple is invalid. So, for example, (65, 180, 102) is a valid RGB triple, but (200, 180, 256) is invalid.

Write the definition for a C++ struct that represents an RGB triple. Give it a short and self-descriptive name.
```
struct RGBcolor {
    int r, g, b;
};
```

Write a boolean function that takes one RGB color struct (that you defined in the previous question) as input, and returns true if it is valid, and false otherwise.

bool is_valid(const RGBcolor& c) {
    return 0 <= c.r && c.r <= 255
        && 0 <= c.g && c.g <= 255
        && 0 <= c.b && c.b <= 255;
}

The RGB triples (a, b, c) and (r, s, t) are equal if a equals c, b equals s, and c equals t. Write a boolean function that takes two RGB color structs as input and returns true if they are equal and false otherwise. If one, or both, of the passed-in colors are invalid, then your function should call the error function instead of returning a value.
```
bool equals(const RGBcolor& a, const RGBcolor& b) {
    if (!is_valid(a) || !is_valid(b)) error("invalid color");
    return (a.r == b.r)
        && (a.g == b.g)
        && (a.b == b.b);
}
```

The perceived brightness of the (r, g, b) triple can be calculated with this formula:

brightness = (299 * r + 587 * g + 114 * b) / 1000

Write a function that returns, as a double, the perceived brightness of the an RGB color struct.

double brightness(const RGBcolor& c) {
    return (299.0 * c.r + 587.0 * c.g + 114.0 * c.b) / 1000.0;
}

Recall that the standard function rand() returns a random integer that is greater than, or equal to 0, and less than, or equal to, some very large positive int called RAND_MAX. Assume that rand() has been included in your code so that it is available to be used.

Write a function that takes no inputs and uses rand() to return a randomly chosen RGB color struct. For example, you could use it like this:
```
RGBcolor fill = rand_color();   // fill is set to some random RGB color
RGBcolor stroke = rand_color(); // stroke is set to some random RGB color
```
All RGB colors should have the same chance of being returned, and an invalid color should never be returned.
```
RGBcolor rand_color() {
   return RGBcolor{rand() % 256, rand() % 256, rand() % 256};
}
```

Enumerated Types: Days of the Week¶

Create a C++ enumerated type (use enum class, not the old-style enum) to create a new data type called Day that can be used like this:

Day yesterday = Day::Thursday;
Day today = Day::Friday;
Day tomorrow = Day::Saturday;

Sample solution:

enum class Day
  { Monday, Tuesday, Wednesday, Thursday, Friday,
    Saturday, Sunday
  };

Write a boolean function called is_weekend(d) that returns true if d (which is of type Day) is Saturday or Sunday, and false otherwise.

Sample solution:
```
bool is_weekend(const Day& d) {
    return d == Day::Saturday || d == Day::Sunday;
}
```
Write a boolean function called is_weekday(d) that returns true if d (which is of type Day) is one of the five weekdays from Monday to Friday, and false otherwise.

Sample solution:
```
bool is_weekday(const Day& d) {
    return !is_weekend(d);
}
```

Write a function called to_string(d) that returns a string representation of d. For example:

cout << to_string(Day::Wednesday)  // prints "Wednesday"
     << to_string(Day::Friday);    // prints "Friday"

Sample solution:

const vector<string> days =
  { "Monday", "Tuesday", "Wednesday", "Thursday", "Friday",
    "Saturday", "Sunday"
  };

string to_string(const Day& d) {
    return days[int(d)];
}

Write a function called next_day that takes a single Day object as input and returns the day that comes after it. For example, next_day(Day::Sunday) should return Day::Monday. Implement it using a switch statement.

Sample solution:

Day next_day(const Day& d) {
    switch(d) {
        case Day::Sunday: return Day::Monday;
        case Day::Monday: return Day::Tuesday;
        case Day::Tuesday: return Day::Wednesday;
        case Day::Wednesday: return Day::Thursday;
        case Day::Thursday: return Day::Friday;
        case Day::Friday: return Day::Saturday;
        case Day::Saturday: return Day::Sunday;
    }
    cmpt::error("invalid day!");
    return Day::Sunday; // to satisfy compiler
}

Summing Numbers in a File¶

Suppose that the file data.txt contains 0, or more, doubles. Write a function that efficiently prints the sum of all the positive numbers in data.txt; negative numbers should be ignored. You can assume that data.txt only contains valid double numbers.

For example, suppose data.txt contains these numbers:
```
-8.1
2.2
1.0
0.0
-233.22
-92.2201
```

Then your program should print 3.2.

Your program should read and process files in the same style as discussed in the lectures and textbook (i.e. C++-style file handling).

Write the necessary #include statements, and put your program entirely inside main.

Sample solution:
#include <iostream>
#include <fstream>

int main() {
    ifstream fin("data.txt");
    double x;
    double sum = 0.0;
    while (fin >> x) {
        if (x > 0) {
            sum += x;
        }
    }
    cout << sum << "\n";
}

Strings and Characters¶

Write a function called is_upper(c) that returns true if the character c is one of the uppercase letters 'A' to 'Z', and false otherwise.

Sample solution:
```
bool is_upper(char c) {
  return c >= 'A' && c <= 'Z';
}
```
Write a function called to_lower(c) that returns the lowercase version of c if it’s an uppercase letter, e.g. to_lower('E') returns 'e'. If c is not an uppercase letter, then c is returned unchanged.

Sample solution:
```
char to_lower(char c) {
  if (is_upper(c)) {
    return c + ('a' - 'A');
  } else {
    return c;
  }
}
```
Write a function called to_lower(s) that returns a new string that is the same as s, except all lowercase letters in s have been converted to uppercase. s itself should not be changed.

Sample solution:
```
string to_lower(string s) {
  for(int i = 0; i < s.size(); ++i) {
    s[i] = to_lower(s[i]);
  }
  return s;
}
```
Write a function called is_vowel(c) that returns true if the character c is a vowel, and false otherwise. The vowels are a, e, i, o, and u, both uppercase and lowercase.

Sample solution:
```
bool is_vowel(char c) {
  c = to_lower(c);
  return c == 'a' || c == 'e' || c == 'i'
      || c == 'o' || c == 'u';
}
```
Write a function called first_vowel_loc(s) that returns the index location of the first vowel in string s. If s is empty, or has no vowels, then return -1. For example first_vowel_loc("sprayer") returns 3, and first_vowel_loc("MBB") returns -1.

Sample solution:
```
int first_vowel_loc(const string& s) {
  for(int i = 0; i < s.size(); ++i) {
    if (is_vowel(s[i])) {
      return i;
    }
  }
  return -1;
}
```

Write a function called swap_heads(s, t) that returns a single string that consists of s, a space, and then t, except leading consonants of s and t have been swapped. If either s, or t, or both, start with a vowel (or are empty), then return s and t with a space between them.

For example:

swap_heads("Donald", "Trump") returns Tronald Dump
swap_heads("Bill", "Gates") returns Gill Bates
swap_heads("Emily", "Carr") returns Emily Carr

Sample solution:

string swap_heads(const string& s, const string& t) {
  int i = first_vowel_loc(s);
  int j = first_vowel_loc(t);
  if (i < 1 || j < 1) {
    return s + " " + t; // no change
  } else {
    string s_head = s.substr(0, i);
    string s_body = s.substr(i);
    string t_head = t.substr(0, j);
    string t_body = t.substr(j);
    return t_head + s_body + ' ' + s_head + t_body;
  }
}

Randomness¶

Give a small but complete program that shows how to call and use the standard rand() function. What possible values could rand() return?

Sample solution:

#include <iostream>
#include <cstdlib>

using namespace std;

int main() {
   cout << "Here are three random numbers from 0 to " << RAND_MAX << ":\n";
   cout << rand() << "\n";
   cout << rand() << "\n";
   cout << rand() << "\n";
}

// rand() returns a value from 0 to RAND_MAX, i.e.
// 0 <= rand() <= RAND_MAX

If you don’t first call the srand function, rand() will always return the same sequence of numbers when you call it.
1. Show how to use srand to initialize the random number generator using the current time as the seed.
  
  Sample solution:
```
#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

int main() {
   srand(time(NULL)); // seed random number generator with current time

   cout << "Here are three random numbers from 0 to " << RAND_MAX << ":\n";
   cout << rand() << "\n";
   cout << rand() << "\n";
   cout << rand() << "\n";
}
```
2. Why might it sometimes be useful to give srand a fixed value, such as 15?
  
  Sample solution:
  
  When debugging a non-working program that uses rand(), it can be useful to call srand with a fixed value so that you get the exact same behavior every time you run the program.
  
  Another possible use of a fixed seed is in video games that use randomness to generate things in the game. For example, in Minecraft, two different people can generate exactly the same world if they use the same seed.
3. Suggest some other ways to get an initial random seed value for srand.
  
  Sample solution:
  There are many things you could try, e.g.:
  - Ask the user to enter some random letters, and make the seed the sum of their ASCII values.
  - If there’s a camera attached, take a picture and use, say, the average brightness of all the pixels as the random seed.
  - Create a special dice-rolling robot that rolls a bunch of real dice, and then use the numbers rolled as the seed.
  In practice, these may not be good or practical ways to generate random seeds. A poor random seed could result in less than random behaviour. This could range from annoying (e.g. a game is less random than it ought to be), to disastrous (e.g. a program that suggests passwords should not be predictable).
Write a new function called rand(n) that returns a random int from 0 up to, but including, the int n. If n is less than 1, then throw an error using cmpt::error.

Sample solution:
```
int rand(int n) {
   if (n < 1) cmpt::error("n must be >= 1");
   return rand() % n;
}
```
Write a new function called rand(lo, hi) that returns a random int that is greater than, or equal to, lo, and less than, or equal to, hi. If lo is greater than hi, then throw an error using cmpt::error.

Be careful with the arithmetic here!

Sample solution:
```
int rand(int lo, int hi) {
   if (lo > hi) cmpt::error("lo must be <= hi");
   int n = hi - lo + 1;  // + 1 because both lo and hi could be returned
   return lo + rand() % n;
}
```

Solutions to Final Exam Practice Questions¶

Vectors and Strings¶

RGB Structures¶

Enumerated Types: Days of the Week¶

Summing Numbers in a File¶

Strings and Characters¶

Randomness¶

Table Of Contents

Previous topic

This Page