Commenting the streams and lambdas increased the score from 44% to 55%, as time complexity decreased. Morale: don't use streams in Codility exercises

Codility semi primes - take 2

// you can also use imports, for example:

import java.util.*;
import java.util.stream.Collectors;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    //codility semi primes
    public static void main(String[] args) {
        Solution app = new Solution();
        int[] test = app.solution(26, new int[]{1, 4, 16}, new int[]{26, 10, 20});
        int debug = 1;
    }

    public int[] solution(int N, int[] P, int[] Q) {
        int[] arrayToReturn = new int[P.length];

        //compute all primes below largest number, just once
        Set<Integer> primesBelowLargest = computePrimesBelow(N);
        int absoluteSmallest = computeSmallest(P, Q);

        Set<Integer> semiPrimesBelowLargest = computeSemiPrimesBelow(primesBelowLargest, N, absoluteSmallest);

        for (int i = 0; i < P.length; i++) {
            int largest = Math.max(P[i], Q[i]);
            int smallest = Math.min(P[i], Q[i]);

            Object[] handy = semiPrimesBelowLargest.toArray();
            int counter = 0;
            for (int j = 0; j < semiPrimesBelowLargest.size(); j++) {
                int current = (int) handy[j];
                if (current >= smallest && current <= largest) {
                    counter++;
                }
            }
            arrayToReturn[i] = counter;
//            arrayToReturn[i] = semiPrimesBelowLargest.stream()
//                    .filter(j -> j >= smallest && j <= largest)
//                    .collect(Collectors.toSet()).size();
        }

        return arrayToReturn;
    }

    private int computeSmallest(int[] p, int[] q) {
        int smallest = Integer.MAX_VALUE;
        for (int i = 0; i < p.length; i++) {
            if (p[i] < smallest) {
                smallest = p[i];
            }
        }
        for (int i = 0; i < q.length; i++) {
            if (q[i] < smallest) {
                smallest = q[i];
            }
        }
        return smallest;
    }

    private Set<Integer> computeSemiPrimesBelow(Set<Integer> primesBelowNumber, int max, int min) {
        Set<Integer> semiPrimes = new HashSet<>();
        Object[] primesArray = primesBelowNumber.toArray();

        for (int i = 0; i < primesArray.length; i++) {
            for (int j = i; j < primesArray.length; j++) {
                int product = (int) primesArray[i] * (int) primesArray[j];
                if (product <= max && product >= min) {
                    semiPrimes.add(product);
                }
            }
        }
        return semiPrimes;
    }

    private Set<Integer> computePrimesBelow(int number) {
        int sqrt = (int) Math.floor(Math.sqrt(number));

        Set<Integer> primes = initialisePrimesArray(number);
        Set<Integer> sieveCopy = new HashSet<>(primes);

        for (Integer i : sieveCopy) {
            // We need only check up to the square root of the max
            if (i <= sqrt) {
                int temp = i;
                while (temp + i <= number) {
                    temp += i;
                    primes.remove(temp);
                }
            }
        }
        return primes;
    }

    private Set<Integer> initialisePrimesArray(int max) {
        Set<Integer> sieve = new HashSet<>();
        sieve.add(2);
        for (int i = 3; i <= max; i += 2) {
            sieve.add(i);
        }
        return sieve;
    }
}