# Practice Problems: Arrays Manipulation

## Example 1

``````=begin

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
"FizzBuzz".

# PEDAC

## Problem

Input: a start and end number
Output: a string with each multiple of 3 as Fizz, each multiple of 5 as Buzz
and each multiple of 3 and 5 as FizzBuzz

Clarify:

- Return a single string? (yes)
- First and last number INCLUSIVE

## Data

Arrays of strings

## Algorithm

. Create local variable result to new Array
. Iterate from min to max
. Case when divide by 3 and 5 and rest is 0
. Save FizzBuzz
. Case when divide by 3 and rest is 0
. Save Fizz
. Case when divide by 5 and rest is 0
. Save Buzz
. Other case
. Save number (as string)
. Join the array with `, `

=end

def fizzbuzz(min, max)
result = []

min.upto(max) do |num|
if num % 5 == 0 && num % 3 == 0
result << 'FizzBuzz'
elsif num % 3 == 0
result << 'Fizz'
elsif num % 5 == 0
result << 'Buzz'
else
result << num.to_s
end
end

result.join(', ')
end

p fizzbuzz(1, 15) == '1, 2, Fizz, 4, Buzz, Fizz, 7, 8, Fizz, Buzz, 11, ' \
'Fizz, 13, 14, FizzBuzz'``````

Time: 09:08

## Example 2

``````=begin
Write a method that takes two numbers. Return an array containing all primes
between the two numbers (include the two given numbers in your answer if they
are prime). Don't use Ruby's 'prime' class.

# PEDAC

## Problem

Find all prime numbers between the two given numbers.

Input: a min and max integer
Output: every prime number between min and max (INCLUSIVE)

Clarification:

- Min/max are included
- A prime number is a number that can only be found by multiplying it by
itself, i.e. is not a product in which both numbers are smaller than itself
- Prime is a natural number greater than 1
- A prime number can be found by trial division

## Data

Arrays of Integers

## Algorithm

. Init a local variable primes_num to a new Array object
. Iterate from min (given number) up to max (given number)
. Check if current number can be divised by one number between 2 and itself
. If not divisable, add current number to to primes_num
. Return primes_num

=end

def prime?(candidate)
limit = Integer.sqrt(candidate)

2.upto(limit) do |num|
if candidate % num == 0
return false
end
end
end

def find_primes(min, max)
primes_num = []
min = 2 if min < 2

min.upto(max) do |number|
if prime?(number)
primes_num << number
end
end

primes_num
end

p find_primes(3, 10) == [3, 5, 7]
p find_primes(11, 20) == [11, 13, 17, 19]
p find_primes(100, 101) == 
p find_primes(1, 100) == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
p find_primes(1, 2) == ``````

Time: 31:25

## Example 3

``````=begin

Write a method that will determine whether an integer is a prime. Do not use the
Prime class.

# PEDAC

## Problem

Given a number, return true if it is a prime number, false otherwise.

Input: a number
Output: a boolean (true if prime, false otherwise)

Clarification:

- Do not use Prime class
- Prime is a number that cannot be created by multiplying natural number
smaller than itself

## Data

Integer

## Algorithm

. Iterate from 2 to the square root of given number
. For each number, find if it can divide given number
. If true, return false
. Return true

=end

def prime?(num)
num_sqrt = Integer.sqrt(num)

2.upto(num_sqrt) do |denominator|
return false if num % denominator == 0
end

true
end

p prime?(3) == true
p prime?(4) == false``````

Time: 05:58

## Example 4

``````=begin

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

# PEDAC

## Problem

Given an array of numbers, count the number of prime it contains.

Input: array of number
Output: a integer, the number of prime in the given array

Clarification:

- Prime are numbers that cannot be found by multiplying a number between 2 and
itself
- Array can have 2 same number? (Yes)

## Data

Arrays

## Algorithm

. COUNT
. Iterate over the array
. Count the number of element that are prime by passing them to PRIME?
. Return the count number

. PRIME?
. Return false if num is less than 2
. Init the limit to the square root of the given number
. Iterate from 2 to limit, passing in factor
. Return false if given number divided by factor remains zero
. Return true

