From 8bb781f790d24de4b4922fec284054cc789dfd12 Mon Sep 17 00:00:00 2001
From: Vitor Oliveira <vbrazo@gmail.com>
Date: Fri, 3 Sep 2021 13:24:58 -0700
Subject: [PATCH] Minor fixes

---
 360                                           |   0
 backtracking/generate_paranthesis.rb          |  12 +-
 bit_manipulation/binary_and_operator.rb       |   6 +-
 bit_manipulation/binary_count_setbits.rb      |   2 +-
 .../binary_count_trailing_zeroes.rb           |   6 +-
 bit_manipulation/binary_or_operator.rb        |   7 +-
 bit_manipulation/binary_xor_operator.rb       |  20 +-
 .../single_bit_binary_operations.rb           |  17 +-
 conversions/temperature_conversions.rb        |  30 +--
 conversions/weight_conversions.rb             |  36 +--
 data_structures/arrays/add_digits.rb          |   4 +-
 data_structures/arrays/good_pairs.rb          |   5 +-
 data_structures/arrays/intersection.rb        |   5 +-
 data_structures/arrays/max_69_number.rb       |   4 +-
 .../arrays/next_greater_element.rb            |   6 +-
 data_structures/arrays/remove_elements.rb     |  30 +--
 .../arrays/richest_customer_wealth.rb         |   8 +-
 data_structures/arrays/shuffle_array.rb       |  12 +-
 data_structures/arrays/single_number.rb       |   6 +-
 .../strings/almost_palindrome_checker.rb      |  11 +-
 .../arrays/strings/jewels_and_stones.rb       |  18 +-
 data_structures/arrays/strings/palindrome.rb  |   4 +-
 .../arrays/strings/remove_vowels.rb           |   4 +-
 data_structures/arrays/sudoku.rb              | 207 +++++++++---------
 data_structures/arrays/two_sum.rb             |   4 +-
 data_structures/hash_table/anagram_checker.rb |   2 +-
 .../hash_table/arrays_intersection.rb         |   2 +-
 .../hash_table/common_characters.rb           |   6 +-
 data_structures/hash_table/good_pairs.rb      |   2 +-
 .../hash_table/isomorphic_strings.rb          |  14 +-
 .../hash_table/richest_customer_wealth.rb     |  12 +-
 data_structures/hash_table/two_sum.rb         |   4 +-
 data_structures/hash_table/uncommon_words.rb  |  10 +-
 data_structures/queues/circular_queue.rb      |  11 +-
 dynamic_programming/climbing_stairs.rb        |  86 ++++----
 .../count_sorted_vowel_strings.rb             |   6 +-
 dynamic_programming/pascal_triangle_ii.rb     |   1 +
 maths/abs_max.rb                              |  12 +-
 maths/abs_min.rb                              |  12 +-
 maths/add.rb                                  |  18 +-
 maths/armstrong_number.rb                     |  12 +-
 maths/average_mean.rb                         |  10 +-
 maths/average_median.rb                       |  20 +-
 maths/count_sorted_vowel_strings.rb           |   1 -
 maths/factorial.rb                            |  12 +-
 .../factorial_non_recursive_non_iterative.rb  |  10 +-
 maths/find_max.rb                             |  26 +--
 maths/find_min.rb                             |  26 +--
 maths/lucas_series.rb                         |   8 +-
 maths/pascal_triangle_ii.rb                   |   6 +-
 maths/power_of_two.rb                         |   6 +-
 maths/prime_number.rb                         |  18 +-
 maths/roman_to_integer.rb                     |  28 +--
 other/number_of_days.rb                       |   7 +-
 searches/number_of_islands.rb                 | 111 +++++-----
 sorting/cocktail_sort.rb                      |   5 +-
 sorting/cocktail_sort_test.rb                 |   1 -
 sorting/comb_sort.rb                          |   2 +-
 sorting/pancake_sort.rb                       |   1 +
 59 files changed, 471 insertions(+), 501 deletions(-)
 create mode 100644 360

diff --git a/360 b/360
new file mode 100644
index 0000000..e69de29
diff --git a/backtracking/generate_paranthesis.rb b/backtracking/generate_paranthesis.rb
index 5c0e3fa..9993a9c 100644
--- a/backtracking/generate_paranthesis.rb
+++ b/backtracking/generate_paranthesis.rb
@@ -26,7 +26,7 @@
 # brackets.
 
 # Complexity Analysis
-# 
+#
 # Time Complexity: O(4^n/sqrt(n)). Each valid sequence has at most n steps during the backtracking procedure.
 # Space Complexity: O(4^n/sqrt(n)), as described above, and using O(n) space to store the sequence.
 
@@ -37,7 +37,7 @@
 # @return {String[]}
 def generate_parenthesis(n)
   parenthesis = []
-  backtrack(parenthesis, "", 0, 0, n)
+  backtrack(parenthesis, '', 0, 0, n)
   parenthesis
 end
 
@@ -47,13 +47,9 @@ def backtrack(parenthesis, curr, open, close, max)
     return
   end
 
-  if open < max
-    backtrack(parenthesis, curr + "(", open + 1, close, max)
-  end
+  backtrack(parenthesis, curr + '(', open + 1, close, max) if open < max
 
-  if close < open
-    backtrack(parenthesis, curr + ")", open, close + 1, max)
-  end
+  backtrack(parenthesis, curr + ')', open, close + 1, max) if close < open
 end
 
 n = 3
diff --git a/bit_manipulation/binary_and_operator.rb b/bit_manipulation/binary_and_operator.rb
index 4cc0f5a..8c2b4bb 100644
--- a/bit_manipulation/binary_and_operator.rb
+++ b/bit_manipulation/binary_and_operator.rb
@@ -1,12 +1,12 @@
 def binary_and(x, y)
-  raise 'Input must only contain positive integers' if x < 0 or y < 0
+  raise 'Input must only contain positive integers' if (x < 0) || (y < 0)
 
-  "0b" + (x & y).to_s(2)
+  '0b' + (x & y).to_s(2)
 end
 
 begin
   binary_and(-1, 0)
-rescue => e
+rescue StandardError => e
   puts e.message
 end
 # Input must only contain positive integers
diff --git a/bit_manipulation/binary_count_setbits.rb b/bit_manipulation/binary_count_setbits.rb
index 4deab5a..b99d8d9 100644
--- a/bit_manipulation/binary_count_setbits.rb
+++ b/bit_manipulation/binary_count_setbits.rb
@@ -8,7 +8,7 @@ end
 
 begin
   binary_count_setbits(-1)
-rescue => e
+rescue StandardError => e
   puts e.message
 end
 # Input must be a positive integer
diff --git a/bit_manipulation/binary_count_trailing_zeroes.rb b/bit_manipulation/binary_count_trailing_zeroes.rb
index 40eafad..e0ed626 100644
--- a/bit_manipulation/binary_count_trailing_zeroes.rb
+++ b/bit_manipulation/binary_count_trailing_zeroes.rb
@@ -5,7 +5,7 @@ def binary_count_trailing_zeroes(x)
 
   count = 0
   binary.chars.reverse_each do |char|
-    break if char == "1"
+    break if char == '1'
 
     count += 1
   end
@@ -15,7 +15,7 @@ end
 
 begin
   binary_count_trailing_zeroes(-1)
-rescue => e
+rescue StandardError => e
   puts e.message
 end
 # Input must be a positive integer
@@ -32,5 +32,5 @@ puts binary_count_trailing_zeroes(1024)
 puts binary_count_trailing_zeroes(54)
 # 1
 
-puts binary_count_trailing_zeroes(121024)
+puts binary_count_trailing_zeroes(121_024)
 # 6
diff --git a/bit_manipulation/binary_or_operator.rb b/bit_manipulation/binary_or_operator.rb
index 43758b7..694e98d 100644
--- a/bit_manipulation/binary_or_operator.rb
+++ b/bit_manipulation/binary_or_operator.rb
@@ -1,12 +1,12 @@
 def binary_or(x, y)
-  raise 'Input must only contain positive integers' if x < 0 or y < 0
+  raise 'Input must only contain positive integers' if (x < 0) || (y < 0)
 
-  "0b" + (x | y).to_s(2)
+  '0b' + (x | y).to_s(2)
 end
 
 begin
   binary_or(-1, 0)
-rescue => e
+rescue StandardError => e
   puts e.message
 end
 # Input must only contain positive integers
@@ -21,4 +21,3 @@ puts binary_or(0, 1023)
 # 0b1111111111
 puts binary_or(16, 58)
 # 0b110010
-
diff --git a/bit_manipulation/binary_xor_operator.rb b/bit_manipulation/binary_xor_operator.rb
index 634e8df..98f1426 100644
--- a/bit_manipulation/binary_xor_operator.rb
+++ b/bit_manipulation/binary_xor_operator.rb
@@ -1,25 +1,25 @@
 def binary_xor(x, y)
-  raise 'Input must only contain positive integers' if x < 0 or y < 0
+  raise 'Input must only contain positive integers' if (x < 0) || (y < 0)
 
   binary_x = x.to_s(2)
   binary_y = y.to_s(2)
 
   if binary_x.length > binary_y.length
-    prefix = "0" * (binary_x.length - binary_y.length)
+    prefix = '0' * (binary_x.length - binary_y.length)
     binary_y = prefix + binary_y
   elsif binary_y.length > binary_x.length
-    prefix = "0" * (binary_y.length - binary_x.length)
+    prefix = '0' * (binary_y.length - binary_x.length)
     binary_x = prefix + binary_x
   end
-  result = "0b"
+  result = '0b'
   binary_x.each_char.with_index do |x_char, i|
     y_char = binary_y[i]
 
-    if (x_char == "1" && y_char != "1") || (x_char != "1" && y_char == "1")
-      result += "1"
-    else
-      result += "0"
-    end
+    result += if (x_char == '1' && y_char != '1') || (x_char != '1' && y_char == '1')
+                '1'
+              else
+                '0'
+              end
   end
 
   result
@@ -27,7 +27,7 @@ end
 
 begin
   binary_xor(-1, 0)
-rescue => e
+rescue StandardError => e
   puts e.message
 end
 # Input must only contain positive integers
diff --git a/bit_manipulation/single_bit_binary_operations.rb b/bit_manipulation/single_bit_binary_operations.rb
index b7da58e..a9eb67e 100644
--- a/bit_manipulation/single_bit_binary_operations.rb
+++ b/bit_manipulation/single_bit_binary_operations.rb
@@ -1,5 +1,5 @@
 def set_bit(x, position)
-  raise "position must be >= 0" if position < 0
+  raise 'position must be >= 0' if position < 0
 
   x | (1 << position)
 end
@@ -18,14 +18,13 @@ puts set_bit(8, 4)
 
 begin
   puts set_bit(8, -4)
-rescue => e
+rescue StandardError => e
   puts e.message
 end
 # position must be >= 0
 
-
 def clear_bit(x, position)
-  raise "position must be > 0" if position < 0
+  raise 'position must be > 0' if position < 0
 
   x & ~(1 << position)
 end
@@ -44,13 +43,13 @@ puts clear_bit(24, 4)
 
 begin
   puts clear_bit(0, -4)
