Sort primes from list to a list: Difference between revisions
No edit summary |
(Added Easylang) |
||
(27 intermediate revisions by 20 users not shown) | |||
Line 12: | Line 12: | ||
{{libheader|ALGOL 68-primes}} |
{{libheader|ALGOL 68-primes}} |
||
{{libheader|ALGOL 68-rows}} |
{{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 "primes.incl.a68" PR # include prime utilities # |
||
PR read "rows.incl.a68" PR # include row (array) utilities # |
PR read "rows.incl.a68" PR # include row (array) utilities # |
||
Line 30: | Line 30: | ||
print( ( newline, " are: " ) ); |
print( ( newline, " are: " ) ); |
||
SHOW ( QUICKSORT prime list FROMELEMENT 1 TOELEMENT p count )[ 1 : p count ] |
SHOW ( QUICKSORT prime list FROMELEMENT 1 TOELEMENT p count )[ 1 : p count ] |
||
END</ |
END</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Prime elements of: 2 43 81 122 63 13 7 95 103 |
Prime elements of: 2 43 81 122 63 13 7 95 103 |
||
are: 2 7 13 43 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|EasyLang}}== |
|||
<syntaxhighlight> |
|||
fastfunc isprim num . |
|||
i = 2 |
|||
while i <= sqrt num |
|||
if num mod i = 0 |
|||
return 0 |
|||
. |
|||
i += 1 |
|||
. |
|||
return 1 |
|||
. |
|||
proc sort . d[] . |
|||
for i = 1 to len d[] - 1 |
|||
for j = i + 1 to len d[] |
|||
if d[j] < d[i] |
|||
swap d[j] d[i] |
|||
. |
|||
. |
|||
. |
|||
. |
|||
inp[] = [ 2 43 81 122 63 13 7 95 103 ] |
|||
for v in inp[] |
|||
if isprim v = 1 |
|||
d[] &= v |
|||
. |
|||
. |
|||
sort d[] |
|||
print d[] |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
[ 2 7 13 43 103 ] |
|||
</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> |
</pre> |
||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
< |
<syntaxhighlight lang="perl">#!/usr/bin/perl |
||
use strict; # https://rosettacode.org/wiki/Sort_primes_from_list_to_a_list |
use strict; # https://rosettacode.org/wiki/Sort_primes_from_list_to_a_list |
||
Line 45: | Line 540: | ||
use List::AllUtils qw( nsort_by ); |
use List::AllUtils qw( nsort_by ); |
||
print "@{[ nsort_by {$_} grep is_prime($_), 2,43,81,122,63,13,7,95,103 ]}\n";</ |
print "@{[ nsort_by {$_} grep is_prime($_), 2,43,81,122,63,13,7,95,103 ]}\n";</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 53: | Line 548: | ||
=={{header|Phix}}== |
=={{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. |
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: #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> |
<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}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 63: | Line 558: | ||
=={{header|Python}}== |
=={{header|Python}}== |
||
===Python: Procedural=== |
|||
<lang python> |
|||
print("working...") |
<syntaxhighlight lang="python">print("working...") |
||
print("Primes are:") |
print("Primes are:") |
||
Line 82: | Line 577: | ||
Temp.sort() |
Temp.sort() |
||
print(Temp) |
print(Temp) |
||
print("done...") |
print("done...")</syntaxhighlight> |
||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre>working... |
||
working... |
|||
Primes are: |
Primes are: |
||
[2, 7, 13, 43, 103] |
[2, 7, 13, 43, 103] |
||
done... |
done...</pre> |
||
</pre> |
|||
===Python: Functional=== |
|||
<syntaxhighlight lang="python">'''Prime elements in rising order''' |
|||
=={{header|Raku}}== |
|||
# primeElementsSorted :: [Int] -> [Int] |
|||
<lang perl6>put <2 43 81 122 63 13 7 95 103>.grep( &is-prime ).sort</lang> |
|||
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}} |
{{out}} |
||
<pre>2 7 13 43 103</pre> |
<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}}== |
=={{header|Ring}}== |
||
< |
<syntaxhighlight lang="ring"> |
||
load "stdlibcore.ring" |
load "stdlibcore.ring" |
||
? "working" |
? "working" |
||
Line 126: | Line 683: | ||
txt = txt + "]" |
txt = txt + "]" |
||
? txt |
? txt |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 133: | Line 690: | ||
[2,7,13,43,103] |
[2,7,13,43,103] |
||
done... |
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> |
</pre> |
||
=={{header|Wren}}== |
=={{header|Wren}}== |
||
{{libheader|Wren-math}} |
{{libheader|Wren-math}} |
||
< |
<syntaxhighlight lang="wren">import "./math" for Int |
||
var lst = [2, 43, 81, 122, 63, 13, 7, 95, 103] |
var lst = [2, 43, 81, 122, 63, 13, 7, 95, 103] |
||
System.print(lst.where { |e| Int.isPrime(e) }.toList.sort())</ |
System.print(lst.where { |e| Int.isPrime(e) }.toList.sort())</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 148: | Line 735: | ||
=={{header|XPL0}}== |
=={{header|XPL0}}== |
||
< |
<syntaxhighlight lang="xpl0">include xpllib; |
||
int Primes, Smallest, I, SI; |
int Primes, Smallest, I, SI; |
||
def Len=9, Inf=1000; |
def Len=9, Inf=1000; |
||
Line 160: | Line 747: | ||
[IntOut(0, Smallest); ChOut(0, ^ )]; |
[IntOut(0, Smallest); ChOut(0, ^ )]; |
||
until Smallest = Inf; |
until Smallest = Inf; |
||
]</ |
]</syntaxhighlight> |
||
{{out}} |
{{out}} |
Latest revision as of 11:46, 31 May 2024
- Task
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
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
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.
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()
- Output:
Log: (*2, 7, 13, 43, 103*) (*2, 5, 7, 13, 19, 23, 43, 103, 137*)
Arturo
lst: [2 43 81 122 63 13 7 95 103]
print sort select lst => prime?
- Output:
2 7 13 43 103
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)
}
- Output:
[2, 7, 13, 43, 103]
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)
}
- Output:
2 7 13 43 103
BASIC
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
- 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 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
- Output:
[2,7,13,43,103]
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
- Output:
Igual que la entrada de FreeBASIC.
Delphi
Uses Delphi TList object to hold and sort the data.
{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;
- Output:
Raw data: [2,43,81,122,63,13,7,95,103] Sorted Primes: [2,7,13,43,103] Elapsed Time: 2.910 ms.
EasyLang
fastfunc isprim num .
i = 2
while i <= sqrt num
if num mod i = 0
return 0
.
i += 1
.
return 1
.
proc sort . d[] .
for i = 1 to len d[] - 1
for j = i + 1 to len d[]
if d[j] < d[i]
swap d[j] d[i]
.
.
.
.
inp[] = [ 2 43 81 122 63 13 7 95 103 ]
for v in inp[]
if isprim v = 1
d[] &= v
.
.
sort d[]
print d[]
- Output:
[ 2 7 13 43 103 ]
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
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
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,103
2 7 13 43 103
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
Mathematica/Wolfram Language
Sort[Select[{2, 43, 81, 122, 63, 13, 7, 95, 103}, PrimeQ]]
- Output:
{2, 7, 13, 43, 103}
Nim
import std/[algorithm, strutils]
let primes = [2, 43, 81, 122, 63, 13, 7, 95, 103]
echo sorted(primes).join(", ")
- Output:
2, 7, 13, 43, 63, 81, 95, 103, 122
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";
- 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 -> 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()
- Output:
[2, 7, 13, 43, 103]
Quackery
eratosthenes
and isprime
are defined at Sieve of Eratosthenes#Quackery.
' [ 2 43 81 122 63 13 7 95 103 ]
sort
dup -1 peek eratosthenes
[] swap witheach
[ dup isprime iff join else drop ]
echo
- 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])
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
- Output:
working Primes are: [2,7,13,43,103] done...
RPL
« SORT { }
1 PICK3 SIZE FOR j
OVER j GET
IF DUP ISPRIME? THEN + ELSE DROP END
NEXT NIP
» 'TASK' STO
{2,43,81,122,63,13,7,95,103} TASK
- Output:
1: { 2 7 13 43 103 }
Ruby
require 'prime'
p [2,43,81,122,63,13,7,95,103].select(&:prime?).sort
- Output:
[2, 7, 13, 43, 103]
Sidef
var arr = [2,43,81,122,63,13,7,95,103]
say arr.grep{.is_prime}.sort
- Output:
[2, 7, 13, 43, 103]
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())
- 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