### Perl Weekly Challenge: Week 164

#### Challenge 1:

**Prime Palindrome**

Write a script to find all prime numbers less than 1000, which are also palindromes in base 10. Palindromic numbers are numbers whose digits are the same in reverse. For example,

313is a palindromic prime, but337is not, even though733(337 reversed) is also prime.

As is so ofter the case, in Raku we can solve this with a one-liner.

```
(1 .. 1000).grep({ $_.is-prime && $_ == $_.flip }).join(q{ }).say;
```

The code is almost self-explanatory.

The Perl solution is longer because we have to provide our own `isPrime()`

function but the core can also be
expressed in one line.

```
say join q{ }, grep { isPrime($_) && $_ == reverse $_ } 1 .. 1000;
```

The Palindromic Primes under 1000 are:

```
2 3 5 7 11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929
```

#### Challenge 2:

**Happy Numbers**

Write a script to find the

first 8 Happy Numbersin base 10. For more information, please check out Wikipedia.Starting with any positive integer, replace the number by the sum of the squares of its digits, and repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle which does not include 1.

Those numbers for which this process end in 1 are happy numbers, while those numbers that do not end in 1 are unhappy numbers.

##### Example:

19 is Happy Number in base 10, as shown:

```
19 => 1^2 + 9^2
=> 1 + 81
=> 82 => 8^2 + 2^2
=> 64 + 4
=> 68 => 6^2 + 8^2
=> 36 + 64
=> 100 => 1^2 + 0^2 + 0^2
=> 1 + 0 + 0
=> 1
```

I started my Raku solution by defining an array to hold the results and a counter for integers starting with 1.

```
my @happy;
my $i = 1;
```

Then, until I have found 8 happy numbers, I check the current number for happiness (which sounds a bit weird when
you say it) using the `isHappy()`

function which I will describe next. If it is a happy number, it is added to
the `@happy`

array. Then we move on to the next number.

```
while @happy.elems < 8 {
if isHappy($i) {
@happy.push($i);
}
$i++;
}
```

And at the end, the happy numbers we found are joined together with spaces and printed out.

```
@happy.join(q{ }).say;
```

The core of the script is in the `isHappy()`

function. This takes an integer to be checked.

```
sub isHappy(Int $i) {
```

According to the spec, if the number is not happy (weird!) the intermediate results will eventually loop. I thought hard about how to detect such a cycle but then I noticed a detail in the linked Wikipedia article. It says that for a base-10 happy number, the maximum length of a cycle is 8. So I decided to count the number of tries I take to bring a sum to 1 and if that has not been achieved by 8 tries, consider the number unhappy. (Sorry I just can't get over this.)

```
my $tries = 0;
```

The intermediate result of each try is stored in the variable `$s`

an abbreviation for sum. But sum is the name of a builtin Raku method which I am going to use in this script so I thought `$sum`

might risk confusion.

```
my $s = $i;
```

Then while we have not reached 1...

```
while $s != 1 {
```

If we have tried 8 times, give up and return `False`

. This is not a happy number.

```
if $tries == 8 {
return False;
}
```

Split the number into digits, square each digit and sum the results. This will be the next value of `$s`

.

```
$s = $s.comb.map({ $_ ** 2 }).sum;
```

Increment the number of tries.

```
$tries++;
}
```

If we have reached this point, `$s`

is 1 so this is a happy number and we can return `True`

.

```
return True;
}
```

In Perl, all we need to add is a `sum()`

function and we can directly translate the Raku version.

```
sub isHappy {
my ($i) = @_;
my $tries = 0;
my $s = $i;
while ($s != 1) {
if ($tries == 8) {
return undef;
}
$s = sum([map { $_ ** 2 } split //, $s]);
$tries++;
}
return 1;
}
my @happy;
my $i = 1;
while (scalar @happy < 10) {
if (isHappy($i)) {
push @happy, $i;
}
$i++;
}
say join q{ }, @happy;
```

The first 8 happy numbers are:

```
1 7 10 13 19 23 28 31
```