Minor fixes

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

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

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

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

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
-

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

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

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')

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

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

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

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]

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
+# => 9999

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.
 

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

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

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]
+# Output: [1,2,1,2]

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
+# Output: 1

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

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
+puts find_jewels('z', 'ZZ')
+# => 0

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

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('')

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
+# explanation: duplicated value in 3x3 grid

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

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
 

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)

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"]
+puts common_characters(%w[cool lock cook])
+# => ["c","o"]

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
+# Output: 0

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

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

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
 

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"]

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
 

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

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}

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|

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!

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!

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!

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!

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)

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!

maths/count_sorted_vowel_strings.rb

@@ -26,7 +26,6 @@
 # Input: n = 33
 # Output: 66045
 
-
 #
 # Approach: Math
 #

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
 

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!

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!

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!

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)

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)

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
 

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

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.

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

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

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

sorting/cocktail_sort_test.rb

@@ -9,4 +9,3 @@ class TestInsertionSort < Minitest::Test
     cocktail_sort(input)
   end
 end
-

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|

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