## Raku and I: Journey begin …

It has been ages since I last blogged about `Raku`

. The only time, I have blogged about when I took part in **The Weekly Challenge**. But then this also changed recently as I finally found time to contribute to the weekly fun challenges but no blogging still.

I would say it is all about my mental state, since I have so much to talk about. Recently I was approached by a very dear friend and senior member of `Raku Community`

if I am interested in contributing to the **Raku Advent Calendar 2022**. So as you guessed it rightly so, I have a compelling reason to get back to blogging.

**But then you know ….**

I always have too many things on my plate, so getting done something new is always tricky. However I had made up my mind, no matter what I would give it my best shot.

**Here I am …**

**So what am I going to talk about then?**

Those who know me personally, are aware that I am a `Perl`

guy by nature. Having said, I started playing with other languages recently thanks to the vibrant group of `Team PWC`

. In this blog post, I would like to talk about some of my contributions to the weekly challenge in the new found love `Raku`

language.

## 1: Prime Sum

You are given a number `$N`

. Write a script to find the minimum number of prime numbers required, whose summation gives you `$N`

.

With the power of `Raku`

built-in features, it is a piece of cake, if you know what you are doing. For me, the official **Raku Documentation** is the answer to all my questions. And if I can’t find what I am looking for then I ask my friends on various social platform. `9 out of 10 times`

, I get the answer instantly.

So in this case, all the hard work in done by `is-prime`

. I am a big fan of method chaining as you can see below. Just for the sake of the reader, I go through the list `2..$sum`

and `grep`

everything that `is-prime`

.

**Isn’t beautiful? For me, it is.**

```
sub find-prime-upto(Int $sum) {
return (2..$sum).grep: { .is-prime };
}
```

Now with the handy subroutine ready, we are read to solve the task as below:

For my `Perl`

friends new to `Raku`

, the only thing might trouble you is the use of `[+]`

, right?

It is the `Reduction Operator []`

that works on lists of values.

```
sub prime-sum(Int $sum) {
my @prime = find-prime-upto($sum);
my @prime-sum = Empty;
for 1..$sum -> $i {
for @prime.combinations: $i -> $j {
my $_sum = [+] $j;
@prime-sum.push: $j if $_sum == $sum;
}
}
return @prime-sum;
}
```

Now glue together everything as below:

```
use v6.d;
sub MAIN(Int $SUM where $SUM > 0) {
prime-sum($SUM).join("\n").say;
}
```

Still not done yet as unit test is nice to have.

```
use Test;
is-deeply prime-sum(6).<>, [], "prime sum = 6";
is-deeply prime-sum(9).<>, [(2, 7),], "prime sum = 9";
is-deeply prime-sum(12).<>, [(5, 7), (2, 3, 7)], "prime sum = 12";
done-testing;
```

## 2: Fibonacci Sum

Write a script to find out all possible combination of `Fibonacci Numbers`

required to get `$N`

on addition.

You are `NOT`

allowed to repeat a number. Print `0`

if none found.

You may find the solution below somewhat similar to the above work but there is something new for `Perl`

fans. In `Perl`

we can get the last element of a list `$list[-1]`

but in `Raku`

it is slightly different as you see below.

One more thing, if you look at closely the parameter checks done in the signature itself which we don’t have in `Perl`

.

`Raku`

rocks !!!

```
sub fibonacci-series-upto(Int $num where $num > 0) {
my @fibonacci = (1, 2);
while @fibonacci.[*-1] + @fibonacci.[*-2] <= $num {
@fibonacci.push: @fibonacci.[*-1] + @fibonacci.[*-2];
}
return @fibonacci;
}
```

Now we are ready to solve the task as below:

**Did you notice something special here?**

Yes, `.combinations`

. Again all built-in, no need to import any library. It generates all possible combinations of given size.

```
sub fibonacci-sum(Int $sum where $sum > 0) {
my @fibonacci = fibonacci-series-upto($sum);
my @fibonacci_sum = Empty;
for 1 .. $sum -> $i {
last if $i > @fibonacci.elems;
for @fibonacci.combinations: $i -> $comb {
my $_sum = [+] $comb;
@fibonacci_sum.push: $comb if $_sum == $sum;
}
}
return |@fibonacci_sum;
}
```

Final application.

```
use v6.d;
sub MAIN(Int :$N where $N > 0) {
fibonacci-sum($N).join("\n").say;
}
```

Time for some unit test too.

```
use Test;
is-deeply fibonacci-sum(6), ((1,5), (1,2,3)), "fibonacci sum = 6";
is-deeply fibonacci-sum(9), ((1,8), (1,3,5)), "fibonacci sum = 9";
done-testing;
```

## 3: Count Set Bits

You are given a positive number `$N`

.

Write a script to count the total numbrer of set bits of the binary representations of all numbers from `1`

to `$N`

and return `$total_count_set_bit % 1000000007`

.

For this task, `Raku`

has most of the funtions built-in, so nothing to be invented.

As you see, it is one-liner, `(1..$n).map( -> $i { $c += [+] $i.base(2).comb; });`

where all the work is done.

`.map()`

works same as in `Perl`

. In this case each element gets assigned to `$i`

. Further on `$i`

gets converted to `base 2`

i.e. binary form then finally split into individual digits using `.comb`

.

How can you not fall in love with `Raku`

?

```
sub count-set-bits(Int $n) {
my $c = 0;
(1..$n).map( -> $i { $c += [+] $i.base(2).comb; });
return $c % 1000000007;
}
```

Unit test to go with it.

```
use Test;
is count-set-bits(4), 5, "testing example 1";
is count-set-bits(3), 4, "testing example 2";
done-testing;
```

## 4: Smallest Positive Number

You are given unsorted list of integers `@N`

.

Write a script to find out the smallest positive number missing.

This task introduced me something new that I wasn’t aware of earlier.

I always wanted to put check on the elements of input list. In this task, I am checking every elements in the given input list is integer. Also the return value is of type integer too. All these done with one line `@n where .all ~~ Int --> Int`

. This is the power of `Raku`

we can have the power in our script.

Also to sort a list, just use `.sort`

together with `.grep`

makes it very powerful.

The `.elems`

gives me the total number of elements in the list.

```
sub smallest-positive-number(@n where .all ~~ Int --> Int) {
my @positive-numbers = @n.sort.grep: { $_ > 0 };
return 1 unless @positive-numbers.elems;
my Int $i = 0;
(1 .. @positive-numbers.tail).map: -> $n {
return $n if $n < @positive-numbers[$i++]
};
return ++@positive-numbers.tail;
}
```

Final application looks like below.

**Did you see something new?**

Well, it shows how to set the default parameter values.

```
use v6.d;
sub MAIN(:@N where .all ~~ Int = (2, 3, 7, 6, 8, -1, -10, 15)) {
say smallest-positive-number(@N);
}
```

Time for unit test again.

```
use Test;
is smallest-positive-number((5, 2, -2, 0)), 1,
"testing (5, 2, -2, 0)";
is smallest-positive-number((1, 8, -1)), 2,
"testing (1, 8, -1)";
is smallest-positive-number((2, 0, -1)), 1,
"testing (2, 0, -1)";
done-testing;
```

## CONCLUSION

Learning `Raku`

is an ongoing journey and I am loving it. I haven’t shared everything to be honest. If you are interested then you can checkout the rest in my **collections**.

Enjoy the break and stay safe.