Curious fractions in functional Ruby
Array multiple assignment
You pass arrays around, and you find yourself calling for x[1] and x.last - this is very unreadable, and brittle.
Ruby allows you to implicitely assign elements of the array to parameters in your block according to its location, so you could write the same "maps" like this:

  .map do|numerator, denominator| 
     [numerator.to_f / denominator.to_f, numerator.chars, denominator.chars, 
      numerator.chars &amp; denominator.chars] 
  end.map do |result, numerator_digits, denominator_digits, mutual_digit| 
    [result, numerator_digits - mutual_digit, denominator_digits - mutual_digit, 
     numerator_digits, denominator_digits]  
  end.select do|result, new_numerator_digits, new_denominator_digits| 
    result == new_numerator_digits.join.to_f/new_denominator_digits.join.to_f 
  end.map do |_, _, _, numerator_digits, denominator_digits| 
    Rational(numerator_digits.join.to_i, denominator_digits.join.to_i) 
  end.reduce(:*)


Note that unneeded array elements at the end of the array are truncated, so you don't have to write them. For the unneeded elements at the beginning of the array I've used the _ idiom which tells the method that I expect these parameters, but I won't need them.

If it deserves a comment - it deserves a method
Instead of commenting your code, consider refactoring it into methods. Each method will do one thing, and, given the proper name, will be descriptive when used, and easily read in itself:

def trivial?(pair)
  pair.any? {|y| y.chars.include? '0'}
end

def identical?(numerator, denominator)
  numerator == denominator
end

def larger_than_one?(numerator, denominator)
  numerator.to_i &gt; numerator.to_i
end

def has_common_digits?(numerator, denominator)
  (numerator.chars &amp; numerator.chars).size &gt; 0
end

a = 10.upto(99).to_a.map(&amp;:to_s)  
puts a.product(a) 
      .reject(&amp;method(:trivial?)) 
      .reject(&amp;method(:identical?)) 
      .reject(&amp;method(:larger_than_one?)) 
      .select(&amp;method(:has_common_digits?))


Make your steps logical
The last few steps you take look like they are held out with gum, and that you made some acrobatics to stay one-line and "idiomatic". It is better to make your methods do something you can explain, than simply adding and removing temp-variables:

def reduced_fraction(numerator, denominator)
  mutual_digit = numerator.chars &amp; denominator.chars
  (numerator.chars - mutual_digit).join.to_f / (denominator.chars - mutual_digit).join.to_f
end


a = 10.upto(99).to_a.map(&amp;:to_s)
puts a.product(a) 
      .reject(&amp;method(:trivial?)) 
      .reject(&amp;method(:identical?)) 
      .reject(&amp;method(:larger_than_one?)) 
      .select(&amp;method(:has_common_digits?))
      .select do |numerator, denominator| 
        numerator.to_f / denominator.to_f == reduced_fraction(numerator, denominator)
      end.map { |fraction| Rational(*fraction) }
      .reduce(:*)




Update
Yes, it seems that using &amp;method(:something) in map and multiple assignment are mutually exclusive... :(

I can suggest a few strategies where you don't have to fall back to using pair.first, pair.last:


Use multiple assignment in the first line of your method:

def identical?(pair)
  numerator, denominator = pair
  ...
end

Use a hash to hold your values, and use keyword arguments in your method

def identical?(numerator: nil, denominator: nil)
  numerator == denominator
end

a = 10.upto(99).to_a.map(&amp;:to_s)
puts a.product(a) 
      .reject(&amp;method(:trivial?)) 
      .map { |numerator, denominator| {numerator: numerator, denominator: denominator } }
      .reject(&amp;method(:identical?))