5.14. Mixed Up Code Practice¶

The program below should print out the even numbers between 20 and 40, inclusive, but the code is mixed up and contains extra blocks. Put the necessary blocks in the correct order.

```
cout << n << '\n';
```
```
int main() {
```
```
int n = 0; #distractor
```
```
int n = 20;
```
```
main(int) {
```
```
n = n * 2;                 #distractor
```
```
n = n + 2;
```
```
n++;                 #distractor
```
```
while (n < 40) {
```
```
while (n <= 40) {
```
```
}
```
```
}
```

The program below should count down from 100 to 0 in decrements of 10 but the code is mixed up and contains extra blocks. Put the necessary blocks in the correct order.

```
cout << n << '\n';
```
```
int main() {
```
```
int n = 100;
```
```
int n = 10; #distractor
```
```
n += 10;                 #distractor
```
```
n -= 10;
```
```
while (n < 0) { #distractor
```
```
while (n > 0) { #distractor
```
```
while (n >= 0) {
```
```
}
```
```
}
```

The program below should find the sum of the first 10 natural numbers, but the code is mixed up and contains extra blocks. Put the necessary blocks in the correct order.

```
cout << n << '\n';  #distractor
```
```
int main() {
```
```
int n = 10; #distractor
```
```
int n = 1;
```
```
int sum = 0;
```
```
int sum = n;  #distractor
```
```
n++;
```
```
sum = sum + n;
```
```
while (n < 100) {  #distractor
```
```
while (n <= 10) {
```
```
while (n <= 9) {  #distractor
```
```
}
```
```
}
```

Let's write the code for the repeat_hello function. repeat_hello should be a void function that takes no arguments and uses a while loop to print out "hello" three times.

```
cout << "hello" << '\n';
```
```
int n = 0
```
```
int n = 0;
```
```
n++;
```
```
repeat_hello () {
```
```
void repeat_hello () {
```
```
while (n < 3) {
```
```
while (n > 3) {
```
```
}
```
```
}
```

Now let's generalize the repeat_hello function so that it repeats a given string three times. Let's write the code for the repeat_string function, which takes input as a parameter and uses a while loop to print out the string three times.

```
cout << input << '\n';
```
```
cout << string << '\n';
```
```
int n = 0;
```
```
n++;
```
```
void repeat_string () {
```
```
void repeat_string (string input) {
```
```
while (3 > n) {
```
```
while (n < 3) {
```
```
}
```
```
}
```

We can further generalize repeat_string so that it repeats a given string a given number of times. Let's write the code for the new repeat_string function, which takes input and x as parameters and uses a while loop to print out the string x number of times.

```
cout << input << '\n';
```
```
int n = 0;
```
```
int n = x;
```
```
n++;
```

void repeat_string (string input, int x) {

void repeat_string (string input, string x) {

```
while (n < x) {
```
```
while (x < n) {
```
```
x++;
```
```
}
```
```
}
```

On the last day of every year, we count down the seconds before the new year arrives. Write the function new_year_countdown, which prints out a countdown from 10 and then prints out "Happy New Year!".

```
   cout << "Happy New Year!" << '\n';
}
```
```
cout << n << ' ';
```
```
int n = 0;
```
```
int n = 10;
```
```
n++;  #
```
```
n--;
```
```
void new_year_countdown () {
```

void new_year_countdown (string input) {

```
while (n != 10) {
```
```
while (n > 0) {
```
```
}
```

Help Goku reach power levels of over 9000! Write the function power_up which takes power_level as a parameter. power_up checks to see if power_level is over 9000. If it isn't, it repeatedly prints "More power!" and increments power_level by 1000 until power_level is over 9000. Then power_up prints "It's over 9000!". Put the necessary blocks in the correct order.

```
   cout << "It's over 9000!" << '\n';
}
```
```
cout << "More power!" << '\n';
```
```
if (power_level < 9000) {  #distractor
```
```
int n = 0;  #distractor
```
```
n++;  #distractor
```
```
power_level = power_level + 1000;
```
```
power_level++;
```
```
void power_up () {
```
```
void power_up (int power_level) {
```
```
while (power_level < 9000) {
```
```
while (power_level > 9000) {
```
```
}
```

Write the function summation which takes two parameters, start and end. summation adds all the integers from start to end, inclusive, together and returns the sum. Put the necessary blocks in the correct order.

```
int n = start;
```
```
int sum = 0;
```
```
int sum = start;  #distractor
```
```
int summation () {  #distractor
```
```
int summation (int start, int end) {
```
```
n++;
```
```
return n;  #distractor
```
```
return sum;
```
```
sum = sum + n;
```

void summation (int start, int end) {  #distractor

```
while (n < end) {
```
```
while (n <= end) {
```
```
}
```
```
}
```

Q10

Write the function reverse_number which takes num as a parameter and returns num but with its digits reversed. For example, reverse_number (1324) returns 4231. Put the necessary blocks in the correct order, with reverse declared first, then temp, and lastly remainder.

```
int remainder = 0;
```
```
int remainder;  #distractor
```
```
int reverse = 0  #distractor
```
```
int reverse = 0;
```
```
int reverse_number (int num) {
```
```
int temp = num;
```
```
remainder = temp % 10;
```
```
return reverse;
```
```
return temp;  #distractor
```
```
reverse = reverse * 10 + remainder;
```
```
temp = temp / 10;
```

void reverse_number (int num) {  #distractor

```
while (temp > 0) {
```
```
}
```
```
}
```