Ruby coding: List out all factors of numbers from 1-100

Question

Write a function that prints out all the factors for each of the numbers 1 through 100.

Really amateur coder but here's my attempt so far.

def factors_numbers(n1,n2)
  (n1..n2).each do |n|
    factors = []
    factors << 1 ##every number has a factor of 1
    factors << n ##every number is a factor of itself
    i = 1
    while i < n 
        new_number = n % (n-i) 
        if new_number == 0 #if 0, divisible and that means two numbers are factors
            factors << new_number
            factors << (n-i)
        end
        i += 1
    end
    return factors
  end
end

Answer 1

Here is an improved version of your code:

def factors_numbers(n1,n2)
  all_factors = {}
  (n1..n2).each do |n|
    factors = []
    (1..Math.sqrt(n).floor).each do |i|
      remainder = n % i
      if remainder == 0 #if 0, divisible and that means two numbers are factors
        factors << i
        factors << n/i
      end
    end
    factors = factors.sort.uniq
    puts "Factors of #{n}: #{factors.join(',')}"
    all_factors[n]=[factors]
  end
  return all_factors
end

Answer 2

Do you want unique factors? That is, in the range 1-100, should I get the number 1 a hundred times, or only once?

The easiest way to do this is by leveraging the "inject" Enumerable method.

def find_all_factors_between(n1,n2)
  (n1..n2).inject([]) do |factors, num|
    factors + (1..num).inject([]) { |arry, test| num % test == 0 ? arry + [test] : arry }
  end
end

One final thing to note is that Ruby has implicit returns; that is, as long as the output of the last line of your method is your factors variable, you don't have to say return factors.

Answer 3

And my entry would be:

def find_all_factors_between(n1, n2)
  factors = -> (n) { (1..n).select {|i| n % i == 0} }
  (n1..n2).each { |n| puts "Factors of #{n}: #{factors.(n).join(', ')}" }
end

find_all_factors_between(1,100)

Answer 4

Well, if you wanted to do it with enumerables, there's always

def factor_numbers(rng)
  factors = rng.map do |n|
    (1..Math.sqrt(n).floor)         # search numbers <= square root
      .select { |d| n % d == 0 }    # find factors <= square root
      .flat_map { |x| [x, n / x] }  # combine with factors >= square root
      .sort                         # order from least to greatest
      .uniq                         # remove dupes (basically the square root)
  end

  Hash[rng.zip(factors)]            # rng = keys, factors = values
end

puts factor_numbers(1..100)

It's not the most efficient, but my point is just that many of the for/while constructs you'd see in languages like C or JavaScript can be expressed in other ways in Ruby.

Answer 5

(n1..n2).each{|x| print "#{x}: #{(1..x).select{|y| x % y == 0}}\n"}

That oughta do it :)

edit: Implemented Cary Swoveland's suggestion

Answer 6

def factor_nums(n1,n2)
    all_factors = {}
    (n1..n2).each do |n|
        factors = []
        (1..n).each do |i|
            remainder = n % i
            factors << i if remainder == 0
        end
        all_factors[n] = factors
    end
return all_factors
end