Basic Ruby

Question 1

How to sum an Array?

Answer 1

array.inject(0, :+)

or

def sum(numbers)
  numbers.inject(0){|total, number| total+number}
end

http://ruby-doc.org/core-1.9.3/Enumerable.html

Question 2

How to multiply the elements of an array?

Answer 2

[1, 2, 3].inject(:*)

Question 3

What is the Ruby power function?

Answer 3

2 ** 3 => 8

Question 4

How to calculate a factorial?

Answer 4

(1..a).inject(:*) || 1

or

def factorial x
  if x <= 1
    1
  else
    x * factorial(x-1)
  end
end

Question 5

Ruby combining an array into one string?

Answer 5

Use the Array#join method (the argument to join is what to insert between the strings - in this case a space):

@arr.join(“ “)

Question 6

Extract first word from a string?

Answer 6

word.split(‘ ‘).first

Question 7

Capitalize first letter in ruby?

Answer 7

def titleize(name)
name.capitalize
end

Question 8

Ruby capitalize every word first letter.

Answer 8

def titleize(name)	name.split.map(&:capitalize).join(' ')
end

//don’t cap “the and over”

def titleize(s)
  words = s.split.map do |word|
    if %w(the and over).include?(word)
      word
    else
      word.capitalize
    end
  end
  words.first.capitalize!
  words.join(" ")
end

Question 9

map method

Answer 9

The map method takes an enumerable object and a block, and runs the block for each element, outputting each returned value from the block (the original object is unchanged unless you use map!):

[1, 2, 3].map { |n| n * n } #=> [1, 4, 9]

Question 10

Whats Iterator?

Answer 10

An iterator is a looping construct in Ruby. It uses method syntax. We optionally use an iteration variable, enclosed in vertical bars.

We invoke times, upto, downto, step and each. These are iterators.

Use a times-loop.
4.times do
puts “a”
end

# Go up from 3 to 5.
3.upto(5) do |x|

# Decrement from 5 to 3.
5.downto(3) do |j|

# Increment from 0 to 10, by 2 each time.
# ... Name the iteration variable "v".
0.step(10, 2) do |v|
    puts v
end

Question 11

Ruby: what does %w(array) mean?

Answer 11

%w(foo bar) is a shortcut for [“foo”, “bar”].

Question 12

What is Sprintf?

Answer 12

sprintf is pretty similar to printf. The major difference is that instead of printing to the screen, sprintf saves the formatted text into a string variable.

Question 13

ternary operator

Answer 13

In Ruby, ? and : can be used to mean “then” and “else” respectively.

def check_sign(number)
  number > 0 ? "#{number} is positive" : "#{number} is negative"
end

Question 14

Filtering elements of an Array

Answer 14

# select even numbers
[1,2,3,4,5,6].select {|number| number % 2 == 0}

Question 15

Array Delete

Answer 15

[1,3,5,4,6,7].delete(5)

[1,2,3,4,5,6,7].delete_if{|i| i < 4 }

Question 16

Iterating over a Hash

Answer 16

restaurant_menu = { “Ramen” => 3, “Dal Makhani” => 4, “Coffee” => 2 }
restaurant_menu.each do |item, price|
restaurant_menu[item] = price + (price * 0.1)
end

Question 17

Extracting the keys and values from a Hash

Answer 17

restaurant_menu.keys

Question 18

Splat Operator

Answer 18

The splat operator is used to handle methods which have a variable parameter list.
def add(*numbers)

Question 19

Lambda

Answer 19

Function without a name. anonymous function.

addition = lambda {|a, b| return a + b }
puts addition.call(5, 6)

Question 20

Namespaces

Answer 20

Namespacing is a way of bundling logically related objects together. Modules serve as a convenient tool for this. This allows classes or modules with conflicting names to co-exist while avoiding collisions.

module Perimeter
  class Array
    def initialize
      @size = 400
    end
  end
end

our_array = Perimeter::Array.new
ruby_array = Array.new

p our_array.class
p ruby_array.class

Question 21

Block

Answer 21

A block is code that you can store in a variable like any other object and run on demand.

Question 22

Proc

Answer 22

Proc.new behaves like it’s a part of the calling method when return is used within it, and returns from both the block itself as well as the calling method.

short = proc { |a, b| a + b }
puts short.call(2, 3)

long = Proc.new { |a, b| a + b }
puts long.call(2, 3)

Question 23

Yield

Answer 23

???

Question 24

Converting implicit blocks to explicit

Answer 24

The block should be the last parameter passed to a method.
Placing an ampersand (&) before the name of the last variable triggers the conversion.

def calculation(a, b, &block) # &block is an explicit (named) parameter
block.call(a, b)
end

puts calculation(5, 5) { |a, b| a + b } # this is an implicit block
                                        # -- it is nameless and is not 
                                        # passed as an explicit parameter.

Question 25

3 Ways to create a block.

Answer 25

Implicitly when invoking a method
Explicitly using the Kernel#lambda factory method
Explicitly using Proc.new

The -> literal form is a shorter version of Kernel#lambda. The following two lines produce identical results.

Question 26

Super

Answer 26

Using super will call the same method, but as defined in the superclass and give you the result.