4.18. Mixed Up Code Practice¶

Vacation time! But before you go, you need to convert your currency. Let's write the code for the dollar_to_yen function. dollar_to_yen takes dollar as a parameter and returns the equivalent amount of Japanese yen. The conversion rate is 1 USD equals 105.42 Japanese yen. Put the necessary blocks of code in the correct order.

```
double dollar_to_yen () {  #distractor
```
```
double dollar_to_yen (double dollar) {
```
```
double yen;  #distractor
```

int dollar_to_yen (double dollar) {  #distractor

```
return 105.42 * dollar;
```
```
return 105.42 * yen;  #distractor
```

void dollar_to_yen (double dollar) {  #distractor

```
}
```

When you buy something, you also need to pay sales tax. For example, a nice shirt could be labeled with a price of exactly $20, but when you pay, you actually need to pay $21.20 in a state with 6% sales tax. However, different states have different tax rates. Write the function price_with_tax, which takes price and percent_tax as parameters. price_with_tax calculates the price after tax and returns it. For example, price_with_tax (20, 6) returns 21.2. Put the necessary blocks of code in the correct order.

double price_with_tax (double price, double percent_tax) {

double price_with_tax (price, percent_tax) {  #distractor

int price_with_tax (double price, int percent_tax) {  #distractor

```
return (1 + percent_tax / 100) * price;
```

return (1 + percent_tax) * price;  #distractor

return percent_tax * price;  #distractor

```
}
```

Most assignments and tests are graded as a percentage, but final grades are letters. Let's write the code for the percent_to_letter function. percent_to_letter takes a percentage and returns the corresponding letter grade. A 90 and above is an 'A', an 80 and above is a 'B', a 70 and above is a 'C', and anything under a 70 is an 'F'. Put the necessary blocks of code in the correct order.

char percent_to_letter (double percentage) {

char percent_to_letter (percentage) {  #distractor

```
else if (percentage > 70) {
```
```
else if (percentage >= 70) {
```
```
else if (percentage >= 80) {
```
```
else {
```
```
if (percentage >= 90) {
```
```
return 'A';
```
```
return 'B'
```
```
return 'B';
```
```
return 'C';
```
```
return 'F';
```
```
return A;
```

void percent_to_letter (double percentage) {  #distractor

void percent_to_letter (int percentage) {  #distractor

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

Let's write the code for the triangle_area function. triangle_area takes two parameters, base and height. It returns the area of the triangle using the formula 1/2 * base * height. Put the necessary blocks of code in the correct order.

cout << 0.5 * base * height << '\n';  #distractor

```
double area;  #distractor
```

double triangle_area (base, height) {  #distractor

double triangle_area (double base, double height) {

int triangle_area (double base, double height) {  #distractor

```
return 0.5 * base * height;
```

void triangle_area (double base, double height) {  #distractor

```
}
```

Let's write the code for the cylinder_volume function. cylinder_volume takes two parameters, radius and height. It returns the volume of the cylinder using the formula pi * radius * radius * height. Put the necessary blocks of code in the correct order.

double cylinder_volume (double radius, double height) {

double cylinder_volume (radius, height) {  #distractor

```
double pi = 3.14;
```
```
return pi * radius * radius * height;
```

void cylinder_volume (double radius, double height) {  #distractor

```
}
```

On a distant planet, depending on the characteristics of an egg, a kenchic, an ooseg, or a guinpen might hatch from it. Let's write the function bird_type which returns an int corresponding to each type of bird (1 for kenchic, 2 for ooseg, and 3 for guinpen). If the egg is round, then it is a guinpen. Otherwise, if the egg is round and it isn't gray, then it is a kenchic. If it isn't a guinpen and it isn't a kenchic, then it's an ooseg. Put the necessary blocks of code in the correct order.

double bird_type (int is_round, char is_gray) {  #distractor

```
else if (!(is_round || is_gray)) {
```
```
else if (!is_round || is_gray) {
```
```
else {
```
```
if (!is_round && !is_gray) {
```
```
if (is_round && !is_gray) {
```

int bird_type (bool is_round, bool is_gray) {

```
return 0;  #distractor
```
```
return 1;
```
```
return 2;
```
```
return 3;
```

void bird_type (bool is_round, bool is_gray) {  #distractor

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

Let's write the code for the is_double_digit function. is_double_digit takes num as a parameter. is_double_digit returns true if num is a double digit number and returns false otherwise. Put the necessary blocks of code in the correct order.

```
bool is_double_digit (int num) {
```
```
else {
```
```
if (10 <= num <= 99) {  #distractor
```

if (num > 10 && num < 100) {  #distractor

if (num > 10 && num <= 100) {  #distractor

```
if (num >= 10 && num < 100) {
```
```
is_double_digit (int num) {
```
```
return false;
```
```
return true;
```
```
}
```
```
}
```
```
}
```

Let's write the code for the compare function. compare takes two integers a, b. compare returns 1 if a is greater than b, -1 if a is less than b and 0 if they are equal. Put the necessary blocks of code in the correct order.

```
bool compare (int a, int b) {
```
```
else if (a &lt b) {
```
```
else if (a > 0){ #distractor
```
```
else if (a!=b) {  #distractor
```
```
else {
```
```
if (a > b && a &lt b) {  #distractor
```
```
if (a > b) {
```
```
int compare (int a, int b) {
```
```
return -1;
```
```
return 0;
```
```
return 1;
```
```
}
```
```
}
```
```
}
```
```
}
```

Let's write the code for the is_factor function. is_factor takes two parameters, num and factor. is_factor returns true if factor is a factor of num and returns false otherwise. Put the necessary blocks of code in the correct order.

```
bool is_factor (int num, int factor) {
```
```
else {
```
```
if (factor % num == 0) {  #distractor
```
```
if (num % factor == 0) {
```
```
if (num % factor) {  #distractor
```
```
if (num / factor == 0) {  #distractor
```
```
return false;
```
```
return true;
```
```
void is_factor (int num, int factor) {
```
```
}
```
```
}
```
```
}
```

Q10

Let's write the code for the is_perfect_square function. is_perfect_square takes input as a parameter and returns true if input is a perfect square and returns false otherwise. Put the necessary blocks of code in the correct order.

bool is_perfect_square (int input) #distractor

```
bool is_perfect_square (int input) {
```

double root = sqrt (input);  #distractor

```
else {
```
```
if (pow (root, 2) == input) {
```
```
if (sqrt (input)) {  #distractor
```

int is_perfect_square (int input) {  #distractor

```
int root = sqrt (input);
```
```
return false;
```
```
return true;
```
```
}
```
```
}
```
```
}
```

Q11

Most bacteria cultures grow exponentially. For this problem, assume the number of cells in a bacterial culture doubles every hour. Let's write the code for the count_bacteria function. count_bacteria takes hour as a parameter and returns the number of bacteria cells after hour hours. Assume when hour is 0, there is one cell. When hour is one, the number of cells doubles to two. When hour is two, the number of cells doubles to four. Use recursion. Put the necessary blocks of code in the correct order.

bool count_bacteria (int hour) {  #distractor

```
else {
```
```
if (hour == 0) {
```
```
if (hour == 1) {
```
```
int count_bacteria (int hour) {
```
```
return 1;
```
```
return 2 * count_bacteria (hour - 1);
```

return 2 * count_bacteria (hour);  #distractor

```
return 2 * hour;  #distractor
```

return 2 + count_bacteria (hour - 1);  #distractor

void count_bacteria (int hour) {  #distractor

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