=end

def prime?(candidate)
return false if candidate < 2

limit = Integer.sqrt(candidate)

2.upto(limit) do |factor|
return false if candidate % factor == 0
end

true
end

def count_primes(numbers)
numbers.count do |number|
prime?(number)
end
end

p count_primes([1, 2, 3, 4]) == 2
p count_primes([4, 6, 8, 10]) == 0``````

Time: 07:42

## Example 5

``````=begin

Write a program that asks the user to enter an integer greater than zero, then
asks if the user wants to determine the sum or product of all numbers between 1
and the entered integer.

# PEDAC

## Problem

Create a program that takes two user inputs: an integer (> 0) then an order
(sum or product between 1 and the integer).

Inputs: a positive integer
`sum` or `product`
Output: The sum or product of all numbers between 1 and the positive integer

Clarification:

- Loop or exit if unwanted input? (loop)
- Ask to retry at the end or not? (no)
- sum is 1 + 2 + 3 + .. n
- product is 1 * 2 * 3 * .. n
- Format output? (yes, string)

## Algorithm

. Outputs a question that ask for an integer greater than zero
. Save the input
. Check if the input is desirable
. Redo if not desirable

. Outputs a question that ask wether to sum or product
. Save input
. Check desirability of the input
. Redo if not desirable
. Otherwise save the return value of DO_SUM or DO_PRODUCT
. And go to OUTPUT_OPERATION

. OUTPUT_OPERATION
. Outputs the return value

. DO_SUM
. Iterate from 1 to input number and sum them

. DO_PRODUCT
. Iterate from 1 to input number and multiply them

=end

input_integer = 0

puts "Please input a positive number:"

loop do
input_integer = gets.chomp.to_i

break if input_integer.positive?

puts "Sorry, your input must be an integer greater than zero."
end

input_integer
end

possible_input = %w(sum product)
input_operation = nil

puts "Do you want to sum or product numbers between 1 and your number?"
puts "Please enter 'sum' or 'product'."

loop do
input_operation = gets.chomp

break if possible_input.include?(input_operation)

puts "Sorry, please enter 'sum' or 'product' without '."
end

input_operation
end

def do_operation(integer, operation)
result = 0

if operation == 'sum'
result = (1..integer).to_a.sum
elsif operation == 'product'
result = (1..integer).to_a.reduce(:*)
end

result
end

def output_operation(integer, operation, result)
puts "The result of #{operation} between 1 and #{integer} is #{result}!"
end

def sum_or_product

result = do_operation(input_integer, input_operation)
output_operation(input_integer, input_operation, result)
end

sum_or_product``````

Time: 29:10

## Example 6

``````=begin

Write a method that returns the number of Friday the 13ths in the year given by
an argument. You may assume that the year is greater than 1752 (when the United
Kingdom adopted the modern Gregorian Calendar) and that it will remain in use
for the foreseeable future.

# PEDAC

## Problem

Return the number of Friday the 13th in a given year. (Gregorian Calendar)

Input: an integer, representing a year (after 1752)
Output: an integer, representing the number of F the 13ths for the given year

Clarification:

- After 1752 (Gregorian Calendar)
- Between 0 and 12
- Use Date lib

## Data

Array

## Algorithm

. Init a local variable month to integer 1
. Init a local variable friday_13_list to empty array
. Loop
. Using the given year, check if the 13 of the current month (iteration) for
this year, is a Friday
. Save results to friday_13_list if true
. Increment month by 1
. Break if month is 12 or more
. Return the count size of friday_13_list

=end
require 'date'

def friday_13th(year)
month = 1
friday_13_list = []

loop do
break if month > 12
friday_13_list << month if Date.new(year, month, 13).friday?

month += 1
end

friday_13_list.size
end

p friday_13th(2015) == 3
p friday_13th(1986) == 1
p friday_13th(2019) == 2``````

Time: 11:31

## Example 7

``````=begin

