# HackerRank Lazy Evaluation problem solution in ruby

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).

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].

## 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)
```