Data update

Task/Almost-prime/Ada/almost-prime.adb

@@ -0,0 +1,25 @@
+with Prime_Numbers, Ada.Text_IO;
+
+procedure Test_Kth_Prime is
+
+   package Integer_Numbers is new
+     Prime_Numbers (Natural, 0, 1, 2);
+   use Integer_Numbers;
+
+   Out_Length: constant Positive := 10; -- 10 k-th almost primes
+   N: Positive; -- the "current number" to be checked
+
+begin
+   for K in 1 .. 5 loop
+      Ada.Text_IO.Put("K =" & Integer'Image(K) &":  ");
+      N := 2;
+      for I in 1 .. Out_Length loop
+	 while Decompose(N)'Length /= K loop
+	    N := N + 1;
+	 end loop; -- now N is Kth almost prime;
+	 Ada.Text_IO.Put(Integer'Image(Integer(N)));
+	 N := N + 1;
+      end loop;
+      Ada.Text_IO.New_Line;
+   end loop;
+end Test_Kth_Prime;

Task/Almost-prime/Agena/almost-prime.agena

@@ -0,0 +1,34 @@
+scope # show some k-almost-primes - translation of C via Algol W
+
+    local proc kPrime( nv :: number, k :: number ) :: boolean
+        local p, f, n := 3, 0, nv;
+        while f <= k and n mod 2 = 0 do
+            n \:= 2;
+            f +:= 1
+        od;
+        while f <= k and p * p <= n do
+            while n mod p = 0 do
+                n \:= p;
+                f +:= 1
+            od;
+            p +:= 2
+        od;
+        if n > 1 then f +:= 1 fi;
+        return f = k
+    end;
+
+    scope # task
+        for k to 5 do
+            printf( "k = %d: ", k );
+            local c, i := 0, 2;
+            while c < 10 do
+                if kPrime( i, k ) then
+                    printf( " %3d", i );
+                    c +:= 1
+                fi;
+                i +:= 1
+            od;
+            print()
+        od
+    epocs
+epocs

Task/Almost-prime/COBOL/almost-prime.cob

@@ -0,0 +1,69 @@
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. ALMOST-PRIME.
+
+       DATA DIVISION.
+       WORKING-STORAGE SECTION.
+       01 CONTROL-VARS.
+          03 K              PIC 9.
+          03 I              PIC 999.
+          03 SEEN           PIC 99.
+          03 N              PIC 999.
+          03 P              PIC 99.
+          03 P-SQUARED      PIC 9(4).
+          03 F              PIC 99.
+          03 N-DIV-P        PIC 999V999.
+          03 FILLER         REDEFINES N-DIV-P.
+             05 NEXT-N      PIC 999.
+             05 FILLER      PIC 999.
+                88 N-DIVS-P VALUE ZERO.
+
+       01 OUT-VARS.
+          03 K-LN           PIC X(70).
+          03 K-LN-PTR       PIC 99.
+          03 LN-HDR.
+             05 FILLER      PIC X(4) VALUE "K = ".
+             05 K-OUT       PIC 9.
+             05 FILLER      PIC X VALUE ":".
+          03 I-FMT.
+             05 FILLER      PIC X VALUE SPACE.
+             05 I-OUT       PIC ZZ9.
+
+       PROCEDURE DIVISION.
+       BEGIN.
+           PERFORM K-ALMOST-PRIMES VARYING K FROM 1 BY 1
+               UNTIL K IS GREATER THAN 5.
+           STOP RUN.
+
+       K-ALMOST-PRIMES.
+           MOVE SPACES TO K-LN.
+           MOVE 1 TO K-LN-PTR.
+           MOVE ZERO TO SEEN.
+           MOVE K TO K-OUT.
+           STRING LN-HDR DELIMITED BY SIZE INTO K-LN
+               WITH POINTER K-LN-PTR.
+           PERFORM I-K-ALMOST-PRIME VARYING I FROM 2 BY 1
+               UNTIL SEEN IS EQUAL TO 10.
+           DISPLAY K-LN.
+
+       I-K-ALMOST-PRIME.
+           MOVE ZERO TO F, P-SQUARED.
+           MOVE I TO N.
+           PERFORM PRIME-FACTOR VARYING P FROM 2 BY 1
+               UNTIL F IS NOT LESS THAN K
+               OR P-SQUARED IS GREATER THAN N.
+           IF N IS GREATER THAN 1, ADD 1 TO F.
+           IF F IS EQUAL TO K,
+               MOVE I TO I-OUT,
+               ADD 1 TO SEEN,
+               STRING I-FMT DELIMITED BY SIZE INTO K-LN
+                   WITH POINTER K-LN-PTR.
+
+       PRIME-FACTOR.
+           MULTIPLY P BY P GIVING P-SQUARED.
+           DIVIDE N BY P GIVING N-DIV-P.
+           PERFORM DIVIDE-FACTOR UNTIL NOT N-DIVS-P.
+
+       DIVIDE-FACTOR.
+           MOVE NEXT-N TO N.
+           ADD 1 TO F.
+           DIVIDE N BY P GIVING N-DIV-P.

Task/Almost-prime/Crystal/almost-prime.cr

@@ -0,0 +1,22 @@
+struct Int
+  def kprime? (k)
+    n = self
+    nf = 0
+    (typeof(n).new(2) .. n).each do |i|
+      while n % i == 0
+        return false if nf == k
+        nf += 1
+        n //= i
+      end
+    end
+    nf == k
+  end
+end
+
+def kprimes (k)
+  (2..).each.select &.kprime?(k)
+end
+
+(1..5).each do |k|
+  print k, ": ", kprimes(k).first(10).to_a, "\n"
+end

Task/Almost-prime/Fennel/almost-prime.fennel

@@ -0,0 +1,33 @@
+(do ;;; show some k-almost-primes - translation of C via Algol W
+
+    (fn k-almost-prime? [nv k]
+        (var (p f n) (values 3 0 nv))
+        (while (and (<= f k) (= (% n 2) 0))
+               (set (n f) (values (math.floor (/ n 2)) (+ f 1)))
+        )
+        (while (and (<= f k) (<= (* p p) n))
+               (while (= (% n p) 0)
+                      (set (n f) (values (math.floor (/ n p)) (+ f 1)))
+               )
+               (set p (+ p 2))
+        )
+        (when (> n 1)
+              (set f (+ f 1))
+        )
+        (= f k)
+    )
+
+    (do ;;; task
+        (for [k 1 5]
+             (var (c i kNumbers) (values 0 2 {}))
+             (while (< c 10)
+                    (when (k-almost-prime? i k)
+                          (table.insert kNumbers (string.format "%3d" i))
+                          (set c (+ c 1))
+                    )
+                    (set i (+ i 1))
+             )
+             (print (.. "k = " k ":  " (table.concat kNumbers " ")))
+        )
+    )
+)

Task/Almost-prime/Oberon-07/almost-prime.oberon

@@ -0,0 +1,52 @@
+MODULE AlmostPrime; (* Show some k-almost-prime numbers - Translation of C Via Algol W *)
+    IMPORT Out, Math;
+
+    (* returns TRUE if nv is k-almost-prime, FALSE otherwise *)
+    PROCEDURE kPrime( nv, k : INTEGER ) : BOOLEAN;
+        VAR   p, f, n, rootN : INTEGER;
+
+        BEGIN
+            n := nv;
+            f := 0;
+            WHILE ( f <= k ) & ~ ODD( n ) DO
+                n := n DIV 2;
+                INC( f )
+            END;
+            p     := 3;
+            rootN := FLOOR( Math.sqrt( FLT( n ) ) );
+            WHILE ( f <= k ) & ( p <= rootN ) DO
+                WHILE n MOD p = 0 DO
+                    n := n DIV p;
+                    INC( f )
+                END;
+                INC( p, 2 )
+            END;
+            IF n > 1 THEN INC( f ) END;
+        RETURN f = k
+        END kPrime ;
+
+    (* Show n k-almost-prime numbers *)
+    PROCEDURE showKAlmostPrimes( k, n : INTEGER );
+        VAR   c, i    : INTEGER;
+
+        BEGIN
+            Out.String( "k = " );Out.Int( k, 0 );Out.String( ": " );
+            c := 0;
+            i := 2;
+            WHILE c < n DO
+                IF kPrime( i, k ) THEN
+                    Out.String( " " );Out.Int( i, 3 );
+                    INC( c )
+                END;
+                INC( i )
+            END;
+            Out.Ln
+        END showKAlmostPrimes;
+
+BEGIN
+    showKAlmostPrimes( 1, 10 );
+    showKAlmostPrimes( 2, 10 );
+    showKAlmostPrimes( 3, 10 );
+    showKAlmostPrimes( 4, 10 );
+    showKAlmostPrimes( 5, 10 )
+END AlmostPrime.

Task/Almost-prime/Rebol/almost-prime.rebol

@@ -0,0 +1,43 @@
+Rebol [
+    title: "Rosetta code: Almost prime"
+    file:  %Almost_prime.r3
+    url:   https://rosettacode.org/wiki/Almost_prime
+]
+
+;- Prime Factorisation --------------------------------------------------
+prime-factors: function [
+    "Returns a block of prime factors for N (with repetition)."
+    n [integer!]
+][
+    factors: clear []
+    d: 2
+    while [(d * d) <= n][
+        while [zero? n % d][
+            append factors d
+            n: n / d
+        ]
+        ++ d
+    ]
+    if n > 1 [append factors n]
+    factors
+]
+;- Almost-Prime Filter --------------------------------------------------
+almost-prime: function [
+    "Returns first list-len integers with exactly k prime factors"
+    k [integer!]  list-len [integer!]
+][
+    result: copy []
+    n: 2
+    while [list-len > length? result][
+        if k = length? prime-factors n [append result n]
+        ++ n
+    ]
+    result
+]
+
+;- Main -----------------------------------------------------------------
+;; Print the first 10 K-almost-primes for K = 1 through 5.
+repeat k 5 [
+    prin rejoin ["k: " k " => "]
+    print almost-prime k 10
+]

Task/Almost-prime/Uiua/almost-prime.uiua

@@ -0,0 +1,2 @@
+▽⊸(=⊣⊸°/×)↘2⇡30
+≡⌟(↙10⍆≡/×⧅≤) +1⇡5

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

@@ -23,5 +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)}")}
 }

