### Perl Weekly Challenge: Week 114

#### Challenge 1:

Next Palindrome Number

You are given a positive integer `\$N`.

Write a script to find out the next `Palindrome Number` higher than the given integer `\$N`.

##### Example
``````Input: \$N = 1234
Output: 1331

Input: \$N = 999
Output: 1001
``````

To solve this, I started from `\$N + 1`. (`\$N` itself could be a palindrome number but the spec says "higher than the given integer.") Then for every successive number I checked if it is a palindrome by comparing it to its reverse; which can be easily produced in Perl with the aptly named `reverse()` function. If it is a palindrome we can stop and print it out otherwise we keep going. The rarely seen `do...until` loop makes this quite succint yet readable.

``````my \$next = \$N + 1;
do \$next++ until \$next == reverse \$next;
say \$next;
``````

(Full code on Github.)

In Raku, you use `.flip()` instead of `reverse()` as that function is reserved for reversing lists. Other than that, it also comes in at a sleek three lines of code.

``````my \$next = \$N + 1;
do \$next++ until \$next == \$next.flip;
say \$next;
``````

(Full code on Github.)

#### Challenge 2:

Higher Integer Set Bits

You are given a positive integer `\$N`.

Write a script to find the next higher integer having the same number of 1 bits in binary representation as `\$N`.

##### Example
``````Input: \$N = 3
Output: 5

Binary representation of \$N is 011. There are two 1 bits. So the next higher integer is 5 having the same the number of 1 bits i.e. 101.

Input: \$N = 12
Output: 17

Binary representation of \$N is 1100. There are two 1 bits. So the next higher integer is 17 having the same number of 1 bits i.e. 10001.
``````

This was another of those cases where I only had the faintest notion about how to proceed and had to look up the algorithm on the Internet. Luckily this page taught me all I needed to know. My answers are basically a translation of the C++ solution given there.

Perl first. We start by finding the smallest 1 bit in `\$N` which will be the rightmost one. A simple way to do this is by doing a bitwise `AND` between `\$N` and its inverse.

``````my \$rightmostOneBit = \$N & -\$N;
``````

This bit might be part of a sequence of 1's (stretching left.) If it is, we can capture the sequnce by adding `\$rightmostOneBit` back to `\$N`.

``````my \$nextHigherOneBit = \$N + \$rightmostOneBit;
``````

and bitwise `XOR`ing the result with `\$N`.

``````my \$rightOnesSequence = \$N ^ \$nextHigherOneBit;
``````

We want all the bits of this sequence except the leftmost, shunted to the right. The next two lines do that.

``````\$rightOnesSequence /= \$rightmostOneBit;
\$rightOnesSequence >>= 2;
``````

Now when we bitwise `OR` `\$nextHigherOneBit` and `\$rightOnesSequence` we have the answer and we can print it.

``````say \$nextHigherOneBit | \$rightOnesSequence;
``````

(Full code on Github.)

Perl uses the same bitwise and shift operators as C/C++ so I was somewhat familiar with them. Raku names them differently, putting a `+` in front. Once I overcame that little hurdle translating the Perl code to Raku was simple.

``````my \$rightmostOneBit = \$N +& -\$N;
my \$nextHigherOneBit = \$N + \$rightmostOneBit;
my \$rightOnesSequence = \$N +^ \$nextHigherOneBit;

\$rightOnesSequence /= \$rightmostOneBit;
\$rightOnesSequence +>= 2;

say \$nextHigherOneBit +| \$rightOnesSequence;
``````

(Full code on Github.)