# Practice Problems: Arrays Manipulation

## Example 1

``````=begin

The maximum sum subarray problem consists in finding the maximum sum of
contiguous subsequence in an array of integers:

maxSequence [-2, 1, -3, 4, -1, 2, 1, -5, 4]
should be 6: [4, -1, 2, 1]

Easy case is when the array is made up of only positive numbers and the maximum
sum is the sum of the whole array. If the array is made up of only negative

Empty array is considered to have zero greatest sum. Note that the empty array
is also a valid subarray.

# PEDAC

# Problem

Input: an array of integer
Output: the maximum sum consisting of CONTIGUOUS subsequence

Clarify:

- All positive: return sum of array
- All negative: return 0
- Empty array: return 0
- CONTIGUOUS subsequences

# Data

arrays

# Algorithm

. Return sum of array if all positive
. Return 0 if all negative
. Return 0 if empty array

. NUMBER TO SELECT FIRST ELEMENT OF SUBARRAY
. Create a loop from 0 up to the number of element -1 in the array
. For each loop, the parameter will be the first element of the subarray

. NUMBER TO SELECT LAST ELEMENT OF SUBARRAY
. Create a loop form FIRST_ELE (above) up to num of element -1 in the array
. For each loop, the parameter will be the last element of the subarray
. Save each sum of subarray in `sequences_sum`

. Return max of `sequences`

=end

def all_sequences(max_sequence, seq_start)
sequence_size = max_sequence.size
subsequences_sum = Array.new

seq_start.upto(sequence_size) do |seq_end|
subsequences_sum << max_sequence[seq_start...seq_end].sum
end

subsequences_sum
end

def max_sequence(max_sequence)
return max_sequence.sum if max_sequence.all?(&:positive?)
return 0                if max_sequence.all?(&:negative?)
return 0                if max_sequence.empty?

sequence_size = max_sequence.size
sequences_sum = Array.new

0.upto(sequence_size - 1) do |seq_start|
sequences_sum << all_sequences(max_sequence, seq_start).max
end

sequences_sum.max
end

p max_sequence([]) == 0
p max_sequence([-2, 1, -3, 4, -1, 2, 1, -5, 4]) == 6
p max_sequence() == 11
p max_sequence([-32]) == 0
p max_sequence([-2, 1, -7, 4, -10, 2, 1, 5, 4]) == 12``````

Time: 30:51

## Example 2

``````=begin

You are going to be given an array of integers. Your job is to take that array
and find an index N where the sum of the integers to the left of N is equal to
the sum of the integers to the right of N. If there is no index that would make
this happen, return -1.

For example:

Let's say you are given the array [1, 2, 3, 4, 3, 2, 1]:

Your method will return the index 3, because at the 3rd position of the array,
the sum of left side of the index [1, 2, 3] and the sum of the right side of
the index [3, 2, 1] both equal 6.

Another one:

You are given the array [20, 10, -80, 10, 10, 15, 35]
At index 0 the left side is []
The right side is [10, -80, 10, 10, 15, 35]
They both are equal to 0 when added. (Empty arrays are equal to 0 in this
problem)
Index 0 is the place where the left side and right side are equal.

# PEDAC

## Problem

Return the index where the sum of the integers to the right and to the left are
equal.

Input: arrays of integer
Output: integer (an index)

Clarify:

- Empty is equal to 0
- Return -1 as last resort

## Data
Arrays

## Algorithm

. Iterate over the given array passing in the index as a param
. Init local variable left_side to the first element until index (non
inclusive)
. Init local variable right_side to index (non inclusive) until last element
. Reassign empty array to right_side is is nil
. Check if sum of left_side equals sum of right_side
. TRUE: return index
. FALSE: continue
. Return -1

=end

def find_even_index(array)
0.upto(array.size) do |index|
# puts "index: #{index}"
left_side = array[0...index]
right_side = array[index + 1..-1]
right_side = [] if right_side.nil?

return index if left_side.sum == right_side.sum
end

-1
end

p find_even_index([1, 2, 3, 4, 3, 2, 1]) == 3
p find_even_index([1, 100, 50, -51, 1, 1]) == 1
p find_even_index([1, 2, 3, 4, 5, 6]) == -1
p find_even_index([20, 10, 30, 10, 10, 15, 35]) == 3
p find_even_index([20, 10, -80, 10, 10, 15, 35]) == 0
p find_even_index([10, -80, 10, 10, 15, 35, 20]) == 6
p find_even_index([-1, -2, -3, -4, -3, -2, -1]) == 3``````