A pangram is a sentence that contains every single letter of the alphabet at
least once. For example, the sentence "The quick brown fox jumps over the lazy
dog" is a pangram, because it uses the letters A-Z at least once (case is
irrelevant).

Given a string, detect whether or not it is a pangram. Return True if it is,
False if not. Ignore numbers and punctuation.

# PEDAC

## Problem

Return true or false, based on wether the given string is a pangram or not.

Input: a string
Output: true or false, if the given string is a pangram or not

Clarification:

-  Pangram must have every letter of the English alphabet (26)
-  Case does not matter
-  Save character can be repeated one or more time

## Data

Array

## Algorithm

.  Init a constant ALPHABET with every letter of the English alphabet
.  Iterate over ALPHABET
.  For each letter, check if it is inside the given string
.  Return false if not
.  Return true

=end

ALPHABET = ('a'..'z').to_a

def pangram?(string)
string.downcase!

ALPHABET.each do |letter|
unless string.include?(letter)
return false
end
end

true
end

p pangram?("The quick brown fox jumps over the lazy dog.") == true
p pangram?("This is not a pangram.") == false``````

Time: 04:49

## Example 8

``````=begin

Write Number in Expanded Form

You will be given a number and you will need to return it as a string in
Expanded Form.

NOTE: All numbers will be whole numbers greater than 0.

# PEDAC

## Problem

Given a number, return its expanded form as a string.

Expanded form is a method for writing numbers that breaks the number down into
digits.

Input: an integer greater than 0
Output: a string representing the expanded form of the given integer

Clarification:

-  Return 0 when given 0
-  Return the number if given num <= 10
-  If the expanded form contains 0, do not write it

## Data

Array

## Algorithm

.  Return num if num is smaller or equal to 10
.  Init a local variable expanded_num
.  Init a local variable size to the size of the string of the given integer -1
.  Init a local variable digits to a new array of digits from the string of the
.  Re-integerize every string in the array
.  Init a local variable current_digit to 0
given integer
.  Iterate trough size to 0 passing in power
.  Multiply the current digit of digits by the number by 10 ^ power
.  Save the result to expanded_num unless it's 0
.  Increment current_digit by 1
.  Join the result with +

=end

def find_expanded_form(digits)
size = digits.size - 1
current_digit = 0
results = []

size.downto(0) do |power|
expanded = digits[current_digit] * (10**power)
results << expanded unless expanded == 0
current_digit += 1
end

results
end

def expanded_form(number)
return number if number <= 10

digits = number.to_s.split('').map(&:to_i)

find_expanded_form(digits).join(' + ')
end

p expanded_form(12) == '10 + 2'
p expanded_form(42) == '40 + 2'
p expanded_form(70304) == '70000 + 300 + 4'``````

Time: 25:17

## Example 9

``````=begin

Write a function, persistence, that takes in a positive parameter num and
returns its multiplicative persistence, which is the number of times you must
multiply the digits in num until you reach a single digit.

For example:

persistence(39) # returns 3, because 3*9=27, 2*7=14, 1*4=4
# and 4 has only one digit
persistence(999) # returns 4, because 9*9*9=729, 7*2*9=126,
# 1*2*6=12, and finally 1*2=2
persistence(4) # returns 0, because 4 is already a one-digit number

# PEDAC

## Problem

Given a number, return the number of times it takes to get to one digit by
divising its digits.

Input: an integer
Output: an integer, te number of multiplication to do to get to on digit from
integer

Clarification:

-  Positive number
-  Persistenec is the number of tiems to multiply to get to a single digit
-  num < 10 returns 0

## Data

Arrays

## Algorithm

.  Init a local variable index to 0
.  Until digits of `num` is less than 10, iterate
.  Takes the digits of the number and multiply them
.  Save the result to `num`
.  Increment index by 1
.  (Continue until condition is met)
.  Return `num`

=end

def persistence(num)
index = 0

until num < 10
num = num.digits.reduce(:*)
index += 1
end

index
end

p persistence(39) == 3
p persistence(4) == 0
p persistence(25) == 2
p persistence(999) == 4``````

Time: 09:09