prime-num | math library for JavaScript and Node.js | Math library

The answer is "usually you don't need a table whose size is a prime number, but there are some implementation reasons why you might want to do this."

Fundamentally, hash tables work best when hash codes are spread out as close to uniformly at random as possible. That prevents items from clustering in any one location within the table. At some level, provided that you have a good enough hash function to make this happen, the size of the table doesn't matter.

So why do folks say to pick tables whose size is a prime? There are two main reasons for this, and they're due to specific cases that don't arise in all hash tables.

One reason why you sometimes see prime-sized tables is due to a specific way of building hash functions. You can build reasonable hash functions by picking functions of the form h(x) = (ax + b) mod p, where a is a number in {1, 2, ..., p-1} and b is a number in the {0, 1, 2, ..., p-1}, assuming that p is a prime. If p isn't prime, hash functions of this form don't spread items out uniformly. As a result, if you're using a hash function like this one, then it makes sense to pick a table whose size is a prime number.

The second reason you see advice about prime-sized tables is if you're using an open-addressing strategy like quadratic probing or double hashing. These hashing strategies work by hashing items to some initial location k. If that slot is full, we look at slot (k + r) mod T, where T is the table size and r is some offset. If that slot is full, we then check (k + 2r) mod T, then (k + 3r) mod T, etc. If the table size is a prime number and r isn't zero, this has the nice, desirable property that these indices will cycle through all the different positions in the table without ever repeating, ensuring that items are nicely distributed over the table. With non-prime table sizes, it's possible that this strategy gets stuck cycling through a small number of slots, which gives less flexibility in positions and can cause insertions to fail well before the table fills up.

So assuming you aren't using double hashing or quadratic probing, and assuming you have a strong enough hash function, feel free to size your table however you'd like.

You didn't manage to translate the first function correctly, no.

• The function is_premier() returns a single boolean value, while is_prime_v3() returns a generator of strings.

• The is_prime_v3() generator produces multiple "Prime" values for non-prime numbers, e.g. for 8, the test 8 % 3 == 0 is false, so "Prime" is generated:

Step one: Move the logic for prime testing to a standalone function.

The break is important!

In your code the for loop was looping, but was never breaking until it reached your original number. You need to break out of the for loop once a prime number is found. If the loop completes without breaking, the else statement will be run. The user input should then be outside of the loop and after the else statement.

As a side note, in Python, brackets are not required on if and while statements, although I did not edit those.

In the first approach, you testing divisibility with each number from 1 to sqrt(x), so the complexity of testing a single number is sqrt(x). According to this formula, the sum of first n roots can be approximated to n*sqrt(n).
Time complexity of method 1: O(N*sqrt(N)) (N is the total count of numbers being tested).

In the second approach, there are 2 cases:

1. If a number isn't prime, all primes upto n are tested. Complexity - O(n/6) = O(n)
2. If a number is prime, we can approximate the complexity to be O(log(n)) (there might be a more accurate calculation of the complexity for this case, I'm making an approximation since this wouldn't matter in the proof)

For the prime numbers, using the fact that we test them with (n/6) primes, the complexity would become 5/6 + 7/6 + 11/6 + 13/6 + 17/6 ..... (last prime before n)/6. This can be reduced to (sum of all prime numbers till n)/6 for the time being. Now, the sum of all prime numbers upto N can be approximated as N^2/(2*logN). Thus the complexity for this step becomes N^2/(6*(2*logN)) = N^2/(12*lognN).

Time complexity of method 2: O(N^2/(12*lognN)) (N is the total count of numbers being tested).

(if you want, you can make more accurate bounds for the time complexities of each step. I have made a few approximations since it helps in proving the point without making any overoptimistic assumption).

1. Please use ; after breaking condition which is i < arr.length here for (let i = 2; i < arr.length, i++) {}

2. You can loop over arr the way you are doing here and validate if index at which you are looping is prime itself.

3. If 2nd step is met you can add the value into summation var sum

4. return sum.

Please follow this thread to find know more about calculating if value is prime. Number prime test in JavaScript

The issue is all your members need to be initialized before entering the constructor body. So you could do:

You need to compile with --release flag. By default, the Crystal compiler is focused on compilation speed, so you get a compiled program fast. This is particularly important during development. If you want a program that runs fast, you need to pass the --release flag which tells the compiler to take time for optimizations (that's handled by LLVM btw.).

You might also be able to shave off some time by using wrapping operators like &+ in location where it's guaranteed that the result can'd overflow. That skips some overflow checks.

A few other remarks:

Instead of 0.to_i64, you can just use a Int64 literal: 0_i64.

Use the following fact:

If n is not prime, then it has a divisor d such that d*d <= n.