## Practice Exercises for Assessment 109

### Problem Set #1

1. Reverse an array without using the built-in reverse method.

2. Select the element out of the array if its index is a fibonacci number.

   **BONUS**: Write a method that finds the nth fibonacci number where `n` is the number passed to the method.

3. Write a method to determine if a word is a palindrome, without using the reverse method.


### Problem Set #2

1. Reverse a string.

2. Write a method that takes two arguments: the first is the starting number, and the second is the ending number. Print out all numbers between the two numbers, except if a number is divisible by 3, print "Fizz", if a number is divisible by 5, print "Buzz", and finally if a number is divisible by 3 and 5 print "FizBuzz".

3. Implement the search function within this code:
  ```ruby
  PRODUCTS = [
    { name: "Thinkpad x210", price: 220 },
    { name: "Thinkpad x220", price: 250 },
    { name: "Thinkpad x250", price: 979 },
    { name: "Thinkpad x230", price: 300 },
    { name: "Thinkpad x230", price: 330 },
    { name: "Thinkpad x230", price: 350 },
    { name: "Thinkpad x240", price: 700 },
    { name: "Macbook Leopard", price: 300 },
    { name: "Macbook Air", price: 700 },
    { name: "Macbook Pro", price: 600 },
    { name: "Macbook", price: 1449 },
    { name: "Dell Latitude", price: 200 },
    { name: "Dell Latitude", price: 650 },
    { name: "Dell Inspiron", price: 300 },
    { name: "Dell Inspiron", price: 450 },
  ]

  query = {
    price_min: 240,
    price_max: 280,
    q: "thinkpad"
  }

  query2 = {
    price_min: 300,
    price_max: 450,
    q: "dell"
  }

  def search(query)
    # implement
  end

  search(query)
  # => [ { name: "Thinkpad x220", price: 250 }]
  search(query2)
  # => [ { name: "Dell Inspiron", price: 300 }, { name: "Dell Inspiron", price: 450 }]
  ```

4. Write a method that takes an array of strings, and returns an array of the same string values, except with the vowels removed.

5. Write a method that takes a string, and returns a boolean indicating whether this string has a balanced set of parentheses.

6. Write a method that takes two numbers. It should print out all primes between the two numbers. Don't use Ruby's `prime` class.

  a. Write a method that will take an array of numbers and only return those that are prime.

  b. Write a method that will take an array of numbers and return the number of primes in the array.

7. Write a program that asks the user to enter an integer greater than 0, then asks if the user wants to determine the sum or product of all numbers between 1 and the entered integer.
  ```
  >> Please enter an integer greater than 0:
  5
  >> Enter 's' to compute the sum, 'p' to compute the product.
  s
  The sum of the integers between 1 and 5 is 15.

  >> Please enter an integer greater than 0:
  6
  >> Enter 's' to compute the sum, 'p' to compute the product.
  p
  The product of the integers between 1 and 6 is 120.
  ```

### Problem Set #3

1. Write a method that returns one UUID when called with no parameters.

2. Determine if an input string is an IP address representing dot-separated numbers. e.g. "10.4.5.11".

3. Create a hash that expresses the frequency with which each letter occurs in the string: "The Flintstones Rock".

4. This will fail if you call this with an input of 0 or a negative number. Refactor.
  ```ruby
  def factors(number)
    dividend = number
    divisors = []
    begin
      divisors << number / dividend if number % dividend == 0
      dividend -= 1
    end until dividend == 0
    divisors
  end
  ```

8. Given the munsters hash below. Modify the hash such that each member of the Munster family has an additional "age_group" key that has one of three values describing the age group the family member is in (kid, adult, or senior).
  ```ruby
  munsters = {
    "Herman" => { "age" => 32, "gender" => "male" },
    "Lily" => { "age" => 30, "gender" => "female" },
    "Grandpa" => { "age" => 402, "gender" => "male" },
    "Eddie" => { "age" => 10, "gender" => "male" },
    "Marilyn" => { "age" => 23, "gender" => "female"}
  }

  ## Your solution should produce the hash below

  { "Herman" => { "age" => 32, "gender" => "male", "age_group" => "adult" },
    "Lily" => {"age" => 30, "gender" => "female", "age_group" => "adult" },
    "Grandpa" => { "age" => 402, "gender" => "male", "age_group" => "senior" },
    "Eddie" => { "age" => 10, "gender" => "male", "age_group" => "kid" },
    "Marilyn" => { "age" => 23, "gender" => "female", "age_group" => "adult" } }
  ```

9. Figure out the total age of just the male members of the family.
  ```ruby
  munsters = {
    "Herman" => { "age" => 32, "gender" => "male" },
    "Lily" => { "age" => 30, "gender" => "female" },
    "Grandpa" => { "age" => 402, "gender" => "male" },
    "Eddie" => { "age" => 10, "gender" => "male" }
  }
  ```

12. Reverse this sentence:

    "Humpty Dumpty sat on a wall."

    It should look like this:

    "wall a on sat Dumpty Humpty."

13. Write a method that rotates an array by moving the first element to the end of the array. The original array should not be modified.

  Do not use the method Array#rotate or Array#rotate! for you implementation.

  Example:
  ```ruby
  rotate_array([7, 3, 5, 2, 9, 1]) == [3, 5, 2, 9, 1, 7]
  rotate_array(['a', 'b', 'c']) == ['b', 'c', 'a']
  rotate_array(['a']) == ['a']

  x = [1, 2, 3, 4]
  rotate_array(x) == [2, 3, 4, 1]   # => true
  x == [1, 2, 3, 4]                 # => true
  ```

14. Write a method that can rotate the last n digits of a number. For example:
  ```ruby
  rotate_rightmost_digits(735291, 1) == 735291
  rotate_rightmost_digits(735291, 2) == 735219
  rotate_rightmost_digits(735291, 3) == 735912
  rotate_rightmost_digits(735291, 4) == 732915
  rotate_rightmost_digits(735291, 5) == 752913
  rotate_rightmost_digits(735291, 6) == 352917
  ```
  Note that rotating just 1 digit leaves the number results in the original number being returned.

  You may use the rotate_array method from the previous exercise if you want.

15. If you take a number like 735291, and rotate it to the left, you get 352917. If you now keep the first digit fixed in place, and rotate the remaining digits, you get 329175. Keep the first 2 digits fixed in place and rotate again to 321759. Keep the first 3 digits fixed in place and rotate again to get 321597. Finally, keep the first 4 digits fixed in place and rotate the final 2 digits to get 321579. The resulting number is called the maximum rotation of the original number.

  Write a method that takes an integer as argument, and returns the maximum rotation of that argument. You can (and probably should) use the rotate_rightmost_digits method from the previous exercise.

  Example:
  ```ruby
  max_rotation(735291) == 321579
  max_rotation(3) == 3
  max_rotation(35) == 53
  max_rotation(105) == 15 # the leading zero gets dropped
  max_rotation(8_703_529_146) == 7_321_609_845
  ```

14. There is a row switches before you numbered from 1 to 1000. Each switch is connected to exactly one light that is initially off. You walk down the row of switches, and turn every one of them on. Then, you go back to the beginning and toggle switches 2, 4, 6, and so on. Repeat for every 3rd, 4th, 5th, 6th and so on, and keep going until you have been through 1000 repetitions of this process.

  Write a program that determines how many lights are on at the end, and which lights are on.