如何使用 FOR 循环打印前 N 个以 3 结尾的素数？

Question

My task is to print with JAVA the first N prime numbers that ends in 3 and then sum them. "N" is an input. Any advice? I'm newbie with JAVA and I'm getting crazy with this task.

For example, if N is 3, then the first three prime numbers that end in 3 are
3
13
23

So my program needs to print those three numbers as well as the sum of those three numbers (which is 39).

Answer 1

Split your problem into smaller sub-problems. You can start with a simple algorithm to find primes. Then build your requirement on top of that.

package example;

import java.util.stream.IntStream;

public class Example {

    public static void main(String[] args) {
        final int N = 3;

        int sumOfTheFirstNPrimesEndingWith3 = primes()// generates a stream of primes (see below)
            .filter(v -> v % 10 == 3)// filter for the primes ending with 3
            .limit(N)// limit to N
            .sum();
    }

    public static IntStream primes() {
        return IntStream.iterate(1, v -> v += 2)// generate an infinite stream of Ints starting at 1, incrementing by 2
            .skip(1L)// skip the fist generated number since we know 1 is not a prime
            .filter(Example::isPrime);// filter primes
    }

    public static boolean isPrime(int num) {
        return IntStream.iterate(num / 2, v -> v > 1, v -> --v)// generate a stream of ints, starting at num / 2 until (exclusive) 1
            .noneMatch(v -> num % v == 0);// check if our number "num" is dividable by the number in our stream
    }
}

Answer 2

To begin, you should take N as input and initialize a variable like this sum=0 . Then, start your foor loop as follows:

for (int i=0;i<N;i++){

}

Inside the loop you should cast your i into a String, so you can use

string.substring(string.length()-1) to get the last char and compare with "3". If it's a "3", use another for loop that starts from 2 to the half of the number you are comparing, to see if that is divisible. If so, add it to "sum" variable, else nothing. That's how it should work. I'm not writing the full code to let you enjoy it, but if you need, I'll do it.

Answer 3

You need to follow below steps:

1. Get the prime numbers from 1 to n.

2. Check whether it's last digit is divisible by 3 or not. If yes, add the value.

    private static void getPrimeNumbers(int n) { int sum = 0; for (int i = 1; i < n; i++) { if (hasNoFactors(i)) { String str = String.valueOf("" + i); if (Integer.valueOf(str.substring(str.length() - 1)) == 3) { sum = sum + i; } } } System.out.println("sum: "+sum); }

// Use Java8 Intstream API with range method:

    private static boolean hasNoFactors(int number) {
    return IntStream.range(2, number).noneMatch(f -> number % f == 0);
    }

Answer 4

Since you are a newcomer, lets start with the basics. I assume you know for loops, while loops and arrays in java.

