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)

# Sort primes from list to a list

Sort primes from list to a list 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.

Let given list:
Primes = [2,43,81,122,63,13,7,95,103]
Show on this page the ascending ordered list of primes from given list.

## ALGOL 68

Library: ALGOL 68-rows
`BEGIN # extract the elements of a list that are prime and sort them #    PR read "primes.incl.a68" PR    # include prime utilities       #    PR read "rows.incl.a68"   PR    # include row (array) utilities #    # list of numbers required by the task #    []INT list = (  2, 43, 81, 122, 63, 13, 7, 95, 103 );    [ 1 : UPB list ]INT prime list;    # count the nunber of primes in list and assign the primes to prime list #    INT p count := 0;    FOR i TO UPB list DO        IF is probably prime( list[ i ] ) THEN            # have a prime #            prime list[ p count +:= 1 ] := list[ i ]        FI    OD;    print( ( "prime elements of: " ) );    SHOW list;    print( ( newline, "              are: " ) );    SHOW ( QUICKSORT prime list FROMELEMENT 1 TOELEMENT p count )[ 1 : p count ]END`
Output:
```Prime elements of:  2 43 81 122 63 13 7 95 103
are:  2 7 13 43 103
```

## AWK

` # syntax: GAWK -f SORT_PRIMES_FROM_LIST_TO_A_LIST.AWKBEGIN {    PROCINFO["sorted_in"] = "@val_num_asc"    split("2,43,81,122,63,13,7,95,103",arr,",")    for (i in arr) {      if (is_prime(arr[i])) {        printf("%d ",arr[i])      }    }    printf("\n")    exit(0)}function is_prime(n,  d) {    d = 5    if (n < 2) { return(0) }    if (n % 2 == 0) { return(n == 2) }    if (n % 3 == 0) { return(n == 3) }    while (d*d <= n) {      if (n % d == 0) { return(0) }      d += 2      if (n % d == 0) { return(0) }      d += 4    }    return(1)} `
Output:
```2 7 13 43 103
```

## BASIC

### BASIC256

Translation of: FreeBASIC
`arraybase 1global temp 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 subroutine sort(array)	for i = 1 to array[?]		for j = i + 1 to array[?]			if temp[i] > temp[j] then				t = temp[i] : temp[i] = temp[j] : temp[j] = t			end if		next j	next iend subroutine subroutine showArray(array)	txt\$ = ""	print "[";	for n = 1 to array[?]		txt\$ &= string(array[n]) & ","	next n	txt\$ = left(txt\$,length(txt\$)-1)	txt\$ &= "]"	print txt\$end subroutine dim Primes(9)Primes[1] = 2Primes[2] = 43Primes[3] = 81Primes[4] = 122Primes[5] = 63Primes[6] = 13Primes[7] = 7Primes[8] = 95Primes[9] = 103c = 1 for n = 1 to Primes[?]	if isprime(Primes[n]) then		redim temp(c)		temp[c] = Primes[n]		c += 1	end ifnext ncall sort(temp)call showArray(temp)end`
Output:
```Igual que la entrada de FreeBASIC.
```

### FreeBASIC

`Dim Shared As Integer temp() Function isPrime(Byval ValorEval As Integer) As Boolean    If ValorEval <= 1 Then Return False    For i As Integer = 2 To Int(Sqr(ValorEval))        If ValorEval Mod i = 0 Then Return False    Next i    Return TrueEnd Function Sub sort(array() As Integer)    For i As Integer = Lbound(array) To Ubound(array)        For j As Integer = i + 1 To Ubound(array)            If temp(i) > temp(j) Then Swap temp(i), temp(j)        Next j    Next iEnd Sub Sub showArray(array() As Integer)    Dim As String txt = ""    Print "[";    For n As Integer = Lbound(array) To Ubound(array)        txt &= Str(array(n)) & ","    Next n    txt = Left(txt,Len(txt)-1)    txt &= "]"    Print txtEnd Sub Dim As Integer Primes(1 To 9) = {2,43,81,122,63,13,7,95,103}Dim As Integer c = 0 For n As Integer = Lbound(Primes) To Ubound(Primes)    If isprime(Primes(n)) Then        Redim Preserve temp(c)        temp(c) = Primes(n)        c += 1    End IfNext n sort(temp())showArray(temp())Sleep`
Output:
`[2,7,13,43,103]`

### Yabasic

`dim Primes(9)Primes(1) = 2Primes(2) = 43Primes(3) = 81Primes(4) = 122Primes(5) = 63Primes(6) = 13Primes(7) = 7Primes(8) = 95Primes(9) = 103c = 1 for n = 1 to arraysize(Primes(),1)	if isPrime(Primes(n)) then		redim temp(c)		temp(c) = Primes(n)		c = c + 1	end ifnext nsort(temp)showArray(temp)end sub isPrime(v)    if v < 2 then return False : fi    if mod(v, 2) = 0 then return v = 2 : fi    if mod(v, 3) = 0 then return v = 3 : fi    d = 5    while d * d <= v        if mod(v, d) = 0 then return False else d = d + 2 : fi    wend    return Trueend sub sub sort(array)	for i = 1 to arraysize(temp(),1)		for j = i + 1 to arraysize(temp(),1)			if temp(i) > temp(j) then				t = temp(i) : temp(i) = temp(j) : temp(j) = t			end if		next j	next iend sub sub showArray(array)	local txt\$ //= ""	print "[";	for n = 1 to arraysize(temp(),1)		txt\$ = txt\$ + str\$(temp(n)) + ","	next n	txt\$ = left\$(txt\$,len(txt\$)-1)	txt\$ = txt\$ + "]"	print txt\$end sub`
Output:
```Igual que la entrada de FreeBASIC.
```

## F#

