在 Ruby 1.9 中有一个 Prime 类，您可以使用它来生成素数，或测试一个数字是否为素数：
require 'prime'
Prime.take(10) #=> [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
Prime.take_while {|p| p < 10 } #=> [2, 3, 5, 7]
Prime.prime?(19) #=> true
Prime 实现了该each方法并包含 Enumerable 模块，因此您可以执行各种有趣的事情，例如过滤、映射等。
如果你想自己做，那么这样的事情可能会起作用：
class Integer < Numeric
def is_prime?
return false if self <= 1
2.upto(Math.sqrt(self).to_i) do |x|
return false if self%x == 0
end
true
end
def next_prime
n = self+1
n = n + 1 until n.is_prime?
n
end
end
现在获取前 10 个素数：
e = Enumerator.new do |y|
n = 2
loop do
y << n
n = n.next_prime
end
end
primes = e.take 10
require 'prime'
Prime.first(10) # => [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
查看埃拉托色尼筛。这不是 Ruby 特有的，但它是一种生成素数的算法。这个算法背后的想法是你有一个数字列表/数组说
2..1000
你抓住第一个数字，2。遍历列表并消除所有能被 2 整除的东西。你将剩下除了 2 本身之外不能被 2 整除的所有东西（例如 [2,3,5,7,9, 11...999]
转到下一个数字 3。再一次，消除可以除以 3 的所有内容。继续前进，直到到达最后一个数字，您将得到一系列素数。希望有帮助。
# First 10 Prime Numbers
number = 2
count = 1
while count < 10
j = 2
while j <= number
break if number%j == 0
j += 1
end
if j == number
puts number
count += 1
end
number += 1
end
实施 Eratosthene 筛（或多或少）
def primes(size)
arr=(0..size).to_a
arr[0]=nil
arr[1]=nil
max=size
(size/2+1).times do |n|
if(arr[n]!=nil) then
cnt=2*n
while cnt <= max do
arr[cnt]=nil
cnt+=n
end
end
end
arr.compact!
end
此外，这是我非常喜欢的单线
def primes_c a
p=[];(2..a).each{|n| p.any?{|l|n%l==0}?nil:p.push(n)};p
end
当然，那些会在第一个数字中找到素n数，而不是第一个n素数，但我认为适应不需要太多努力。
这是一种从头开始生成素数直至“最大”参数的方法，无需使用素数或数学。让我知道你的想法。
def prime_test max
primes = []
(1..max).each {|num|
if
(2..num-1).all? {|denom| num%denom >0}
then
primes.push(num)
end
}
puts primes
end
prime_test #enter max
我认为对于非常大的最大数字来说，这可能是一个昂贵的解决方案，但在其他方面似乎效果很好：
def multiples array
target = array.shift
array.map{|item| item if target % item == 0}.compact
end
def prime? number
reversed_range_array = *(2..number).reverse_each
multiples_of_number = multiples(reversed_range_array)
multiples_of_number.size == 0 ? true : false
end
def primes_in_range max_number
range_array = *(2..max_number)
range_array.map{|number| number if prime?(number)}.compact
end
class Numeric
def prime?
return self == 2 if self % 2 == 0
(3..Math.sqrt(self)).step(2) do |x|
return false if self % x == 0
end
true
end
end
有了这个，现在3.prime?返回true，6.prime?返回false。
无需努力实现筛算法，只需验证直到平方根的可除性并跳过奇数，仍然可以快速节省时间。然后，遍历数字，检查素数。
记住：人类时间>机器时间。
我这样做是为了编码 kata，并使用 Eratosthenes 筛。
puts "Up to which number should I look for prime numbers?"
number = $stdin.gets.chomp
n = number.to_i
array = (1..n).to_a
i = 0
while array[i]**2 < n
i = i + 1
array = array.select do |element|
element % array[i] != 0 || element / array[i] == 1
end
end
puts array.drop(1)
Ruby：打印 N 个素数 http://mishra-vishal.blogspot.in/2013/07/include-math-def-printnprimenumbernoofp.html
include Math
def print_n_prime_number(no_of_primes=nil)
no_of_primes = 100 if no_of_primes.nil?
puts "1 \n2"
count = 1
number = 3
while count < no_of_primes
sq_rt_of_num = Math.sqrt(number)
number_divisible_by = 2
while number_divisible_by <= sq_rt_of_num
break if(number % number_divisible_by == 0)
number_divisible_by = number_divisible_by + 1
end
if number_divisible_by > sq_rt_of_num
puts number
count = count+1
end
number = number + 2
end
end
print_n_prime_number
与问题本身完全无关，但仅供参考：
试试这个片段：
require 'prime'
for p in Prime::Generator23.new
# `p` brings subsequent prime numbers until the end of the days (or until your computer explodes)
# so here put your fabulous code
break if #.. I don't know, I suppose in some moment it should stop the loop
end
fp
如果您需要它，您还可以使用其他更复杂的生成器作为Prime::TrialDivisionGeneratoror Prime::EratosthenesGenerator。更多信息
这是一个超级紧凑的方法，它用一行代码生成一个素数数组。
def get_prime(up_to)
(2..up_to).select { |num| (2...num).all? { |div| (num % div).positive? } }
end
def get_prime(number)
(2..number).each do |no|
if (2..no-1).all? {|num| no % num > 0}
puts no
end
end
end
get_prime(100)