The Weekly Challenge ‐ Perl and Raku

left_trun_primes = [2, 3, 5, 7]
primes = [2, 3, 5, 7]
index_ltp = [1, 5]

lastelement(array) = array[length(array)]
x_no_less_than_sqrt_y(x, y) = x ≤ √y


function grep(func, array)
    # See how I like the *ix-style functions?
    implementation details skipped here
    return Tuple(ans)
end

function is_prime(int)
    # return boolean; details skipped here
end


function append_ltp(digits)
    k = 0
    for d = 1:9
        for ind = index_ltp[digits-1]:(index_ltp[digits]-1)
            new_num = parse(Int64, string(d) * string(left_trun_primes[ind]))
            if is_prime(new_num)
                push!(left_trun_primes, new_num)
                k += 1
            end
        end
    end
    push!(index_ltp, lastelement(index_ltp) + k + 1)
end


function append_primes(min,max)
    for num = min:max
        if is_prime(num)
            push!(primes, num)
        end
    end
end

append_ltp(2)
append_primes(10,sqrt(999))
append_ltp(3)
println(left_trun_primes[1:20])

my @ltp = ();
my @recent_ltp = (2,3,5,7);
my @new_ltp = ();

my @prime = (2,3,5,7);

sub is_prime {
    # trivial
    # implementation details skipped here
}



sub append_primes {
    # How much different is it compared to the append_primes(min,max) above?
    my $max = $_[0];
    HERE: for my $can ($prime[-1]+1..$max) {
        for my $p (@prime) {
            next HERE if $can % $p == 0;
            last if $p > sqrt($can);
        }
        push @prime, $can;
    }
}



sub append_ltp {
    my $target_size = $_[0];
    if ($target_size <= (scalar @ltp + scalar @recent_ltp)) {
        push @ltp, @recent_ltp;
        return;
    }
    for my $d (1..9) {
        for my $num (@recent_ltp) {
            my $new_num = $d . $num;
            push @new_ltp, $new_num if is_prime($new_num);
        }
    }
    push @ltp, @recent_ltp;
    @recent_ltp = @new_ltp;
    @new_ltp = ();
    append_ltp($target_size);   # Recursion!
}

Smalltalk at: #Primes put: nil.

Ltp := OrderedCollection new.

RecentLtp := OrderedCollection with: 2 with: 3 with: 5 with: 7.

NewLtp := OrderedCollection new.

my_Primes := OrderedCollection with: 2 with: 3 with: 5 with: 7.

Smalltalk at: #Primes put: my_Primes.

Number extend [
    inc [
        ^(self+1)
    ]
    dec [
        ^(self-1)
    ]
    sqrt [  "behavior of sqrt is strange in GNU Smalltalk, so I overrided it;"
    "a better name should be something like sqrt_int"
        |smallNum|
        smallNum := 1.
        [smallNum squared > self] whileFalse: [smallNum := smallNum inc].
        ^(smallNum dec)
    ]
    isPrime [
        |b i|
        i := 1.
        [ (b := self \\ (Primes at: i) ~= 0) & (((Primes at: i) > self sqrt) not) ] whileTrue: [i := i inc].
         ^b
    ]
]



p := 10.

