палиндромные числа

Question

Вот рабочий код:

p = (10..14).map { |a|
  (a..14).map { |b|
    a * b
  }
flatten.select { |p|
  p.to_s == p.to_s.reverse
}

Но я хочу сохранить информацию о «a» и «b», которая произвела «a * b»:

p = (10..14).map { |a|
  (a..14).map { |b|
    [a, b, a * b, '=']
  }
}.select { |v|
  v[2].to_s == v[2].to_s.reverse
}

puts p

Этот код печатает непалиндромное число. Я думаю, что причина в массиве. Как мне изменить код, чтобы получить палиндромное число?

Answer 1

Вы хотите сгладить только один уровень, поэтому используйте flatten(1).

(10..14).map { |a|
  (a..14).map { |b|
    [a, b, a * b, '=']
  }
}.flatten(1).select { |v|
  v[2].to_s == v[2].to_s.reverse
}

В качестве альтернативы, замените ваш внешний map на flat_map:

(10..14).flat_map { |a|
  (a..14).map { |b|
    [a, b, a * b, '=']
  }
}.select { |v|
  v[2].to_s == v[2].to_s.reverse
}

Примечание : flatten принимает аргумент начиная с Ruby 1.8.7.flat_map является новым для Ruby 1.9.2.Убедитесь, что у вас правильная версия, или require "backports/1.9.2/enumerable/flat_map" или require "backports/1.8.7/array/flatten".

Answer 2

palindromes = []

(10..14).each do |a|
  (a..14).each do |b|
    p = (a * b).to_s
    palindromes << [a,b] if p == p.reverse
  end
end

puts palindromes.join(',')

wesbailey@feynman:~/code_katas> ruby palindrome.rb 
11,11

Answer 3

Да, поскольку вы не вызываете flatten во второй версии, массив слишком вложенный и выбор не работает, потому что v - это строка элементов, а не один элемент. Однако если вы просто вызовете flatten, как в первой версии, результирующий массив будет слишком плоским.

Есть несколько способов решить эту проблему:

1. В 1.9.2 вы можете заменить внешний вызов на «map with flat_map which works like map`, но автоматически создаст плоский массив.
2. В 1.8.7+ вы можете вызвать flatten(1) вместо flatten, что сгладит массив ровно на один уровень вложенности, в результате чего вы получите желаемую структуру.
3. Вместо массива вы можете определить класс для представления числа, что устраняет проблему случайного выравнивания внутренних массивов и позволяет более осмысленно обращаться к свойствам числа.

Вариант 3 может выглядеть так:

Product = Struct.new(:factor1, :factor2) do
  def product
    factor1 * factor2
  end

  def to_s
    "#{factor1} * #{factor2} = #{product}"
  end
end

products = (10..14).map { |a|
  (a..14).map { |b|
    Product.new(a,b)
  }
}.flatten.select { |prod|
  prod.product.to_s == prod.product.to_s.reverse
}

puts products