Data commit

Task/Fortunate-numbers/00-META.yaml

@@ -0,0 +1,3 @@
+---
+from: http://rosettacode.org/wiki/Fortunate_numbers
+note: Prime Numbers

Task/Fortunate-numbers/00-TASK.txt

@@ -0,0 +1,21 @@
+;Definition
+
+A [https://en.wikipedia.org/wiki/Fortunate_number Fortunate number] is the smallest integer '''m > 1''' such that for a given positive integer '''n''', '''primorial(n) + m''' is a prime number, where '''primorial(n)''' is the product of the first '''n''' prime numbers.
+
+For example the first fortunate number is 3 because primorial(1) is 2 and 2 + 3 = 5 which is prime whereas 2 + 2 = 4 is composite. 
+
+
+;Task
+
+After sorting and removal of any duplicates, compute and show on this page the first '''8''' Fortunate numbers or, if your language supports ''big integers'', the first '''50''' Fortunate numbers.
+
+
+;Related task
+* [[Primorial numbers]]
+
+ 
+;See also
+* [[oeis:A005235]] Fortunate numbers 		
+* [[oeis:A046066]] Fortunate numbers, sorted with duplicates removed
+<br><br>
+

Task/Fortunate-numbers/11l/fortunate-numbers.11l

@@ -0,0 +1,65 @@
+F isProbablePrime(n, k = 10)
+   I n < 2 | n % 2 == 0
+      R n == 2
+
+   V d = n - 1
+   V s = 0
+   L d % 2 == 0
+      d I/= 2
+      s++
+
+   assert(2 ^ s * d == n - 1)
+
+   Int nn
+   I n < 7FFF'FFFF
+      nn = Int(n)
+   E
+      nn = 7FFF'FFFF
+
+   L(_) 0 .< k
+      V a = random:(2 .< nn)
+      V x = pow(a, d, n)
+      I x == 1 | x == n - 1
+         L.continue
+      L(_) 0 .< s - 1
+         x = pow(x, 2, n)
+         I x == 1
+            R 0B
+         I x == n - 1
+            L.break
+      L.was_no_break
+         R 0B
+
+   R 1B
+
+F is_prime(a)
+   I a == 2
+      R 1B
+   I a < 2 | a % 2 == 0
+      R 0B
+   L(i) (3 .. Int(sqrt(a))).step(2)
+      I a % i == 0
+         R 0B
+   R 1B
+
+V primorial = BigInt(1)
+
+V nn = 50
+V lim = 75
+V s = Set[Int]()
+L(n) 1..
+   I is_prime(n)
+      primorial *= n
+      V m = 3
+      L
+         I isProbablePrime(primorial + m, 25)
+            s.add(m)
+            L.break
+         m += 2
+      I --lim == 0
+         L.break
+
+print(‘First ’nn‘ fortunate numbers:’)
+L(m) sorted(Array(s))[0 .< nn]
+   V i = L.index
+   print(‘#3’.format(m), end' I (i + 1) % 10 == 0 {"\n"} E ‘ ’)

Task/Fortunate-numbers/Arturo/fortunate-numbers.arturo

@@ -0,0 +1,18 @@
+firstPrimes: select 1..100 => prime?
+primorial: function [n][
+    product first.n: n firstPrimes
+]
+
+fortunates: []
+i: 1
+
+while [8 > size fortunates][
+    m: 3
+    pmi: primorial i
+    while -> not? prime? m + pmi
+          -> m: m+2
+    fortunates: unique fortunates ++ m
+    i: i + 1
+]
+
+print sort fortunates

Task/Fortunate-numbers/C/fortunate-numbers.c

@@ -0,0 +1,73 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <gmp.h>
+
+int *primeSieve(int limit, int *length) {
+    int i, p, *primes;
+    int j, pc = 0;
+    limit++;
+    // True denotes composite, false denotes prime.
+    bool *c = calloc(limit, sizeof(bool)); // all false by default
+    c[0] = true;
+    c[1] = true;
+    for (i = 4; i < limit; i += 2) c[i] = true;
+    p = 3; // Start from 3.
+    while (true) {
+        int p2 = p * p;
+        if (p2 >= limit) break;
+        for (i = p2; i < limit; i += 2 * p) c[i] = true;
+        while (true) {
+            p += 2;
+            if (!c[p]) break;
+        }
+    }
+    for (i = 0; i < limit; ++i) {
+        if (!c[i]) ++pc;
+    }
+    primes = (int *)malloc(pc * sizeof(int));
+    for (i = 0, j = 0; i < limit; ++i) {
+        if (!c[i]) primes[j++] = i;
+    }
+    free(c);
+    *length = pc;
+    return primes;
+}
+
+int compare(const void* a, const void* b) {
+    int arg1 = *(const int*)a;
+    int arg2 = *(const int*)b;
+    if (arg1 < arg2) return -1;
+    if (arg1 > arg2) return 1;
+    return 0;
+}
+
+int main() {
+    int i, j, f, pc, ac, limit = 379, fc = 0;
+    int *primes = primeSieve(limit, &pc);
+    int fortunates[80];
+    mpz_t primorial, temp;
+    mpz_init_set_ui(primorial, 1);
+    mpz_init(temp);
+    for (i = 0; i < pc; ++i) {
+        mpz_mul_ui(primorial, primorial, primes[i]);
+        for (j = 3; ; j += 2) {
+            mpz_add_ui(temp, primorial, j);
+            if (mpz_probab_prime_p(temp, 15) > 0) {
+                fortunates[fc++] = j;
+                break;
+            }
+        }
+    }
+    qsort(fortunates, fc, sizeof(int), compare);
+    printf("After sorting, the first 50 distinct fortunate numbers are:\n");
+    for (i = 0, ac = 0; ac < 50; ++i) {
+       f = fortunates[i];
+       if (i > 0 && f == fortunates[i-1]) continue;
+       printf("%3d ", f);
+       ++ac;
+       if (!(ac % 10)) printf("\n");
+    }
+    free(primes);
+    return 0;
+}

Task/Fortunate-numbers/Factor/fortunate-numbers.factor

@@ -0,0 +1,8 @@
+USING: grouping io kernel math math.factorials math.primes
+math.ranges prettyprint sequences sets sorting ;
+
+"First 50 distinct fortunate numbers:" print
+75 [1,b] [
+    primorial dup next-prime 2dup - abs 1 =
+    [ next-prime ] when - abs
+] map members natural-sort 50 head 10 group simple-table.

Task/Fortunate-numbers/FreeBASIC/fortunate-numbers.basic

@@ -0,0 +1,45 @@
+#include "isprime.bas"
+#include "sets.bas"
+#include "bubblesort.bas"
+
+function prime(n as uinteger) as uinteger
+    if n = 1 then return 2
+    dim as integer c=1, p=3
+    while c<n
+        if isprime(p) then c+=1
+        p += 2
+    wend
+    return p
+end function
+
+function primorial( n as uinteger ) as ulongint
+    dim as ulongint ret = 1
+    for i as uinteger = 1 to n
+        ret *= prime(i)
+    next i
+    return ret
+end function
+
+function fortunate(n as uinteger) as uinteger
+    dim as uinteger m = 3
+    dim as ulongint pp = primorial(n)
+    while not isprime(m+pp)
+        m+=2
+    wend
+    return m
+end function
+
+redim as integer forts(-1)
+dim as integer n = 0, m
+while ubound(forts) < 6
+    n += 1
+    m = fortunate(n)
+    if not is_in(m, forts()) then
+        add_to_set(m, forts())
+    end if
+wend
+
+bubblesort(forts())
+for n=0 to 6
+    print forts(n)
+next n

Task/Fortunate-numbers/Go/fortunate-numbers.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+    "fmt"
+    "math/big"
+    "rcu"
+    "sort"
+)
+
+func main() {
+    primes := rcu.Primes(379)
+    primorial := big.NewInt(1)
+    var fortunates []int
+    bPrime := new(big.Int)
+    for _, prime := range primes {
+        bPrime.SetUint64(uint64(prime))
+        primorial.Mul(primorial, bPrime)
+        for j := 3; ; j += 2 {
+            jj := big.NewInt(int64(j))
+            bPrime.Add(primorial, jj)
+            if bPrime.ProbablyPrime(5) {
+                fortunates = append(fortunates, j)
+                break
+            }
+        }
+    }
+    m := make(map[int]bool)
+    for _, f := range fortunates {
+        m[f] = true
+    }
+    fortunates = fortunates[:0]
+    for k := range m {
+        fortunates = append(fortunates, k)
+    }
+    sort.Ints(fortunates)
+    fmt.Println("After sorting, the first 50 distinct fortunate numbers are:")
+    for i, f := range fortunates[0:50] {
+        fmt.Printf("%3d ", f)
+        if (i+1)%10 == 0 {
+            fmt.Println()
+        }
+    }
+    fmt.Println()
+}

Task/Fortunate-numbers/Haskell/fortunate-numbers.hs

@@ -0,0 +1,14 @@
+import Data.Numbers.Primes (primes)
+import Math.NumberTheory.Primes.Testing (isPrime)
+import Data.List (nub)
+
+primorials :: [Integer]
+primorials = 1 : scanl1 (*) primes
+
+nextPrime :: Integer -> Integer
+nextPrime n
+  | even n = head $ dropWhile (not . isPrime) [n+1, n+3..]
+  | even n = nextPrime (n+1)
+
+fortunateNumbers :: [Integer]
+fortunateNumbers = (\p -> nextPrime (p + 2) - p) <$> tail primorials

Task/Fortunate-numbers/J/fortunate-numbers.j

@@ -0,0 +1,3 @@
+fortunate =: p -~ 4 p: 2 + p =. */ @: p: @ i. @ x:
+echo 'Unique fortunate numbers'
+echo _10 [\ 50 {. /:~ ~. fortunate"0 >: i. 75

Task/Fortunate-numbers/Jq/fortunate-numbers.jq

@@ -0,0 +1,17 @@
+def primes:
+  2, range(3; infinite; 2) | select(is_prime);
+
+# generate an infinite stream of primorials
+def primorials:
+  foreach primes as $p (1; .*$p; .);
+
+# Emit a sorted array of the first $limit distinct fortunate numbers
+# generated in order of the primoridials
+def fortunates($limit):
+  label $out
+  | foreach primorials as $p ([];
+      first( range(3; infinite; 2) | select($p + . | is_prime)) as $q
+      | . + [$q] | unique;
+      if length >= $limit then ., break $out else empty end);
+
+fortunates(10)

Task/Fortunate-numbers/Julia/fortunate-numbers.julia

@@ -0,0 +1,11 @@
+using Primes
+
+primorials(N) = accumulate(*, primes(N), init = big"1")
+
+primorial = primorials(800)
+
+fortunate(n) = nextprime(primorial[n] + 2) - primorial[n]
+
+println("After sorting, the first 50 distinct fortunate numbers are:")
+foreach(p -> print(rpad(last(p), 5), first(p) % 10 == 0 ? "\n" : ""),
+    (map(fortunate, 1:100) |> unique |> sort!)[begin:50] |> enumerate)

Task/Fortunate-numbers/Mathematica/fortunate-numbers.math

@@ -0,0 +1,11 @@
+ClearAll[primorials]
+primorials[n_] := Times @@ Prime[Range[n]]
+vals = Table[
+   primor = primorials[i];
+   s = NextPrime[primor];
+   t = NextPrime[s];
+   Min[DeleteCases[{s - primor, t - primor}, 1]]
+   ,
+   {i, 100}
+   ];
+TakeSmallest[DeleteDuplicates[vals], 50]

Task/Fortunate-numbers/Nim/fortunate-numbers.nim

@@ -0,0 +1,34 @@
+import algorithm, sequtils, strutils
+import bignum
+
+const
+  N = 50      # Number of fortunate numbers.
+  Lim = 75    # Number of primorials to compute.
+
+
+iterator primorials(lim: Positive): Int =
+  var prime = newInt(2)
+  var primorial = newInt(1)
+  for _ in 1..lim:
+    primorial *= prime
+    prime = prime.nextPrime()
+    yield primorial
+
+
+var list: seq[int]
+for p in primorials(Lim):
+  var m = 3
+  while true:
+    if probablyPrime(p + m, 25) != 0:
+      list.add m
+      break
+    inc m, 2
+
+list.sort()
+list = list.deduplicate(true)
+if list.len < N:
+  quit "Not enough values. Wanted $1, got $2.".format(N, list.len), QuitFailure
+list.setLen(N)
+echo "First $# fortunate numbers:".format(N)
+for i, m in list:
+  stdout.write ($m).align(3), if (i + 1) mod 10 == 0: '\n' else: ' '

Task/Fortunate-numbers/Perl/fortunate-numbers.pl

@@ -0,0 +1,15 @@
+use strict;
+use warnings;
+use List::Util <first uniq>;
+use ntheory qw<pn_primorial is_prime>;
+
+my $upto = 50;
+my @candidates;
+for my $p ( map { pn_primorial($_) } 1..2*$upto ) {
+    push @candidates, first { is_prime($_ + $p) } 2..100*$upto;
+}
+
+my @fortunate = sort { $a <=> $b } uniq grep { is_prime $_ } @candidates;
+
+print "First $upto distinct fortunate numbers:\n" .
+    (sprintf "@{['%6d' x $upto]}", @fortunate) =~ s/(.{60})/$1\n/gr;

Task/Fortunate-numbers/Phix/fortunate-numbers.phix

@@ -0,0 +1,20 @@
+(phixonline)-->
+ <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
+ <span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
+ <span style="color: #004080;">mpz</span> <span style="color: #000000;">primorial</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_init</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">),</span>
+     <span style="color: #000000;">pj</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_init</span><span style="color: #0000FF;">()</span>
+ <span style="color: #004080;">sequence</span> <span style="color: #000000;">fortunates</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
+ <span style="color: #008080;">for</span> <span style="color: #000000;">p</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">75</span> <span style="color: #008080;">do</span>
+     <span style="color: #7060A8;">mpz_mul_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">primorial</span><span style="color: #0000FF;">,</span><span style="color: #000000;">primorial</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">get_prime</span><span style="color: #0000FF;">(</span><span style="color: #000000;">p</span><span style="color: #0000FF;">))</span>
+     <span style="color: #004080;">integer</span> <span style="color: #000000;">j</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">3</span>
+     <span style="color: #7060A8;">mpz_add_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">pj</span><span style="color: #0000FF;">,</span><span style="color: #000000;">primorial</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">)</span>
+     <span style="color: #008080;">while</span> <span style="color: #008080;">not</span> <span style="color: #7060A8;">mpz_prime</span><span style="color: #0000FF;">(</span><span style="color: #000000;">pj</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+         <span style="color: #7060A8;">mpz_add_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">pj</span><span style="color: #0000FF;">,</span><span style="color: #000000;">pj</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span>
+         <span style="color: #000000;">j</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">j</span> <span style="color: #0000FF;">+</span> <span style="color: #000000;">2</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
+     <span style="color: #000000;">fortunates</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">j</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+ <span style="color: #000000;">fortunates</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">unique</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">deep_copy</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fortunates</span><span style="color: #0000FF;">))[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">50</span><span style="color: #0000FF;">]</span>
+ <span style="color: #000000;">fortunates</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">join_by</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">,{{</span><span style="color: #008000;">"%3d"</span><span style="color: #0000FF;">},</span><span style="color: #000000;">fortunates</span><span style="color: #0000FF;">}),</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)</span>
+ <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"The first 50 distinct fortunate numbers are:\n%s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">fortunates</span><span style="color: #0000FF;">})</span>
+<!--

