In this HackerRank Lazy Evaluation problem solution in ruby programming, Lazy evaluation is an evaluation strategy that delays the assessment of an expression until its value is needed.

Ruby 2.0 introduced a lazy enumeration feature. Lazy evaluation increases performance by avoiding needless calculations, and it has the ability to create potentially infinite data structures.

Example:

power_array = -> (power, array_size) do 

    1.upto(Float::INFINITY).lazy.map { |x| x**power }.first(array_size) 

end


puts power_array.(2 , 4)    #[1, 4, 9, 16]

puts power_array.(2 , 10)   #[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

puts power_array.(3, 5)     #[1, 8, 27, 64, 125]


In this example, lazy avoids needless calculations to compute power_array.

If we remove lazy from the above code, then our code would try to compute all x ranging from 1 to Float::INFINITY.

To avoid timeouts and memory allocation exceptions, we use lazy. Now, our code will only compute up to first(array_size).

Task

Your task is to print an array of the first N palindromic prime numbers.

For example, the first 10 palindromic prime numbers are [2,3,5,7,11,101,131,151,181,191].

HackerRank Lazy Evaluation problem solution in ruby programming


Problem solution.

# Enter your code here. Read input from STDIN. Print output to STDOUT

def prime?(x)
    return false if x == 1 
    return true if x < 4
    m = (x**0.5).to_i
    (2..m).none? { |div| x % div == 0 }
end

def  palindromic?(x)
    x.to_s == x.to_s.reverse and prime?(x)
end

n = gets
p 1.upto(Float::INFINITY).lazy.select { |x| palindromic?(x) }.first(n.to_i)


Second solution.

def prime? (n)
  if n <= 1
    return false
  elsif n <= 3
    return true
  elsif n % 2 == 0 || n % 3 == 0
    return false
  end
  
  i = 5
  while i*i <= n
    if n % i == 0 || n % (i+2) == 0
      return false
    end
    i += 6
  end
  return true
end

def palindrome? (s)
  return s == s.reverse
end

array = -> (n) do
  1.upto(Float::INFINITY).lazy.select { |x|
    x if prime?(x) && palindrome?(x.to_s) 
  }.first(n)
end

p array.(gets.strip.to_i)