Rosetta Code

Almost prime: Difference between revisions

Page Discussion

Almost prime (view source)

Revision as of 05:26, 8 March 2024

8,986 bytes added ,  2 months ago
→‎functional
(add RPL)
 
(18 intermediate revisions by 13 users not shown)
Line 787:
230 LET iskprime = (f = k)
240 RETURN</syntaxhighlight>
 
==={{header|Craft Basic}}===
<syntaxhighlight lang="basic">for k = 1 to 5
 
print "k = ", k, ": ",
 
let e = 2
let c = 0
 
do
 
if c < 10 then
 
let n = e
gosub kprime
 
if r then
 
print tab, e,
let c = c + 1
 
endif
 
let e = e + 1
 
endif
 
loop c < 10
 
print
 
next k
 
end
 
sub kprime
 
let f = 0
 
for i = 2 to n
 
do
 
if n mod i = 0 then
 
if f = k then
 
let r = 0
return
 
endif
 
let f = f + 1
let n = n / i
 
wait
 
endif
 
loop n mod i = 0
 
next i
 
let r = f = k
 
return</syntaxhighlight>
{{out| Output}}
<pre>
k = 1: 2 3 5 7 11 13 17 19 23 29
k = 2: 4 6 9 10 14 15 21 22 25 26
k = 3: 8 12 18 20 27 28 30 42 44 45
k = 4: 16 24 36 40 54 56 60 81 84 88
k = 5: 32 48 72 80 108 112 120 162 168 176
</pre>
 
==={{header|FreeBASIC}}===
Line 830 ⟶ 904:
k = 5 : 32 48 72 80 108 112 120 162 168 176
</pre>
 
==={{header|Gambas}}===
<syntaxhighlight lang="vbnet">Public Sub Main()
Dim i As Integer, c As Integer, k As Integer
 
For k = 1 To 5
Print "k = "; k; " : ";
i = 2
c = 0
While c < 10
If kPrime(i, k) Then
Print Format$(Str$(i), "### ");
c += 1
End If
i += 1
Wend
Print
Next
End
 
Function kPrime(n As Integer, k As Integer) As Boolean
 
Dim f As Integer = 0
For i As Integer = 2 To n
While n Mod i = 0
If f = k Then Return False
f += 1
n \= i
Wend
Next
Return f = k
 
End Function</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
 
==={{header|GW-BASIC}}===
Line 1,972 ⟶ 2,083:
k = 4: 16 24 36 40 54 56 60 81 84 88
k = 5: 32 48 72 80 108 112 120 162 168 176</pre>
 
=={{header|EasyLang}}==
{{trans|FreeBASIC}}
<syntaxhighlight lang=easylang>
func kprime n k .
i = 2
while i <= n
while n mod i = 0
if f = k
return 0
.
f += 1
n /= i
.
i += 1
.
if f = k
return 1
.
return 0
.
for k = 1 to 5
write "k=" & k & " : "
i = 2
c = 0
while c < 10
if kprime i k = 1
write i & " "
c += 1
.
i += 1
.
print ""
.
</syntaxhighlight>
 
=={{header|EchoLisp}}==
Line 2,385 ⟶ 2,531:
in map f (1...m)
</syntaxhighlight>
 
 
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
local fn K_Prime( n as long, k as long ) as BOOL
long f = 0, i = 0
BOOL result
for i = 2 to n
while ( n mod i == 0 )
if f = k then exit fn = NO
f += 1
n /= i
wend
next
result = f = k
end fn = result
 
 
long i, c, k
 
for k = 1 to 5
printf @"k = %ld:\b", k
i = 2
c = 0
while ( c < 10 )
if ( fn K_Prime( i, k ) )
printf @"%4ld\b", i
c++
end if
i++
wend
print
next
 
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
k = 1 : 2 3 5 7 11 13 17 19 23 29
k = 2 : 4 6 9 10 14 15 21 22 25 26
k = 3 : 8 12 18 20 27 28 30 42 44 45
k = 4 : 16 24 36 40 54 56 60 81 84 88
k = 5 : 32 48 72 80 108 112 120 162 168 176
</pre>
 
