I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

Minimum primes

From Rosetta Code
Minimum primes is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.
Task


Given three lists:

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


then:

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



ALGOL 68[edit]

Translation of: Wren

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

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
Output:
[ 43 101 79 59 67 ]

AWK[edit]

 
# 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) }
 
Output:
43 101 79 59 67


BASIC256[edit]

Translation of: FreeBASIC
dim Num1 = { 5,45,23,21,67}
dim Num2 = {43,22,78,46,38}
dim Num3 = { 9,98,12,54,53}
 
print "The minimum prime numbers of three lists"
print "[ ";
for n = 0 to 4
maxi = max(Num1[n], max(Num2[n], Num3[n]))
if maxi mod 2 = 0 then maxi += 1
while not isPrime(maxi)
maxi += 2
end while
print maxi; " ";
next n
print "]"
end
 
function max(a, b)
if a > b then return a else return b
end function
 
function isPrime(v)
if v < 2 then return False
if v mod 2 = 0 then return v = 2
if v mod 3 = 0 then return v = 3
d = 5
while d * d <= v
if v mod d = 0 then return False else d += 2
end while
return True
end function


C[edit]

Translation of: Wren
#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;
}
Output:
43 101 79 59 67 


C#[edit]

Translation of: Ring
...solution #1.
using System;
using System.Linq;
using static System.Console;
 
class Program {
 
static int nxtPrime(int x) {
int j = 2; do {
if (x % j == 0) { j = 2; x++; }
else j += j < 3 ? 1 : 2;
} while (j * j <= x); return x; }
 
static void Main(string[] args) {
WriteLine("working...");
int[] Num1 = new int[]{ 5, 45, 23, 21, 67 },
Num2 = new int[]{ 43, 22, 78, 46, 38 },
Num3 = new int[]{ 9, 98, 12, 54, 53 };
int n = Num1.Length; int[] Nums = new int[n];
for (int i = 0; i < n; i++)
Nums[i] = nxtPrime(new int[]{ Num1[i], Num2[i], Num3[i] }.Max());
WriteLine("The minimum prime numbers of three lists = [{0}]", string.Join(",", Nums));
Write("done..."); } }
Output:

Same as Ring.

F#[edit]

This task uses Extensible Prime Generator (F#)

 
// 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)))
 
Output:
[43; 101; 79; 59; 67]

Factor[edit]

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 .
Output:
{ 43 101 79 59 67 }


FreeBASIC[edit]

#define MAX(a, b) iif((a) > (b), (a), (b))
 
Function isPrime(Byval ValorEval As Integer) As Boolean
If ValorEval < 2 Then Return False
If ValorEval Mod 2 = 0 Then Return ValorEval = 2
If ValorEval Mod 3 = 0 Then Return ValorEval = 3
Dim d As Integer = 5
While d * d <= ValorEval
If ValorEval Mod d = 0 Then Return False Else d += 2
Wend
Return True
End Function
 
Dim As Integer Num1(5) = { 5,45,23,21,67}
Dim As Integer Num2(5) = {43,22,78,46,38}
Dim As Integer Num3(5) = { 9,98,12,54,53}
 
Print "The minimum prime numbers of three lists..."
Print "[";
For n As Integer = 0 To 4
Dim As Integer maxi = MAX(num1(n), MAX(num2(n), num3(n)))
If (maxi Mod 2 = 0) Then maxi += 1
While Not isPrime(maxi)
maxi += 2
Wend
Print maxi; ", ";
Next n
Print !"\b\b ]"
Sleep
Output:
[ 43, 101, 79, 59, 67 ]


Go[edit]

Translation of: Wren
Library: Go-rcu
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)
}
Output:
[43 101 79 59 67]

jq[edit]

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:

 
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;

Explicit Iteration

[range(0;5)
| [Numbers1[.], Numbers2[.], Numbers3[.]] | max
| first(primes(.; infinite))]

Functional

[Numbers1, Numbers2, Numbers3]
| transpose
| [map(max | first(primes(.; infinite)))]
Output:
[43,101,79,59,67]

Julia[edit]

using Primes
 
println(nextprime.(maximum(hcat([5,45,23,21,67], [43,22,78,46,38], [9,98,12,54,53]), dims=2)))
 
Output:
[43; 101; 79; 59; 67;;]


Nim[edit]

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
Output:
[43, 101, 79, 59, 67]

Perl[edit]

Library: ntheory
#!/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";
Output:
43 101 79 59 67

Phix[edit]

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[edit]

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

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 }
Output:
(43 101 79 59 67)

Ring[edit]

Solution #1[edit]

? "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]]))
next
 
? "The minimum prime numbers of three lists = " + fmtArray(Nums)
put "done..."
 
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)
Output:
working...
The minimum prime numbers of three lists = [43,101,79,59,67]
done...

Solution #2[edit]

 
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)
next
 
see "Minimum primes = "
see showArray(Primes)
see nl + "done..." + nl
 
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
 
Output:
working...
Minimum primes = [43,101,79,59,67]
done...

Ruby[edit]

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?) }
Output:
[43, 101, 79, 59, 67]

Wren[edit]

Library: Wren-math
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)
Output:
[43, 101, 79, 59, 67]

XPL0[edit]

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, ^ );
];
]
Output:
43 101 79 59 67