Start learning free

LESSON 151 OF 414 · LOOPS & GLOBAL VARIABLES

H4ck3r Sp34k in Rust: Building a String with chars and push

Practice Read the full explanation

Given a string, write a function that returns a coded (h4ck3r 5p34k) version of the string.

In order to work properly, the function should replace all "a"s with 4, "e"s with 3, "i"s with 1, "o"s with 0, and "s"s with 5.

Example 1:

Input:  "javascript is cool"

Output: "j4v45cr1pt 15 c00l"

Example 2:

Input:  "programming is fun"

Output: "pr0gr4mm1ng 15 fun"

Example 3:

Input:  "become a coder"

Output: "b3c0m3 4 c0d3r"
Hints:

We have to iterate through every character of input, check for each scenario and treat it accordingly:
  • Is it an 'a'? If so, replace with '4'. Otherwise:
  • Is it an 'e'? If so, replace with '3'. Otherwise:
  • Is it an 'i'? If so, replace with '1'. Otherwise:
  • Is it an 'o'? If so, replace with '0'. Otherwise:
  • Is it an 's'? If so, replace with '5'. Otherwise, keep it as it is.
In many languages strings are immutable, so we don't change input in place. How does that affect us? How can we put this strategy into code?

In many languages strings are immutable, which means you cannot directly change a character of a string (for example, assigning '4' to the character at index 4 of input). So we create a new string where we will store the solution as we build it. How can we translate these two hints in code?

Let's create a new string named solution, initially empty, where we will push all the encoded characters of input. We will use a for loop and a character variable c to iterate through input and treat the scenarios inside the loop:
  • Start with solution as an empty string.
  • For each character c of input: if c is 'a', append '4' to solution; if it is 'e', append '3'; if 'i', append '1'; if 'o', append '0'; if 's', append '5'; otherwise append c itself.
  • After the loop, return solution.


We have a for loop that performs exactly n iterations (n is the length of input), thus the Time Complexity is O(n).
The extra space we use is the extra string solution. Its length will be n in the end, thus the Extra Space used is also O(n).
(This assumes appending a character takes constant time. In languages where += on an immutable string copies the whole string each time, the running time can be closer to O(n2).)
STEP 1 OF 9
    Ctrl + Enter to check

    RUST · LOOPS & GLOBAL VARIABLES

    Hacker Speak in Rust, explained

    Problem overview

    The function convert_to_hacker_speak takes a String called input and returns a new string in which some letters are replaced by digits:

    • a becomes 4;
    • e becomes 3;
    • i becomes 1;
    • o becomes 0;
    • s becomes 5.

    Every other character, including spaces, stays as it is. For "javascript is cool" the result is "j4v45cr1pt 15 c00l": the two as, the s, the i and the two os are replaced.

    Approach

    Go through the input one character at a time and decide what to add to the output. For each character, there are six cases: the five special letters and everything else. A chain of if / else if branches covers them, and only the first branch whose condition is true runs.

    The result is built in a separate new string. The loop reads from input and appends to the new string, which starts out empty and grows by one character per pass. The input is never edited in place. Rust strings are stored as UTF-8 bytes, and there is no way to assign to the character at a position, so building a new string is the natural approach.

    Here is the word "coder" traced. The c matches no branch and is copied. The o becomes 0, the d is copied, the e becomes 3 and the r is copied. The output after the last pass is "c0d3r", which has the same length as the input, because each replacement swaps one character for one character.

    The order of the branches does not matter for correctness here, since no character can match two of the conditions. What does matter is that every character reaches exactly one push.

    Step by step

    1. Create the output string. String::new() gives an empty, growable string. It needs mut so that characters can be appended.
    2. Iterate over the characters. A String cannot be looped over directly. The chars() method returns an iterator that yields each character as a char, and the loop binds each one to c.
    3. Handle 'a'. When c == 'a', push '4'. push appends a single char.
    4. Handle 'e' in an else if, pushing '3'. The else if is only tested when the conditions above it failed.
    5. Handle 'i', pushing '1'.
    6. Handle 'o', pushing '0'.
    7. Handle 's', pushing '5'.
    8. Keep everything else. The final else pushes c unchanged, so spaces, digits, punctuation and other letters survive.
    9. Return the result after the loop, when every character has been handled.

    The solution in Rust

    impl Solution {
    fn convert_to_hacker_speak(input: String) -> String {
        let mut solution = String::new();
        for c in input.chars() {
            if c == 'a' {
                solution.push('4');
            } else if c == 'e' {
                solution.push('3');
            } else if c == 'i' {
                solution.push('1');
            } else if c == 'o' {
                solution.push('0');
            } else if c == 's' {
                solution.push('5');
            } else {
                solution.push(c);
            }
        }
        return solution;
    }
}

    Some Rust details here:

    • char versus string. Single quotes make a char, such as 'a', and double quotes make a string slice, such as "a". The comparison c == 'a' needs a char on both sides.
    • push versus push_str. push appends one char. push_str appends a whole &str. Writing solution.push("4") does not compile.
    • Why chars() and not indexing. Rust does not allow input[i] on a string, because a byte position is not always a character position. Characters outside plain ASCII take more than one byte. chars() decodes the text correctly, so accented letters pass through untouched.
    • Ownership. The function takes input by value, so it owns the string. Iterating with chars() only borrows it. The returned solution is moved out to the caller.

    A shorter way to write the same chain

    Rust has a match expression that fits a case list like this one. It picks a replacement character, and a single push follows:

    let r = match c {
    'a' => '4',
    'e' => '3',
    'i' => '1',
    'o' => '0',
    's' => '5',
    other => other,
};
solution.push(r);

    The last arm, other => other, catches every remaining character and passes it through. It behaves exactly like the if chain. The lesson uses the chain because if and else if are the tools of this chapter.

    Complexity

    Time: O(n), where n is the number of characters. The loop visits each one once, and each branch takes constant time. Appending is cheap on average, because the string's buffer grows geometrically.

    Space: O(n). The new string holds one character for each character of the input.

    Edge cases and common mistakes

    • An empty string. The loop does not run, and the result is an empty string.
    • Uppercase letters. Only lowercase letters are replaced. "Apple Orange SEA" becomes "Appl3 Or4ng3 SEA": the capital A, O, S and E are left alone, as the task describes.
    • Using separate if statements instead of else if. A final else then belongs only to the last if, so every character that was already replaced by an earlier branch is also pushed a second time, unchanged. The chain needs else if so that exactly one branch runs.
    • Forgetting the default case. Without the final else, spaces and the other letters would be dropped from the output.
    • Returning inside the loop. The return solution; belongs after the closing brace of the loop.
    • Non-ASCII text. "café ñ" becomes "c4fé ñ". Characters that are not in the list are copied whole.

    Testing

    • "javascript is cool" gives "j4v45cr1pt 15 c00l".
    • "programming is fun" gives "pr0gr4mm1ng 15 fun".
    • "become a coder" gives "b3c0m3 4 c0d3r".
    • "" gives "".
    Keep going with RustAbout 340 step-by-step lessons, from your first line of code to coding interviews. Free to start.
    Start learning free