-rescue => e
+rescue StandardError => e
   puts e.message
 end
 # position must be > 0
 
 def flip_bit(x, position)
-  raise "position must be > 0" if position < 0
+  raise 'position must be > 0' if position < 0
 
   x ^ (1 << position)
 end
@@ -69,13 +68,13 @@ puts flip_bit(24, 4)
 
 begin
   puts flip_bit(0, -4)
-rescue => e
+rescue StandardError => e
   puts e.message
 end
 # position must be > 0
 
 def is_bit_set(x, position)
-  raise "position must be > 0" if position < 0
+  raise 'position must be > 0' if position < 0
 
   ((x >> position) & 1) == 1
 end
@@ -94,7 +93,7 @@ puts is_bit_set(24, 4)
 
 begin
   puts is_bit_set(0, -4)
-rescue => e
+rescue StandardError => e
   puts e.message
 end
 # position must be > 0
diff --git a/conversions/temperature_conversions.rb b/conversions/temperature_conversions.rb
index d62b807..090e2bd 100644
--- a/conversions/temperature_conversions.rb
+++ b/conversions/temperature_conversions.rb
@@ -5,48 +5,48 @@ module TemperatureConversion
   def self.celsius_to_kelvin(celsius_input)
     kelvin_output = (celsius_input + 273.15).round(2)
     puts "#{celsius_input}°C = #{kelvin_output}K"
-  rescue
-    puts "Error: Please provide number only!"
+  rescue StandardError
+    puts 'Error: Please provide number only!'
   end
 
   # kelvin -> celsius = vale of kelvin - 273.15 => °C
   def self.kelvin_to_celsius(kelvin_input)
     celsius_output = (kelvin_input - 273.15).round(2)
     puts "#{kelvin_input}K = #{celsius_output}°C"
-  rescue
-    puts "Error: Please provide number only!"
+  rescue StandardError
+    puts 'Error: Please provide number only!'
   end
 
   # celsius -> fahrenheit = (value of celsius * 9 / 5) + 32 => °F
   def self.celsius_to_fahrenheit(celsius_input)
     fahrenheit_output = ((celsius_input * 9 / 5) + 32).round(2)
     puts "#{celsius_input}°C = #{fahrenheit_output}°F"
-  rescue
-    puts "Error: Please provide number only!"
+  rescue StandardError
+    puts 'Error: Please provide number only!'
   end
 
   # fahrenheit -> celsius = (value of fahrenheit - 32) * 5 / 9 => °C
   def self.fahrenheit_to_celsius(fahrenheit_input)
     celsius_output = ((fahrenheit_input - 32) * 5 / 9).round(2)
     puts "#{fahrenheit_input}°F = #{celsius_output}°C"
-  rescue
-    puts "Error: Please provide number only!"
+  rescue StandardError
+    puts 'Error: Please provide number only!'
   end
 
   # fahrenheit -> kelvin = [(value of fahrenheit - 32) * 5 / 9] + 273.15 => K
   def self.fahrenheit_to_kelvin(fahrenheit_input)
     kelvin_output = ((fahrenheit_input - 32) * 5 / 9).round(2).round(2)
     puts "#{fahrenheit_input}°F = #{kelvin_output}K"
-  rescue
-    puts "Error: Please provide number only!"
+  rescue StandardError
+    puts 'Error: Please provide number only!'
   end
 
   # kelvin -> fahrenheit = [(value of kelvin - 32) * 5 / 9] + 273.15 => K
   def self.kelvin_to_fahrenheit(kelvin_input)
     fahrenheit_output = (((kelvin_input - 273.15) * 9 / 5) + 32).round(2).round(2)
     puts "#{kelvin_input}K = #{fahrenheit_output}°F"
-  rescue
-    puts "Error: Please provide number only!"
+  rescue StandardError
+    puts 'Error: Please provide number only!'
   end
 end
 
@@ -55,18 +55,18 @@ TemperatureConversion.celsius_to_kelvin(20)
 TemperatureConversion.kelvin_to_celsius(20)
 
 # Invalid input
-TemperatureConversion.kelvin_to_celsius("a")
+TemperatureConversion.kelvin_to_celsius('a')
 
 # celsius <-> fahrenheit
 TemperatureConversion.celsius_to_fahrenheit(-20)
 TemperatureConversion.fahrenheit_to_celsius(68)
 
 # Invalid input
-TemperatureConversion.celsius_to_fahrenheit("abc")
+TemperatureConversion.celsius_to_fahrenheit('abc')
 
 # fahrenheit <-> kelvin
 TemperatureConversion.fahrenheit_to_kelvin(60)
 TemperatureConversion.kelvin_to_fahrenheit(-60)
 
 # Invalid input
-TemperatureConversion.fahrenheit_to_kelvin("60")
+TemperatureConversion.fahrenheit_to_kelvin('60')
diff --git a/conversions/weight_conversions.rb b/conversions/weight_conversions.rb
index e1f86f1..d3a8ec9 100644
--- a/conversions/weight_conversions.rb
+++ b/conversions/weight_conversions.rb
@@ -3,7 +3,7 @@
 module WeightConversion
   # Kilogram -> Gram = (kilogram_value * 1000) grams
   def self.kilogram_to_gram(kilogram_input)
-    raise StandardError unless Integer === kilogram_input
+    raise StandardError unless kilogram_input.is_a?(Integer)
 
     gram = kilogram_input * 1000
 
@@ -40,7 +40,7 @@ module WeightConversion
 
   # Pound -> Kilogram = (pound_input / 2.205) kg
   def self.pound_to_kilogram(pound_input)
-    raise StandardError unless Integer === pound_input
+    raise StandardError unless pound_input.is_a?(Integer)
 
     kilogram = (pound_input / 2.205).round(2)
 
@@ -48,9 +48,9 @@ module WeightConversion
   end
 end
 
-# 
+#
 # Valid inputs
-# 
+#
 
 puts WeightConversion.kilogram_to_gram(2)
 # 2 kg = 2000 g
@@ -65,42 +65,42 @@ puts WeightConversion.kilogram_to_pound(1)
 puts WeightConversion.pound_to_kilogram(100)
 # 100 lb = 45.35 kg
 
-# 
+#
 # Invalid inputs
-# 
+#
 
 begin
-  puts WeightConversion.kilogram_to_gram("a")
+  puts WeightConversion.kilogram_to_gram('a')
 rescue StandardError
-  puts "Error: Please provide number only!"
+  puts 'Error: Please provide number only!'
 end
 
 begin
-  puts WeightConversion.kilogram_to_gram("3000")
+  puts WeightConversion.kilogram_to_gram('3000')
 rescue StandardError
-  puts "Error: Please provide number only!"
+  puts 'Error: Please provide number only!'
 end
 
 begin
-  puts WeightConversion.kilogram_to_gram("16")
+  puts WeightConversion.kilogram_to_gram('16')
 rescue StandardError
-  puts "Error: Please provide number only!"
+  puts 'Error: Please provide number only!'
 end
 
 begin
-  puts WeightConversion.kilogram_to_gram("x ")
+  puts WeightConversion.kilogram_to_gram('x ')
 rescue StandardError
-  puts "Error: Please provide number only!"
+  puts 'Error: Please provide number only!'
 end
 
 begin
-  puts WeightConversion.kilogram_to_gram("weight")
+  puts WeightConversion.kilogram_to_gram('weight')
 rescue StandardError
-  puts "Error: Please provide number only!"
+  puts 'Error: Please provide number only!'
 end
 
 begin
-  puts WeightConversion.kilogram_to_gram("100")
+  puts WeightConversion.kilogram_to_gram('100')
 rescue StandardError
-  puts "Error: Please provide number only!"
+  puts 'Error: Please provide number only!'
 end
diff --git a/data_structures/arrays/add_digits.rb b/data_structures/arrays/add_digits.rb
index 2662484..3b529d6 100644
--- a/data_structures/arrays/add_digits.rb
+++ b/data_structures/arrays/add_digits.rb
@@ -20,9 +20,7 @@
 # Time complexity: O(n)
 #
 def add_digits(num)
-  if num.to_s.length < 2
-    return num
-  end
+  return num if num.to_s.length < 2
 
   digits_to_sum = num.to_s.split('')
   sum = 0
diff --git a/data_structures/arrays/good_pairs.rb b/data_structures/arrays/good_pairs.rb
index b62572d..853d01b 100644
--- a/data_structures/arrays/good_pairs.rb
+++ b/data_structures/arrays/good_pairs.rb
@@ -19,9 +19,8 @@ def num_identical_pairs(nums)
     target = num
     nums.each_with_index do |num, j|
       next if i >= j
-      if num == target
-        count += 1
-      end
+
+      count += 1 if num == target
     end
   end
   count
diff --git a/data_structures/arrays/intersection.rb b/data_structures/arrays/intersection.rb
index dfcd49b..42eda4f 100644
--- a/data_structures/arrays/intersection.rb
+++ b/data_structures/arrays/intersection.rb
@@ -25,6 +25,7 @@ def intersect(arr1, arr2)
   shorter.each do |matcher|
     longer.each do |number|
       next if number != matcher
+
       result.push(number)
       break
     end
@@ -60,7 +61,7 @@ def intersect(arr1, arr2)
 
   hash = Hash.new(0)
 
-  arr2.each {|num| hash[num] += 1 }
+  arr2.each { |num| hash[num] += 1 }
 
   arr1.each do |num|
     if hash.has_key?(num)
@@ -107,7 +108,7 @@ def intersect(nums1, nums2)
       p2 += 1
     end
   end
-  
+
   result
 end
 nums1 = [1, 2, 2, 1]
diff --git a/data_structures/arrays/max_69_number.rb b/data_structures/arrays/max_69_number.rb
index 871b461..884347b 100644
--- a/data_structures/arrays/max_69_number.rb
+++ b/data_structures/arrays/max_69_number.rb
@@ -1,6 +1,6 @@
 # Challenge name: Maximum 69 number
 #
-# Given a positive integer num consisting only of digits 6 and 9. 
+# Given a positive integer num consisting only of digits 6 and 9.
 # Return the maximum number you can get by changing at most one digit (6 becomes 9, and 9 becomes 6).
 #
 # Example 1:
@@ -37,4 +37,4 @@ puts max_number(9669)
 # => 9969
 
 puts max_number(9996)
-# => 9999
\ No newline at end of file
+# => 9999
diff --git a/data_structures/arrays/next_greater_element.rb b/data_structures/arrays/next_greater_element.rb
index 92b3344..10ee4d3 100644
--- a/data_structures/arrays/next_greater_element.rb
+++ b/data_structures/arrays/next_greater_element.rb
@@ -23,12 +23,12 @@
 # For number 2 in the first array, the next greater number for it in the second array is 3.
 # For number 4 in the first array, there is no next greater number for it in the second array, so output -1.
 
-# 
+#
 # Approach: Brute Force
-# 
+#
 
 # Complexity Analysis
-# 
+#
 # Time complexity: O(m*n). The complete nums1 array (of size n) needs to be scanned for all the m elements of nums2 in the worst case.
 # Space complexity: O(1). No additional space since we're swapping elements in nums1 and returning the input array.
 