[p < 1000] whileTrue: [
    (p isPrime) ifTrue: [my_Primes add: p. Smalltalk at: #Primes put: my_Primes.].
    p := p inc
].



[Ltp size + RecentLtp size >= 20] whileFalse: [
    1 to: 9 do: [ :D |
        RecentLtp do: [ :Num |
            |NewNum|
            NewNum := ((D asString, Num asString) asInteger).
            (NewNum isPrime) ifTrue: [NewLtp add: NewNum]
        ].
    ].
    Ltp addAll: RecentLtp.
    RecentLtp := NewLtp.
    NewLtp := OrderedCollection new.
].

Ltp addAll: RecentLtp.

(Ltp copyFrom: 1 to: 20) printNl.

ObjectMemory quit.

import java.util.*;

public class LeftTruncatablePrime
{
    public static List<Integer> Primes;
    public static List<Integer> LTPrimes;
    public static List<Integer> recentLTPrimes;
    public static List<Integer> newLTPrimes;

    public static void main(String... args)
    {
        Integer[] singleDigitPrimes = {2, 3, 5, 7};
        Primes = new ArrayList<Integer>();
        Collections.addAll(Primes, singleDigitPrimes);

        LTPrimes = new ArrayList<Integer>();
        recentLTPrimes = new ArrayList<Integer>();
        Collections.addAll(recentLTPrimes, singleDigitPrimes);
        newLTPrimes = new ArrayList<Integer>();
        appendPrimes(1000);
        appendLTPrimes(20);

        for (int i = 0; i < 20; i++)
            System.out.println(LTPrimes.get(i));
    }

    public static boolean isPrime(Integer x)
    {
        Integer p = 0;
        for (int i = 0; p <= Math.sqrt(x) ; i++ )
        {
            p = Primes.get(i);
            if (x % p == 0)
                return false;
        }
        return true;
    }

    public static void appendPrimes(Integer max)
    {
        Integer i = Primes.get(Primes.size()-1)+1;
        while (Primes.get(Primes.size()-1) < max)
        {
            if (isPrime(i))
                Primes.add(i);
            i++;
        }
    }


    public static void appendLTPrimes(Integer targetSize)
    {
        if (targetSize <= LTPrimes.size() + recentLTPrimes.size())
        {
            LTPrimes.addAll(recentLTPrimes);
            return;
        }
        for (int d = 1; d <= 9; d++) {
            for (Integer num : recentLTPrimes)
            {
                int newNum = Integer.parseInt(d + "" + num);
                if (isPrime(newNum)) {
                    newLTPrimes.add(newNum);
                }
            }
        }
        LTPrimes.addAll(recentLTPrimes);
        recentLTPrimes = (List)((ArrayList)newLTPrimes).clone();
        //the toughest part for someone who has been used to dynamically typed languages
        //(through "type" and "object class" are different concepts) 
        // The code can be simplified as: ...  = (ArrayList)newLTPrimes.clone();  
        //if the lists are declared as _ArrayList_ instead of _List_ in the beginning

        newLTPrimes.clear();
        appendLTPrimes(targetSize);
    }
}

void append_ltp(int target_size) {
    if (target_size <= ltp.size() + recent_ltp.size() ) {
        ltp.insert( ltp.end(), recent_ltp.begin(), recent_ltp.end() );
        return;
    }
    for (int d = 1; d <= 9; d++) {
        for (int r = 0; r < recent_ltp.size(); r++ ) {
            char str[20];
            int num = recent_ltp.at(r);
            sprintf(str, "%d%d", d, num);
            int new_num = atoi(str);
            if (is_prime(new_num))
                new_ltp.push_back(new_num);
        }
    }
    ltp.insert( ltp.end(), recent_ltp.begin(), recent_ltp.end() );
    recent_ltp = new_ltp;
    new_ltp = {};
    append_ltp(target_size);
}

target_size=20
prime=(2 3 5 7)

i=4
for ((n=10; n<1000; n=$n+1));
do
    loop=1
    for ((k=2;k<=n/3; k=$k+1));
    do
        if [[ $n%$k -eq 0 ]];
        then
            loop=0
            break
        fi
    done
    if [[ $loop -eq 1 ]];
    then
        prime[$((i))]=$n
        i=$i+1
    fi
done

i=0
n=0
while [ $((prime[$n])) -le 900 ]  # 997 or above will return error
                        #  ^^^   a bit cheating here
do
    loop=0
    k=0
    for ((k=0; $((prime[$k]))<=996; k=$k+1));
    do
        if [[ $((prime[$n]))%10 -eq $((prime[$k])) ]];
        then
            loop=$loop+1
        fi
        if [[ $((prime[$n]))%100 -eq $((prime[$k])) ]];
        then
            loop=$loop+1
        fi
    done
    if [[ $loop -eq 2 ]];
    then
        echo $((prime[$n]))
        i=$i+1
    fi
    n=$n+1
    if [[ $i -gt $target_size ]]
    then
        exit
    fi
done