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

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.

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)

## ALGOL 68

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

` # syntax: GAWK -f MINIMUM_PRIMES.AWKBEGIN {    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

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 nprint "]"end function max(a, b)	if a > b then return a else return bend 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 Trueend function`

## C

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#

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#

This task uses Extensible Prime Generator (F#)

` // Minimum primes. Nigel Galloway: October 29th., 2021let 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

`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

`#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 TrueEnd 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 nPrint !"\b\b ]"Sleep`
Output:
```[ 43, 101, 79, 59, 67 ]
```

## Go

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

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>=2def 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

`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;;]`

## Mathematica / Wolfram Language

`minPrime[x_List] := If[[email protected]@x, [email protected], [email protected]@x]  MapThread[ [email protected]{##} &, {{5., 45, 23, 21, 67}, {43, 22, 78, 46, 38}, {9, 98,    12, 54, 53}}]`
Output:
```
{43,101,79,59,67}

```

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

## Perl

Library: ntheory
`#!/usr/bin/perl use strict; # https://rosettacode.org/wiki/Minimum_primesuse 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

```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... ¯\_(ツ)_/¯

`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

### Solution #1

`? "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

` 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

`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]
```

## Sidef

`var lists = [    [ 5,45,23,21,67],    [43,22,78,46,38],    [ 9,98,12,54,53],] say lists.zip.map { next_prime(.max - 1) }`
Output:
```[43, 101, 79, 59, 67]
```

## Wren

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

`func IsPrime(N);        \Return 'true' if N is a prime numberint  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
```