primes

The code snippet below checks whether a given number is a prime number. Can someone explain to me why this works? This code was on a study guide given to us for a Java exam. public static void main(String[] args) { int j = 2; int result = 0; int number = 0; Scanner reader = new Scanner(System.in); System.out.println("Please enter a number: "); number = reader.nextInt(); while (j <= number / 2) { if (number % j == 0) { result = 1; } j++; } if (result == 1) { System.out.println("Number: " + number + " is Not Prime."); } else { System.out.println("Number: " + number + " is Prime. "); } } Overall

When I run this code, even for just counting to the 10th prime number (instead of 1000) I get a skewed/jacked output--all "not prime" titles for my is_composite variable, my test_num is giving me prime and composite numbers, and my prime_count is off Some of the answers that developers have shared use functions and the math import--that's something we haven't yet covered. I am not trying to get the most efficient answer; I am just trying to write workable python code to understand the basics of looping. # test a prime by diving number by previous sequence of number(s) (% == 0). Do this by #

I run out of memory while finding the 10,001th prime number. object Euler0007 { def from(n: Int): Stream[Int] = n #:: from(n + 1) def sieve(s: Stream[Int]): Stream[Int] = s.head #:: sieve(s.filter(_ % s.head != 0)) def primes = sieve(from(2)) def main(args: Array[String]): Unit = { println(primes(10001)) } } Is this because after each "iteration" (is this the correct term in this context?) of primes , I increase the stack of functions to be called to get the next element by one? One solution that I've found on the web which doesn't resort to an iterative solution (which I'd like to avoid to

Consider the following method: public static boolean isPrime(int n) { return ! (new String(new char[n])).matches(".?|(..+?)\\1+"); } I've never been a regular expression guru, so can anyone fully explain how this method actually works? Furthermore , is it efficient compared to other possible methods for determining whether an integer is prime? First, note that this regex applies to numbers represented in a unary counting system, i.e. 1 is 1 11 is 2 111 is 3 1111 is 4 11111 is 5 111111 is 6 1111111 is 7 and so on. Really, any character can be used (hence the . s in the expression), but I'll use

I am practicing past exam papers for a basic java exam, and I am finding it difficult to make a for loop work for testing whether a number is prime. I don't want to complicate it by adding efficiency measures for larger numbers, just something that would at least work for 2 digit numbers. At the moment it always returns false even if n IS a prime number. I think my problem is that I am getting something wrong with the for loop itself and where to put the "return true;" and "return false;"... I'm sure it's a really basic mistake I'm making... public boolean isPrime(int n) { int i; for (i = 2; i

I am trying to write a program to find the largest prime factor of a very large number, and have tried several methods with varying success. All of the ones I have found so far have been unbelievably slow. I had a thought, and am wondering if this is a valid approach: long number = input; while(notPrime(number)) { number = number / getLowestDivisiblePrimeNumber(); } return number; This approach would take an input, and would do the following: 200 -> 100 -> 50 -> 25 -> 5 (return) 90 -> 45 -> 15 -> 5 (return) It divides currentNum repeatedly by the smallest divisible number (most often 2, or 3)

Is there a function which will return the approximate value of the n th prime? I think this would be something like an approximate inverse prime counting function. For example, if I gave this function 25 it would return a number around 100, or if I gave this function 1000 it would return a number around 8000. I don't care if the number returned is prime or not, but I do want it to be fast (so no generating the first n prime numbers to return the n th.) I would like this so that I can generate the first n prime numbers using a sieve ( Eratosthenes or Atkin ). Therefore, the approximation for n