You've successfully subscribed to The Poor Coder | Hackerrank Solutions
Great! Next, complete checkout for full access to The Poor Coder | Hackerrank Solutions
Welcome back! You've successfully signed in.
Success! Your account is fully activated, you now have access to all content.
Hackerrank Lambdas Solution

Hackerrank Lambdas Solution

Beeze Aal
Beeze Aal

.MathJax_SVG_Display {text-align: center; margin: 1em 0em; position: relative; display: block!important; text-indent: 0; max-width: none; max-height: none; min-width: 0; min-height: 0; width: 100%} .MathJax_SVG .MJX-monospace {font-family: monospace} .MathJax_SVG .MJX-sans-serif {font-family: sans-serif} .MathJax_SVG {display: inline; font-style: normal; font-weight: normal; line-height: normal; font-size: 100%; font-size-adjust: none; text-indent: 0; text-align: left; text-transform: none; letter-spacing: normal; word-spacing: normal; word-wrap: normal; white-space: nowrap; float: none; direction: ltr; max-width: none; max-height: none; min-width: 0; min-height: 0; border: 0; padding: 0; margin: 0} .MathJax_SVG * {transition: none; -webkit-transition: none; -moz-transition: none; -ms-transition: none; -o-transition: none} .mjx-svg-href {fill: blue; stroke: blue}

Lambdas are anonymous functions. Lambdas in Ruby are objects of the class Proc.
They are useful in most of the situations where you would use a proc.

The simplest lambda takes no argument and returns nothing as shown below:

Example:

#Ruby version <= 1.8
    lambda { .... } 

    lambda do
        ....
    end

#Ruby version >= 1.9, "stabby lambda" syntax is added
    -> { .... }

    -> do
        ....
    end

Ruby version  can use both lambda and stabby lambda, ->.

Lambdas can be used as arguments to higher-order functions. They can also be used to construct the result of a higher-order function that needs to return a function.

Example:

(a). Lambda that takes no arguments.

def area (l, b)
   -> { l * b } 
end

x = 10.0; y = 20.0

area_rectangle = area(x, y).call
area_triangle = 0.5 * area(x, y).()

puts area_rectangle     #200.0
puts area_triangle      #100.0

(b). Lambda that takes one or more arguments.

area = ->(a, b) { a * b }

x = 10.0; y = 20.0

area_rectangle = area.(x, y)
area_triangle = 0.5 * area.call(x, y)

puts area_rectangle     #200.0
puts area_triangle      #100.0    

In the above example, we can see that lambdas can be called using both .call() and .().

Is there any difference between lambdas and procs?
Yes, there is difference between a proc and a lambda in Ruby.


Task

You are given a partially complete code. Your task is to fill in the blanks (______).
There are  variables defined below:

  • square is a lambda that squares an integer.
  • plus_one is a lambda that increments an integer by .
  • into_2 is a lambda that multiplies an integer by .
  • adder is a lambda that takes two integers and adds them.
  • values_only is a lambda that takes a hash and returns an array of hash values.

Solution in ruby

Approach 1.

# Write a lambda which takes an integer and square it
square      = -> (x) {x**2}

# Write a lambda which takes an integer and increment it by 1
plus_one    = -> (x) {x + 1}

# Write a lambda which takes an integer and multiply it by 2
into_2      = -> (x) {x * 2}

# Write a lambda which takes two integers and adds them
adder       = ->(x, y) {x + y}

# Write a lambda which takes a hash and returns an array of hash values
values_only = ->(hash) { hash.values}

input_number_1 = gets.to_i
input_number_2 = gets.to_i
input_hash = eval(gets)

a = square.(input_number_1); b = plus_one.(input_number_2);c = into_2.(input_number_1); 
d = adder.(input_number_1, input_number_2);e = values_only.(input_hash)

p a; p b; p c; p d; p e

Approach 2.

# Write a lambda which takes an integer and square it
square      = -> (n) {n*n}

# Write a lambda which takes an integer and increment it by 1
plus_one    = -> (n) {n+=1}

# Write a lambda which takes an integer and multiply it by 2
into_2      = -> (n) { n*2 }

# Write a lambda which takes two integers and adds them
adder       = -> (x, y) { x + y }

# Write a lambda which takes a hash and returns an array of hash values
values_only = -> (hash) {hash.values}


input_number_1 = gets.to_i
input_number_2 = gets.to_i
input_hash = eval(gets)

a = square.(input_number_1); b = plus_one.(input_number_2);c = into_2.(input_number_1); 
d = adder.(input_number_1, input_number_2);e = values_only.(input_hash)

p a; p b; p c; p d; p e

Approach 3.

# Write a lambda which takes an integer and square it
square      = ->(i) { i * i } 

# Write a lambda which takes an integer and increment it by 1
plus_one    = ->(i) { i + 1} 

# Write a lambda which takes an integer and multiply it by 2
into_2      = ->(i) { i * 2 }

# Write a lambda which takes two integers and adds them
adder       = ->(a, b) { a + b }

# Write a lambda which takes a hash and returns an array of hash values
values_only = ->(h) { h.values }


input_number_1 = gets.to_i
input_number_2 = gets.to_i
input_hash = eval(gets)

a = square.(input_number_1); b = plus_one.(input_number_2);c = into_2.(input_number_1); 
d = adder.(input_number_1, input_number_2);e = values_only.(input_hash)

p a; p b; p c; p d; p e