Task/Fortunate-numbers/Python/fortunate-numbers.py

@@ -0,0 +1,27 @@
+from sympy.ntheory.generate import primorial
+from sympy.ntheory import isprime
+
+def fortunate_number(n):
+    '''Return the fortunate number for positive integer n.'''
+    # Since primorial(n) is even for all positive integers n,
+    # it suffices to search for the fortunate numbers among odd integers.
+    i = 3
+    primorial_ = primorial(n)
+    while True:
+        if isprime(primorial_ + i):
+            return i
+        i += 2
+
+fortunate_numbers = set()
+for i in range(1, 76):
+    fortunate_numbers.add(fortunate_number(i))
+
+# Extract the first 50 numbers.
+first50 = sorted(list(fortunate_numbers))[:50]
+
+print('The first 50 fortunate numbers:')
+print(('{:<3} ' * 10).format(*(first50[:10])))
+print(('{:<3} ' * 10).format(*(first50[10:20])))
+print(('{:<3} ' * 10).format(*(first50[20:30])))
+print(('{:<3} ' * 10).format(*(first50[30:40])))
+print(('{:<3} ' * 10).format(*(first50[40:])))

Task/Fortunate-numbers/REXX/fortunate-numbers.rexx

@@ -0,0 +1,54 @@
+/*REXX program finds/displays fortunate numbers  N,  where  N  is specified (default=8).*/
+numeric digits 12
+parse arg n cols .                               /*obtain optional argument from the CL.*/
+if    n=='' |    n==","  then    n=  8           /*Not specified?  Then use the default.*/
+if cols=='' | cols==","  then cols= 10           /* "      "         "   "   "     "    */
+call genP n**2                                   /*build array of semaphores for primes.*/
+pp.= 1
+      do i=1  for n+1;   im= i - 1;    pp.i= pp.im * @.i   /*calculate primorial numbers*/
+      end   /*i*/
+i=i-1;  call genp pp.i + 1000
+                     title= ' fortunate numbers'
+w= 10                                            /*maximum width of a number in any col.*/
+say ' index │'center(title, 1 + cols*(w+1)     )
+say '───────┼'center(""   , 1 + cols*(w+1), '─')
+found= 0;                           idx= 1       /*number of fortunate (so far) & index.*/
+!!.= 0;                             maxFN= 0     /*(stemmed)  array of fortunate numbers*/
+        do j=1  until found==n;     pt= pp.j     /*search for fortunate numbers in range*/
+        pt= pp.j                                 /*get the precalculated primorial prime*/
+                     do m=3  by 2;  t= pt + m    /*find  M  that satisfies requirement. */
+                     if !.t==''  then leave      /*Is !.t prime?  Then we found a good M*/
+                     end   /*m*/
+        if !!.m  then iterate                    /*Fortunate # already found?  Then skip*/
+        !!.m= 1;      found= found + 1           /*assign fortunate number;  bump count.*/
+        maxFN= max(maxFN, t)                     /*obtain max fortunate # for displaying*/
+        end   /*j*/
+$=;                                 finds= 0     /*$:  line of output;    FINDS:  count.*/
+      do k=1  for maxFN;  if \!!.k  then iterate /*show the fortunate numbers we found. */
+      finds= finds + 1                           /*bump the  count of numbers (for $).  */
+      c= commas(k)                               /*maybe add commas to the number.      */
+      $= $  right(c, max(w, length(c) ) )        /*add a nice prime ──► list, allow big#*/
+      if found//cols\==0  then iterate           /*have we populated a line of output?  */
+      say center(idx, 7)'│'  substr($, 2);   $=  /*display what we have so far  (cols). */
+      idx= idx + cols                            /*bump the  index  count for the output*/
+      end   /*k*/
+
+if $\==''  then say center(idx, 7)"│"  substr($, 2)  /*possible display residual output.*/
+say '───────┴'center(""   , 1 + cols*(w+1), '─')     /*display the foot separator.      */
+say
+say 'Found '       commas(found)      title
+exit 0                                           /*stick a fork in it,  we're all done. */
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+commas: parse arg ?;  do jc=length(?)-3  to 1  by -3; ?=insert(',', ?, jc); end;  return ?
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+genP:        @.1=2; @.2=3; @.3=5; @.4=7;  @.5=11 /*define some low primes.              */
+      !.=0;  !.2=;  !.3=;  !.5=;  !.7=;   !.11=  /*   "     "   "    "     semaphores.  */
+                           #= 5;  sq.#= @.#**2   /*squares of low primes.*/
+        do j=@.#+2  by 2  to arg(1)              /*find odd primes from here on.        */
+        parse var j '' -1 _;     if _==5  then iterate       /*J ÷ by 5 ?               */
+        if j//3==0  then iterate;  if j//7==0  then iterate  /*" "  " 3?;    J ÷ by 7 ? */
+               do k=5  while sq.k<=j             /* [↓]  divide by the known odd primes.*/
+               if j // @.k == 0  then iterate j  /*Is  J ÷ X?  Then not prime.     ___  */
+               end   /*k*/                       /* [↑]  only process numbers  ≤  √ J   */
+        #= #+1;    @.#= j;    sq.#= j*j;  !.j=   /*bump # of Ps; assign next P;  P²; P# */
+        end          /*j*/;               return

