Using control flow, we can modify a user's input and return it to them. In this project, we'll make them sound like Daffy Duck!

Thith Meanth War!

Home stretch—now we want to display the Daffy Duckified string to the user. You can do that using the string interpolation we learned earlier:
```rb
my_string = "muchachos"
print "Adios, #{my_string}!"
# ==> "Adios, muchachos!"
```

Returning the Final String—Er, "Thtring"

Good! Now let's complete our `if` statement.

When we find `"s"`, we want Ruby to replace every instance of `"s"` it finds with `"th"`. We can do this with the `.gsub!` method, which stands for **g**lobal **sub**stitution.

The syntax looks like this:
```rb
string_to_change.gsub!(/s/, "th")
```

When we get to later lessons, we'll explain why the `/s/` has to be between slashes instead of between quotes. Note: you *cannot* put a space between `gsub!` and the bit in parentheses.

Remember, you want the `!` at the end of the method name so that Ruby will change the string in-place.

Setting Up the 'If' Branch, Part 2

All right! Time to add in a little control flow.

For the `if` half of our branch, we want to check whether the user's input contains an `"s"`. 

```rb
if string_to_check.include? "substring"
```

We can do that using Ruby's `.include?` method, which evaluates to `true` if it finds what it's looking for and `false` otherwise.

(As a general rule, Ruby methods that end with `?` evaluate to the boolean values `true` or `false`.)

Setting Up the 'If' Branch, Part 1

Great work!

How might you improve this project? You could:

* Add an additional `if` statement to re-prompt the user for input if they don't enter anything
* Think about how you might account for words in which the letter "c" sounds like an "s"
* Think about how you might preserve the user's original capitalization

Congratulationth!

The hard part's over! Now we just need to let the user know if we don't find any instances of the letter "s".

Setting Up the 'Else' Branch

Now that we can direct our program using `if` / `else` statements, we can produce different results based on different user input.

In this project, we'll combine control flow with a few new Ruby string methods to Daffy Duckify a user's string, replacing each `"s"` with `"th"`.

What You'll Be Building

First, we should `print` a statement to prompt the user for input, then set that input to a variable using `gets.chomp`.

Getting User Input

We want to make sure we capture both `"S"` and `"s"` in the user's input. We could write separate `if` / `else` statements to handle this, but we can also use `.downcase!` to convert the user's input to all lower case. That way, we only have to search for `"s"`.