RogerBW's Blog

I’ve been doing the Weekly Challenges. The latest involved prime searches and pentagonal numbers. (Note that this is open until 16 January 2022.)

Task 1: Truncatable Prime

Write a script to generate first 20 left-truncatable prime numbers in base 10.

A left-truncatable prime is a prime number which, in a given base, contains no 0, and if the leading left digit is successively removed, then all resulting numbers are primes.

The sequence of these primes – which in base 10 is finite – is at the OEIS.

This is clearly a job for a hash. Assume that each of these first 20 numbers is N or below. Then all the truncations of them, which I'll have to test for primality, are also N or below. So I start with Eratosthenes (the same generator I used in last week's challenge 1); and given the constraint, it's probably easier to work with strings than with numbers even in a language that cares about the difference. Here's the Rust:

fn ltruncprimes(count: usize) -> Vec<u32> {
    let mut out: Vec<u32>=Vec::new();
    let mut lt=0;
    let p =
        genprimes(500).iter().map(|i| i.to_string()).collect::<Vec<String>>();
    let pp: HashSet<String>=HashSet::from_iter(p.clone());

At this point p is a list of the primes as strings, and pp lets me look up any string to see whether it's a prime. (The "contains no 0" constraint is handled automatically, because no string representation of a number will have a leading zero, and each relevant substring of the candidate prime will be tested.)

So we build each slice of characters, see if it's in the table of prime strings, and if not bail out of the loop.

    for pc in p {
        let l=pc.len()-1;
        let mut c=true;
        for i in 1..=l {
            if !pp.contains(&pc[i..=l]) {
                c=false;
                break;
            }
        }

If all the sub-primes were present, push it (as a number) onto the output list.

        if c {
            out.push(pc.parse::<u32>().unwrap());
            lt += 1;
            if lt >= count {
                break;
            }
        }
    }
    out
}

The main difference between languages is whether a string slice takes an end character or a range of indices (Rust, Python, most of the other language), or a length (Perl, PostScript). Every language here has some sort of reasonably clean string slicing approach.

Task 2: Pentagon Numbers

Write a script to find the first pair of Pentagon Numbers whose sum and difference are also a Pentagon Number.

Pentagon numbers can be defined as P(n) = n(3n - 1)/2.

And they can be found in the OEIS of course.

I ended up trading off memory usage for speed, using a cache of pentagonal numbers rather than testing individually for pentagonality (which would involve a square root or similar), and filling it with as-needed calculation.

In Raku, the helper function:

sub pentagon($n) {
    return $n*(3*$n-1)/2;
}

sub pentpair {

Set up the forward and reverse lookup tables. Forward is index to value, a simple array; reverse is value to index, a hash.

    my @fpent=[0];
    my %rpent;
    my $mx=0;
    my $a=1;
    while (1) {

$a is the index of the larger pentagonal number being considered in each pass. If we don't already have the forward and reverse pentagon tables filled up to $a, do that now.

        while ($mx < $a) {
            $mx++;
            push @fpent,pentagon($mx);
            %rpent{@fpent[$mx]}=$mx;
        }

Now test each lower index as a $b value.

        for 1..$a-1 -> $b {

Checking the difference is cheaper than checking the sum, so we'll do that first.

            my $d=@fpent[$a]-@fpent[$b];

If this is valid, we'll already have a cache entry for it without having to extend the cache. So only in this case do we carry on testing.

            if (%rpent{$d}:exists) {

Now we look at the sum.

                my $s=@fpent[$a]+@fpent[$b];

If necessary, extend the cache until the highest cached entry is no lower than the sum.

                while ($s > @fpent[$mx]) {
                    $mx++;
                    push @fpent,pentagon($mx);
                    %rpent{@fpent[$mx]}=$mx;
                }

Now see if that sum value is in the cache, and if so then print the finding and exit.

                if (%rpent{$s}:exists) {
                    print "P($a) + P($b) = @fpent[$a] + @fpent[$b] = $s = P(%rpent{$s})\n";
                    print "P($a) + P($b) = @fpent[$a] + @fpent[$b] = $d = P(%rpent{$d})\n";
                    exit 0;
                }
            }
        }
        $a++;
    }
}

I didn't tackle this one in PostScript because of the need for arbitrarily large lookup tables. I did use my Rust code, without the exit at first success, to find:

P(2167) + P(1020) = 7042750 + 1560090 = 8602840 = P(2395)
P(2167) - P(1020) = 7042750 - 1560090 = 5482660 = P(1912)

P(91650) + P(52430) = 12599537925 + 4123331135 = 16722869060 = P(105587)
P(91650) - P(52430) = 12599537925 - 4123331135 = 8476206790 = P(75172)

P(110461) + P(95506) = 18302393551 + 13682046301 = 31984439852 = P(146024)
P(110461) - P(95506) = 18302393551 - 13682046301 = 4620347250 =  P(55500)

P(121168) + P(111972) = 22022465752 + 18806537190 = 40829002942 = P(164983)
P(121168) - P(111972) = 22022465752 - 18806537190 = 3215928562 = P(46303)

P(129198) + P(73745) = 25038120207 + 8157450665 = 33195570872 = P(148763)
P(129198) - P(73745) = 25038120207 - 8157450665 = 16880669542 = P(106084)

P(224159) + P(186517) = 75370773842 + 52182793675 = 127553567517 = P(291609)
P(224159) - P(186517) = 75370773842 - 52182793675 = 23187980167 = P(124333)

Full code on github.