Time: 18:48

## Example 3

``````=begin

Imagine a sequence of consecutive even integers, beginning with 2. The integers
are grouped in rows, with the first row containing one integer, the second row
two integers, the third row three integers, and so on. Given an integer
representing the number of a particular row, return an integer representing the
sum of all the integers in that row.

# PEDAC

## Problem

Given a row number, return the sum of the sequence in that row.
A sequence consist of n consecutive even number for each row n, starting at
two.

Input: integer representing the row
Output: integer representing the sum of the sequence at the given row number

Clarification:

- Only positive number? (Yes)
- Rows are 1 indexed? (Yes)

## Data

Arrays of arrays
[
,
[4, 6],
[8, 10, 12],
[14, 16, 18, 20],
]

## Algorithm

. CREATE_SEQUENCE
. Init local variable index to 1, to know current row number
. Init local variable current_num to 2, to know current number in array
. Init local variable sequence to new Array
. Loop
. Break condition: sequence array size is greater than given row_num number
of arrays
. Init local variable row to new Array
. Loop for index times
. Increment current_num by 2
. Increment index by 1
. Return sequence

. SUM_ROW
. Save return value of CREATE_SEQUENCE to initialized local variable sequence
. Return sum of sequence at row_num
=end

def create_sequence(max_row)
index = 1
current_num = 2
sequence = Array.new

loop do
break if sequence.size > max_row
row = Array.new

index.times do
row << current_num
current_num += 2
end

sequence << row
index += 1
end

sequence
end

def sum_even_number_row(row_num)
sequence = create_sequence(row_num)

sequence[row_num - 1].sum
end

p sum_even_number_row(1) == 2
p sum_even_number_row(2) == 10
p sum_even_number_row(4) == 68``````

Time: 20:35

## Example 4

``````=begin

You are given an array that contains only integers (positive and negative).
Your job is to sum only the numbers that are the same and consecutive. The
result should be one array.

You can assume there is never an empty array and there will always be an
integer.

# PEDAC

## Problem

Given an array of positive and negative numbers, sum the same consecutive
number and return the new array.

Input: An array of positive and negatives numbers with some behing the same and
consecutive.
Output: An new array of numbers, each different

Clarification:

- Positive and negative numbers
- No empty array
- Only integers
- Array on the left will always be bigger than array on the right (except for
next point)
- Return given array if each integer are different
- Do I need to return same array? (No)

## Data

Arrays of integers

## Algorithm

. Init a local variable result to a new Array object
. Init a local variabe outer_index to 0
. Iterate over the given array
. Init local var inner_index to 1
. Init local var sum to current element
. Loop until next element is different from current element
. Add element at inner_index to sum
. Increment inner_index
. Break if next element different from current element
. Save sum to result array
. Increment outer_index by inner_index
. Break if outer_index is equal to array size
. Return the result array

=end

def sum_consecutives(array)
result = []
outer_index = 0

loop do
inner_index = 1
sum = array[outer_index]

loop do
break if array[outer_index + inner_index].nil?

if array[outer_index] == array[outer_index + inner_index]
sum += array[outer_index + inner_index]
inner_index += 1
else
break
end
end

result << sum
outer_index += inner_index
break if outer_index > array.size
end

result.compact
end

p sum_consecutives([1, 4, 4, 4, 0, 4, 3, 3, 1, 1]) == [1, 12, 0, 4, 6, 2]
p sum_consecutives([1, 1, 7, 7, 3]) == [2, 14, 3]
p sum_consecutives([-5, -5, 7, 7, 12, 0]) == [-10, 14, 12, 0]``````

Time: 33:58

## Example 5

``````=begin

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

# PEDAC

## Problem

Return an array of given strings without their vowels.

Input: An array of strings
Output: An array of the same strings, without their vowels

Clarification:

- Same array? (no)
- What are vowels in English? (a, i, u, e, o)
- Case important? (yes)
- Order important

## Data

Arrays of strings

## Algorithm

. Init a constant with each vowels of English
. Loop over the given array
. For each string, look for each vowels and delete if they exists
. Return each string
. Return the new array with the return value of the loop

=end