Task/Fortunate-numbers/Raku/fortunate-numbers.raku

@@ -0,0 +1,11 @@
+my @primorials = [\*] grep *.is-prime, ^∞;
+
+say display :title("First 50 distinct fortunate numbers:\n"),
+   (squish sort @primorials[^75].hyper.map: -> $primorial {
+       (2..∞).first: (* + $primorial).is-prime
+   })[^50];
+
+sub display ($list, :$cols = 10, :$fmt = '%6d', :$title = "{+$list} matching:\n") {
+    cache $list;
+    $title ~ $list.batch($cols)».fmt($fmt).join: "\n"
+}

Task/Fortunate-numbers/Ruby/fortunate-numbers.rb

@@ -0,0 +1,16 @@
+require "gmp"
+
+primorials = Enumerator.new do |y|
+  cur = prod = 1
+  loop {y << prod *= (cur = GMP::Z(cur).nextprime)}
+end
+
+limit = 50
+fortunates = []
+while fortunates.size < limit*2 do
+  prim = primorials.next
+  fortunates << (GMP::Z(prim+2).nextprime - prim)
+  fortunates = fortunates.uniq.sort
+end
+
+p fortunates[0, limit]

Task/Fortunate-numbers/Sidef/fortunate-numbers.sidef

@@ -0,0 +1,20 @@
+func fortunate(n) {
+    var P = n.pn_primorial
+    2..Inf -> first {|m| P+m -> is_prob_prime }
+}
+
+var limit = 50
+var uniq = Set()
+var all = []
+
+for (var n = 1; uniq.len < 2*limit; ++n) {
+    var m = fortunate(n)
+    all << m
+    uniq << m
+}
+
+say "Fortunate numbers for n = 1..#{limit}:"
+say all.first(limit)
+
+say "\n#{limit} Fortunate numbers, sorted with duplicates removed:"
+say uniq.sort.first(limit)

Task/Fortunate-numbers/Wren/fortunate-numbers.wren

@@ -0,0 +1,24 @@
+import "/math" for Int
+import "/big" for BigInt
+import "/sort" for Sort
+import "/seq" for Lst
+import "/fmt" for Fmt
+
+var primes = Int.primeSieve(379)
+var primorial = BigInt.one
+var fortunates = []
+for (prime in primes) {
+    primorial = primorial * prime
+    var j = 3
+    while (true) {
+        if ((primorial + j).isProbablePrime(5)) {
+            fortunates.add(j)
+            break
+        }
+        j = j + 2
+    }
+}
+fortunates = Lst.distinct(fortunates)
+Sort.quick(fortunates)
+System.print("After sorting, the first 50 distinct fortunate numbers are:")
+for (chunk in Lst.chunks(fortunates[0..49], 10)) Fmt.print("$3d", chunk)