## Create a method new_cat which takes as its input two strings. It should concatenate the strings and return the concatenated value, without modifying either of the input strings. Call this method and send your first and last name as arguments.

def new_cat(string1, string2)
  "#{string1}#{string2}"
end

puts new_cat("michael", "kaiser-nyman")


## Write a method called sum which takes as its input an array of integers and returns their sum.

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

puts sum([1,2,3,4])


## Consider the following array:
##
## ["ruby", "is", "the", "best", "programming" ,"language", "ever"]
##
## What value is stored at index 3? What is the index of the word "ruby?" What is the length of the array?

# "best", 0, 7


## Create a new instance method on the String class called fun_string! which is called on a String object and permanently modifies it by capitalizing the even characters (counting from 1) and then reversing the string. See if you can do it in a single line.

class String
  def fun_string!
    self.split("").each_with_index { |character, index| index.odd? ? character.upcase! : character }.join.reverse!
  end
end

puts s = "apples".fun_string!
puts s


## Write a method called fizzblam that prints the numbers from 1 to 100. But for multiples of 5 print "Fizz" instead of the number and for the multiples of 7 print "Blam". For numbers which are multiples of both 5 and 7 print "FizzBlam."

def fizzblam
  (1..100).each do |number|
    if number % 35 == 0
      puts "FizzBlam"
    elsif number % 7 == 0
      puts "Blam"
    elsif number % 5 == 0
      puts "Fizz"
    else
      puts number
    end
  end
end

fizzblam


## Create a GuessingGame class which is initialized with an integer called "answer."

## Define an instance method GuessingGame#guess which takes an integer called "guess" as its input. guess should return the symbol :high if the guess is larger than the answer, :correct if the guess is equal to the answer, and :low if the guess is lower than the answer.

## Define an instance method GuessingGame#solved? which returns false until a correct guess has been given.

class GuessingGame
  def initialize(answer)
    @answer = answer
    @solved = false
  end

  def guess(guess)
    if guess > @answer
      :high
    elsif guess < @answer
      :low
    else
      @solved = true
      :correct
    end
  end

  def solved?
    @solved
  end
end

puts game = GuessingGame.new(6)
puts game.solved?
puts game.guess(5)
puts game.guess(7)
puts game.guess(6)
puts game.solved?


## Explain the four levels of variable scope in Ruby and give a brief description of how you would use each.

# local variable: available only within the method or block in which it was defined. use unless you have a good reason not to.
# instance variable: available within the entire instance of the class, and available to all methods and blocks within the class. use if the variable needs to be accessed in multiple methods.
# class variable: available to all instances of the class and the class itself. use to track class-wide information (only example i can think of is how many times a particular method has been run, but surely there are more uses).
# global variable: available to everything, everywhere, every time. don't use unless you are shaquille o'neal.


## Using proper terminology, explain the difference between Array#each, Array#map, and Array#select. Write clearly, using examples if necessary, as if you were explaining it to a friend.

# i don't have friends. but here goes nothing. each lets you run through each element in an array and do stuff with it. when it's done, it returns the original array. map is like each, but instead of returning the orginal array, it returns an array with the results of each pass through in an array. select runs through each element of an array and lets you do stuff with it. if the result of what you do is true, then the element gets added to an array that is returned at the end. damn.


## Consider the following code examples.... For each example, explain in a one or two plain-English sentences what the given method does when passed an array of positive integers. Choose one method (not the first!) and refactor it into something shorter. Give the working code of the refactored method.

# 1. it displays each number in the array multiplied by 100.
# 2. it returns the largest number in the array.
# 3. it returns an array like the original one but with 80 added to each number.
# 4. it returns an array containing only the even elements of the first array.

def method_4(array)
  array.select { |number| number % 2 == 0}
end

p method_4([1,2,3,4,5,6])


## Explain why the following code examples raise an exception, and how you’d need to change the code to fix the error. Offer multiple solutions if you know of any.

# 1. the initialize method requires 1 argument, and line 7 calls the new method (which calls initialize) with no arguments. give it an argument, yo!
# 2. there is no num= method for the Foo class. create one, or use attr_writer :num.
# 3. uh, still no num= method. change attr_reader :num to attr_accessor :num. c'mon, guys.


## Consider the following method.... What will the following code print to the console and why?

# hash = {:dog => 'woof', 'cat' => 'meow', 'duck' => 'quack'}
#
# print_value(hash, :dog)     -> "woof" because it is accessing the hash with the :dog key, which has value 'woof'.
# print_value(hash, 'dog')    -> nil because it is accessing the hash with the 'dog' key, which is not in the hash. the :dog symbol is, but not the 'dog' string.
# print_value(hash, 'cat')    -> 'meow' because it is accessing the hash with the 'cat' key, which has value 'meow'.
# print_value(hash, 'quack')  -> nil because it is accessing the hash with the 'quack' key, which is not in the hash. 'quack' is in the has as a value, but not a key.
# print_value(hash, :duck)    -> nil because it is accessing the hash with the :duck key, which is not in the hash. the 'duck' string is, but not the :duck symbol.


## Explain in plain English the difference between return and puts. You’re free to use code examples to illustrate your point.

# when Ruby runs a line or a block of code, it returns the results of its calculations and musings (what we call "evaluation") to whatever called it. return lets you tell Ruby exactly what you want it to return. by default, it returns the last thing it evaluates. puts lets us tell Ruby to display something on the screen. Ruby doesn't ever display something on the screen unless we tell it to.

# for example, [1,2,3].each { |number| puts number ** 2 } will display the square of each number on the screen. however, the return will be [1,2,3] because the each method returns the array on which it was called.


# How long does fib_slow(40) take to execute? How long does fib_fast(40) take to execute? Why is fib_fast so much faster than fib_slow? Hint: set t1=Time.now then run the code then set t2=Time.now , and find t2-t1 for the time.


def fib_slow(n)
  return 0 if n == 0
  return 1 if n == 1
  return fib_slow(n-1) + fib_slow(n-2)
end

def fib_fast(n)
  fib = [0,1]

  2.upto(n).each do |i|
    last = fib[1]
    fib_n = fib[1] + fib[0]
    fib = [last, fib_n]
  end

  return fib[1]
end

t1 = Time.now
fib_slow(30)
t2 = Time.now
puts running_time = t2 - t1

# running_time = 0.335455

t1 = Time.now
fib_fast(30)
t2 = Time.now
puts running_time = t2 - t1

# running_time = 2.7e-05

# fib_slow calls itself recursively twice each time it runs. and each time it runs, it loads itself into memory. so for fib_slow(n), it loads itself into memory on the magnitude of 2 ** n. fib_fast isn't recursive and so only loads itself once. boo-ya.