Hackerrank Lambdas Solution
- Published
- Updated
- Reading time
- 4 min read
- Length
- 633 words
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
....
endRuby 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 eApproach 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 eApproach 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