Task/Almost-prime/VBScript/almost-prime.vbs

@@ -0,0 +1,54 @@
+For k = 1 To 5
+	count = 0
+	increment = 1
+	WScript.StdOut.Write "K" & k & ": "
+	Do Until count = 10
+		If PrimeFactors(increment) = k Then
+			WScript.StdOut.Write increment & " "
+			count = count + 1
+		End If
+		increment = increment + 1
+	Loop
+	WScript.StdOut.WriteLine
+Next
+
+Function PrimeFactors(n)
+	PrimeFactors = 0
+	arrP = Split(ListPrimes(n)," ")
+	divnum = n
+	Do Until divnum = 1
+		For i = 0 To UBound(arrP)-1
+			If divnum = 1 Then
+				Exit For
+			ElseIf divnum Mod arrP(i) = 0 Then
+				divnum = divnum/arrP(i)
+				PrimeFactors = PrimeFactors + 1
+			End If
+		Next
+	Loop
+End Function
+
+Function IsPrime(n)
+	If n = 2 Then
+		IsPrime = True
+	ElseIf n <= 1 Or n Mod 2 = 0 Then
+		IsPrime = False
+	Else
+		IsPrime = True
+		For i = 3 To Int(Sqr(n)) Step 2
+			If n Mod i = 0 Then
+				IsPrime = False
+				Exit For
+			End If
+		Next
+	End If
+End Function
+
+Function ListPrimes(n)
+	ListPrimes = ""
+	For i = 1 To n
+		If IsPrime(i) Then
+			ListPrimes = ListPrimes & i & " "
+		End If
+	Next
+End Function