如何找到给定输入值以下的所有质数？

Question

I have been tasked with finding all the prime numbers in Ruby (without using the prime method)

Below is my logic, the issue, my code and the output.

My Logic:

All primes have only 2 distinct divisors. Hence if we count the number of divisors a number has and it is greater than 2, then it is not prime (apart from 1, which I havn't dealth with yet)

Therefore I have made an array, filled it with all the numbers from 1 – 10 (I'll do 1000 later) and am removing all that have more than 2 divisors

The issue:

The code below seems to not be checking 5,7, or 9.

My code (ruby)

#Create an array that will be your list of prime numbers
primes = [] 
 
#create variables
x = 1
counter = 0
y=1  
 
#fill array with numbers (I'm using 10 rather than 1000 for now)
for x in 1..10 # 1..10 is inclusive in ruby
primes.push(x)  #put x into primes array
end
 
primes.each do |prime_number|  for y in 1..10 do #for each x and each y, do the following
      puts "#{prime_number} , #{y}" #puts is print with a new line
      if prime_number % y == 0   #check if element in array divided by numbers 1-10 is mod 0
        counter +=1   #is so increase counter by 1
        if counter > 2
          primes.delete(prime_number)
          counter = 0   #if counter get's above 2 then number cannot be prime. hence remove it from array
        end
      end
    end
end
 
puts primes  #print out primes to check result
sum_of_primes = primes.inject(:+)  #sum of all primes
puts sum_of_primes #print answer

Here is output:

1 , 1
1 , 2
1 , 3
1 , 4
1 , 5
1 , 6
1 , 7
1 , 8
1 , 9
1 , 10
2 , 1
2 , 2
2 , 3
2 , 4
2 , 5
2 , 6
2 , 7
2 , 8
2 , 9
2 , 10
4 , 1
4 , 2
4 , 3
4 , 4
4 , 5
4 , 6
4 , 7
4 , 8
4 , 9
4 , 10
6 , 1
6 , 2
6 , 3
6 , 4
6 , 5
6 , 6
6 , 7
6 , 8
6 , 9
6 , 10
8 , 1
8 , 2
8 , 3
8 , 4
8 , 5
8 , 6
8 , 7
8 , 8
8 , 9
8 , 10
10 , 1
10 , 2
10 , 3
10 , 4
10 , 5
10 , 6
10 , 7
10 , 8
10 , 9
10 , 10
[1, 3, 5, 7, 9]
25 

Answer 1

TL;DR

You can refactor your iterators to avoid explicit loops and counters. Even though you're still iterating, leveraging core methods can be faster and easier to debug.

For completeness, I also provide an example using Ruby's Prime module from the standard library. This is probably the most correct solution, but the use of the module is a solution that largely dodges the iteration question entirely, at least from a pragmatic point of view.

Simplify Using Iterators

If your question is for schoolwork, then my answer may not help you learn whatever it is your instructor wants you to learn from the lesson. Other answers may explain why your current code doesn't work as intended; I will instead focus on an alternate approaches that leverage more of Ruby's core capabilities.

Here's one way to find all the positive primes up to a given maximum value:

# Use a Range object to check each Integer between 2 and
# (int - 1) to see if there's a remainder. If not, the value
# of i is added to the anonymous array returned by #map. The
# int is prime if there are no elements in the array.
def prime? int 
  (2...int).none? { |i| int.modulo(i).zero? }
end

# Iterate from 2 to the maximum value, using #select to
# return the subset of values passed to the block where the
# return value of #prime? is truthy.
#
# NB: 1 isn't prime, which is why we start from 2. Reference:
# <https://en.wikipedia.org/wiki/Prime_number#Primality_of_one>
def find_primes max_value
  2.upto(max_value).select { |i| prime? i }
end

find_primes 10
#=> [2, 3, 5, 7]

There are certainly other ways to do this, but leveraging built-in iterators like Array#none? and Array#select while avoiding counters seems like a net win to me. Your mileage may vary.

Use the Standard Library

As a further simplification, you might simply use the Prime module from the Ruby standard library. For example, Prime#each returns an enumerable Prime::EratosthenesGenerator . You can then call Enumerable#to_a to convert the results to an Array. For example:

require 'prime'

def primes max_value
  Prime.each(max_value).to_a
end

primes 10
#=> [2, 3, 5, 7]

Leveraging core and standard library classes is usually faster (and potentially less error-prone) than implementing your own routines, but this may be "a bridge too far" for educational purposes. Nevertheless, I include it here for completeness and to help future visitors.

Answer 2

The code below seems to not be checking 5,7, or 9

That's because you are deleting elements from the array while traversing it.

As a workaround, you can traverse the array in reverse order using reverse_each :

primes = (2..20).to_a

primes.reverse_each do |prime_number|
  counter = 0
  1.upto(20) do |y|
    if prime_number % y == 0
      counter += 1
      primes.delete(prime_number) if counter > 2
    end
  end
end

primes
#=> [2, 3, 5, 7, 11, 13, 17, 19]

Or you could use delete_if which deletes the current element in-place if the block evaluates to true :

primes = (2..20).to_a

primes.delete_if do |prime_number|
  counter = 0
  (1..20).find do |y|
    counter += 1 if prime_number % y == 0
    counter > 2
  end
end

primes
#=> [2, 3, 5, 7, 11, 13, 17, 19]