diff --git a/data_structures/arrays/remove_elements.rb b/data_structures/arrays/remove_elements.rb
index ad7204b..a1f207b 100644
--- a/data_structures/arrays/remove_elements.rb
+++ b/data_structures/arrays/remove_elements.rb
@@ -19,13 +19,13 @@
 # Time complexity: O(n)
 #
 def remove_elements(nums, val)
-  nums.delete_if{ |num| num == val }
+  nums.delete_if { |num| num == val }
   nums.length
 end
 
-puts remove_elements([3,2,2,3], 3)
+puts remove_elements([3, 2, 2, 3], 3)
 # => 2
-puts remove_elements([0,1,2,2,3,0,4,2], 2)
+puts remove_elements([0, 1, 2, 2, 3, 0, 4, 2], 2)
 # => 5
 
 #
@@ -37,20 +37,20 @@ def remove_elements(nums, val)
   result_length = nums.length
   shift_length = 0
   nums.each_with_index do |num, i|
-    if num == val
-      nums.delete_at(i)
-      nums.unshift('removed')
-      result_length -=1
-      shift_length += 1
-    end
+    next unless num == val
+
+    nums.delete_at(i)
+    nums.unshift('removed')
+    result_length -= 1
+    shift_length += 1
   end
   nums.shift(shift_length)
   result_length
 end
 
-puts remove_elements([3,2,2,3], 3)
+puts remove_elements([3, 2, 2, 3], 3)
 # => 2
-puts remove_elements([0,1,2,2,3,0,4,2], 2)
+puts remove_elements([0, 1, 2, 2, 3, 0, 4, 2], 2)
 # => 5
 
 #
@@ -78,9 +78,9 @@ def remove_element(nums, val)
   pointer1
 end
 
-puts remove_elements([3,2,2,3], 3)
+puts remove_elements([3, 2, 2, 3], 3)
 # => 2
-puts remove_elements([0,1,2,2,3,0,4,2], 2)
+puts remove_elements([0, 1, 2, 2, 3, 0, 4, 2], 2)
 # => 5
 
 #
@@ -111,7 +111,7 @@ def remove_element(nums, val)
   pointer1
 end
 
-puts remove_elements([3,2,2,3], 3)
+puts remove_elements([3, 2, 2, 3], 3)
 # => 2
-puts remove_elements([0,1,2,2,3,0,4,2], 2)
+puts remove_elements([0, 1, 2, 2, 3, 0, 4, 2], 2)
 # => 5
diff --git a/data_structures/arrays/richest_customer_wealth.rb b/data_structures/arrays/richest_customer_wealth.rb
index 4efabeb..3b6f557 100644
--- a/data_structures/arrays/richest_customer_wealth.rb
+++ b/data_structures/arrays/richest_customer_wealth.rb
@@ -45,12 +45,12 @@ def find_richest_customer_wealth(accounts)
     summed_accounts.push(summed)
   end
 
-  summed_accounts.sort.pop()
+  summed_accounts.sort.pop
 end
 
-puts find_richest_customer_wealth([[1,2,3],[3,2,1]])
+puts find_richest_customer_wealth([[1, 2, 3], [3, 2, 1]])
 # => 6
-puts find_richest_customer_wealth([[1,5],[7,3],[3,5]])
+puts find_richest_customer_wealth([[1, 5], [7, 3], [3, 5]])
 # => 10
-puts find_richest_customer_wealth([[2,8,7],[7,1,3],[1,9,5]])
+puts find_richest_customer_wealth([[2, 8, 7], [7, 1, 3], [1, 9, 5]])
 # => 17
diff --git a/data_structures/arrays/shuffle_array.rb b/data_structures/arrays/shuffle_array.rb
index 22ec07a..eeb5a38 100644
--- a/data_structures/arrays/shuffle_array.rb
+++ b/data_structures/arrays/shuffle_array.rb
@@ -28,8 +28,8 @@
 #
 def shuffle(nums, n)
   result = []
-  (0..n-1).count do |i|
-    result.push(nums[i], nums[i+n])
+  (0..n - 1).count do |i|
+    result.push(nums[i], nums[i + n])
   end
   result
 end
@@ -55,7 +55,7 @@ print(shuffle(nums, n))
 
 def shuffle(nums, n)
   current_index = 1
-  (0..n-1).each do |i|
+  (0..n - 1).each do |i|
     nums.insert(current_index, nums.delete_at(i + n))
     current_index += 2
   end
@@ -88,8 +88,8 @@ def shuffle(nums, n)
 
   while p1 < n
     result.push(nums[p1], nums[p2])
-    p1 +=1
-    p2 +=1
+    p1 += 1
+    p2 += 1
   end
 
   result
@@ -106,4 +106,4 @@ print(shuffle(nums, n))
 nums = [1, 1, 2, 2]
 n = 2
 print(shuffle(nums, n))
-# Output: [1,2,1,2]
\ No newline at end of file
+# Output: [1,2,1,2]
diff --git a/data_structures/arrays/single_number.rb b/data_structures/arrays/single_number.rb
index 163b7b1..1dc63c0 100644
--- a/data_structures/arrays/single_number.rb
+++ b/data_structures/arrays/single_number.rb
@@ -9,7 +9,7 @@
 # @param {Integer[]} nums
 # @return {Integer}
 
-# 
+#
 # Approach 1: Hash map
 #
 # Time Complexity: O(n)
@@ -18,7 +18,7 @@ def single_number(nums)
   result_hash = {}
   nums.each do |num|
     if result_hash[num]
-      result_hash[num] +=1 
+      result_hash[num] += 1
     else
       result_hash[num] = 1
     end
@@ -58,4 +58,4 @@ puts(single_number(nums))
 # Output: 4
 nums = [1]
 puts(single_number(nums))
-# Output: 1
\ No newline at end of file
+# Output: 1
diff --git a/data_structures/arrays/strings/almost_palindrome_checker.rb b/data_structures/arrays/strings/almost_palindrome_checker.rb
index 0115ec3..a785135 100644
--- a/data_structures/arrays/strings/almost_palindrome_checker.rb
+++ b/data_structures/arrays/strings/almost_palindrome_checker.rb
@@ -28,16 +28,14 @@
 # Time Complexity: O(n)
 # Space Complexity: O(1)
 
-
 def almost_palindrome_checker(string)
   p1 = 0
   p2 = string.length - 1
   array = string.split('')
 
   while p1 < p2
-    if array[p1] != array[p2]
-      return palindrome_checker(array, p1, p2 - 1) || palindrome_checker(array, p1 + 1, p2)
-    end
+    return palindrome_checker(array, p1, p2 - 1) || palindrome_checker(array, p1 + 1, p2) if array[p1] != array[p2]
+
     p1 += 1
     p2 -= 1
   end
@@ -47,9 +45,8 @@ end
 
 def palindrome_checker(array, p1, p2)
   while p1 < p2
-    if array[p1] != array[p2]
-      return false
-    end
+    return false if array[p1] != array[p2]
+
     p1 += 1
     p2 -= 1
   end
diff --git a/data_structures/arrays/strings/jewels_and_stones.rb b/data_structures/arrays/strings/jewels_and_stones.rb
index a777534..3c1c924 100644
--- a/data_structures/arrays/strings/jewels_and_stones.rb
+++ b/data_structures/arrays/strings/jewels_and_stones.rb
@@ -30,23 +30,21 @@
 # Time Complexity: O(n^2)
 #
 
-def find_jewels(jewels, stones) 
+def find_jewels(jewels, stones)
   jewels_array = jewels.split('')
   stones_array = stones.split('')
   result = 0
   jewels_array.each do |jewel|
     stones_array.each do |stone|
-      if jewel == stone
-        result += 1
-      end
+      result += 1 if jewel == stone
     end
   end
   result
 end
 
-puts find_jewels("aA", "aAAbbbb")
+puts find_jewels('aA', 'aAAbbbb')
 # => 3
-puts find_jewels("z", "ZZ")
+puts find_jewels('z', 'ZZ')
 # => 0
 
 #
@@ -62,7 +60,7 @@ def find_jewels(jewels, stones)
   result = 0
 
   stones_array.each do |stone|
-    if result_hash[stone] 
+    if result_hash[stone]
       result_hash[stone] += 1
     else
       result_hash[stone] = 1
@@ -80,7 +78,7 @@ def find_jewels(jewels, stones)
   result
 end
 
-puts find_jewels("aA", "aAAbbbb")
+puts find_jewels('aA', 'aAAbbbb')
 # => 3
-puts find_jewels("z", "ZZ")
-# => 0
\ No newline at end of file
+puts find_jewels('z', 'ZZ')
+# => 0
diff --git a/data_structures/arrays/strings/palindrome.rb b/data_structures/arrays/strings/palindrome.rb
index 587e242..b130aee 100644
--- a/data_structures/arrays/strings/palindrome.rb
+++ b/data_structures/arrays/strings/palindrome.rb
@@ -52,8 +52,8 @@ puts is_palindrome(s)
 # Time Complexity: O(n), in length n of the string.
 #
 # We need to iterate through the string: When we filter out non-alphanumeric characters and convert the remaining
-# characters to lower-case. When we reverse the string. When we compare the original and the reversed strings. 
-# Each iteration runs linearly in time (since each character operation completes in constant time). 
+# characters to lower-case. When we reverse the string. When we compare the original and the reversed strings.
+# Each iteration runs linearly in time (since each character operation completes in constant time).
 # Thus, the effective run-time complexity is linear.
 #
 # Space Complexity: O(n), in length n of the string. We need O(n) additional
diff --git a/data_structures/arrays/strings/remove_vowels.rb b/data_structures/arrays/strings/remove_vowels.rb
index 30d3042..3e516ea 100644
--- a/data_structures/arrays/strings/remove_vowels.rb
+++ b/data_structures/arrays/strings/remove_vowels.rb
@@ -26,9 +26,7 @@ def remove_vowels(s)
   start_array = s.split('')
 
   start_array.each do |letter|
-    if letter != 'a' && letter != 'e' && letter != 'i' && letter != 'o' && letter != 'u'
-      result_array.push(letter)
-    end
+    result_array.push(letter) if letter != 'a' && letter != 'e' && letter != 'i' && letter != 'o' && letter != 'u'
   end
 
   result_array.join('')
diff --git a/data_structures/arrays/sudoku.rb b/data_structures/arrays/sudoku.rb
index 9a6b3ae..fea0e7a 100644
--- a/data_structures/arrays/sudoku.rb
+++ b/data_structures/arrays/sudoku.rb
@@ -20,7 +20,8 @@ def is_valid_sudoku(board)
   board.each do |row|
     row_hash = Hash.new(0)
     row.each do |num|
-      next if num == "."
+      next if num == '.'
+
       row_hash[num] += 1
     end
     rows << row_hash
@@ -28,10 +29,8 @@ def is_valid_sudoku(board)
 
   # check each row hash for duplicated value
   rows.each do |row|
-    row.each do |k, v|
-      if v > 1
-        return false
-      end
+    row.each do |_k, v|
+      return false if v > 1
     end
   end
 
@@ -39,7 +38,8 @@ def is_valid_sudoku(board)
   (0..8).each do |i|
     column_hash = Hash.new(0)
     board.each do |row|
-      next if row[i] == "."
+      next if row[i] == '.'
+
       column_hash[row[i]] += 1
       columns << column_hash
     end
