7.18. Mixed Up Code Practice¶

Write a program that prints the 4th character of word, and finds and replaces all instances of 'i' with 'e'. Finally, print out the string. Put the necessary blocks in the correct order.

cout << irritating[3] << '\n';  #distractor

```
cout << word << '\n';
```

cout << word.at(4) << '\n';  #distractor

```
cout << word[3] << '\n';
```
```
cout << word[4] << '\n';  #distractor
```
```
int main() {
```
```
string word = "irritating";
```

while ((int)word.find('e') != -1) {  #distractor

```
while ((int)word.find('i') != -1) {
```

while ((int)word.find('i')) {  #distractor

word[word.find('e')] = 'i';  #distractor

```
word[word.find('i')] = 'e';
```
```
}
```
```
}
```

An anagram is a play on words by rearranging the letters of the original words to form new words. For example, the letters in "listen" can be rearranged to make "silent". Write a program that rearranges "night" into "thing" and prints the anagram. Put the necessary blocks in the correct order.

anagram[0] = original[original.find('t')];

anagram[1] = original[original.find('h')];

anagram[2] = original[original.find('i')];

anagram[3] = original[original.find('n')];

anagram[4] = original[original.find('g')];

```
cout << anagram;
```
```
int main() {
```
```
string anagram = original;
```
```
string original = "night";
```
```
string original = "thing";
```
```
}
```

Let's write the function longer_string, which takes two parameters, first and second. If first has more letters than second, longer_string prints "first is longer than second", and vice versa. If they have the same number of letters, longer_string prints "first and second are the same length". Put the necessary blocks in the correct order.

cout << first << " and " << second << " are the same length" << '\n';

cout << first << " is longer than " << second << '\n';

cout << second << " is longer than " << first << '\n';

cout << second << " is longer than " << second << '\n';

else (first.length() == second.length()) {  #distractor

else if (first.length() < second.length()) {

```
else {
```
```
if (first.length() > second.length()) {
```

if (first.length() >= second.length()) {

string longer_string (string first, string second) {

void longer_string (string first, string second) {

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

Let's write the code for the cipher_text function. cipher_text should be a void function that takes input as a parameter, increases the value of each character by 1 (i.e. "bad" turns into "cbe"), and prints the encrypted string.

```
cout << input;
```
```
i++;
```
```
input[i] = input[i] + 1;
```
```
input[i] = input[i] - 1;
```
```
int i = 0;
```
```
return input;
```
```
string cipher_text (string input) {
```
```
void cipher_text (string input) {
```
```
while (i < input.length() - 1) {
```
```
while (i < input.length()) {
```
```
}
```
```
}
```

The program below should print out the number of occurences of the character 't' in the string tongue_twister but the code is mixed up. Put the necessary blocks in the correct order, with declaration in the order of tongue_twister, count, and i.

```
count++;
```
```
cout << count;
```
```
i++;
```
```
if (tongue_twister[i] = 't') {
```
```
if (tongue_twister[i] == 't') {
```
```
int count = 0;
```
```
int count = 1;
```
```
int i = 0;
```
```
int main() {
```

string tongue_twister = "twelve twins twirled twelve twigs";

while (i < (int)tongue_twister.length()) {

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

The program below should print out the index of the second instance of the character 'i' but the code is mixed up and contains extra blocks. Put the necessary blocks in the correct order.

```
cout << first;
```
```
cout << index;
```
```
int first = quote.find('i');
```
```
int i = 0;  #distractor
```

int index = find (quote, 'i', first + 1);

```
int index = find (quote, 'i', first);
```
```
int main() {
```

string quote = "Your time is limited, so don't waste it living someone else's life.";

while (i < quote.length()) {  #distractor

```
}
```

Deep in the forest live the 7 dwarves named Sorty, Torty, Vorty, Worty, Xorty, Yorty, and Zorty. The program below should print out each of their names but the code is mixed up and contains extra blocks. Put the necessary blocks in the correct order.

```
char letter = 'S';
```
```
cout << letter + suffix << '\n';
```
```
if (letter != 'U') {
```
```
if (letter == 'U') {
```
```
int main() {
```
```
letter++;
```
```
string name = “Sorty”; #distractor
```
```
string suffix = "orty";
```
```
suffix++;
```
```
while (letter <= 'Z') {
```
```
}
```
```
}
```
```
}
```

On the strange planet of Noes, there's a law that prohibits the usage of the letter "e". As a result, they hired you to write a function called censor_e that replaces all occurences of the letter "e" in a string with an asterisk and returns the censored string. For example, if the input is "hello world", the function returns "h*llo world".

```
'*' = input[i];
```
```
i++;
```
```
if (input[i] = 'e') {
```
```
if (input[i] == 'e') {
```
```
input[i] = '*';
```
```
int i = 0;
```
```
return input;
```
```
string censor_e (string input) {
```
```
string copy = input;  #distractor
```
```
void censor_e (string input) {
```
```
while (i < input.length() - 1) {
```
```
while (i < input.length()) {
```
```
}
```
```
}
```
```
}
```

Your work for the planet of Noes impressed the nearby planets of Noas, Nois, Noos, and Nous. They want you to write different functions that censor out each planet's corresponding forbidden letter. However, your galaxy brain knows better than to write a different function for each planet. Using generalization, write the function censor_letter which takes input and a char to censor as parameters and returns a censored string. For example, censor_letter("Bye world", 'o') returns the string "Bye w*rld".

```
'*' = input[i];
```
```
i++;
```
```
if (input[i] == "letter") {
```
```
if (input[i] == letter) {
```
```
input[i] = '*';
```
```
int i = 0;
```
```
int i = 1;
```
```
return input;
```
```
string censor_letter (string input) {
```

string censor_letter (string input, char letter) {

```
while (i < input.length()) {
```
```
}
```
```
}
```
```
}
```

Q10

Let's write a function called alpha_combine which takes two strings, first and second, and returns a string which concatenates first and second in alphabetical order. For example, alphabetizer ("zebra, mega") returns the string "megazebra" since "mega" comes before "zebra" in the alphabet. Put the necessary blocks in the correct order.

   cout << second << first;  #distractor
}

```
cout << first << second;
```
```
else {
```
```
if ("first" > "second") {
```
```
if (first > second) {
```
```
return first + second;
```
```
return second + first;
```

string alpha_combine (string first, string second) {

void alpha_combine (string first, string second) {

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

Q11

Let's write a function called <code>ispalindrome</code> which takes a <code>string</code> named input and returns a <code>bool</code> The function returns true if the <code>string</code> is a palindrome and false if not. palindromes are symmetrical strings. That is a string that reads the same backwards is palindrome. palindromes: "hih", "i", "bob", "tenet", "soos", "madam" . not palindromes: "join", "hat", "frat", "supper", "rhythm". The code is mixed up and contains extra blocks. Put the necessary blocks in the correct order.

```
back = back - 1;
```
```
bool ispalindrome(string input) {
```
```
else { #distractor
```
```
front = front + 1;
```
```
if( input[b] != input[e] ) {
```

int front = 0 , back = input.length() - 1;

```
int front = 0 , back = input.length();
```
```
return false;
```
```
return true;
```
```
string ispalindrome(bool input) {
```
```
while ( front &gt back) {
```
```
while ( front &lt back) {
```
```
}
```
```
}
```
```
}
```