After a year, I’ve finally decided to take part in the Perl Weekly Challenge. Here are my solutions for the 53rd week:

We have the following matrix:

```
1 2 3
4 5 6
7 8 9
```

The goal is to rotate it 90/180/270 degrees clockwise.

First, here’s my *somewhat* one-line solution:

```
raku -e 'my @M = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]; .put for (@M = reverse(do @M[*;$_] for ^@M[0]) for ^(get() / 90 % 4 || 4))[*-1]'
```

I’m not saying *somewhat* just because it’s way longer than a *normal* line, but because for me “a line” means “a statement”. My solution “clearly” has two statements. I couldn’t do it with a single statement, because then I couldn’t have modified the matrix; and there’s just not enough `$_`

.

The basis of my script is to use positive angles for counterclockwise rotations and negative angles for clockwise rotations. And I’m not limiting it to just those three angles. This is just sentimental, really.

So. We got our degrees. Since after four 90-degree rotations we’ll be back where we started, we find the number of times we have to rotate modulo 4. The `|| 4`

is so that we don’t get `Effective index out of range`

in case the angle is a multiple of 360.

Each time, we use each column, which is easily accessible via two-dimensional subscripting `[*;$_]`

, as a row in our matrix. After this, we reverse the matrix because otherwise it’ll look upside down. (Duh!)

Since our inner loop returns all rotations in order, we take out the last one and `put`

it on screen, row by row.

This is the problem:

Write a script to accept an integer 1 <= N <= 5 that would print all possible strings of size N formed by using only vowels (a, e, i, o, u).

The string should follow the following rules:

‘a’ can only be followed by ‘e’ and ‘i’.

‘e’ can only be followed by ‘i’.

‘i’ can only be followed by ‘a’, ‘e’, ‘o’, and ‘u’.

‘o’ can only be followed by ‘a’ and ‘u’.

‘u’ can only be followed by ‘o’ and ‘e’.

And this is the solution:

```
raku -e '.say for <a e i o u>.combinations(get).map(*.permutations.map(*.join))[*;*].grep({!m/ao|au|ea|eo|eu|oe|oi|ua|ui/}).sort'
```

It’s a pretty straightforward and kinda lame one-liner. (But at least it *is* one.) We find all combinations of a given size — which we `get`

— out of the five letters we have. Then, for each combination we calculate every permutation and turn it into a word — via `join`

. After that, we can find the ones that do not match that simple pattern, which are basically the ones that follow the rules.