Minimum primes

Task

Given three lists:

Numbers1 = [5,45,23,21,67]
Numbers2 = [43,22,78,46,38]
Numbers3 = [9,98,12,54,53]

then:

Select the maximum (max) of Numbers[n], Numbers2[n] and Numbers3[n], where n <= 5 (one based).
For each value of max, find the least prime, minPrime, such that minPrime >= max
Add minPrime to a new list (Primes)
Show Primes on this page.

ALGOL 68

Translation of: Wren

Can handle the possibility of the maximum elements being negative, 0, 1 or 2.

Library: ALGOL 68-primes

<lang algol68>BEGIN # show the minimum prime >= the maximum elements of three lists #

   PR read "primes.incl.a68" PR
   []INT numbers1 = (  5, 45, 23, 21, 67 );
   []INT numbers2 = ( 43, 22, 78, 46, 38 );
   []INT numbers3 = (  9, 98, 12, 54, 53 );
   [ 1 : UPB numbers1 ]INT prime list;
   INT max element := numbers1[ 1 ];
   FOR i TO UPB numbers1 DO
       INT m := numbers1[ i ];
       IF numbers2[ i ] > m THEN m := numbers2[ i ] FI;
       IF numbers3[ i ] > m THEN m := numbers3[ i ] FI;
       IF m > max element THEN max element := m FI;
       prime list[ i ] := m
   OD;
   # construct a sieve of primes big enough for the maximum element #
   []BOOL prime = PRIMESIEVE ( max element * 2 );
   # replace the elements of prime list wih the smallest prime >= the element #
   FOR i TO UPB prime list DO
       INT m := prime list[ i ];
       # find the next prime >= m #
       IF   m <= 2 THEN m := 2 
       ELSE
           IF NOT ODD m THEN m +:= 1 FI;
           WHILE NOT prime[ m ] DO m +:= 2 OD
       FI;
       prime list[ i ] := m
   OD;
   print( ( "[" ) );
   FOR i TO UPB prime list DO print( ( " ", whole( prime list[ i ], 0 ) ) ) OD;
   print( ( " ]" ) )

END</lang>

Output:

[ 43 101 79 59 67 ]

AWK

syntax: GAWK -f MINIMUM_PRIMES.AWK

BEGIN {

   n1 = split("5,45,23,21,67",numbers1,",")
   n2 = split("43,22,78,46,38",numbers2,",")
   n3 = split("9,98,12,54,53",numbers3,",")
   if (n1 != n2 || n1 != n3) {
     print("error: arrays must be same length")
     exit(1)
   }
   for (i=1; i<=n1; i++) {
     m = max(max(numbers1[i],numbers2[i]),numbers3[i])
     if (m % 2 == 0) { m++ }
     while (!is_prime(m)) { m += 2 }
     primes[i] = m
     printf("%d ",primes[i])
   }
   printf("\n")
   exit(0)

} function is_prime(x, i) {

   if (x <= 1) {
     return(0)
   }
   for (i=2; i<=int(sqrt(x)); i++) {
     if (x % i == 0) {
       return(0)
     }
   }
   return(1)

} function max(x,y) { return((x > y) ? x : y) } </lang>

Output:

43 101 79 59 67

C

Translation of: Wren

<lang c>#include <stdio.h>

define TRUE 1
define FALSE 0

int isPrime(int n) {

   int d;
   if (n < 2) return FALSE;
   if (n%2 == 0) return n == 2;
   if (n%3 == 0) return n == 3;
   d = 5;
   while (d*d <= n) {
       if (!(n%d)) return FALSE;
       d += 2;
       if (!(n%d)) return FALSE;
       d += 4;
   }
   return TRUE;

}

int max(int a, int b) {

   if (a > b) return a;
   return b;

}

int main() {

   int n, m;
   int numbers1[5] = { 5, 45, 23, 21, 67};
   int numbers2[5] = {43, 22, 78, 46, 38};
   int numbers3[5] = { 9, 98, 12, 54, 53};
   int primes[5]   = {};
   for (n = 0; n < 5; ++n) {
       m = max(max(numbers1[n], numbers2[n]), numbers3[n]);
       if (!(m % 2)) m++;
       while (!isPrime(m)) m += 2;
       primes[n] = m;
       printf("%d ", primes[n]);
   }
   printf("\n");
   return 0;

}</lang>

