Hackerrank Lambdas Solution
3 min read

Hackerrank Lambdas Solution

Hackerrank Lambdas Solution

.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

Enjoying these posts? Subscribe for more


Adblocker detected! Please consider reading this notice.

We've detected that you are using AdBlock Plus or some other adblocking software which is preventing the page from fully loading.

That's okay. But without advertising-income, we can't keep making this site awesome.

We don't have any banner, Flash, animation, obnoxious sound, or popup ad. We do not implement these annoying types of ads!

We need money to operate the site, and almost all of it comes from our online advertising.

Please add thepoorcoder.com to your ad blocking whitelist or disable your adblocking software.

×