@@ -47,10 +47,8 @@ def is_valid_sudoku(board)
 
   # check each column hash for duplicated value
   columns.each do |column|
-    column.each do |k, v|
-      if v > 1
-        return false
-      end
+    column.each do |_k, v|
+      return false if v > 1
     end
   end
 
@@ -58,17 +56,20 @@ def is_valid_sudoku(board)
   (0..2).each do |i|
     grid_hash = Hash.new(0)
     board.first(3).each do |row|
-      next if row[i] == "."
+      next if row[i] == '.'
+
       grid_hash[row[i]] += 1
       grids << grid_hash
     end
     board[3..5].each do |row|
-      next if row[i] == "."
+      next if row[i] == '.'
+
       grid_hash[row[i]] += 1
       grids << grid_hash
     end
     board.each do |row|
-      next if row[i] == "."
+      next if row[i] == '.'
+
       grid_hash[row[i]] += 1
       grids << grid_hash
     end
@@ -76,17 +77,20 @@ def is_valid_sudoku(board)
   (3..5).each do |i|
     grid_hash = Hash.new(0)
     board.first(3).each do |row|
-      next if row[i] == "."
+      next if row[i] == '.'
+
       grid_hash[row[i]] += 1
       grids << grid_hash
     end
     board[3..5].each do |row|
-      next if row[i] == "."
+      next if row[i] == '.'
+
       grid_hash[row[i]] += 1
       grids << grid_hash
     end
     board.each do |row|
-      next if row[i] == "."
+      next if row[i] == '.'
+
       grid_hash[row[i]] += 1
       grids << grid_hash
     end
@@ -94,17 +98,20 @@ def is_valid_sudoku(board)
   (6..8).last(3).each do |i|
     grid_hash = Hash.new(0)
     board.first(3).each do |row|
-      next if row[i] == "."
+      next if row[i] == '.'
+
       grid_hash[row[i]] += 1
       grids << grid_hash
     end
     board[3..5].each do |row|
-      next if row[i] == "."
+      next if row[i] == '.'
+
       grid_hash[row[i]] += 1
       grids << grid_hash
     end
     board.each do |row|
-      next if row[i] == "."
+      next if row[i] == '.'
+
       grid_hash[row[i]] += 1
       grids << grid_hash
     end
@@ -112,63 +119,61 @@ def is_valid_sudoku(board)
 
   # check each grid hash for duplicated value
   grids.each do |grid|
-    grid.each do |k, v|
-      if v > 1
-        return false
-      end
+    grid.each do |_k, v|
+      return false if v > 1
     end
   end
 
   true
 end
 
-board = [["5","3",".",".","7",".",".",".","."],
-        ["6",".",".","1","9","5",".",".","."],
-        [".","9","8",".",".",".",".","6","."],
-        ["8",".",".",".","6",".",".",".","3"],
-        ["4",".",".","8",".","3",".",".","1"],
-        ["7",".",".",".","2",".",".",".","6"],
-        [".","6",".",".",".",".","2","8","."],
-        [".",".",".","4","1","9",".",".","5"],
-        [".",".",".",".","8",".",".","7","9"]]
+board = [['5', '3', '.', '.', '7', '.', '.', '.', '.'],
+         ['6', '.', '.', '1', '9', '5', '.', '.', '.'],
+         ['.', '9', '8', '.', '.', '.', '.', '6', '.'],
+         ['8', '.', '.', '.', '6', '.', '.', '.', '3'],
+         ['4', '.', '.', '8', '.', '3', '.', '.', '1'],
+         ['7', '.', '.', '.', '2', '.', '.', '.', '6'],
+         ['.', '6', '.', '.', '.', '.', '2', '8', '.'],
+         ['.', '.', '.', '4', '1', '9', '.', '.', '5'],
+         ['.', '.', '.', '.', '8', '.', '.', '7', '9']]
 print(is_valid_sudoku(board))
 # => true
 
-board = [["8","3",".",".","7",".",".",".","."],
-        ["6",".",".","1","9","5",".",".","."],
-        [".","9","8",".",".",".",".","6","."],
-        ["8",".",".",".","6",".",".",".","3"],
-        ["4",".",".","8",".","3",".",".","1"],
-        ["7",".",".",".","2",".",".",".","6"],
-        [".","6",".",".",".",".","2","8","."],
-        [".",".",".","4","1","9",".",".","5"],
-        [".",".",".",".","8",".",".","7","9"]]
+board = [['8', '3', '.', '.', '7', '.', '.', '.', '.'],
+         ['6', '.', '.', '1', '9', '5', '.', '.', '.'],
+         ['.', '9', '8', '.', '.', '.', '.', '6', '.'],
+         ['8', '.', '.', '.', '6', '.', '.', '.', '3'],
+         ['4', '.', '.', '8', '.', '3', '.', '.', '1'],
+         ['7', '.', '.', '.', '2', '.', '.', '.', '6'],
+         ['.', '6', '.', '.', '.', '.', '2', '8', '.'],
+         ['.', '.', '.', '4', '1', '9', '.', '.', '5'],
+         ['.', '.', '.', '.', '8', '.', '.', '7', '9']]
 print(is_valid_sudoku(board))
 # => false
 # explanation: duplicated value in column
 
-board = [["8","3",".",".","7",".","3",".","."],
-        ["6",".",".","1","9","5",".",".","."],
-        [".","9","8",".",".",".",".","6","."],
-        ["8",".",".",".","6",".",".",".","3"],
-        ["4",".",".","8",".","3",".",".","1"],
-        ["7",".",".",".","2",".",".",".","6"],
-        [".","6",".",".",".",".","2","8","."],
-        [".",".",".","4","1","9",".",".","5"],
-        [".",".",".",".","8",".",".","7","9"]]
+board = [['8', '3', '.', '.', '7', '.', '3', '.', '.'],
+         ['6', '.', '.', '1', '9', '5', '.', '.', '.'],
+         ['.', '9', '8', '.', '.', '.', '.', '6', '.'],
+         ['8', '.', '.', '.', '6', '.', '.', '.', '3'],
+         ['4', '.', '.', '8', '.', '3', '.', '.', '1'],
+         ['7', '.', '.', '.', '2', '.', '.', '.', '6'],
+         ['.', '6', '.', '.', '.', '.', '2', '8', '.'],
+         ['.', '.', '.', '4', '1', '9', '.', '.', '5'],
+         ['.', '.', '.', '.', '8', '.', '.', '7', '9']]
 print(is_valid_sudoku(board))
 # => false
 # explanation: duplicated value in row
 
-board = [["8","3",".",".","7",".",".",".","."],
-        ["6",".",".","1","9","5",".",".","."],
-        [".","9","8",".",".",".",".","6","."],
-        [".",".",".",".","6",".",".",".","3"],
-        ["4",".",".","8",".","3",".",".","1"],
-        ["7",".",".",".","2",".",".",".","6"],
-        [".","6",".",".",".",".","2","8","."],
-        [".",".",".","4","1","9",".",".","5"],
-        [".",".",".",".","8",".",".","7","9"]]
+board = [['8', '3', '.', '.', '7', '.', '.', '.', '.'],
+         ['6', '.', '.', '1', '9', '5', '.', '.', '.'],
+         ['.', '9', '8', '.', '.', '.', '.', '6', '.'],
+         ['.', '.', '.', '.', '6', '.', '.', '.', '3'],
+         ['4', '.', '.', '8', '.', '3', '.', '.', '1'],
+         ['7', '.', '.', '.', '2', '.', '.', '.', '6'],
+         ['.', '6', '.', '.', '.', '.', '2', '8', '.'],
+         ['.', '.', '.', '4', '1', '9', '.', '.', '5'],
+         ['.', '.', '.', '.', '8', '.', '.', '7', '9']]
 print(is_valid_sudoku(board))
 # => false
 # explanation: duplicated value in 3x3 grid
@@ -181,6 +186,7 @@ require 'set'
 def is_valid_sudoku(board)
   return false unless check_rows(board)
   return false unless check_cols(board)
+
   row = -3
   while (row += 3) < 9
     col = - 3
@@ -198,8 +204,9 @@ def check_grid(board, start_point)
   ss = Set.new
   (row..(row + 2)).each do |cur_row|
     (col..(col + 2)).each do |cur_col|
-      next if board[cur_row][cur_col] == "."
+      next if board[cur_row][cur_col] == '.'
       return false if ss.member?(board[cur_row][cur_col])
+
       ss.add board[cur_row][cur_col]
     end
   end
@@ -209,8 +216,9 @@ end
 def check_col(board, col)
   ss = Set.new
   (0..8).each do |row|
-    next if board[row][col] == "."
+    next if board[row][col] == '.'
     return false if ss.member?(board[row][col])
+
     ss.add board[row][col]
   end
   true
@@ -219,8 +227,9 @@ end
 def check_row(board, row)
   ss = Set.new
   (0..8).each do |col|
-    next if board[row][col] == "."
+    next if board[row][col] == '.'
     return false if ss.member?(board[row][col])
+
     ss.add board[row][col]
   end
   true
@@ -240,53 +249,53 @@ def check_cols(board)
   true
 end
 
-board = [["5","3",".",".","7",".",".",".","."],
-        ["6",".",".","1","9","5",".",".","."],
-        [".","9","8",".",".",".",".","6","."],
-        ["8",".",".",".","6",".",".",".","3"],
-        ["4",".",".","8",".","3",".",".","1"],
-        ["7",".",".",".","2",".",".",".","6"],
-        [".","6",".",".",".",".","2","8","."],
-        [".",".",".","4","1","9",".",".","5"],
-        [".",".",".",".","8",".",".","7","9"]]
+board = [['5', '3', '.', '.', '7', '.', '.', '.', '.'],
+         ['6', '.', '.', '1', '9', '5', '.', '.', '.'],
+         ['.', '9', '8', '.', '.', '.', '.', '6', '.'],
+         ['8', '.', '.', '.', '6', '.', '.', '.', '3'],
+         ['4', '.', '.', '8', '.', '3', '.', '.', '1'],
+         ['7', '.', '.', '.', '2', '.', '.', '.', '6'],
+         ['.', '6', '.', '.', '.', '.', '2', '8', '.'],
+         ['.', '.', '.', '4', '1', '9', '.', '.', '5'],
+         ['.', '.', '.', '.', '8', '.', '.', '7', '9']]
 print(is_valid_sudoku(board))
 # => true
 
-board = [["8","3",".",".","7",".",".",".","."],
-        ["6",".",".","1","9","5",".",".","."],
-        [".","9","8",".",".",".",".","6","."],
-        ["8",".",".",".","6",".",".",".","3"],
-        ["4",".",".","8",".","3",".",".","1"],
-        ["7",".",".",".","2",".",".",".","6"],
-        [".","6",".",".",".",".","2","8","."],
-        [".",".",".","4","1","9",".",".","5"],
-        [".",".",".",".","8",".",".","7","9"]]
+board = [['8', '3', '.', '.', '7', '.', '.', '.', '.'],
+         ['6', '.', '.', '1', '9', '5', '.', '.', '.'],
+         ['.', '9', '8', '.', '.', '.', '.', '6', '.'],
+         ['8', '.', '.', '.', '6', '.', '.', '.', '3'],
+         ['4', '.', '.', '8', '.', '3', '.', '.', '1'],
+         ['7', '.', '.', '.', '2', '.', '.', '.', '6'],
+         ['.', '6', '.', '.', '.', '.', '2', '8', '.'],
+         ['.', '.', '.', '4', '1', '9', '.', '.', '5'],
+         ['.', '.', '.', '.', '8', '.', '.', '7', '9']]
 print(is_valid_sudoku(board))
 # => false
 # explanation: duplicated value in column
 