Output:

43 101 79 59 67

This task uses Extensible Prime Generator (F#) <lang fsharp> // Minimum primes. Nigel Galloway: October 29th., 2021 let N1,N2,N3=[5;45;23;21;67],[43;22;78;46;38],[9;98;12;54;53] let fN g=primes32()|>Seq.find((<=)g) printfn "%A" (List.zip3 N1 N2 N3|>List.map(fun(n,g,l)->fN(max (max n g) l))) </lang>

Output:

[43; 101; 79; 59; 67]

Factor

<lang factor>USING: math math.order math.primes prettyprint sequences ;

{ 5 45 23 21 67 } { 43 22 78 46 38 } { 9 98 12 54 53 } [ max max 1 - next-prime ] 3map .</lang>

Output:

{ 43 101 79 59 67 }

Go

Translation of: Wren

Library: Go-rcu

<lang go>package main

import (

   "fmt"
   "rcu"

)

func main() {

   numbers1 := [5]int{5, 45, 23, 21, 67}
   numbers2 := [5]int{43, 22, 78, 46, 38}
   numbers3 := [5]int{9, 98, 12, 54, 53}
   primes := [5]int{}
   for n := 0; n < 5; n++ {
       max := rcu.Max(rcu.Max(numbers1[n], numbers2[n]), numbers3[n])
       if max % 2 == 0 {
           max++
       }
       for !rcu.IsPrime(max) {
           max += 2
       }
       primes[n] = max
   }
   fmt.Println(primes)

}</lang>

Output:

[43 101 79 59 67]

jq

Works with: jq

Works with gojq, the Go implementation of jq

This entry uses `is_prime` as defined, for example, at Erdős-primes#jq.

Two solutions are presented following these preliminaries: <lang jq> include "is_prime"; # reminder

def Numbers1: [5,45,23,21,67]; def Numbers2: [43,22,78,46,38]; def Numbers3: [9,98,12,54,53];

Generate primes in range(m;n) provided m>=2

def primes(m; n):

 if m%2 == 0 then primes(m+1;n)
 else range(m; n; 2) | select(is_prime)
 end;</lang>

Explicit Iteration <lang jq>[range(0;5)

| [Numbers1[.], Numbers2[.], Numbers3[.]] | max
| first(primes(.; infinite))]</lang>

Functional <lang jq>[Numbers1, Numbers2, Numbers3]

| transpose
| [map(max | first(primes(.; infinite)))] </lang>

Output:

[43,101,79,59,67]

Julia

<lang julia>using Primes

println(nextprime.(maximum(hcat([5,45,23,21,67], [43,22,78,46,38], [9,98,12,54,53]), dims=2)))

</lang>

Output:

[43; 101; 79; 59; 67;;]

Nim

<lang Nim>const

 Numbers1 = [ 5, 45, 23, 21, 67]
 Numbers2 = [43, 22, 78, 46, 38]
 Numbers3 = [ 9, 98, 12, 54, 53]

var numbers: array[0..Numbers1.high, int]

template isEven(n: int): bool = (n and 1) == 0

func isPrime(n: Positive): bool =

 if n < 2: return false
 if n.isEven: return n == 2
 if n mod 3 == 0: return n == 3
 var k = 5
 var delta = 2
 while k * k <= n:
   if n mod k == 0: return false
   inc k, delta
   delta = 6 - delta
 result = true

func minPrime(n: int): int =

 if n == 2: return 2
 result = if n.isEven: n + 1 else: n
 while not result.isPrime():
   inc result, 2

for i in 0..numbers.high:

 let m = max(max(Numbers1[i], Numbers2[i]), Numbers3[i])
 numbers[i] = minPrime(m)

echo numbers</lang>

Output:

[43, 101, 79, 59, 67]

Perl

Library: ntheory

<lang perl>#!/usr/bin/perl

use strict; # https://rosettacode.org/wiki/Minimum_primes use warnings; use ntheory qw( next_prime ); use List::Util qw( max );

my @Numbers1 = (5,45,23,21,67); my @Numbers2 = (43,22,78,46,38); my @Numbers3 = (9,98,12,54,53);

my @Primes = map {

 next_prime( max( $Numbers1[$_], $Numbers2[$_], $Numbers3[$_] ) - 1 )
 } 0 .. 4;

print "@Primes\n";</lang>

Output:

43 101 79 59 67

Phix

with javascript_semantics
function nextprime(sequence s)
    sequence res = repeat(0,length(s[1]))
    for i=1 to length(res) do
        res[i] = get_prime(length(get_primes_le(maxsq(vslice(s,i))-1))+1)
    end for
    return res
end function
printf(1,"%V\n",{nextprime({{ 5, 45, 23, 21, 67},
                            {43, 22, 78, 46, 38},
                            { 9, 98, 12, 54, 53}})})

Output:

{43,101,79,59,67}

Raku

Seems kind of pointless to specify a maximum of 5 terms when there are only 5 elements in each list but... ¯\_(ツ)_/¯

<lang perl6>say ([Zmax] <5 45 23 21 67>, <43 22 78 46 38>, <9 98 12 54 53>)».&next-prime[^5];

sub next-prime { ($^m..*).first: &is-prime }</lang>

Output:

(43 101 79 59 67)

Ring

Solution #1

<lang ring>? "working..."

Num1 = [ 5,45,23,21,67] Num2 = [43,22,78,46,38] Num3 = [ 9,98,12,54,53] n = len(Num1) Nums = list(n)

for i = 1 to n

   Nums[i] = nxtPrime(max([Num1[i], Num2[i], Num3[i]]))

func fmtArray(ar)

   rv = ar[1]
   for n = 2 to len(ar) rv += "," + ar[n] next
   return "[" + rv + "]"

func nxtPrime(x)

   j = 2
   while true
       if x % j = 0 j = 2 x++
       else j++ ok
       if j * j > x exit ok
   end return string(x)</lang>

Output:

working...
The minimum prime numbers of three lists = [43,101,79,59,67]
done...

Solution #2

<lang ring> load "stdlib.ring" see "working..." + nl

Primes = [] Numbers1 = [5,45,23,21,67] Numbers2 = [43,22,78,46,38] Numbers3 = [9,98,12,54,53]

for n = 1 to len(Numbers1)

   Temp = []
   add(Temp,Numbers1[n])
   add(Temp,Numbers2[n])
   add(Temp,Numbers3[n])
   max = max(Temp)
   max--
   while true 
         max++
         if isprime(max) 
            exit
         ok
   end
   add(Primes,max)

func showArray(array)

    txt = ""
    see "["
    for n = 1 to len(array)
        txt = txt + array[n] + ","
    next
    txt = left(txt,len(txt)-1)
    txt = txt + "]"
    see txt

</lang>

Output:

working...
Minimum primes = [43,101,79,59,67]
done...

Ruby

<lang ruby>require "prime" numbers1 = [ 5, 45, 23, 21, 67] numbers2 = [43, 22, 78, 46, 38] numbers3 = [ 9, 98, 12, 54, 53]

p [numbers1, numbers2, numbers3].transpose.map{|ar| (ar.max..).find(&:prime?) }</lang>

Output:

[43, 101, 79, 59, 67]

Wren

Library: Wren-math

<lang ecmascript>import "./math" for Int

var numbers1 = [ 5, 45, 23, 21, 67] var numbers2 = [43, 22, 78, 46, 38] var numbers3 = [ 9, 98, 12, 54, 53] var primes = List.filled(5, 0) for (n in 0..4) {

   var max = numbers1[n].max(numbers2[n]).max(numbers3[n])
   if (max % 2 == 0) max = max + 1
   while(!Int.isPrime(max)) max = max + 2
   primes[n] = max

} System.print(primes)</lang>

Output:

[43, 101, 79, 59, 67]

XPL0

<lang XPL0>func IsPrime(N); \Return 'true' if N is a prime number int N, I; [if N <= 1 then return false; for I:= 2 to sqrt(N) do

   if rem(N/I) = 0 then return false;

return true; ];

int Numbers1, Numbers2, Numbers3, N, Max; [Numbers1:= [5,45,23,21,67];

Numbers2:= [43,22,78,46,38];
Numbers3:= [9,98,12,54,53];
for N:= 0 to 4 do
       [Max:= Numbers1(N);
       if Numbers2(N) > Max then Max:= Numbers2(N);
       if Numbers3(N) > Max then Max:= Numbers3(N);
       while not IsPrime(Max) do Max:= Max+1;
       IntOut(0, Max);  ChOut(0, ^ );
       ];

]</lang>

Output:

43 101 79 59 67