## Hackerrank Procs 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}

Passing blocks is one way to pass functions as arguments to other functions.

Blocks are one of the very few exceptions to the "everything is an object" rule in Ruby. Blocks are not objects, and they can't be saved to variables.

**Proc** objects are blocks of code that can be bound to a set of local variables. You can think of a *proc* object as a "saved" block.

Procs are a great way of keeping your code DRY. DRY stands for *Do not Repeat Yourself*.

**Example:**

_{CODE}

```
def foo(a, b, my_proc)
my_proc.call(a, b)
end
add = proc {|x, y| x + y}
puts foo(15, 10, add)
```

_{OUTPUT}

```
25
```

In this example, we have created the proc *add*, which adds two numbers.

The proc *add* is passed as a parameter to the method *foo*.

In the method *foo*, `my_proc.call(a, b)`

executes the proc.

**Task**

You are given a partially complete code. Your task is to fill in the blanks (`______`

).

The *square_of_sum* method computes the sum of the elements in an input array and returns the square of the summed elements.

**For example**:

```
Input array: [1, 2, 3]
Output: 36
```

### Solution in ruby

**Approach 1**.

```
def square_of_sum my_array
(my_array.inject :+)**2
end
my_array = gets.split().map(&:to_i)
puts square_of_sum(my_array)
```

**Approach 2**.

```
def square_of_sum (my_array, proc_square, proc_sum)
sum = proc_sum.call(my_array)
proc_square.call(sum)
end
proc_square_number = proc {|x| x**2 }
proc_sum_array = proc {|y| y.inject(:+)}
my_array = gets.split().map(&:to_i)
puts square_of_sum(my_array, proc_square_number, proc_sum_array)
```

**Approach 3**.

```
def square_of_sum (my_array, proc_square, proc_sum)
sum = proc_sum.call(my_array)
proc_square.call(sum)
end
proc_square_number = proc {|x| x*x}
proc_sum_array = proc {|a| a.reduce(:+)}
my_array = gets.split().map(&:to_i)
puts square_of_sum(my_array, proc_square_number, proc_sum_array)
```