-board = [["8","3",".",".","7",".","3",".","."],
-        ["6",".",".","1","9","5",".",".","."],
-        [".","9","8",".",".",".",".","6","."],
-        ["8",".",".",".","6",".",".",".","3"],
-        ["4",".",".","8",".","3",".",".","1"],
-        ["7",".",".",".","2",".",".",".","6"],
-        [".","6",".",".",".",".","2","8","."],
-        [".",".",".","4","1","9",".",".","5"],
-        [".",".",".",".","8",".",".","7","9"]]
+board = [['8', '3', '.', '.', '7', '.', '3', '.', '.'],
+         ['6', '.', '.', '1', '9', '5', '.', '.', '.'],
+         ['.', '9', '8', '.', '.', '.', '.', '6', '.'],
+         ['8', '.', '.', '.', '6', '.', '.', '.', '3'],
+         ['4', '.', '.', '8', '.', '3', '.', '.', '1'],
+         ['7', '.', '.', '.', '2', '.', '.', '.', '6'],
+         ['.', '6', '.', '.', '.', '.', '2', '8', '.'],
+         ['.', '.', '.', '4', '1', '9', '.', '.', '5'],
+         ['.', '.', '.', '.', '8', '.', '.', '7', '9']]
 print(is_valid_sudoku(board))
 # => false
 # explanation: duplicated value in row
 
-board = [["8","3",".",".","7",".",".",".","."],
-        ["6",".",".","1","9","5",".",".","."],
-        [".","9","8",".",".",".",".","6","."],
-        [".",".",".",".","6",".",".",".","3"],
-        ["4",".",".","8",".","3",".",".","1"],
-        ["7",".",".",".","2",".",".",".","6"],
-        [".","6",".",".",".",".","2","8","."],
-        [".",".",".","4","1","9",".",".","5"],
-        [".",".",".",".","8",".",".","7","9"]]
+board = [['8', '3', '.', '.', '7', '.', '.', '.', '.'],
+         ['6', '.', '.', '1', '9', '5', '.', '.', '.'],
+         ['.', '9', '8', '.', '.', '.', '.', '6', '.'],
+         ['.', '.', '.', '.', '6', '.', '.', '.', '3'],
+         ['4', '.', '.', '8', '.', '3', '.', '.', '1'],
+         ['7', '.', '.', '.', '2', '.', '.', '.', '6'],
+         ['.', '6', '.', '.', '.', '.', '2', '8', '.'],
+         ['.', '.', '.', '4', '1', '9', '.', '.', '5'],
+         ['.', '.', '.', '.', '8', '.', '.', '7', '9']]
 print(is_valid_sudoku(board))
 # => false
-# explanation: duplicated value in 3x3 grid
\ No newline at end of file
+# explanation: duplicated value in 3x3 grid
diff --git a/data_structures/arrays/two_sum.rb b/data_structures/arrays/two_sum.rb
index a08eefd..fc72b9e 100644
--- a/data_structures/arrays/two_sum.rb
+++ b/data_structures/arrays/two_sum.rb
@@ -71,9 +71,7 @@ def two_sum(nums, target)
     target_difference = target - num
 
     nums.each_with_index do |num, j|
-      if i != j && num == target_difference
-        return [i, j]
-      end
+      return [i, j] if i != j && num == target_difference
     end
   end
 end
diff --git a/data_structures/hash_table/anagram_checker.rb b/data_structures/hash_table/anagram_checker.rb
index e15eed4..5020e0a 100644
--- a/data_structures/hash_table/anagram_checker.rb
+++ b/data_structures/hash_table/anagram_checker.rb
@@ -38,7 +38,7 @@ def is_anagram(s, t)
     counter[t[i]] -= 1
   end
 
-  counter.each do |k, v|
+  counter.each do |_k, v|
     return false unless v == 0
   end
 
diff --git a/data_structures/hash_table/arrays_intersection.rb b/data_structures/hash_table/arrays_intersection.rb
index f100e37..7d270fc 100644
--- a/data_structures/hash_table/arrays_intersection.rb
+++ b/data_structures/hash_table/arrays_intersection.rb
@@ -32,7 +32,7 @@ def arrays_intersection(arr1, arr2, arr3)
   add_to_hash(arr2, hash)
   add_to_hash(arr3, hash)
 
-  hash.select { |key, value| value == 3 }.keys
+  hash.select { |_key, value| value == 3 }.keys
 end
 
 def add_to_hash(arr, hash)
diff --git a/data_structures/hash_table/common_characters.rb b/data_structures/hash_table/common_characters.rb
index 6d126c5..8a9ded1 100644
--- a/data_structures/hash_table/common_characters.rb
+++ b/data_structures/hash_table/common_characters.rb
@@ -44,8 +44,8 @@ def common_characters(arr)
   result
 end
 
-puts common_characters(["bella","label","roller"])
+puts common_characters(%w[bella label roller])
 # => ["e","l","l"]
 
-puts common_characters(["cool","lock","cook"])
-# => ["c","o"]
\ No newline at end of file
+puts common_characters(%w[cool lock cook])
+# => ["c","o"]
diff --git a/data_structures/hash_table/good_pairs.rb b/data_structures/hash_table/good_pairs.rb
index 9f7beeb..ec5742a 100644
--- a/data_structures/hash_table/good_pairs.rb
+++ b/data_structures/hash_table/good_pairs.rb
@@ -40,4 +40,4 @@ puts(num_identical_pairs(nums))
 
 nums = [1, 2, 3]
 puts(num_identical_pairs(nums))
-# Output: 0
\ No newline at end of file
+# Output: 0
diff --git a/data_structures/hash_table/isomorphic_strings.rb b/data_structures/hash_table/isomorphic_strings.rb
index cc875ab..343f2f5 100644
--- a/data_structures/hash_table/isomorphic_strings.rb
+++ b/data_structures/hash_table/isomorphic_strings.rb
@@ -2,7 +2,7 @@
 #
 # Given two strings s and t, determine if they are isomorphic.
 # Two strings s and t are isomorphic if the characters in s can be replaced to get t.
-# All occurrences of a character must be replaced with another character while preserving the order of characters. 
+# All occurrences of a character must be replaced with another character while preserving the order of characters.
 # No two characters may map to the same character, but a character may map to itself.
 #
 # Example 1:
@@ -38,27 +38,27 @@ def isomorphic_strings_check(s, t)
     char2 = t[i]
 
     # if char1 is mapped
-    if map[char1] 
+    if map[char1]
       # return false if char1 is mapped to a different character than already present
       return false if map[char1] != char2
     # if char1 is not mapped
     else
       # return false if char2 is already mapped to a different character
       return false if set.include?(char2)
+
       # checks passed: add new character map and track that char2 has been mapped
       map[char1] = char2
       set << char2
     end
-
   end
-  return true
+  true
 end
 
-puts isomorphic_strings_check("egg", "add")
+puts isomorphic_strings_check('egg', 'add')
 # => true
 
-puts isomorphic_strings_check("foo", "bar")
+puts isomorphic_strings_check('foo', 'bar')
 # => false
 
-puts isomorphic_strings_check("paper", "title")
+puts isomorphic_strings_check('paper', 'title')
 # => true
diff --git a/data_structures/hash_table/richest_customer_wealth.rb b/data_structures/hash_table/richest_customer_wealth.rb
index 11849e1..d6e0a28 100644
--- a/data_structures/hash_table/richest_customer_wealth.rb
+++ b/data_structures/hash_table/richest_customer_wealth.rb
@@ -42,18 +42,16 @@ def find_richest_customer_wealth(accounts)
   end
 
   highest_value = 0
-  result_hash.each do |k, v|
-    if v > highest_value
-      highest_value = v
-    end
+  result_hash.each do |_k, v|
+    highest_value = v if v > highest_value
   end
 
   highest_value
 end
 
-puts find_richest_customer_wealth([[1,2,3],[3,2,1]])
+puts find_richest_customer_wealth([[1, 2, 3], [3, 2, 1]])
 # => 6
-puts find_richest_customer_wealth([[1,5],[7,3],[3,5]])
+puts find_richest_customer_wealth([[1, 5], [7, 3], [3, 5]])
 # => 10
-puts find_richest_customer_wealth([[2,8,7],[7,1,3],[1,9,5]])
+puts find_richest_customer_wealth([[2, 8, 7], [7, 1, 3], [1, 9, 5]])
 # => 17
diff --git a/data_structures/hash_table/two_sum.rb b/data_structures/hash_table/two_sum.rb
index 14dafcf..1ff0446 100644
--- a/data_structures/hash_table/two_sum.rb
+++ b/data_structures/hash_table/two_sum.rb
@@ -48,9 +48,7 @@ def two_sum(nums, target)
   nums.each_with_index do |num, i|
     difference_target = target - num
 
-    if hash[difference_target] && hash[difference_target] != i
-      return [i, hash[difference_target]]
-    end
+    return [i, hash[difference_target]] if hash[difference_target] && hash[difference_target] != i
   end
 end
 
diff --git a/data_structures/hash_table/uncommon_words.rb b/data_structures/hash_table/uncommon_words.rb
index ff0ace9..81be43a 100644
--- a/data_structures/hash_table/uncommon_words.rb
+++ b/data_structures/hash_table/uncommon_words.rb
@@ -24,7 +24,7 @@
 # Time Complexitiy: O(n)
 
 def find_uncommon_words(strA, strB)
-  array = strA.concat(" ", strB).split(" ")
+  array = strA.concat(' ', strB).split(' ')
   hash = Hash.new(0)
   result = []
 
@@ -33,16 +33,14 @@ def find_uncommon_words(strA, strB)
   end
 
   hash.each do |k, v|
-    if v < 2
-      result.push(k)
-    end
+    result.push(k) if v < 2
   end
 
   result
 end
 
-puts find_uncommon_words("this apple is sweet", "this apple is sour")
+puts find_uncommon_words('this apple is sweet', 'this apple is sour')
 # => ["sweet", "sour"]
 
-puts find_uncommon_words("apple apple", "banana")
+puts find_uncommon_words('apple apple', 'banana')
 # => ["banana"]
diff --git a/data_structures/queues/circular_queue.rb b/data_structures/queues/circular_queue.rb
index 0905ab5..aaf07d1 100644
--- a/data_structures/queues/circular_queue.rb
+++ b/data_structures/queues/circular_queue.rb
@@ -12,7 +12,7 @@
 # All of the methods in our circular data structure are of constant time complexity.
 #
 # Space Complexity: O(N).
-# The overall space complexity of the data structure is linear, where N is the pre-assigned capacity of the queue. 
+# The overall space complexity of the data structure is linear, where N is the pre-assigned capacity of the queue.
 # However, it is worth mentioning that the memory consumption of the data structure remains as its pre-assigned capacity during its entire life cycle.
 
 class CircularQueue
