Data update

Task/Fortunate-numbers/C++/fortunate-numbers.cpp

@@ -0,0 +1,50 @@
+#include <algorithm>
+#include <cstdint>
+#include <iostream>
+#include <set>
+#include <vector>
+
+std::vector<int32_t> prime_numbers(const int32_t& limit) {
+	const int32_t half_limit = ( limit % 2 == 0 ) ? limit / 2 : 1 + limit / 2;
+	std::vector<bool> composite(half_limit, false);
+	for ( int32_t i = 1, p = 3; i < half_limit; p += 2, ++i ) {
+		if ( ! composite[i] ) {
+			for ( int32_t a = i + p; a < half_limit; a += p ) {
+				composite[a] = true;
+			}
+		}
+	}
+
+	std::vector<int32_t> primes{2};
+	for ( int32_t i = 1, p = 3; i < half_limit; p += 2, ++i ) {
+		if ( ! composite[i] ) {
+			primes.push_back(p);
+		}
+	}
+	return primes;
+}
+
+bool contains(const std::vector<int32_t>& list, const int32_t& n) {
+	return std::find(list.begin(), list.end(), n) != list.end();
+}
+
+int main() {
+	std::vector<int32_t> primes = prime_numbers(250'000'000);
+	std::set<int32_t> fortunates;
+	int32_t primorial = 1;
+	int32_t index = 0;
+
+	while ( fortunates.size() < 8 ) {
+		primorial *= primes[index++];
+		int32_t candidate = 3;
+		while ( ! contains(primes, primorial + candidate) ) {
+			candidate += 2;
+		}
+		fortunates.emplace(candidate);
+	}
+
+	std::cout << "The first 8 distinct fortunate numbers are:" << std::endl;
+	for ( const int32_t& fortunate : fortunates ) {
+		std::cout << fortunate << " ";
+	}
+}

Task/Fortunate-numbers/Java/fortunate-numbers.java

@@ -0,0 +1,41 @@
+import java.math.BigInteger;
+import java.util.BitSet;
+import java.util.NavigableSet;
+import java.util.TreeSet;
+
+public final class FortunateNumbers {
+
+	public static void main(String[] aArgs) {
+		BitSet primes = primeSieve(400);		
+		NavigableSet<Integer> fortunates = new TreeSet<Integer>();
+        BigInteger primorial = BigInteger.ONE;
+		
+		for ( int prime = 2; prime >= 0; prime = primes.nextSetBit(prime + 1) ) {
+		    primorial = primorial.multiply(BigInteger.valueOf(prime));
+		    int candidate = 3;
+		    while ( ! primorial.add(BigInteger.valueOf(candidate)).isProbablePrime(CERTAINTY_LEVEL) ) {
+		    	candidate += 2;
+		    }
+		    fortunates.add(candidate);
+		}
+		
+		System.out.println("The first 50 distinct fortunate numbers are:");
+		for ( int i = 0; i < 50; i++ ) {
+			System.out.print(String.format("%4d%s", fortunates.pollFirst(), ( i % 10 == 9 ? "\n" : "" )));
+		}
+	}
+	
+	private static BitSet primeSieve(int aNumber) {
+		BitSet sieve = new BitSet(aNumber + 1);
+		sieve.set(2, aNumber + 1);
+		for ( int i = 2; i <= Math.sqrt(aNumber); i = sieve.nextSetBit(i + 1) ) {
+			for ( int j = i * i; j <= aNumber; j = j + i ) {
+				sieve.clear(j);
+			}
+		}		
+		return sieve;
+	}
+	
+	private static final int CERTAINTY_LEVEL = 10;
+
+}