=={{header|Go}}==
Line 2,573 ⟶ 2,764:
5: 32 48 72 80 108 112 120 162 168 176
->
</pre>
 
=={{Header|Insitux}}==
 
<syntaxhighlight lang="insitux">
(function prime-sieve search siever sieved
(return-when (empty? siever) (.. vec sieved search))
(let [p ps] ((juxt 0 (skip 1)) siever))
(recur (remove #(div? % p) search)
(remove #(div? % p) ps)
(append p sieved)))
 
(function primes n
(prime-sieve (range 2 (inc n)) (range 2 (ceil (sqrt n))) []))
 
(function decompose n ps factors
(return-when (= n 1) factors)
(let div (find (div? n) ps))
(recur (/ n div) ps (append div factors)))
 
(function almost-prime up-to n k
(return-when (zero? up-to) [])
(let ps (primes n))
(if (= k (len (decompose n ps [])))
(prepend n (almost-prime (dec up-to) (inc n) k))
(almost-prime up-to (inc n) k)))
 
(function row n
(-> n
@(almost-prime 10 1)
(join " ")
@(str n (match n 1 "st" 2 "nd" 3 "rd" "th") " almost-primes: " )))
 
(join "\n" (map row (range 1 6)))
</syntaxhighlight>
 
{{out}}
 
<pre>
1st almost-primes: 2 3 5 7 11 13 17 19 23 29
2nd almost-primes: 4 6 9 10 14 15 21 22 25 26
3rd almost-primes: 8 12 18 20 27 28 30 42 44 45
4th almost-primes: 16 24 36 40 54 56 60 81 84 88
5th almost-primes: 32 48 72 80 108 112 120 162 168 176
</pre>
 
Line 2,973 ⟶ 3,208:
k = 5: 32 48 72 80 108 112 120 162 168 176</pre>
 
=={{header|Maxima}}==
<syntaxhighlight lang="maxima">
/* Predicate function that checks k-almost primality for given integer n and parameter k */
k_almost_primep(n,k):=if integerp((n)^(1/k)) and primep((n)^(1/k)) then true else
lambda([x],(length(ifactors(x))=k and unique(map(second,ifactors(x)))=[1]) or (length(ifactors(x))<k and apply("+",map(second,ifactors(x)))=k))(n)$
 
/* Function that given a parameter k1 returns the first len k1-almost primes */
k_almost_prime_count(k1,len):=block(
count:len,
while length(sublist(makelist(i,i,count),lambda([x],k_almost_primep(x,k1))))<len do (count:count+1),
sublist(makelist(i,i,count),lambda([x],k_almost_primep(x,k1))))$
 
/* Test cases */
k_almost_prime_count(1,10);
k_almost_prime_count(2,10);
k_almost_prime_count(3,10);
k_almost_prime_count(4,10);
k_almost_prime_count(5,10);
</syntaxhighlight>
{{out}}
<pre>
[2,3,5,7,11,13,17,19,23,29]
[4,6,9,10,14,15,21,22,25,26]
[8,12,18,20,27,28,30,42,44,45]
[16,24,36,40,54,56,60,81,84,88]
[32,48,72,80,108,112,120,162,168,176]
</pre>
 
=={{header|MiniScript}}==
<syntaxhighlight lang="miniscript">
primeFactory = function(n=2)
if n < 2 then return ""
for i in range(2, n)
p = floor(n / i)
q = n % i
if not q then return str(i) + " " + str(primeFactory(p))
end for
return n
end function
 
getAlmostPrimes = function(k)
almost = []
n = 2
while almost.len < 10
primes = primeFactory(n).trim.split
if primes.len == k then almost.push(n)
n += 1
end while
return almost
end function
 
for i in range(1, 5)
print i + ": " + getAlmostPrimes(i)
end for
</syntaxhighlight>
 
{{out}}
<pre>
]run
1: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
2: [4, 6, 9, 10, 14, 15, 21, 22, 25, 26]
3: [8, 12, 18, 20, 27, 28, 30, 42, 44, 45]
4: [16, 24, 36, 40, 54, 56, 60, 81, 84, 88]
5: [32, 48, 72, 80, 108, 112, 120, 162, 168, 176]
</pre>
=={{header|Modula-2}}==
<syntaxhighlight lang="modula2">MODULE AlmostPrime;
Line 3,089 ⟶ 3,389:
k = 4: 16 24 36 40 54 56 60 81 84 88
k = 5: 32 48 72 80 108 112 120 162 168 176</pre>
 
=={{header|Odin}}==
<syntaxhighlight lang="Go">
package almostprime
import "core:fmt"
main :: proc() {
i, c, k: int
for k in 1 ..= 5 {
fmt.printf("k = %d:", k)
for i, c := 2, 0; c < 10; i += 1 {
if kprime(i, k) {
fmt.printf(" %v", i)
c += 1
}
}
fmt.printf("\n")
}
}
kprime :: proc(n: int, k: int) -> bool {
p, f: int = 0, 0
n := n
for p := 2; f < k && p * p <= n; p += 1 {
for (0 == n % p) {
n /= p
f += 1
}
}
return f + (n > 1 ? 1 : 0) == k
}
</syntaxhighlight>
{{out}}
<pre>
k = 1: 2 3 5 7 11 13 17 19 23 29
k = 2: 4 6 9 10 14 15 21 22 25 26
k = 3: 8 12 18 20 27 28 30 42 44 45
k = 4: 16 24 36 40 54 56 60 81 84 88
k = 5: 32 48 72 80 108 112 120 162 168 176
</pre>
 
=={{header|Oforth}}==
Line 3,115 ⟶ 3,453:
[16, 24, 36, 40, 54, 56, 60, 81, 84, 88]
[32, 48, 72, 80, 108, 112, 120, 162, 168, 176]
</pre>
 
=={{header|Onyx (wasm)}}==
===procedural===
<syntaxhighlight lang="ts">
package main
use core {printf}
main :: () -> void {
printf("\n");
for k in 1..6 {
printf("k = {}:", k);
i := 2;
c: i32;
while c < 10 {
if kprime(i, k) {
printf(" {}", i);
c += 1;
}
i += 1;
}
printf("\n");
}
}
kprime :: (n: i32, k: i32) -> bool {
f: i32;
while p := 2; f < k && p * p <= n {
while n % p == 0 {
n /= p;
f += 1;
}
p += 1;
}
return f + (1 if n > 1 else 0) == k;
}
</syntaxhighlight>
{{out}}
<pre>
k = 1: 2 3 5 7 11 13 17 19 23 29
k = 2: 4 6 9 10 14 15 21 22 25 26
k = 3: 8 12 18 20 27 28 30 42 44 45
k = 4: 16 24 36 40 54 56 60 81 84 88
k = 5: 32 48 72 80 108 112 120 162 168 176
</pre>
 
===functional===
<syntaxhighlight lang="TS">
//+optional-semicolons
use core {printf}
use core.iter
 
main :: () {
generator :=
iter.counter(1)
|> iter.map(k => .{
k = k, kprimes = kprime_iter(k)->take(10)
})
|> iter.take(5)
 
for val in generator {
printf("k = {}:", val.k)
for p in val.kprimes do printf(" {}", p)
printf("\n")
}
}
 
kprime_iter :: k =>
iter.counter(2)
|> iter.filter((i, [k]) => kprime(i, k))
 
kprime :: (n, k) => {
f := 0
for p in iter.counter(2) {
if f >= k do break
if p * p > n do break
 
while n % p == 0 {
n /= p
f += 1
}
}
 
return f + (1 if n > 1 else 0) == k
}
</syntaxhighlight>
{{out}}
<pre>
k = 1: 2 3 5 7 11 13 17 19 23 29
k = 2: 4 6 9 10 14 15 21 22 25 26
k = 3: 8 12 18 20 27 28 30 42 44 45
k = 4: 16 24 36 40 54 56 60 81 84 88
k = 5: 32 48 72 80 108 112 120 162 168 176
</pre>
 
Line 4,202 ⟶ 4,631:
'''NEXT'''
k == 1 FS? AND SWAP DROP
≫ ≫ ''''<span style="color:blue">KPRIM'''</span>' STO
≪ 5 1 '''FOR''' k
{ } 2
'''WHILE''' OVER SIZE 10 < '''REPEAT'''
'''IF''' DUP k '''<span style="color:blue">KPRIM'''</span> '''THEN''' SWAP OVER + SWAP '''END'''
1 + '''END''' DROP
-1 '''STEP'''
≫ ''''<span style="color:blue">TASK'''</span>' STO
|
'''<span style="color:blue">KPRIM'''</span> ''( n k --→ boolean ) ''
Dim f As Integer = 0
For i As Integer = 2 To n
Line 4,434 ⟶ 4,863:
 
=={{header|Sidef}}==
Efficient algorithm for generating all the k-almost prime numbers in a given range '''[a,b]''':
{{trans|Raku}}
<syntaxhighlight lang="ruby">func is_k_almost_primealmost_primes(na, b, k) {
 
for (var (p, f) = (2, 0); (f < k) && (p*p <= n); ++p) {
a (n /= p; ++f) while max(p `divides`2**k, na)
}var arr = []
 
n > 1 ? (f.inc == k) : (f == k)
func (m, lo, k) {
 
var hi = idiv(b,m).iroot(k)
 
if (k == 1) {
 
lo = max(lo, idiv_ceil(a, m))
 
each_prime(lo, hi, {|p|
arr << m*p
})
 
return nil
}
 
each_prime(lo, hi, {|p|
 
var t = m*p
var u = idiv_ceil(a, t)
var v = idiv(b, t)
 
next if (u > v)
 
__FUNC__(t, p, k-1)
})
}(1, 2, k)
 
return arr.sort
}
 
for k in (1..5) {
{ |k|
var (x=10, lo=1, 10hi=2)
sayvar gatherarr {= []
loop { |i|
arr += if almost_primes(is_k_almost_prime(ilo, hi, k)) {
break if (arr.len >= take(ix)
--xlo == 0 && breakhi+1
hi = }2*lo
} << 1..Inf
}
say arr.first(x)
} << 1..5</syntaxhighlight>
}</syntaxhighlight>
{{out}}
<pre>
Line 4,461 ⟶ 4,918:
[32, 48, 72, 80, 108, 112, 120, 162, 168, 176]
</pre>
 
Also built-in:
 
<syntaxhighlight lang="ruby">for k in (1..5) {
var x = 10
say k.almost_primes(x.nth_almost_prime(k))
}</syntaxhighlight>
 
(same output as above)
 
=={{header|Swift}}==
Line 4,697 ⟶ 5,163:
 
=={{header|V (Vlang)}}==
{{trans|goGo}}
<syntaxhighlight lang="v (vlang)">fn k_prime(n int, k int) bool {
fn k_prime(n int, k int) bool {
mut nf := 0
mut nn := n
for i in 2 .. nn + 1 {
for nn % i == 0 {
if nf == k {return false}
return false
}
nf++
nn /= i
}
}
Line 4,716 ⟶ 5,181:
mut r := []int{len:n}
mut nx := 2
for i in 0 .. n {
for !k_prime(nx, k) {nx++}
nx++
}
r[i] = nx
nx++
Line 4,727 ⟶ 5,190:
 
fn main(){
for k in 1..6 {println('$k ${gen(k,10)}')}
}
println('$k ${gen(k,10)}')
</syntaxhighlight>
}
}</syntaxhighlight>
{{out}}
<pre>
Line 4,742 ⟶ 5,204:
=={{header|Wren}}==
{{trans|Go}}
<syntaxhighlight lang="ecmascriptwren">var kPrime = Fn.new { |n, k|
var nf = 0
var i = 2
FLAT
16

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/341596...361371"