@@ -38,8 +38,7 @@ class CircularQueue
   end
 
   def add(x)
-    raise "Queue is at max capacity" if size == max_size
-
+    raise 'Queue is at max capacity' if size == max_size
 
     queue[back] = x
     @back = (back + 1) % max_size
@@ -47,7 +46,7 @@ class CircularQueue
   end
 
   def pop
-    raise "Queue is empty" if size == 0
+    raise 'Queue is empty' if size == 0
 
     temp = queue[front]
     queue[front] = nil
@@ -62,7 +61,7 @@ queue = CircularQueue.new(3)
 
 begin
   queue.pop
-rescue => e
+rescue StandardError => e
   puts e.message
 end
 
@@ -72,7 +71,7 @@ queue.add(3)
 
 begin
   queue.add(4)
-rescue => e
+rescue StandardError => e
   puts e.message
 end
 
diff --git a/dynamic_programming/climbing_stairs.rb b/dynamic_programming/climbing_stairs.rb
index 8f058b7..67f9732 100644
--- a/dynamic_programming/climbing_stairs.rb
+++ b/dynamic_programming/climbing_stairs.rb
@@ -1,62 +1,56 @@
-#You are climbing a staircase. It takes n steps to reach the top.
-#Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?
+# You are climbing a staircase. It takes n steps to reach the top.
+# Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?
 
-#Example 1:
-#Input: n = 2
-#Output: 2
-#Explanation: There are two ways to climb to the top.
-#1. 1 step + 1 step
-#2. 2 steps
+# Example 1:
+# Input: n = 2
+# Output: 2
+# Explanation: There are two ways to climb to the top.
+# 1. 1 step + 1 step
+# 2. 2 steps
 
-#Example 2:
-#Input: n = 3
-#Output: 3
-#Explanation: There are three ways to climb to the top.
-#1. 1 step + 1 step + 1 step
-#2. 1 step + 2 steps
-#3. 2 steps + 1 step
+# Example 2:
+# Input: n = 3
+# Output: 3
+# Explanation: There are three ways to climb to the top.
+# 1. 1 step + 1 step + 1 step
+# 2. 1 step + 2 steps
+# 3. 2 steps + 1 step
 
-#Constraints:
-#1 <= n <= 45
+# Constraints:
+# 1 <= n <= 45
 
+# Dynamic Programming, Recursive Bottom Up Approach - O(n) Time / O(n) Space
+# Init memoization hash (only 1 parameter)
+# Set base cases which are memo[0] = 1 and memo[1] = 1, since there are only 1 way to get to each stair
+# Iterate from 2..n and call recurse(n, memo) for each value n.
+# Return memo[n].
 
-
-
-#Dynamic Programming, Recursive Bottom Up Approach - O(n) Time / O(n) Space
-#Init memoization hash (only 1 parameter)
-#Set base cases which are memo[0] = 1 and memo[1] = 1, since there are only 1 way to get to each stair
-#Iterate from 2..n and call recurse(n, memo) for each value n. 
-#Return memo[n].
-
-#recurse(n, memo) - Recurrence Relation is n = (n - 1) + (n - 2)
-#return memo[n] if memo[n] exists. 
-#otherwise, memo[n] = recurse(n - 1, memo) + recurse(n - 2, memo)               
-
+# recurse(n, memo) - Recurrence Relation is n = (n - 1) + (n - 2)
+# return memo[n] if memo[n] exists.
+# otherwise, memo[n] = recurse(n - 1, memo) + recurse(n - 2, memo)
 
 # @param {Integer} n
 # @return {Integer}
 def climb_stairs(n)
-    memo = Hash.new
-    
-    memo[0] = 1
-    memo[1] = 1
-    
-    return memo[n] if n == 0 || n == 1
-    
-    (2..n).each do |n|
-      recurse(n, memo)
-    end
-    
-    memo[n]
-end
+  memo = {}
 
+  memo[0] = 1
+  memo[1] = 1
+
+  return memo[n] if [0, 1].include?(n)
+
+  (2..n).each do |n|
+    recurse(n, memo)
+  end
+
+  memo[n]
+end
 
 def recurse(n, memo)
-    return memo[n] if memo[n]
-    
-    memo[n] = recurse(n - 1, memo) + recurse(n - 2, memo)
-end
+  return memo[n] if memo[n]
 
+  memo[n] = recurse(n - 1, memo) + recurse(n - 2, memo)
+end
 
 puts climb_stairs(2)
 # => 2
diff --git a/dynamic_programming/count_sorted_vowel_strings.rb b/dynamic_programming/count_sorted_vowel_strings.rb
index e6a9fbe..9ae972b 100644
--- a/dynamic_programming/count_sorted_vowel_strings.rb
+++ b/dynamic_programming/count_sorted_vowel_strings.rb
@@ -30,16 +30,16 @@
 # Approach: Using Recursion + Memoization, Top Down Dynamic Programming
 #
 
-# 
+#
 # Algorithm: Dynamic Programming state transition.
-# 
+#
 # F(0) = 1
 # F(n)a = F(n-1)a + F(n-1)e + F(n-1)i + F(n-1)o +F(n-1)u
 # F(n)e = F(n-1)e + F(n-1)i + F(n-1)o + F(n-1)u
 # F(n)i = F(n-1)i + F(n-1)o +F(n-1)u
 # F(n)o = F(n-1)o + F(n-1)u
 # F(n)u = F(n-1)u
-# 
+#
 
 # @param {Integer} n
 # @return {Integer}
diff --git a/dynamic_programming/pascal_triangle_ii.rb b/dynamic_programming/pascal_triangle_ii.rb
index f9e73f3..db6c76d 100644
--- a/dynamic_programming/pascal_triangle_ii.rb
+++ b/dynamic_programming/pascal_triangle_ii.rb
@@ -69,6 +69,7 @@ end
 
 def generate(num_rows)
   return [[1]] if num_rows < 1
+
   result = [[1], [1, 1]]
 
   (2...num_rows + 1).each do |row|
diff --git a/maths/abs_max.rb b/maths/abs_max.rb
index d3130d9..cf4f002 100644
--- a/maths/abs_max.rb
+++ b/maths/abs_max.rb
@@ -3,10 +3,10 @@
 
 def abs_max(x, y)
   num = x - y
-  max_value = ((x + y + num.abs()) / 2)
+  max_value = ((x + y + num.abs) / 2)
   "The Abs Max of #{x} and #{y} is #{max_value}."
-  rescue
-    "Error: Provide number only!"
+rescue StandardError
+  'Error: Provide number only!'
 end
 
 # Valid inputs
@@ -20,11 +20,11 @@ puts abs_max(9, -121)
 # The Abs Max of 9 and -121 is 9.
 
 # Invalid inputs
-puts abs_max(2, "-1")
+puts abs_max(2, '-1')
 # Error: Provide number only!
 
-puts abs_max("3", "5")
+puts abs_max('3', '5')
 # Error: Provide number only!
 
-puts abs_max("a", "5")
+puts abs_max('a', '5')
 # Error: Provide number only!
diff --git a/maths/abs_min.rb b/maths/abs_min.rb
index 20e341c..93a9c96 100644
--- a/maths/abs_min.rb
+++ b/maths/abs_min.rb
@@ -3,10 +3,10 @@
 
 def abs_min(x, y)
   num = x - y
-  min_value = ((x + y - num.abs()) / 2)
+  min_value = ((x + y - num.abs) / 2)
   "The Abs Min of #{x} and #{y} is #{min_value}."
-  rescue
-    "Error: Provide number only!"
+rescue StandardError
+  'Error: Provide number only!'
 end
 
 #
@@ -24,11 +24,11 @@ puts abs_min(9, -121)
 #
 # Invalid inputs
 #
-puts abs_min(2, "-1")
+puts abs_min(2, '-1')
 # Error: Provide number only!
 
-puts abs_min("3", "5")
+puts abs_min('3', '5')
 # Error: Provide number only!
 
-puts abs_min("a", "5")
+puts abs_min('a', '5')
 # Error: Provide number only!
diff --git a/maths/add.rb b/maths/add.rb
index a8a6c35..3efbec1 100644
--- a/maths/add.rb
+++ b/maths/add.rb
@@ -4,15 +4,15 @@
 
 def add(*array)
   sum = 0
-  array.each { |a| sum+=a }
+  array.each { |a| sum += a }
   puts "The sum of following elements #{array} is #{sum}"
-  rescue
-    puts "Error: Please provide number only!"
+rescue StandardError
+  puts 'Error: Please provide number only!'
 end
 
-# 
+#
 # Valid inputs
-# 
+#
 
 puts add(1)
 # The sum of following elements [1] is 1
@@ -23,12 +23,12 @@ puts add(2, 5, -4)
 puts add(25, 45)
 # The sum of following elements [25, 45] is 70
 
-# 
+#
 # Invalid inputs
-# 
+#
 
-puts add("1", 2, 3)
+puts add('1', 2, 3)
 # Error: Please provide number only!
 
-puts add("a", 1)
+puts add('a', 1)
 # Error: Please provide number only!
diff --git a/maths/armstrong_number.rb b/maths/armstrong_number.rb
index b312891..f5022c7 100644
--- a/maths/armstrong_number.rb
+++ b/maths/armstrong_number.rb
@@ -11,9 +11,9 @@ def armstrong_number(number)
   num = number
   sum = 0
   len = number.digits.count
-  while(number != 0)
+  while number != 0
     remainder = number % 10
-    sum += remainder ** len
+    sum += remainder**len
     number /= 10
   end
 
@@ -22,8 +22,8 @@ def armstrong_number(number)
   else
     "The number #{num} is not an Armstrong number."
   end
-  rescue
-    "Error: Please provide number only!"
+rescue StandardError
+  'Error: Please provide number only!'
 end
 
 #
@@ -50,8 +50,8 @@ puts armstrong_number(123)
 #
 # Invalid inputs
 #
-puts armstrong_number("153")
+puts armstrong_number('153')
 # Error: Please provide number only!
 
-puts armstrong_number("a")
+puts armstrong_number('a')
 # Error: Please provide number only!
diff --git a/maths/average_mean.rb b/maths/average_mean.rb
index 0efd5d0..695799a 100644
--- a/maths/average_mean.rb
+++ b/maths/average_mean.rb
@@ -5,15 +5,15 @@ module AverageMean
   def self.average_mean(n, *array)
     if n.instance_of? Integer
       if n == array.size
-        puts "The average mean of the following elements #{array} is #{array.sum/array.size}."
+        puts "The average mean of the following elements #{array} is #{array.sum / array.size}."
       else
         puts "Provide the required #{n} elements properly!"
       end
     else
       raise
     end
-    rescue
-      puts "Error: Please provide number only!"
+  rescue StandardError
+    puts 'Error: Please provide number only!'
   end
 end
 
@@ -24,5 +24,5 @@ AverageMean.average_mean(3, 2, 2, 2)
 
 # Invalid inputs
 AverageMean.average_mean(2, 3, 1, 5)