VOWELS = %w(a e i o u A E I O U)

def remove_vowels(array)
array.map do |word|
VOWELS.each do |vowel|
word.delete!(vowel)
end

word
end
end

p remove_vowels(['green', 'yellow', 'black', 'white']) == ['grn', 'yllw',
'blck', 'wht']``````

Time: 07:34

## Example 6

``````=begin

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

# PEDAC

## Problem

Given an array of integers, return an array with the number from the given
array that are prime.

Input: array of integers
Output: array of integers (prime)

Clarification:

- Prime is a number that cannot be composed from the product of numbers smaller
than itself
- Create new array? (No, mutation)

## Data

Array

## Algorithm

. Loop over the array
. For each number, PRIME?
. Delete the number from the array if PRIME? returns false
. Break when iteration is equal or bigger than number of element in the array
. Return the array

. PRIME?
. Iterate from 2 to square root of the given number
. Check if the remainder of given number as numerator and current number as
denominator is zero
. If true, return false
. Return true

=end

def prime?(numerator)
return false if numerator < 2
limit = Integer.sqrt(numerator)

2.upto(limit) do |denominator|
return false if numerator % denominator == 0
end

true
end

def select_primes(candidates)
iterator = 0

loop do
unless prime?(candidates[iterator])
candidates.delete(candidates[iterator])
iterator -= 1
end
iterator += 1
break if candidates[iterator].nil?
end

candidates
end

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

Time: 18:41

## Example 7

``````=begin

Write a method that combines two Arrays passed in as arguments and returns a new
Array that contains all elements from both Array arguments, with the elements
taken in alternation.

You may assume that both input Arrays are non-empty and that they have the same
number of elements.

# PEDAC

## Problem

Combine two arrays, starting with the first, then the second, then the first
etc alternatively.

Input: Two arrays
Output: The combinaison of both array

Clarification:

- Non-empty
- Same number of element
- Order matters (don't modify it)
- New array

## Data

Array

## Algorithm

. Init a local variable interleave to a new empty Array
. Create a loop
. Delete the first object of the first array and save it to interleave
. Delete the first object of the second array and save it to interleave
. Break if the first array is empty
. Return interleave

=end

def interleave(array1, array2)
interleave = []

loop do
interleave << array1.shift
interleave << array2.shift

break if array1.empty?
end

p interleave
end

p interleave([1, 2, 3], ['a', 'b', 'c']) == [1, "a", 2, "b", 3, "c"]``````

Time: 09:10

## Example 8

``````=begin

You are given array of integers, your task will be to count all pairs in that
array and return their count.

Notes:

Array can be empty or contain only one value; in this case return 0

If there are more pairs of a certain number, count each pair only once. E.g.:
for [0, 0, 0, 0] the return value is 2 (= 2 pairs of 0s)

Random tests: maximum array length is 1000, range of values in array is between
0 and 1000

Examples

[1, 2, 5, 6, 5, 2]  -->  2
...because there are 2 pairs: 2 and 5

[1, 2, 2, 20, 6, 20, 2, 6, 2]  -->  4
...because there are 4 pairs: 2, 20, 6 and 2 (again)

# PEDAC

## Problem

Count the pairs in an array of integers and return the count

Input: Array of integers with one or more duplicates
Output: Integer representing the number of pair

Clarification:

- Pair is 2 same number
- If there are more than 2 same numbers, count the pair (4 same num = 2 pairs)
- Return 0 if the array is empty

## Data

Array

## Algorithm

.  Return 0 if array is empty
.  Init a local variale pairs to 0
.  Iterate over the array passing in num
.  Count the number of num in the array
.  If the count is more than 1
.  Increment pairs by half of the count
.  Delete the num from the array
.  Return pairs

=end

def pairs(array)
return 0 if array.empty?

pairs = 0
candidates = array.dup

array.each do |num|
duplicates = candidates.count(num)

if duplicates > 1
pairs += duplicates / 2
end

candidates.delete(num)
end

pairs
end

p pairs([1, 2, 5, 6, 5, 2]) == 2
p pairs([1, 2, 2, 20, 6, 20, 2, 6, 2]) == 4
p pairs([0, 0, 0, 0, 0, 0, 0]) == 3
p pairs([1000, 1000]) == 1
p pairs([]) == 0
p pairs() == 0``````

Time: 12:49