View source for Sort primes from list to a list

{{Draft task}}

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

=={{header|ALGOL 68}}==
{{libheader|ALGOL 68-primes}}
{{libheader|ALGOL 68-rows}}
<syntaxhighlight lang="algol68">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</syntaxhighlight>
{{out}}
<pre>
Prime elements of:  2 43 81 122 63 13 7 95 103
              are:  2 7 13 43 103
</pre>

=={{header|AppleScript}}==
The strangely worded title and task description suggest to this native English speaker that the task is to sort each prime into the primes list ''as it's identified'', which is certainly a less pointless coding exercise than simply extracting all the primes and then sorting them. The implementation here allows for the primes list to be created from scratch or supplied with a few ordered numbers already in it. The sort process is part of an insertion sort.

<syntaxhighlight lang="applescript">on isPrime(n)
    if (n < 4) then return (n > 1)
    if ((n mod 2 is 0) or (n mod 3 is 0)) then return false
    repeat with i from 5 to (n ^ 0.5) div 1 by 6
        if ((n mod i is 0) or (n mod (i + 2) is 0)) then return false
    end repeat
    
    return true
end isPrime

-- primes list created from scratch.
on sortPrimesFromList:givenList
    return my sortPrimesFromList:givenList toList:{}
end sortPrimesFromList:

-- primes list supplied as a parameter, its current contents assumed to be already ordered ascending.
on sortPrimesFromList:givenList toList:primes
    set j to (count primes)
    repeat with this in givenList
        set this to this's contents
        if (isPrime(this)) then
            set end of primes to this
            set j to j + 1
            if (j > 1) then
                repeat with i from (j - 1) to 1 by -1
                    set v to primes's item i
                    if (v > this) then
                        set primes's item (i + 1) to v
                    else
                        set i to i + 1
                        exit repeat
                    end if
                end repeat
                set primes's item i to this
            end if
        end if
    end repeat
    
    return primes
end sortPrimesFromList:toList:

on demo()
    set primes to my sortPrimesFromList:{2, 43, 81, 22, 63, 13, 7, 95, 103}
    log primes
    my sortPrimesFromList:{8, 137, 19, 5, 44, 23} toList:primes
    log primes
end demo

demo()</syntaxhighlight>

{{output}}
<pre>Log:
(*2, 7, 13, 43, 103*)
(*2, 5, 7, 13, 19, 23, 43, 103, 137*)</pre>

=={{header|Arturo}}==

<syntaxhighlight lang="arturo">lst: [2 43 81 122 63 13 7 95 103]

print sort select lst => prime?</syntaxhighlight>

{{out}}

<pre>2 7 13 43 103</pre>

=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">Primes := [2,43,81,122,63,13,7,95,103]

t := [], result := []
for i, n in Primes
	if isPrime(n)
		t[n, i] := true
	
for n, obj in t
    for i, v in obj
        result.push(n)
	
isPrime(n){
	Loop, % floor(sqrt(n))
		v := A_Index = 1 ? n : mod(n,A_Index) ? v : v "," A_Index "," n//A_Index
	Return (v = n)
}</syntaxhighlight>
{{out}}
<pre>[2, 7, 13, 43, 103]</pre>

=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f SORT_PRIMES_FROM_LIST_TO_A_LIST.AWK
BEGIN {
    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)
}
</syntaxhighlight>
{{out}}
<pre>
2 7 13 43 103
</pre>


=={{header|BASIC}}==
==={{header|BASIC256}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="basic256">arraybase 1
global 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 True
end 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 i
end 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] = 2
Primes[2] = 43
Primes[3] = 81
Primes[4] = 122
Primes[5] = 63
Primes[6] = 13
Primes[7] = 7
Primes[8] = 95
Primes[9] = 103
c = 1

for n = 1 to Primes[?]
	if isprime(Primes[n]) then
		redim temp(c)
		temp[c] = Primes[n]
		c += 1
	end if
next n
call sort(temp)
call showArray(temp)
end</syntaxhighlight>
{{out}}
<pre>
Igual que la entrada de FreeBASIC.
</pre>

==={{header|FreeBASIC}}===
<syntaxhighlight lang="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 True
End 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 i
End 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 txt
End 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 If
Next n 
sort(temp())
showArray(temp())
Sleep</syntaxhighlight>
{{out}}
<pre>[2,7,13,43,103]</pre>