-AverageMean.average_mean(2, 3, "a")
-AverageMean.average_mean("a", 1, 2)
+AverageMean.average_mean(2, 3, 'a')
+AverageMean.average_mean('a', 1, 2)
diff --git a/maths/average_median.rb b/maths/average_median.rb
index 9e447bd..96ce1f7 100644
--- a/maths/average_median.rb
+++ b/maths/average_median.rb
@@ -6,8 +6,8 @@ module AverageMedian
     if n.instance_of? Integer
       if n == array.size
         array.sort
-        if array.size % 2 == 0
-          mid_element_1 = array.size/2
+        if array.size.even?
+          mid_element_1 = array.size / 2
           mid_element_2 = mid_element_1 + 1
           puts "The average median of the following elements #{array} is #{(array[mid_element_1 - 1] + array[mid_element_2 - 1]) / 2}."
         else
@@ -20,14 +20,14 @@ module AverageMedian
     else
       raise
     end
-    rescue
-      puts "Error: Please provide number only!"
+  rescue StandardError
+    puts 'Error: Please provide number only!'
   end
 end
 
-# 
+#
 # Valid inputs
-# 
+#
 
 puts AverageMedian.average_median(2, 3, 1)
 # The average median of the following elements [3, 1] is 2.
@@ -41,14 +41,14 @@ puts AverageMedian.average_median(3, 2, 2, 2)
 puts AverageMedian.average_median(1, 5)
 # The average median of the following elements [5] is 5.
 
-# 
+#
 # Invalid inputs
-# 
+#
 
 puts AverageMedian.average_median(2, 3, 1, 5)
 # Provide the required 2 elements properly!
 
-puts AverageMedian.average_median(2, 3, "a")
+puts AverageMedian.average_median(2, 3, 'a')
 # Traceback (most recent call last):
 #         4: from /Users/voliveira/.rvm/rubies/ruby-2.7.0/bin/irb:23:in `<main>'
 #         3: from /Users/voliveira/.rvm/rubies/ruby-2.7.0/bin/irb:23:in `load'
@@ -56,5 +56,5 @@ puts AverageMedian.average_median(2, 3, "a")
 #         1: from (irb):30
 # NameError (undefined local variable or method `verageMedian' for main:Object)
 
-puts AverageMedian.average_median("a", 1, 2)
+puts AverageMedian.average_median('a', 1, 2)
 # Error: Please provide number only!
diff --git a/maths/count_sorted_vowel_strings.rb b/maths/count_sorted_vowel_strings.rb
index 630f1f8..a707ccf 100644
--- a/maths/count_sorted_vowel_strings.rb
+++ b/maths/count_sorted_vowel_strings.rb
@@ -26,7 +26,6 @@
 # Input: n = 33
 # Output: 66045
 
-
 #
 # Approach: Math
 #
diff --git a/maths/factorial.rb b/maths/factorial.rb
index e83b347..2b7dfff 100644
--- a/maths/factorial.rb
+++ b/maths/factorial.rb
@@ -1,8 +1,6 @@
-=begin
-A ruby program calculate factorial of a given number.
-Mathematical Explanation: The factorial of a number is the product of all the integers from 1 to that number. 
-i.e: n! = n*(n-1)*(n-2)......*2*1
-=end
+# A ruby program calculate factorial of a given number.
+# Mathematical Explanation: The factorial of a number is the product of all the integers from 1 to that number.
+# i.e: n! = n*(n-1)*(n-2)......*2*1
 
 #
 # Approach: Interative
@@ -10,14 +8,14 @@ i.e: n! = n*(n-1)*(n-2)......*2*1
 
 def factorial(n)
   return nil if n < 0
-  
+
   fac = 1
 
   while n > 0
     fac *= n
     n -= 1
   end
-  
+
   fac
 end
 
diff --git a/maths/factorial_non_recursive_non_iterative.rb b/maths/factorial_non_recursive_non_iterative.rb
index f992a92..c1159fd 100644
--- a/maths/factorial_non_recursive_non_iterative.rb
+++ b/maths/factorial_non_recursive_non_iterative.rb
@@ -8,15 +8,15 @@
 
 def factorial(number)
   if number < 0
-    "Please check your input number! The given number is a negative number."
+    'Please check your input number! The given number is a negative number.'
   elsif number == 0
     "The factorial of #{number} is 1."
   else
     result = (1..number).inject(:*)
     "The factorial of #{number} is #{result}."
   end
-  rescue
-    "Error: Please provide integer only!"
+rescue StandardError
+  'Error: Please provide integer only!'
 end
 
 # Valid inputs
@@ -36,8 +36,8 @@ puts factorial(-5)
 # Please check your input number! The given number is a negative number.
 
 # Invalid inputs
-puts factorial("a")
+puts factorial('a')
 # Error: Please provide integer only!
 
-puts factorial("2")
+puts factorial('2')
 # Error: Please provide integer only!
diff --git a/maths/find_max.rb b/maths/find_max.rb
index ec13cfb..02ce139 100644
--- a/maths/find_max.rb
+++ b/maths/find_max.rb
@@ -4,27 +4,25 @@
 def find_max(*array)
   max = array[0]
   array.each do |a|
-    if a >= max
-      max = a
-    end
+    max = a if a >= max
   end
-    "The Max of the following elements #{array} is #{max}."
-  rescue
-    "Error: Please provide number only!"
+  "The Max of the following elements #{array} is #{max}."
+rescue StandardError
+  'Error: Please provide number only!'
 end
 
 # Max method will return the maximum element from the set of input elements provided
 def predefined_max(*array)
   "The Max of the following elements #{array} is #{array.max}."
-  rescue
-    "Error: Please provide number only!"
+rescue StandardError
+  'Error: Please provide number only!'
 end
 
 # Sort method will sort the elements in ascending order. Last method will return the end element out of the array
 def predefined_sort_last_max(*array)
-  "The Max of the following elements #{array} is #{array.sort.last}."
-  rescue
-    "Error: Please provide number only!"
+  "The Max of the following elements #{array} is #{array.max}."
+rescue StandardError
+  'Error: Please provide number only!'
 end
 
 # Using find_max
@@ -36,7 +34,7 @@ puts find_max(-221, -852, -1100, -10)
 # The Max of the following elements [-221, -852, -1100, -10] is -10.
 
 # Invalid inputs
-puts find_max(5, "95", 2)
+puts find_max(5, '95', 2)
 # Error: Please provide number only!
 
 # Using predefined_max
@@ -48,7 +46,7 @@ puts predefined_max(-11, -51, -10, -10)
 # The Max of the following elements [-11, -51, -10, -10] is -10.
 
 # Invalid inputs
-puts predefined_max("x", 5, 95, 2)
+puts predefined_max('x', 5, 95, 2)
 # Error: Please provide number only!
 
 # Using predefined_sort_last_max
@@ -60,5 +58,5 @@ puts predefined_sort_last_max(-21, -52, -100, -1)
 # The Max of the following elements [-21, -52, -100, -1] is -1.
 
 # Invalid inputs
-puts predefined_sort_last_max(5, 95, 2, "a")
+puts predefined_sort_last_max(5, 95, 2, 'a')
 # Error: Please provide number only!
diff --git a/maths/find_min.rb b/maths/find_min.rb
index f78e4f4..51c936d 100644
--- a/maths/find_min.rb
+++ b/maths/find_min.rb
@@ -4,27 +4,25 @@
 def find_min(*array)
   min = array[0]
   array.each do |a|
-    if a <= min
-      min = a
-    end
+    min = a if a <= min
   end
-    "The Min of the following elements #{array} is #{min}."
-  rescue
-    "Error: Please provide number only!"
+  "The Min of the following elements #{array} is #{min}."
+rescue StandardError
+  'Error: Please provide number only!'
 end
 
 # Min method will return the minimum element from the set of input elements provided
 def predefined_min(*array)
   "The Min of the following elements #{array} is #{array.min}."
-  rescue
-    "Error: Please provide number only!"
+rescue StandardError
+  'Error: Please provide number only!'
 end
 
 # Sort method will sort the elements in ascending order. First method will return the beginning element out of the array
 def predefined_sort_first_min(*array)
-  "The Min of the following elements #{array} is #{array.sort.first}."
-  rescue
-    "Error: Please provide number only!"
+  "The Min of the following elements #{array} is #{array.min}."
+rescue StandardError
+  'Error: Please provide number only!'
 end
 
 # Using find_min
@@ -36,7 +34,7 @@ puts find_min(-221, -852, -1100, -10)
 # The Min of the following elements [-221, -852, -1100, -10] is -10.
 
 # Invalid inputs
-puts find_min(5, "95", 2)
+puts find_min(5, '95', 2)
 # Error: Please provide number only!
 
 # Using predefined_min
@@ -48,7 +46,7 @@ puts predefined_min(-11, -51, -10, -10)
 # The Min of the following elements [-11, -51, -10, -10] is -10.
 
 # Invalid inputs
-puts predefined_min("x", 5, 95, 2)
+puts predefined_min('x', 5, 95, 2)
 # Error: Please provide number only!
 
 # Using predefined_sort_first_min
@@ -60,5 +58,5 @@ puts predefined_sort_first_min(-21, -52, -100, -1)
 # The Min of the following elements [-21, -52, -100, -1] is -1.
 
 # Invalid inputs
-puts predefined_sort_first_min(5, 95, 2, "a")
+puts predefined_sort_first_min(5, 95, 2, 'a')
 # Error: Please provide number only!
diff --git a/maths/lucas_series.rb b/maths/lucas_series.rb
index 85fb41f..9acff78 100644
--- a/maths/lucas_series.rb
+++ b/maths/lucas_series.rb
@@ -13,9 +13,9 @@
 
 def lucas(number)
   golden_ratio = (1 + 5**0.5) / 2
-  ((golden_ratio**number).round()).to_i
-  rescue
-    "Error: Provide number only!"
+  (golden_ratio**number).round.to_i
+rescue StandardError
+  'Error: Provide number only!'
 end
 
 puts lucas(4)
@@ -24,7 +24,7 @@ puts lucas(4)
 puts lucas(3)
 # 4
 
-puts lucas("3")
+puts lucas('3')
 # Error: Provide number only!
 
 puts lucas(2)
diff --git a/maths/pascal_triangle_ii.rb b/maths/pascal_triangle_ii.rb
index de60abd..6820b4c 100644
--- a/maths/pascal_triangle_ii.rb
+++ b/maths/pascal_triangle_ii.rb
@@ -1,4 +1,4 @@
-# Given an integer row_index, return the rowIndexth (0-indexed) row of the Pascal's triangle. 
+# Given an integer row_index, return the rowIndexth (0-indexed) row of the Pascal's triangle.
 
 # Example 1:
 #
@@ -16,12 +16,12 @@
 # Output: [1,1]
 
 # Complexity Analysis
-# 
+#
 # Time complexity: O(k).
 # Space complexity: O(k).
 
 def get_row(row_index)
-  (0..row_index).map {|num| combination(row_index, num) }
+  (0..row_index).map { |num| combination(row_index, num) }
 end
 
 def combination(num1, num2)
diff --git a/maths/power_of_two.rb b/maths/power_of_two.rb
index f507aa5..fec28e1 100644
--- a/maths/power_of_two.rb
+++ b/maths/power_of_two.rb
@@ -38,7 +38,7 @@
 def is_power_of_two(n)
   if n == 1
     true
