Ruby ) 基本事实=[] （1..num）。每个都有| 如果num%i==0&&prime？（i） 基本事实[2,3] 放 打印素数系数（60）#=>[2,3,5] 放 打印素数因子（13195）#[5,7,13,29] 放 完美。我以前使用过select和an

) 基本事实=[] （1..num）。每个都有| 如果num%i==0&&prime？（i） 基本事实[2,3] 放 打印素数系数（60）#=>[2,3,5] 放 打印素数因子（13195）#[5,7,13,29] 放

---

完美。我以前使用过select和any，但我从来没有想过这样组合它们。看来我还有很长的路要走。干杯@欢迎来到StackOverflow！如果有帮助的话就别担心。谢谢，多好的地方啊。我想知道，因为我认为你给了一个先进的答案，如果它可以用每一个和一个IF像我最初尝试的那样。@ 7UM可以做到，你当前的循环逻辑是不正确的-我已经更新了SeaFrimeSimple。我以前使用过select和any，但我从来没有想过这样组合它们。看来我还有很长的路要走。干杯@欢迎来到StackOverflow！如果有帮助的话就别担心。谢谢，多好的地方啊。我想知道，因为我认为你给了一个先进的答案，如果它可以使用每一个和一个IF像我最初尝试的那样。@ 7UM可以做到，你当前的循环逻辑是不正确的-我已经更新了答案它不是最大的素数高达13195所要的，这是131195年的最大素数。@CarySwoveland你是对的，我没有正确阅读，是因子的“树”是它想要的它不是13195年的最大素数，它是131195年的最大素数。@CarySwoveland你是对的，我没有正确阅读，是因子的“树”是它想要的

    # find out all numbers that divide without remainder into 13195

    array = []
    count = 2

    13195.times do 
        if 13195 % count == 0
            array.push(count)   
        end
        count += 1
    end



    #From those numbers that divide cleanly into 13195, find out which are prime aka can only be divided by themselves and 1

    new_count = 2
    primes = 0

    array.each do |x|
        while new_count < x 
            if x % new_count != 0
            else
                if x > primes
                primes = x
            end
            end
        new_count += 1
        end
    end

     puts primes

result = array.select {|x| not (2..x-1).any? {|i| x % i  == 0} }.max
#=> 29

array.each do |x|
    is_prime = true
    while new_count < x 
        if x % new_count == 0
            is_prime = false
        end
        new_count += 1
    end
    new_count = 2
    primes = x if is_prime and x > primes
end

require 'prime'

def largest_prime_factor(n)
  Prime.prime_division(n).max_by(&:first).first
end

largest_prime_factor(13195)
  #=> 29

(1..1000).to_a.sample(15).sort.each {|n| puts "%3d: %3d" % [n, largest_prime_factor(n)]}
 61:  61
 80:   5
 88:  11
250:   5
304:  19
414:  23
514: 257
548: 137
679:  97
716: 179
754:  29
770:  11
906: 151
907: 907
968:  11

n = 13195
a = Prime.prime_division(n)
  #=> [[5, 1], [7, 1], [13, 1], [29, 1]] 
b = a.max_by(&:first)
  #=> [29, 1] 
b.first
  #=> 29 

Prime.prime_division(n).last.first

require 'prime'
primes = Prime.each(13195).to_a
upper = primes.last

def prime_factors(n)
  prime_array = []    
  p = 2
  if n < 2
      return p
  end


  while p < n && p < 1000000
    if n % p == 0
      prime_array.push(p)
    end
  p +=1
  end

  primes = []

  prime_array.size.times do |i|
    if n > 1
      n = n / prime_array[i]
      primes.push(prime_array[i])
    end
  end
  return primes.last
end

#prime_factors(600851475143)
puts prime_factors(600851475143)

#prime_factors(13195)
puts prime_factors(13195)

require 'prime'
(13195).prime_division.map(&:first).max
=> 29

def prime?(num)

    if num < 2
        return false
    end
   (2...num).each do |ele|
      if num % ele == 0 
        return false
      end
   end
  return true
end

def prime_factors(num)

prime_facts = []

(1..num).each do |i|
    if  num % i == 0 && prime?(i)
        prime_facts << i
    end
end
return prime_facts
end 

print prime_factors(24) #=> [2, 3]
puts
print prime_factors(60) #=> [2, 3, 5]
puts
print prime_factors(13195) # [5, 7, 13, 29]
puts