help with prime pairs code

[Jabari Zakiya]

On Sunday, 2 February 2025 at 01:39:34 UTC, user1234 wrote:
> On Sunday, 2 February 2025 at 01:12:59 UTC, user1234 wrote:
>> On Saturday, 1 February 2025 at 21:56:23 UTC, Jabari Zakiya 
>> wrote:
>>> On Saturday, 1 February 2025 at 00:21:22 UTC, user1234 wrote:
>>>> On Friday, 31 January 2025 at 20:05:54 UTC, Jabari Zakiya 
>>>> wrote:
>>>>> [...]
>>>>
>>>> A first draft of the translation, not very idiomatic D code:
>>>>
>>>> ```d
>>>> module prime_pairs;
>>>> import std;
>>>>
>>>> [...]
>>>
>>> Thank you very much!
>>>
>>> As you can see, D is not my primary language, but I respect 
>>> its speed and readability.
>>> I also have a faster Crystal version, almost identical (96%) 
>>> to the Rudy code.
>>
>> yeah Crystal is in my scope. Whyle I'm usualy not into dynamic 
>> typed langs, there's something I like in the Crystal lang.
>
> [Gradual 
> typing](https://en.wikipedia.org/wiki/Gradual_typing#:~:text=Gradual%20typing%20allows%20software%20developers,static%20typing%20to%20be%20used.)
>
> That's the shit I like with Crystal.

Here's the Crystal version of the Ruby code.

```
# Compile: crystal build --release --mcpu native 
prime_pairs_lohi.cr
# Run as: ./prime_pairs_lohi 123_456_780

     def prime_pairs_lohi(n)
       return puts "Input not even n > 2" unless n.even? && n > 2
       return (pp [n, 1]; pp [n//2, n//2]; pp [n//2, n//2]) if n 
<= 6

       # generate the low-half-residues (lhr) r < n/2
       lhr = 3u64.step(to: n//2, by: 2).select { |r| r if r.gcd(n) 
== 1 }.to_a
       ndiv2, rhi = n//2, n-2           # lhr:hhr midpoint, max 
residue limit
       lhr_mults = [] of typeof(n)      # for lhr values not part 
of a pcp

       # store all the powers of the lhr members < n-2
       lhr.each do |r|                  # step thru the lhr members
         r_pwr = r                      # set to first power of r
         break if r > rhi // r_pwr      # exit if r^2 > n-2, as 
all others are too
         while    r < rhi // r_pwr      # while r^e < n-2
           lhr_mults << (r_pwr *= r)    # store its current power 
of r
         end
       end

       # store all the cross-products of the lhr members < n-2
       lhr_dup = lhr.dup                # make copy of the lhr 
members list
       while (r = lhr_dup.shift) && !lhr_dup.empty? # do mults of 
1st list r w/others
         ri_max = rhi // r              # ri can't multiply r with 
values > this
         break if lhr_dup[0] > ri_max   # exit if product of 
consecutive r’s > n-2
         lhr_dup.each do |ri|           # for each residue in 
reduced list
           break if ri > ri_max         # exit for r if 
cross-product with ri > n-2
           lhr_mults << r * ri          # store value if < n-2
         end                            # check cross-products of 
next lhr member
       end

       # remove from lhr its lhr_mults, convert vals > n/2 to lhr 
complements first
       lhr -= lhr_mults.map { |r_del| r_del > ndiv2 ? n - r_del : 
r_del }

       pp [n, lhr.size]                 # show n and pcp prime 
pairs count
       pp [lhr.first, n-lhr.first]      # show first pcp prime 
pair of n
       pp [lhr.last,  n-lhr.last]       # show last  pcp prime 
pair of n
     end

def tm; t = Time.monotonic; yield; Time.monotonic - t end  # time 
code execution

     def gen_pcp
       n = (ARGV[0].to_u64 underscore: true) # get n input from 
terminal
       puts tm { prime_pairs_lohi(n) }       # show execution 
runtime as last output
     end

gen_pcp
```

Add this to the D code to take terminal input and to time 
execution.
I don't know if this is most idiomatic, but it works.


     import std.datetime.stopwatch : StopWatch;
     void main() {
       int n;
       readf("%s", &n);
       auto stopWatchExecution = StopWatch();
       stopWatchExecution.start();
       prime_pairs_lohi(n);
       stopWatchExecution.stop();
       writeln(stopWatchExecution.peek());
     }


The D version is way slower, because of the array operations.
For an input of 1000000 (1M): D: 12+ secs; Crystal: 0.036 secs.

In Ruby|Crystal you can just do: lhr -= lhr_mult
to remove elements of one array from another, and not one at a 
time.
I assume there's a D equivalent?!?

As n increases so do those arrays, and the times become much 
longer.