First we need to check if a number is a prime or not. There are many advanced ways (Check this if you are interested: https://github.com/google/guava/blob/ef0ce9216a991ea40774ef82f4fd3ea255c48597/android/guava/src/com/google/common/math/LongMath.java#L1003 ) but lets stick to the basics for now.

Check out this code. It checks if a number is prime or not.

public static boolean isPrimeNumber(int number) {
        if (number == 2 || number == 3) {
            return true;
        }
        if (number % 2 == 0) {
            return false;
        }
        int sqrt = (int) Math.sqrt(number) + 1;
        for (int i = 3; i < sqrt; i += 2) {
            if (number % i == 0) {
                return false;
            }
        }
        return true;
 }

This method is fairly basic. I got this method from here ( https://www.java67.com/2014/01/how-to-check-if-given-number-is-prime.html )

As I told in the comments, these methods are already on the internet.

Now we should find the primes which ends in 3. Check out this method.

public static boolean doesEndsWith(int number, int end) {
        return String.valueOf(number).endsWith(String.valueOf(end));
}

This uses the built-in String.valueOf() to convert int to string so cross checking would be easy. I check the prime number (int number) against your number 3 (int end) here. This method can be integrated into final answer but I broken it to simplify things.

Now as a finale, we should print the sum of the primes. Check out this method:

public static int sumOfFilteredPrimes(int N) {
    int sum = 0;
    int i = 1;
    for (int j = 0; j < N; j++) {
        while (true) {
            if (isPrimeNumber(i) && doesEndsWith(i, 3)) {
                sum += i;
                i++;
                break;
            } else i++;
        }
    }
    return sum;
}

I use outer for loop as a counter which counts upto N, and inner while loop to search for prime numbers which match our parameters.

If you combine all methods, you get the answer (As I said in the comments)

public class App {
    public static void main(String[] args) {

        System.out.println(sumOfFilteredPrimes(3));

    }

    public static boolean isPrimeNumber(int number) {
        if (number == 2 || number == 3) {
            return true;
        }
        if (number % 2 == 0) {
            return false;
        }
        int sqrt = (int) Math.sqrt(number) + 1;
        for (int i = 3; i < sqrt; i += 2) {
            if (number % i == 0) {
                return false;
            }
        }
        return true;
    }

    public static boolean doesEndsWith(int number, int end) {
        return String.valueOf(number).endsWith(String.valueOf(end));
    }

    public static int sumOfFilteredPrimes(int N) {
        int sum = 0;
        int i = 1;
        for (int j = 0; j < N; j++) {
            while (true) {
                if (isPrimeNumber(i) && doesEndsWith(i, 3)) {
                    sum += i;
                    i++;
                    break;
                } else i++;
            }
        }
        return sum;
    }
}

Getting input from user is your part to work on... :)

Answer 5

Your task lends itself to reactive streams , in my opinion. In your case, you want some source to emit a [infinite] stream of integers and from those emitted integers you want to capture the first N prime numbers that end in 3.

Below are two implementations of your required task. First using class java.util.concurrent.Flow which was first added in JDK 9. Note that this is the first time I have used this class and I couldn't find an example that I understood so I pretty much winged it. As a result, I'm guessing it's a clumsy effort on my part. Nonetheless I wanted to share it with the community.

First a class that implements the Subscriber interface.

import java.util.concurrent.Flow;

public class Subscrib implements Flow.Subscriber<Integer> {
    private int  number;
    private int  sum;
    private long  counter;
    private Flow.Subscription  subscription;

    public Subscrib(int n) {
        number = n;
    }

    @Override
    public void onSubscribe(Flow.Subscription subscription) {
        this.subscription = subscription;
        subscription.request(counter++);
    }

    @Override
    public void onNext(Integer item) {
        System.out.println(item);
        sum += item.intValue();
        if (counter == number) {
            subscription.cancel();
        }
        else {
            subscription.request(counter++);
        }
    }

    @Override
    public void onError(Throwable throwable) {
        throwable.printStackTrace();
    }

    @Override
    public void onComplete() {
        System.out.println("sum = " + sum);
    }

    public static void main(String[] args) {
        if (args.length > 0) {
            int n = Integer.parseInt(args[0]);
            System.out.printf("n = %d%n", n);
            new Publishe().subscribe(new Subscrib(n));
        }
        else {
            System.out.println("ARGS: <total number of primes>");
        }
    }
}

Note that the above class has a main() method and so it is the class to launch when running this implementation.

Next the Publisher implementation.

import java.util.concurrent.Flow;

public class Publishe implements Flow.Publisher<Integer> {
    Flow.Subscriber<? super Integer>  subscriber;

    @Override
    public void subscribe(Flow.Subscriber<? super Integer> subscriber) {
        this.subscriber = subscriber;
        subscriber.onSubscribe(new Subscrip(this));
    }

    public Flow.Subscriber<? super Integer> getSubscriber() {
        return subscriber;
    }
}

Finally, the Subscription implementation.

import java.util.concurrent.Flow;

public class Subscrip implements Flow.Subscription {
    private int  last;
    private Publishe publishe;

    public Subscrip(Publishe publishe) {
        this.publishe = publishe;
        last = 1;
    }

    @Override
    public void request(long n) {
        if (last == 0) {
            publishe.getSubscriber().onError(new RuntimeException("Exhausted"));
        }
        else {
            last = getNextPrime();
            publishe.getSubscriber().onNext(Integer.valueOf(last));
        }
    }

    @Override
    public void cancel() {
        publishe.getSubscriber().onComplete();
    }

    private int getNextPrime() {
        int count = last + 1;
        while (count < Integer.MAX_VALUE) {
            if (isCandidate(count)) {
                break;
            }
            count++;
        }
        if (count == Integer.MAX_VALUE) {
            count = 0;
        }
        return count;
    }

    private boolean isCandidate(int x) {
        return isPrime(x)  &&  x % 10 == 3;
    }

    private boolean isPrime(int x) {
        boolean isPrime = true;
        double root = Math.sqrt(x);
        root = Math.floor(root);
        int limit = Math.round((float) root);
        for (int i = 2; i < limit; i++) {
            if (x % i == 0) {
                isPrime = false;
                break;
            }
        }
        return isPrime;
    }
}

Of-course the JDK arrived late to the reactive streams party and there are several, third-party libraries that provide implementations. These libraries existed before JDK 9 came out and so are compatible with earlier JDK versions, like JDK 1.8. Below is an implementation of your task that uses RxJava which has a much simpler (and richer) API.

import io.reactivex.rxjava3.core.Observable;

public class PrimeNos {
    private static boolean isPrime(long x) {
        boolean isPrime = true;
        double root = Math.sqrt(x);
        root = Math.floor(root);
        int limit = Math.round((float) root);
        for (int i = 2; i < limit; i++) {
            if (x % i == 0) {
                isPrime = false;
                break;
            }
        }
        return isPrime;
    }

    public static void main(String[] args) {
        if (args.length > 0) {
            int n = Integer.parseInt(args[0]);
            long[] sum = new long[1];
            Observable.range(2, Integer.MAX_VALUE - 1)
                      .filter(x -> isPrime(x))
                      .filter(x -> x % 10 == 3)
                      .take(n)
                      .subscribe(x -> {System.out.println(x); sum[0] += x;},
                                 t -> t.printStackTrace(),
                                 () -> System.out.println("sum = " + sum[0]));
        }
        else {
            System.out.println("ARGS: N");
        }
    }
}