Words Longer Than 20 Characters (Solution)

The solution to the simplest exercise—printing all the words of words.txt that are longer than 20 characters—is:

for 'words.txt'.IO.lines -> $line {
    say $line if $line.chars > 20
}

Because the code is so simple, this is a typical example of a possible and useful one-liner (as described in “One-Liner Mode”). Assuming you want to know the words that are longer than 20 characters, you don’t even need to write a script, save it, and run it. You can simply type this at your operating system prompt:

$ perl6 -n -e '$_.say if $_.chars > 20;' words.txt

The “-e” option tells Perl that the script to be run comes next on the command line between quotation marks. The “-n” asks Perl to read line by line the file after the end of the command line, to store each line in the $_ topical variable, and to apply the content of the script to each line. And the one-line script is just printing the content of $_ if its length is greater than 20.

To simplify a bit, the two options -n and -e may be grouped together as perl6 -ne. In addition, the $_ topical variable can be omitted in method calls (in other words, if a method has no invocant, the invocant will be defaulted to $_). Finally, the trailing semicolon may also be removed. The one-liner above can thus be made somewhat shorter:

$ perl6 -ne '.say if .chars > 20' words.txt

Remember that, if you’re trying this under Windows, you need to replace the single quotes with double quotes (and vice-versa if the scripts itself contains double quotes):

C:UsersLaurent>perl6 -ne ".say if .chars > 20" words.txt

Words with No “e” (Solution)

A subroutine that returns True for words that have no “e” (Exercise 8-2) is also quite straightforward:

sub has-no-e (Str $word) {
    return True unless defined index $word, "e";
    return False;
}

The subroutine simply returns True if the index function did not find any “e” in the word received as a parameter and False otherwise.

Note that this works correctly because the word list used (words.txt) is entirely in lowercase letters. The above subroutine would need to be modified if it might be called with words containing uppercase letters.

Since the defined function returns a Boolean value, we could shorten our subroutine to this:

sub has-no-e (Str $word) {
    not defined index $word, "e";
}

We could also have used a regex for testing the presence of a “e” on the second line of this subroutine:

    return True unless $word ~~ /e/;

This fairly concise syntax is appealing, but when looking for an exact literal match, the index function is likely to be slightly more efficient (faster) than a regex.

Looking for the words without “e” in our word list and counting them is not very difficult:

sub has-no-e (Str $word) {
    not defined index $word, "e";
}

my $total-count = 0;
my $count-no-e = 0;
for 'words.txt'.IO.lines -> $line { 
    $total-count++;
    if has-no-e $line {
        $count-no-e++;
        say $line;
    }
}
say "=" x 24;
say "Total word count: $total-count";
say "Words without 'e': $count-no-e";
printf "Percentage of words without 'e': %.2f %%
", 
        100 * $count-no-e / $total-count;

The above program will display the following at the end of its output:

========================
Total word count: 113809
Words without 'e': 37641
Percentage of words without 'e': 33.07 %

So, less than one-third of the words of our list have no “e”.

Avoiding Other Letters (Solution)

The avoids subroutine is a more general version of has_no_e, but it has the same structure:

sub avoids (Str $word, Str $forbidden) {
    for 0..$forbidden.chars - 1 -> $idx {
        my $letter = substr $forbidden, $idx, 1;
        return False if defined index $word, $letter;
    }
    True;
}

We can return False as soon as we find a forbidden letter; if we get to the end of the loop, we return True. Since a subroutine returns the last evaluated expression, we don’t need to explicitly use a return True statement in the last code line above. I used this feature here as an example; you might find it clearer to explicitly return values, except perhaps for very simple one-line subroutines.

Note that we have here implicitly two nested loops. We could reverse the outer and the inner loops:

sub avoids (Str $word, Str $forbidden) {
    for 0..$words.chars - 1 -> $idx {
        my $letter = substr $words, $idx, 1;
        return False if defined index $forbidden, $letter;
    }
    True;
}

The main code calling the above subroutine is similar to the code calling has-no-e and might look like this:

my $total-count = 0;
my $count-no-forbidden = 0;