==={{header|Yabasic}}===
<syntaxhighlight lang="yabasic">dim Primes(9)
Primes(1) = 2
Primes(2) = 43
Primes(3) = 81
Primes(4) = 122
Primes(5) = 63
Primes(6) = 13
Primes(7) = 7
Primes(8) = 95
Primes(9) = 103
c = 1

for n = 1 to arraysize(Primes(),1)
	if isPrime(Primes(n)) then
		redim temp(c)
		temp(c) = Primes(n)
		c = c + 1
	end if
next n
sort(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 True
end 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 i
end 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</syntaxhighlight>
{{out}}
<pre>
Igual que la entrada de FreeBASIC.
</pre>

=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
Uses Delphi TList object to hold and sort the data.

<syntaxhighlight lang="Delphi">
{Raw data to process}

var NumList: array [0..8] of integer = (2,43,81,122,63,13,7,95,103);

function Compare(P1,P2: pointer): integer;
{Compare for quick sort}
begin
Result:=Integer(P1)-Integer(P2);
end;

procedure GetSortedPrimes(Nums: Array of integer; var IA: TIntegerDynArray);
{Extract data from array "Nums" and return a sorted list of primes}
var I: integer;
var List: TList;
begin
List:=TList.Create;
try
{Put the primes in the TList object}
for I:=0 to High(Nums) do
 if IsPrime(Nums[I]) then List.Add(Pointer(Nums[I]));
{Sort the list}
List.Sort(Compare);
{Put the result in array}
SetLength(IA,List.Count);
for I:=0 to List.Count-1 do
 IA[I]:=Integer(List[I]);
finally List.Free; end;
end;


function ArrayToStr(Nums: array of integer): string;
{Convert array of integers to a string}
var I: integer;
begin
Result:='[';
for I:=0 to High(Nums) do
	begin
	if I<>0 then Result:=Result+',';
	Result:=Result+IntToStr(Nums[I]);
	end;
Result:=Result+']';
end;


procedure ShowSortedPrimes(Memo: TMemo);
var I: integer;
var IA: TIntegerDynArray;
var S: string;
begin
GetSortedPrimes(NumList,IA);
Memo.Lines.Add('Raw data:      '+ArrayToStr(NumList));
Memo.Lines.Add('Sorted Primes: '+ArrayToStr(IA));
end;


</syntaxhighlight>
{{out}}
<pre>
Raw data:      [2,43,81,122,63,13,7,95,103]
Sorted Primes: [2,7,13,43,103]
Elapsed Time: 2.910 ms.
</pre>


=={{header|F_Sharp|F#}}==
This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_functions Extensible Prime Generator (F#)]
<syntaxhighlight lang="fsharp">
// 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 ""
</syntaxhighlight>
{{out}}
<pre>
2 7 13 43 103 
</pre>

=={{header|Factor}}==
{{works with|Factor|0.99 2021-06-02}}
<syntaxhighlight lang="factor">USING: math.primes prettyprint sequences sorting ;

{ 2 43 81 122 63 13 7 95 103 } [ prime? ] filter natural-sort . </syntaxhighlight>
{{out}}
<pre>
{ 2 7 13 43 103 }
</pre>

=={{header|Go}}==
{{libheader|Go-rcu}}
<syntaxhighlight lang="go">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)
}</syntaxhighlight>

{{out}}
<pre>
[2 7 13 43 103]
</pre>

=={{header|J}}==

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

<syntaxhighlight lang="j">   /:~ (#~ 1&p:)2,43,81,122,63,13,7,95,103
2 7 13 43 103</syntaxhighlight>

=={{header|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.
<syntaxhighlight lang="jq">def lst: [2, 43, 81, 122, 63, 13, 7, 95, 103];

lst | map( select(is_prime) ) | sort</syntaxhighlight>
{{out}}
<pre>
[2,7,13,43,103]
</pre>


=={{header|Julia}}==
<syntaxhighlight lang="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
</syntaxhighlight>

=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">Sort[Select[{2, 43, 81, 122, 63, 13, 7, 95, 103}, PrimeQ]]</syntaxhighlight>
{{out}}
<pre>{2, 7, 13, 43, 103}</pre>

=={{header|Nim}}==
<syntaxhighlight lang="Nim">import std/[algorithm, strutils]

let primes = [2, 43, 81, 122, 63, 13, 7, 95, 103]
echo sorted(primes).join(", ")
</syntaxhighlight>
{{out}}

<pre>2, 7, 13, 43, 63, 81, 95, 103, 122
</pre>

=={{header|Perl}}==
<syntaxhighlight lang="perl">#!/usr/bin/perl

use strict; # https://rosettacode.org/wiki/Sort_primes_from_list_to_a_list
use 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";</syntaxhighlight>
{{out}}
<pre>
2 7 13 43 103
</pre>

=={{header|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.
<!--<syntaxhighlight lang="phix">(phixonline)-->
 <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
 <span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sort</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">filter</span><span style="color: #0000FF;">({</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">43</span><span style="color: #0000FF;">,</span><span style="color: #000000;">81</span><span style="color: #0000FF;">,</span><span style="color: #000000;">122</span><span style="color: #0000FF;">,</span><span style="color: #000000;">63</span><span style="color: #0000FF;">,</span><span style="color: #000000;">13</span><span style="color: #0000FF;">,</span><span style="color: #000000;">7</span><span style="color: #0000FF;">,</span><span style="color: #000000;">95</span><span style="color: #0000FF;">,</span><span style="color: #000000;">103</span><span style="color: #0000FF;">},</span><span style="color: #7060A8;">is_prime</span><span style="color: #0000FF;">)))</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
{2,7,13,43,103}
</pre>

=={{header|Python}}==
===Python: Procedural===
<syntaxhighlight lang="python">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...")</syntaxhighlight>
{{out}}
<pre>working...
Primes are:
[2, 7, 13, 43, 103]
done...</pre>

===Python: Functional===
<syntaxhighlight lang="python">'''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 -> Bool
def 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()</syntaxhighlight>
{{Out}}
<pre>[2, 7, 13, 43, 103]</pre>

=={{header|Quackery}}==

<code>eratosthenes</code> and <code>isprime</code> are defined at [[Sieve of Eratosthenes#Quackery]].

<syntaxhighlight lang="Quackery">  ' [ 2 43 81 122 63 13 7 95 103 ]
  sort 
  dup -1 peek eratosthenes
  [] swap witheach
    [ dup isprime iff join else drop ]
  echo</syntaxhighlight>

{{out}}

<pre>[ 2 7 13 43 103 ]</pre>

=={{header|Raku}}==
<syntaxhighlight lang="raku" line>put <2 43 81 122 63 13 7 95 103>.grep( &is-prime ).sort</syntaxhighlight>
{{out}}
<pre>2 7 13 43 103</pre>
''Of course "ascending" is a little ambiguous. That ^^^ is numerically. This vvv is lexicographically.
<syntaxhighlight lang="raku" line>put <2 43 81 122 63 13 7 95 103>.grep( &is-prime ).sort: ~*</syntaxhighlight>
{{out}}
<pre>103 13 2 43 7</pre>

=={{header|Ring}}==
<syntaxhighlight lang="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])
     ok
next

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
</syntaxhighlight>
{{out}}
<pre>
working
Primes are:
[2,7,13,43,103]
done...
</pre>

=={{header|RPL}}==
{{works with|HP|49}}
 « SORT { }
   1 PICK3 SIZE '''FOR''' j
      OVER j GET
      '''IF''' DUP ISPRIME? '''THEN''' + '''ELSE''' DROP '''END'''
   '''NEXT''' NIP
 » '<span style="color:blue">TASK</span>' STO 

 {2,43,81,122,63,13,7,95,103} <span style="color:blue">TASK</span>
{{out}}
<pre>1: { 2 7 13 43 103 }
</pre>

=={{header|Ruby}}==
<syntaxhighlight lang="ruby">require 'prime'

p [2,43,81,122,63,13,7,95,103].select(&:prime?).sort</syntaxhighlight>
{{out}}
<pre>[2, 7, 13, 43, 103]
</pre>

=={{header|Sidef}}==
<syntaxhighlight lang="ruby">var arr = [2,43,81,122,63,13,7,95,103]
say arr.grep{.is_prime}.sort</syntaxhighlight>
{{out}}
<pre>
[2, 7, 13, 43, 103]
</pre>

=={{header|Wren}}==
{{libheader|Wren-math}}
<syntaxhighlight lang="wren">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())</syntaxhighlight>

{{out}}
<pre>
[2, 7, 13, 43, 103]
</pre>

=={{header|XPL0}}==
<syntaxhighlight lang="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;
]</syntaxhighlight>

{{out}}
<pre>
2 7 13 43 103 
</pre>