# Working with words in the Raku programming language

A solution to the task 1 of the Weekly Challenge 233, where the goal is to find the words constructed from the same letters.

In this post, I will demonstrate my solution to another Task of The Weekly Challenge, week 233. Here’s how it reads:

## Similar words

You are given an array of words made up of alphabets only.

Write a script to find the number of pairs of similar words. Two words are similar if they consist of the same characters.

Example 1

``````Input: @words = ("aba", "aabb", "abcd", "bac", "aabc")
Output: 2

Pair 1: similar words ("aba", "aabb")
Pair 2: similar words ("bac", "aabc")
``````

Example 2

``````Input: @words = ("aabb", "ab", "ba")
Output: 3

Pair 1: similar words ("aabb", "ab")
Pair 2: similar words ("aabb", "ba")
Pair 3: similar words ("ab", "ba")
``````

Example 3

``````Input: @words = ("nba", "cba", "dba")
Output: 0``````

There’s a slight moment that may be needs extra comments. In the second example all three words constructed of the same two letters, a and b. So, all of the three words match the definition of a ‘similar’ word. But as the task needs to find pairs, we need to construct all the possible pairs out of those three words.

In my solution, I chose to use a handy `classify` method. For an array, it creates a hash, where the keys are the common classifying symbol, and the values are the lists of the input elements that match this classification property.

Here is the whole first program together with all the test cases provided in the description. The program maps every word to a corresponding string that consists of the sorted unique letters in the word.

```my @tests = ["aba", "aabb", "abcd", "bac", "aabc"],
["aabb", "ab", "ba"],
["nba", "cba", "dba"];

for @tests -> @words {
say @words.classify(*.comb.unique.sort.join).grep(*.value.elems > 1);
}```

For example, the word aba will be associated with the key ab. The program prints the following output:

```\$ raku ch-1.raku
(ab => [aba aabb] abc => [bac aabc])
(ab => [aabb ab ba])
()```

The format of the output differs from the examples, but it can be enhanced if needed. My goal was to create a compact solution 😉

But I would assume that you’d be interested in looking at what `classify` produces. I am also curious. For the same `@tests`, it returns the following three hashes:

```{ab => [aba aabb], abc => [bac aabc], abcd => [abcd]}
{ab => [aabb ab ba]}
{abc => [cba], abd => [dba], abn => [nba]}```

As you see, each string was put into one of the classification bins.

The second part of the task is to find pairs. After the `grep`, we already filtered out everything that has less than two elements, so if data passed through this filter, there will be at least one pair. For bigger arrays, we can use another Raku’s built-in mechanism: the `combinations` method.

The updated mail loop of the program looks like this now.

```for @tests -> @words {
say "Test case: ", @words;

my %classification = @words.classify(*.comb.unique.sort.join).grep(*.value.elems > 1);

my \$pairs = 0;
for %classification.kv -> \$k, \$v {
my @pairs = \$v.combinations(2);
\$pairs += @pairs.elems;

say "\$k: ", @pairs;
}
say "Answer: \$pairs pair{\$pairs == 1 ?? '' !! 's'}.\n";
}```

The ‘redundant’ code here is added just to have a more detailed output so that we can see which pairs were actually found. Let us look at the output for the initial test cases:

```\$ raku ch-1.raku
Test case: [aba aabb abcd bac aabc]
ab: [(aba aabb)]
abc: [(bac aabc)]