for 'words.txt'.IO.lines -> $line { 
    $total-count++;
    $count-no-forbidden++ if avoids $line, "eiou";
}

say "=" x 24;
say "Total word count: $total-count";
say "Words without forbidden: $count-no-forbidden";
printf "Percentage of words with no forbidden letter: %.2f %%
", 
        100 * $count-no-forbidden / $total-count;

Using Only Some Letters (Solution)

uses-only is similar to our avoids subroutine except that the sense of the condition is reversed:

sub uses-only (Str $word, Str $available) {
    for 0..$word.chars - 1 -> $idx {
        my $letter = substr $word, $idx, 1;
        return False unless defined index $available, $letter;
    }
    True;
}

Instead of a list of forbidden letters, we have a list of available letters. If we find a letter in word that is not in available, we can return False. And we return True if we reach the loop end.

Using All Letters of a List (Solution)

uses-all is similar to the previous two subroutines, except that we reverse the role of the word and the string of letters:

sub uses-all(Str $word, Str $required) {
    for 0..$required.chars - 1 -> $idx {
        my $letter = substr $word, $idx, 1;
        return False unless defined index $word, $letter;
    }
    return True;
}

Instead of traversing the letters in $word, the loop traverses the required letters. If any of the required letters do not appear in the word, we can return False.

If you were really thinking like a computer scientist, you would have recognized that uses-all was an instance of a previously solved problem in reverse: if word A uses all letters of word B, then word B uses only letters of word A. So, we can call the uses-only subroutine and write:

sub uses-all ($word, $required) {
    return uses-only $required, $word;
}

This is an example of a program development plan called reduction to a previously solved problem, which means that you recognize the problem you are working on as an instance of a solved problem and apply an existing solution.

Alphabetic Order (Solution)

For is_abecedarian we have to compare adjacent letters. Each time in our for loop, we define one letter as our current letter and compare it with the previous one:

sub is_abecedarian ($word) {
    for 1..$word.chars - 1 -> $idx {    
        my $curr-letter = substr $word, $idx, 1;
        return False if $curr-letter lt substr $word, $idx - 1, 1;  
    }     
    return True
}

An alternative is to use recursion:

sub is-abecedarian (Str $word) {
    return True if $word.chars <= 1;
    return False if substr($word, 0, 1) gt substr($word, 1, 1);
    return is-abecedarian substr $word, 1;
}

Another option is to use a while loop:

sub is_abecedarian (Str $word):
    my $i = 0;
    while $i < $word.chars -1 {
        if substr($word, $i, 1) gt substr ($word, $i+1, 1) {
            return False;
        }
        $i++;
    }
    return True;
}

The loop starts at $i=0 and ends when i=$word.chars -1. Each time through the loop, it compares the ith character (which you can think of as the current character) to the i+1th character (which you can think of as the next).

If the next character is less than (alphabetically before) the current one, then we have discovered a break in the abecedarian trend, and we return False.

If we get to the end of the loop without finding a fault, then the word passes the test. To convince yourself that the loop ends correctly, consider an example like 'flossy'. The length of the word is 6, so the last time the loop runs is when $i is 4, which is the index of the second-to-last character. On the last iteration, it compares the second-to-last character (the second “s”) to the last (the “y”), which is what we want.

Another Example of Reduction to a Previously Solved Problem

Here is a version of is_palindrome (see Exercise 5-3) that uses two indices; one starts at the beginning and goes up, while the other starts at the end and goes down:

sub one-char (Str $string, $idx) {
    return substr $string, $idx, 1;
}
sub is-palindrome (Str $word) {
    my $i = 0;
    my $j = $word.chars - 1;

    while $i < $j {
        return False if one-char($word, $i) ne one-char($word, $j);
        $i++;
        $j--;
    }
    return True;
}

Or we could reduce to a previously solved problem and write:

sub is-palindrome (Str $word) {
    return is-reverse($word, $word); 
}

using is-reverse from “Debugging” (but you should probably choose the corrected version of the is-reversed subroutine given in the appendix: see “Exercise: is-reverse Subroutine”).