Is there a way to substitute operators depending on a condition? - ruby

Question

I have an if/else condition, and the if and else sections are identical, save for the operator used. In one case <, and in the other >. Is there a way to conditionally set that operator, to DRY out the code?
if count_year < end_year
while count_year <= end_year
if count_year % 4 == 0
if count_year % 100 != 0
all_years << count_year unless (count_year % 400 == 0)
end
end
count_year += 1
end
puts all_years
elsif count_year > end_year
while count_year >= end_year
if count_year % 4 == 0
if count_year % 100 != 0
all_years << count_year unless (count_year % 400 == 0)
end
end
count_year -= 1
end
puts all_years.reverse
end
This is part of a program for printing out leap years between two given years. I feel like there must be a way to not have to repeat the loop twice. Something like: count_year < end_year ? operator = "<" : operator = ">" - Then using that variable to substitute the operator into a code block or something? Any ideas?

Answer 1

For one small improvement, you can extract really identical parts into a method. Then duplication stops being so massive.
# I'm too lazy to come up with a proper name for it.
def foo count_year, all_years
if count_year % 4 == 0
if count_year % 100 != 0
all_years << count_year unless (count_year % 400 == 0)
end
end
end
# later...
if count_year < end_year
while count_year <= end_year
foo count_year, all_years
count_year += 1
end
puts all_years
elsif count_year > end_year
while count_year >= end_year
foo count_year, all_years
count_year -= 1
end
puts all_years.reverse
end
But, the operator substitution...
Yes, there is a way to dynamically choose an operator for evaluation. You see, operators in ruby are just method calls, nothing more. These two lines are equivalent:
7 > 5
7.>(5)
And here's a snippet that chooses random operator for comparison. I leave it up to you to adapt it for your problem (if you want, that is. I advise you against this).
def is_7_greater_than_5
operator = [:<, :>].sample # pick random operator
7.send(operator, 5)
end
is_7_greater_than_5 # => false
is_7_greater_than_5 # => false
is_7_greater_than_5 # => true
is_7_greater_than_5 # => true
is_7_greater_than_5 # => true

Answer 2

def example count_year, end_year
all_years = []
dir, test = count_year < end_year ?
[ 1, proc { |c, e| c <= e }] : count_year > end_year ?
[-1, proc { |c, e| c > e }] :
[ 0, proc { |c, e| false }]
while test.call count_year, end_year
if count_year % 4 == 0
if count_year % 100 != 0
all_years << count_year unless count_year % 400 == 0
end
end
count_year += dir
puts dir > 0 ? all_years : all_years.reverse
end
end

Answer 3

Aww. Why did you do a code golf exercise and accept an answer so quickly? Boo! :( hehe. just kidding. The early bird gets the worm. I perhaps took the problem too literally as I think you're just looking to experiment with compare.
I would use the built in functions of ruby and decomposed this method into a class. :)
require 'date'
class LeapYearFinder
attr_reader :years, :years_reversed
def initialize(start_year, end_year)
#start_year = Date.parse("1/1/#{start_year.to_s}")
#end_year = Date.parse("1/1/#{end_year.to_s}")
#years ||= leap_years
end
def compare_range
#compare_range ||= Range.new(#start_year, #end_year)
end
def leap_years
years = []
compare_range.step {|x| years << x.year if x.leap? }
years.uniq!
end
def years_reversed
#years.reverse
end
end
lp = LeapYearFinder.new(1900, 2012)
puts "Years putzed"
lp.years.map {|x| puts x}
puts "Years reversed"
lp.years_reversed.map {|x| puts x}
Some corner case issues
handle a reverse date input
step properly through the range thus avoiding the uniq! and maybe yielding better performance