计算非质数

Question

I would like to create a method that will return the number of non prime numbers from int array.

The method that I use to mark the prime numbers in array look like this(this part don't need any changes):

public static int markNonePrimeNumbers(int[] array) {
        createInitialArray(100);
        for (int j = 2; j < array.length; j++) {
            for (int i = j * 2; i < array.length; i += j) {
                array[i] = 0;
            }
        }

I want to modify it so it could return numbers of array[i] = 0 and count it.

I went this far by adding a HashMap:

public static int[] markNonePrimeNumbers(int[] array) {
    createInitialArray(100);
    for (int j = 2; j < array.length; j++) {
        for (int i = j * 2; i < array.length; i += j) {
            array[i] = 0;
        }
    }
    Map<Integer, Integer> map = new HashMap<>();
    for (int key : array) {
        if (map.containsKey(key)) {
            int occurrence = map.get(key);
            occurrence++;
            map.put(key, occurrence);
        } else {
            map.put(key, 0);
        }
    }
    for (Integer key : map.keySet()) {
        int occurrence = map.get(key);
        System.out.println(occurrence);
    }

In general I am close but I don't know how to remove all index from Map that is above 1. It already calculate the amount of 0 on first index.

Answer 1

Here is my solution approach.

1) First crete a very simple method to check whether a number is prime or not. See below:

public static boolean checkPrime(int number) {
    if (number <= 1) {
        return false;
    }
    System.out.println(number);

    for (int i=2; i <= Math.sqrt(number); i++) {
        if(number % i == 0) {
            System.out.println(i);
            return false;
        } 
    }
    return true;

}

2) Create another method that will loop through your array and call the above method:

public static int numOfPrimesInArray(int[] arr){
    int counter = 0;
    for (int num: arr){
        if (!checkPrime(num)) counter++;
    }
    return counter;
}

3) Then simply call this from your main method:

public static void main(String[] args){
    int[] nums = {1,2,3,5,6,7,8,9,10};
    int nonprimes = numOfPrimesInArray(nums);
    System.out.println(nonprimes);
}

If I did not make any mistake when writing this shoul give you the number of non primes in your array.

Answer 2

Your method for calculating the prime numbers was not correct and hence your count was not coming correct. You approach to count the number of non prime numbers was almost on point.

I have modified the code a bit to work correctly here

public static void main(String[] args){

        int[] array = new int[]{1,2,3,4,57,10,7,11,13,17,16};
        for (int i = 0; i < array.length; i++) {
            int temp = 0;
            for(int j=2;j<=array[i]/2;j++)
            {
                temp=array[i]%j;
                if(temp==0)
                {
                    array[i] = 0;
                    break;
                }
            }
        }
        Map<Integer, Integer> map = new HashMap<>();
        for (int key : array) {
            if (map.containsKey(key)) {
                int occurrence = map.get(key);
                occurrence++;
                map.put(key, occurrence);
            } else {
                map.put(key, 1);
            }
        }
        if(map.containsKey(0)){
            System.out.println(map.get(0));
        } else {
            System.out.println("could not find");
        }
    }

Answer 3

One of the best ways to do this is to keep a running list of primes and then check the list. The first part is driver code so it needs no explanation.

        int[] array = new int[] { 1,19, 2, 3, 4, 57, 10, 7, 11,
                13, 17, 16 };
        List<Integer> nonPrimes = new ArrayList<>();
        for (int c : array) {
            if (!isPrime(c)) {
                nonPrimes.add(c);
            }
        }
        System.out.println(nonPrimes);

Here is the start of the prime lookup method. Key points are as follows:

1. It uses a LinkedHashSet to store the primes.
   a. It maintains order.
   b.Allows for quick lookup for a specific value

2. It finds all the primes up to the submitted value and stores them. This is only done if the submitted value is greater than than last prime recorded.

3. The subsequent candidate primes start with the last prime recorded + 2. Since all primes after 2 are odd, this is also guaranteed to be the next odd value. Candidates are incremented by 2 to skip even numbers.

4. to detect if a candidate is prime, division by previously recorded primes is done (but only up to the square root of the candidate).

    static Set<Integer> primes = new LinkedHashSet<>() {
        {   // seed the first two primes.
            add(2);
            add(3);
        }
    };

    // last recorded prime
    static int lastPrime = 3;

    public static boolean isPrime(int val) {
        for (int candidate = lastPrime+2; candidate <= val; candidate += 2) {
           int max = (int)(Math.sqrt(candidate)) + 1;
            for (int p : primes) {
                // if candidate is divisible by any prime, then discontinue
                // testing and move on to next candidate via outer loop
                if (candidate % p == 0) {
                    break;
                }
                // if the limit has been reached, then a prime has been
                // found, so add to list of primes and continue with
                // next candidate.  Only check up tot he square root of the candidate.
                if (p >= max) {
                    // add new found prime to list
                    primes.add(candidate);
                    lastPrime = candidate;
                    break;
                }
            }
        }
        // Now check the newly built (if required) hash set to see if the passed value
        // is in the list.
        return primes.contains(val);
    }