Data update

Task/Almost-prime/Icon/almost-prime-2.icon

@@ -0,0 +1,29 @@
+(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)))

Task/Almost-prime/MiniScript/almost-prime.mini

@@ -0,0 +1,24 @@
+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

Task/Almost-prime/Sidef/almost-prime-1.sidef

@@ -0,0 +1,46 @@
+func almost_primes(a, b, k) {
+
+    a = max(2**k, a)
+    var arr = []
+
+    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) {
+    var (x=10, lo=1, hi=2)
+    var arr = []
+    loop {
+        arr += almost_primes(lo, hi, k)
+        break if (arr.len >= x)
+        lo = hi+1
+        hi = 2*lo
+    }
+    say arr.first(x)
+}

Task/Almost-prime/Sidef/almost-prime-2.sidef

@@ -0,0 +1,4 @@
+for k in (1..5) {
+    var x = 10
+    say k.almost_primes(x.nth_almost_prime(k))
+}

Task/Almost-prime/Sidef/almost-prime.sidef

@@ -1,18 +0,0 @@
-func is_k_almost_prime(n, k) {
-    for (var (p, f) = (2, 0); (f < k) && (p*p <= n); ++p) {
-        (n /= p; ++f) while (p `divides` n)
-    }
-    n > 1 ? (f.inc == k) : (f == k)
-}
-
-{ |k|
-    var x = 10
-    say gather {
-        { |i|
-            if (is_k_almost_prime(i, k)) {
-                take(i)
-                --x == 0 && break
-            }
-        } << 1..Inf
-    }
-} << 1..5

Task/Almost-prime/V-(Vlang)/almost-prime.v

@@ -1,13 +1,11 @@
 fn k_prime(n int, k int) bool {
     mut nf := 0
     mut nn := n
-    for i in 2 .. nn+1 {
+    for i in 2..nn + 1 {
         for nn % i == 0 {
-            if nf == k {
-                return false
-            }
+            if nf == k {return false}
             nf++
-            nn/=i
+            nn /= i
         }
     }
     return nf == k
@@ -16,10 +14,8 @@ fn k_prime(n int, k int) bool {
 fn gen(k int, n int) []int {
     mut r := []int{len:n}
     mut nx := 2
-    for i in 0 .. n {
-        for !k_prime(nx, k) {
-            nx++
-        }
+    for i in 0..n {
+        for !k_prime(nx, k) {nx++}
         r[i] = nx
         nx++
     }
@@ -27,7 +23,5 @@ fn gen(k int, n int) []int {
 }
 
 fn main(){
-    for k in 1..6 {
-        println('$k ${gen(k,10)}')
-    }
+    for k in 1..6 {println('$k ${gen(k,10)}')}
 }