This task uses Extensible Prime Generator (F#)

` // Primes from a list. Nigel Galloway: Januuary 23rd., 2022[2;43;81;122;63;13;7;95;103]|>List.filter isPrime|>List.sort|>List.iter(printf "%d "); printfn "" `
Output:
```2 7 13 43 103
```

## Factor

Works with: Factor version 0.99 2021-06-02
`USING: math.primes prettyprint sequences sorting ; { 2 43 81 122 63 13 7 95 103 } [ prime? ] filter natural-sort . `
Output:
```{ 2 7 13 43 103 }
```

## Go

Library: Go-rcu
`package main import (    "fmt"    "rcu"    "sort") func main() {    list := []int{2, 43, 81, 122, 63, 13, 7, 95, 103}    var primes []int    for _, e := range list {        if rcu.IsPrime(e) {            primes = append(primes, e)        }    }    sort.Ints(primes)    fmt.Println(primes)}`
Output:
```[2 7 13 43 103]
```

## J

This is a filter (on primality) and a sort (though we could first sort then filter if we preferred):

`   /:~ (#~ 1&p:)2,43,81,122,63,13,7,95,1032 7 13 43 103`

## jq

Works with: jq

Works with gojq, the Go implementation of jq

See Erdős-primes#jq for a suitable definition of `is_prime` as used here.

`def lst: [2, 43, 81, 122, 63, 13, 7, 95, 103]; lst | map( select(is_prime) ) | sort`
Output:
```[2,7,13,43,103]
```

## Julia

`julia> using Primes julia> sort(filter(isprime, [2,43,81,122,63,13,7,95,103]))5-element Vector{Int64}:   2   7  13  43 103 `

## Perl

`#!/usr/bin/perl use strict; # https://rosettacode.org/wiki/Sort_primes_from_list_to_a_listuse warnings;use ntheory qw( is_prime );use List::AllUtils qw( nsort_by ); print "@{[ nsort_by {\$_} grep is_prime(\$_), 2,43,81,122,63,13,7,95,103 ]}\n";`
Output:
```2 7 13 43 103
```

## Phix

You could also use unique() instead of sort(), since that (by default) performs a sort() internally anyway. It wouldn't be any slower, might even be better, also it does not really make much difference here whether you filter() before or after the sort(), though of course some more expensive filtering operations might be faster given fewer items.

```with javascript_semantics
pp(sort(filter({2,43,81,122,63,13,7,95,103},is_prime)))
```
Output:
```{2,7,13,43,103}
```

## Python

### Python: Procedural

`print("working...")print("Primes are:") def isprime(m):    for i in range(2,int(m**0.5)+1):        if m%i==0:            return False    return True Primes = [2,43,81,122,63,13,7,95,103]Temp = [] for n in range(len(Primes)):	if isprime(Primes[n]):		Temp.append(Primes[n]) Temp.sort()print(Temp)print("done...")`
Output:
```working...
Primes are:
[2, 7, 13, 43, 103]
done...```

### Python: Functional

`'''Prime elements in rising order'''  # primeElementsSorted :: [Int] -> [Int]def primeElementsSorted(xs):    '''The prime elements of xs in rising order'''    return sorted(x for x in xs if isPrime(x))  # ------------------------- TEST -------------------------# main :: IO ()def main():    '''Filtered elements of given list in rising order'''     print(        primeElementsSorted([            2, 43, 81, 122, 63, 13, 7, 95, 103        ])    )  # ----------------------- GENERIC ------------------------ # isPrime :: Int -> Booldef isPrime(n):    '''True if n is prime.'''    if n in (2, 3):        return True    if 2 > n or 0 == n % 2:        return False    if 9 > n:        return True    if 0 == n % 3:        return False     def p(x):        return 0 == n % x or 0 == n % (2 + x)     return not any(map(p, range(5, 1 + int(n ** 0.5), 6)))  # MAIN ---if __name__ == '__main__':    main()`
Output:
`[2, 7, 13, 43, 103]`

## Raku

`put <2 43 81 122 63 13 7 95 103>.grep( &is-prime ).sort`
Output:
`2 7 13 43 103`

Of course "ascending" is a little ambiguous. That ^^^ is numerically. This vvv is lexicographically.

`put <2 43 81 122 63 13 7 95 103>.grep( &is-prime ).sort: ~*`
Output:
`103 13 2 43 7`

## Ring

` load "stdlibcore.ring"? "working" Primes = [2,43,81,122,63,13,7,95,103]Temp = [] for n = 1 to len(Primes)     if isprime(Primes[n])        add(Temp,Primes[n])     oknext Temp = sort(Temp)showarray(Temp)? "done..." func showArray(array)     txt = ""     see "["     for n = 1 to len(array)         txt = txt + array[n] + ","     next     txt = left(txt,len(txt)-1)     txt = txt + "]"     ? txt `
Output:
```working
Primes are:
[2,7,13,43,103]
done...
```

## Wren

Library: Wren-math
`import "./math" for Int var lst = [2, 43, 81, 122, 63, 13, 7, 95, 103]System.print(lst.where { |e| Int.isPrime(e) }.toList.sort())`
Output:
```[2, 7, 13, 43, 103]
```

## XPL0

`include xpllib;int Primes, Smallest, I, SI;def Len=9, Inf=1000;[Primes:= [2,43,81,122,63,13,7,95,103];repeat  Smallest:= Inf;        for I:= 0 to Len-1 do            if Primes(I) < Smallest then                [Smallest:= Primes(I);  SI:= I];        Primes(SI):= Inf;       \cross off        if IsPrime(Smallest) then            [IntOut(0, Smallest);  ChOut(0, ^ )];until   Smallest = Inf;]`
Output:
```2 7 13 43 103
```