-  elsif n % 2 == 0
+  elsif n.even?
     is_power_of_two(n / 2)
   else
     false
@@ -67,9 +67,7 @@ puts is_power_of_two(n)
 # Time Complexity: O(n)
 #
 def is_power_of_two(n)
-  while n % 2 == 0 && n != 0
-    n /= 2
-  end
+  n /= 2 while n.even? && n != 0
   n == 1
 end
 
diff --git a/maths/prime_number.rb b/maths/prime_number.rb
index 28a22f4..b1a0f56 100644
--- a/maths/prime_number.rb
+++ b/maths/prime_number.rb
@@ -3,15 +3,15 @@
 
 # Prime number check function
 def prime_number(number)
-  if number <= 1
-    non_prime_flag = true
-  elsif number == 2
-    non_prime_flag = false
-  elsif number % 2 == 0
-    non_prime_flag = true
-  else
-    non_prime_flag = (2..Math.sqrt(number)).any? { |i| number % i == 0 }
-  end
+  non_prime_flag = if number <= 1
+                     true
+                   elsif number == 2
+                     false
+                   elsif number.even?
+                     true
+                   else
+                     (2..Math.sqrt(number)).any? { |i| number % i == 0 }
+                   end
 
   if !non_prime_flag
     puts "The given number #{number} is a Prime."
diff --git a/maths/roman_to_integer.rb b/maths/roman_to_integer.rb
index c2f2d3d..e9604ee 100644
--- a/maths/roman_to_integer.rb
+++ b/maths/roman_to_integer.rb
@@ -10,7 +10,7 @@
 # C             100
 # D             500
 # M             1000
-# 
+#
 # For example, 2 is written as II in Roman numeral, just two one's added together. 12 is written as XII, which is simply X + II. The number 27 is written as XXVII, which is XX + V + II.
 #
 # Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not IIII. Instead, the number four is written as IV. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as IX. There are six instances where subtraction is used:
@@ -36,13 +36,13 @@
 # Because only a constant number of single-value variables are used, the space complexity is O(1).
 
 ROM_NUMS = {
-  "I" => 1,
-  "V" => 5,
-  "X" => 10,
-  "L" => 50,
-  "C" => 100,
-  "D" => 500,
-  "M" => 1000
+  'I' => 1,
+  'V' => 5,
+  'X' => 10,
+  'L' => 50,
+  'C' => 100,
+  'D' => 500,
+  'M' => 1000
 }
 
 # Now, recall that each symbol adds its own value, except for when a smaller
@@ -61,7 +61,7 @@ def roman_to_int(s)
 
   s.chars.each_with_index do |el, i|
     # subtractive case: if at least 2 symbols remaining AND value of s[i] < value of s[i + 1]
-    if ROM_NUMS[s[i + 1]] && ROM_NUMS[el] < ROM_NUMS[s[i+1]]
+    if ROM_NUMS[s[i + 1]] && ROM_NUMS[el] < ROM_NUMS[s[i + 1]]
       temp = ROM_NUMS[el]
     else
       # Else this is NOT the subtractive case.
@@ -73,24 +73,24 @@ def roman_to_int(s)
   res
 end
 
-s = "III"
+s = 'III'
 puts roman_to_int(s)
 # Output: 3
 
-s = "IV"
+s = 'IV'
 puts roman_to_int(s)
 # Output: 4
 
-s = "IX"
+s = 'IX'
 puts roman_to_int(s)
 # Output: 9
 
-s = "LVIII"
+s = 'LVIII'
 puts roman_to_int(s)
 # Output: 58
 # Explanation: L = 50, V= 5, III = 3.
 
-s = "MCMXCIV"
+s = 'MCMXCIV'
 puts roman_to_int(s)
 # Output: 1994
 # Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.
diff --git a/other/number_of_days.rb b/other/number_of_days.rb
index b5dc5c5..1c4d4b2 100644
--- a/other/number_of_days.rb
+++ b/other/number_of_days.rb
@@ -2,7 +2,7 @@
 #
 # Write a program to count the number of days between two dates.
 #
-# The two dates are given as strings, their format is YYYY-MM-DD as shown in the examples. 
+# The two dates are given as strings, their format is YYYY-MM-DD as shown in the examples.
 # Example 1:
 # Input: date1 = "2019-06-29", date2 = "2019-06-30"
 # Output: 1
@@ -13,7 +13,6 @@
 #
 # Constraints: The given dates are valid dates between the years 1971 and 2100.
 
-
 #
 # Approach 1: Using Ruby built-in feature Date.parse
 # Time complexity: O(1)
@@ -28,8 +27,8 @@ def number_of_days(date1, date2)
   (end_date - beginning_date).to_i.abs
 end
 
-puts number_of_days("2019-06-29", "2019-06-30")
+puts number_of_days('2019-06-29', '2019-06-30')
 # => 1
 
-puts number_of_days("2020-01-15", "2019-12-31")
+puts number_of_days('2020-01-15', '2019-12-31')
 # => 15
diff --git a/searches/number_of_islands.rb b/searches/number_of_islands.rb
index b782c41..7549da5 100644
--- a/searches/number_of_islands.rb
+++ b/searches/number_of_islands.rb
@@ -1,79 +1,76 @@
-#Given an m x n 2D binary grid grid which represents a map of '1's (land) and '0's (water), return the number of islands.
-#An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.
+# Given an m x n 2D binary grid grid which represents a map of '1's (land) and '0's (water), return the number of islands.
+# An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.
 
-#Example 1:
-#Input: grid = [
+# Example 1:
+# Input: grid = [
 #  ["1","1","1","1","0"],
 #  ["1","1","0","1","0"],
 #  ["1","1","0","0","0"],
 #  ["0","0","0","0","0"]
-#]
-#Output: 1
+# ]
+# Output: 1
 
-#Example 2:
-#Input: grid = [
+# Example 2:
+# Input: grid = [
 #  ["1","1","0","0","0"],
 #  ["1","1","0","0","0"],
 #  ["0","0","1","0","0"],
 #  ["0","0","0","1","1"]
-#]
-#Output: 3
+# ]
+# Output: 3
 
-#Constraints:
-#m == grid.length
-#n == grid[i].length
-#1 <= m, n <= 300
-#grid[i][j] is '0' or '1'.
+# Constraints:
+# m == grid.length
+# n == grid[i].length
+# 1 <= m, n <= 300
+# grid[i][j] is '0' or '1'.
 
+# DFS, Recursive Bottom Up Approach - O(n*m) Time / O(1) Space
+# Init num_of_islands = 0, return if the grid is empty
+# Start a double loop with index to iterate through each plot (each value is a plot of either water or land in this case)
+# if the plot is land, dfs(grid, x, y)
+# num_of_islands += 1
+# Return num_of_islands
 
-
-
-#DFS, Recursive Bottom Up Approach - O(n*m) Time / O(1) Space
-#Init num_of_islands = 0, return if the grid is empty
-#Start a double loop with index to iterate through each plot (each value is a plot of either water or land in this case)
-#if the plot is land, dfs(grid, x, y)
-#num_of_islands += 1
-#Return num_of_islands
-
-#dfs(grid, x, y)
-#Return if x or y are out of bounds, or if the plot is water
-#Make the current plot water
-#Call dfs again for up, down, left, and right     
+# dfs(grid, x, y)
+# Return if x or y are out of bounds, or if the plot is water
+# Make the current plot water
+# Call dfs again for up, down, left, and right
 
 # @param {Character[][]} grid
 # @return {Integer}
 def num_islands(grid)
-    return 0 if grid.empty?
-    
-    #init num of islands
-    islands = 0
-    
-    #loop through each element (plot) in the 2d array
-    grid.each_with_index do |row, x|
-      row.each_with_index do |plot, y|
-        #if the plot is water, start a dfs
-        if plot == "1"
-          dfs(grid, x, y)
-          #add 1 to islands once all connected land plots are searched
-          islands += 1
-        end
-      end
+  return 0 if grid.empty?
+
+  # init num of islands
+  islands = 0
+
+  # loop through each element (plot) in the 2d array
+  grid.each_with_index do |row, x|
+    row.each_with_index do |plot, y|
+      # if the plot is water, start a dfs
+      next unless plot == '1'
+
+      dfs(grid, x, y)
+      # add 1 to islands once all connected land plots are searched
+      islands += 1
     end
-    
-    #return ans
-    islands
+  end
+
+  # return ans
+  islands
 end
 
 def dfs(grid, x, y)
-    #don't search if out of bounds, or if it's already water
-    return if x < 0 || x >= grid.length || y < 0 || y >= grid[0].length || grid[x][y] == "0"
-    
-    #set the plot to water
-    grid[x][y] = "0"
-    
-    #search each adjacent plot
-    dfs(grid, x - 1, y) #up
-    dfs(grid, x + 1, y) #down
-    dfs(grid, x, y - 1) #left
-    dfs(grid, x, y + 1) #right
+  # don't search if out of bounds, or if it's already water
+  return if x < 0 || x >= grid.length || y < 0 || y >= grid[0].length || grid[x][y] == '0'
+
+  # set the plot to water
+  grid[x][y] = '0'
+
+  # search each adjacent plot
+  dfs(grid, x - 1, y) # up
+  dfs(grid, x + 1, y) # down
+  dfs(grid, x, y - 1) # left
+  dfs(grid, x, y + 1) # right
 end
diff --git a/sorting/cocktail_sort.rb b/sorting/cocktail_sort.rb
index fd83d23..16e12b8 100644
--- a/sorting/cocktail_sort.rb
+++ b/sorting/cocktail_sort.rb
@@ -11,7 +11,10 @@ def cocktail_sort(array)
       end
     end
     break unless swapped
-    start, finish, way = swapped, start, -way
+
+    finish = start
+    start = swapped
+    way = -way
   end
   array
 end
diff --git a/sorting/cocktail_sort_test.rb b/sorting/cocktail_sort_test.rb
index ce669ba..9e1e78f 100644
--- a/sorting/cocktail_sort_test.rb
+++ b/sorting/cocktail_sort_test.rb
@@ -9,4 +9,3 @@ class TestInsertionSort < Minitest::Test
     cocktail_sort(input)
   end
 end
-
diff --git a/sorting/comb_sort.rb b/sorting/comb_sort.rb
index 3cb20ea..e9e50f3 100644
--- a/sorting/comb_sort.rb
+++ b/sorting/comb_sort.rb
@@ -1,7 +1,7 @@
 def comb_sort(array)
   gap = array.length
   swaps = true
-  while gap > 1 or swaps
+  while (gap > 1) || swaps
     gap = [1, (gap / 1.25).to_i].max
     swaps = false
     0.upto(array.length - gap - 1) do |i|
diff --git a/sorting/pancake_sort.rb b/sorting/pancake_sort.rb
index 3f07e0f..5ce0109 100644
--- a/sorting/pancake_sort.rb
+++ b/sorting/pancake_sort.rb
@@ -1,5 +1,6 @@
 def pancake_sort(array)
   return array if array.length <= 1
+
   (array.length - 1).downto(1) do |index|
     max_index = array[0..index].index(array[0..index].max)
     next if max_index == index