Merge branch 'master' into jk-anagram

DIRECTORY.md

@@ -13,10 +13,14 @@
     * [Find The Highest Altitude](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/arrays/find_the_highest_altitude.rb)
     * [Fizz Buzz](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/arrays/fizz_buzz.rb)
     * [Get Products Of All Other Elements](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/arrays/get_products_of_all_other_elements.rb)
-    * [Jewels And Stones](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/arrays/jewels_and_stones.rb)
     * [Remove Elements](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/arrays/remove_elements.rb)
+    * [Richest Customer Wealth](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/arrays/richest_customer_wealth.rb)
+    * [Shuffle Array](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/arrays/shuffle_array.rb)
     * [Single Number](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/arrays/single_number.rb)
     * [Sort Squares Of An Array](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/arrays/sort_squares_of_an_array.rb)
+    * Strings
+      * [Jewels And Stones](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/arrays/strings/jewels_and_stones.rb)
+      * [Remove Vowels](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/arrays/strings/remove_vowels.rb)
     * [Two Sum](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/arrays/two_sum.rb)
     * [Two Sum Ii](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/arrays/two_sum_ii.rb)
   * Binary Trees
@@ -24,6 +28,10 @@
     * [Invert](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/binary_trees/invert.rb)
     * [Postorder Traversal](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/binary_trees/postorder_traversal.rb)
     * [Preorder Traversal](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/binary_trees/preorder_traversal.rb)
+  * Hash Table
+    * [Find All Duplicates In An Array](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/hash_table/find_all_duplicates_in_an_array.rb)
+    * [Richest Customer Wealth](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/hash_table/richest_customer_wealth.rb)
+    * [Two Sum](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/hash_table/two_sum.rb)
   * Linked Lists
     * [Circular Linked List](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/linked_lists/circular_linked_list.rb)
     * [Doubly Linked List](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/linked_lists/doubly_linked_list.rb)
@@ -57,6 +65,7 @@
   * [Fibonacci](https://github.com/TheAlgorithms/Ruby/blob/master/maths/fibonacci.rb)
   * [Number Of Digits](https://github.com/TheAlgorithms/Ruby/blob/master/maths/number_of_digits.rb)
   * [Power Of Two](https://github.com/TheAlgorithms/Ruby/blob/master/maths/power_of_two.rb)
+  * [Prime Number](https://github.com/TheAlgorithms/Ruby/blob/master/maths/prime_number.rb)
   * [Square Root](https://github.com/TheAlgorithms/Ruby/blob/master/maths/square_root.rb)
   * [Square Root Test](https://github.com/TheAlgorithms/Ruby/blob/master/maths/square_root_test.rb)
   * [Sum Of Digits](https://github.com/TheAlgorithms/Ruby/blob/master/maths/sum_of_digits.rb)

data_structures/arrays/find_all_duplicates_in_an_array.rb

@@ -87,44 +87,3 @@ Benchmark.bmbm do |x|
     print(find_duplicates(long_array))
   end
 end
-
-#
-# Approach 3: Hash map
-#
-
-#
-# Complexity Analysis
-#
-# Time complexity: O(n) average case.
-#
-
-def find_duplicates(array)
-  result_hash = {}
-  result_array = []
-
-  # loop through array and build a hash with counters
-  # where the key is the array element and the counter is the value
-  # increase counter when duplicate is found
-  array.each do |num|
-    if result_hash[num].nil?
-      result_hash[num] = 1
-    else
-      result_hash[num] += 1
-    end
-  end
-
-  # loop through hash and look for values > 1
-  result_hash.each do |k, v|
-    result_array.push(k) if v > 1
-  end
-
-  # return keys
-  result_array
-end
-
-Benchmark.bmbm do |x|
-  x.report('execute algorithm 3') do
-    print(find_duplicates(array))
-    print(find_duplicates(long_array))
-  end
-end

data_structures/arrays/richest_customer_wealth.rb

@@ -0,0 +1,56 @@
+# Challenge name: Richest Customer Wealth
+#
+# You are given an m x n integer grid accounts where accounts[i][j]
+# is the amount of money the i​​​​​​​​​​​th​​​​ customer has in the j​​​​​​​​​​​th​​​​ bank.
+#
+# Return the wealth that the richest customer has.
+# A customer's wealth is the amount of money they have in all
+# their bank accounts. The richest customer is the customer that
+# has the maximum wealth.
+#
+# Example 1:
+# Input: accounts = [[1,2,3],[3,2,1]]
+# Output: 6
+# Explanation:
+# 1st customer has wealth = 1 + 2 + 3 = 6
+# 2nd customer has wealth = 3 + 2 + 1 = 6
+# Both customers are considered the richest with a wealth of 6
+# each, so return 6.
+#
+# Example 2:
+# Input: accounts = [[1,5],[7,3],[3,5]]
+# Output: 10
+# Explanation:
+# 1st customer has wealth = 6
+# 2nd customer has wealth = 10
+# 3rd customer has wealth = 8
+# The 2nd customer is the richest with a wealth of 10.
+#
+# Example 3:
+# Input: accounts = [[2,8,7],[7,1,3],[1,9,5]]
+# Output: 17
+
+#
+# Approach: Brute Force
+#
+# Time Complexity: O(n)
+#
+def find_richest_customer_wealth(accounts)
+  summed_accounts = []
+  accounts.each do |customer|
+    summed = 0
+    customer.each do |account|
+      summed += account
+    end
+    summed_accounts.push(summed)
+  end
+
+  summed_accounts.sort.pop()
+end
+
+puts find_richest_customer_wealth([[1,2,3],[3,2,1]])
+# => 6
+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]])
+# => 17

data_structures/arrays/shuffle_array.rb

@@ -0,0 +1,109 @@
+# Challenge name: Shuffle the array
+#
+# Given the array nums consisting of 2n elements
+# in the form [x1,x2,...,xn,y1,y2,...,yn].
+# Return the array in the form [x1,y1,x2,y2,...,xn,yn].
+#
+# Example 1:
+# Input: nums = [2,5,1,3,4,7], n = 3
+# Output: [2,3,5,4,1,7]
+# Explanation: Since x1=2, x2=5, x3=1, y1=3, y2=4, y3=7 then the answer is [2,3,5,4,1,7].
+#
+# Example 2:
+# Input: nums = [1,2,3,4,4,3,2,1], n = 4
+# Output: [1,4,2,3,3,2,4,1]
+#
+# Example 3:
+# Input: nums = [1,1,2,2], n = 2
+# Output: [1,2,1,2]
+#
+# @param {Integer[]} nums
+# @param {Integer} n
+# @return {Integer[]}
+
+#
+# Approach 1: New Array
+#
+# Time Complexity: O(N)
+#
+def shuffle(nums, n)
+  result = []
+  (0..n-1).count do |i|
+    result.push(nums[i], nums[i+n])
+  end
+  result
+end
+
+nums = [2, 5, 1, 3, 4, 7]
+n = 3
+print(shuffle(nums, n))
+# Output: [2,3,5,4,1,7]
+nums = [1, 2, 3, 4, 4, 3, 2, 1]
+n = 4
+print(shuffle(nums, n))
+# Output: [1,4,2,3,3,2,4,1]
+nums = [1, 1, 2, 2]
+n = 2
+print(shuffle(nums, n))
+# Output: [1,2,1,2]
+
+#
+# Approach 2: Use Ruby methods .insert() and .delete_at()
+#
+# Time Complexity: O(N)
+#
+
+def shuffle(nums, n)
+  current_index = 1
+  (0..n-1).each do |i|
+    nums.insert(current_index, nums.delete_at(i + n))
+    current_index += 2
+  end
+  nums
+end
+
+nums = [2, 5, 1, 3, 4, 7]
+n = 3
+print(shuffle(nums, n))
+# Output: [2,3,5,4,1,7]
+nums = [1, 2, 3, 4, 4, 3, 2, 1]
+n = 4
+print(shuffle(nums, n))
+# Output: [1,4,2,3,3,2,4,1]
+nums = [1, 1, 2, 2]
+n = 2
+print(shuffle(nums, n))
+# Output: [1,2,1,2]
+
+#
+# Approach 3: Two Pointers
+#
+# Time Complexity: O(N)
+#
+
+def shuffle(nums, n)
+  result = []
+  p1 = 0
+  p2 = n
+
+  while p1 < n
+    result.push(nums[p1], nums[p2])
+    p1 +=1
+    p2 +=1
+  end
+
+  result
+end
+
+nums = [2, 5, 1, 3, 4, 7]
+n = 3
+print(shuffle(nums, n))
+# Output: [2,3,5,4,1,7]
+nums = [1, 2, 3, 4, 4, 3, 2, 1]
+n = 4
+print(shuffle(nums, n))
+# Output: [1,4,2,3,3,2,4,1]
+nums = [1, 1, 2, 2]
+n = 2
+print(shuffle(nums, n))
+# Output: [1,2,1,2]

data_structures/arrays/strings/remove_vowels.rb

@@ -0,0 +1,76 @@
+# Challenge name: Remove vowels from a string
+#
+# Given a string s, remove the vowels 'a', 'e', 'i', 'o', and 'u'
+# from it, and return the new string.
+#
+# Example 1:
+# Input: s = "leetcodeisacommunityforcoders"
+# Output: "ltcdscmmntyfrcdrs"
+#
+# Example 2:
+# Input: s = "aeiou"
+# Output: ""
+#
+# @param {String} s
+# @return {String}
+
+#
+# Approach 1: Brute Force
+#
+# Time Complexity: O(n)
+#
+
+def remove_vowels(s)
+  result_array = []
+  s.downcase!
+  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
+  end
+
+  result_array.join('')
+end
+
+s = 'leetcodeisacommunityforcoders'
+puts(remove_vowels(s))
+# => "ltcdscmmntyfrcdrs"
+s = 'aeiou'
+puts(remove_vowels(s))
+# => ""
+
+#
+# Approach 2: Regex
+#
+# Time Complexity: O(n)
+#
+def remove_vowels(s)
+  vowels = /[aeiou]/i
+  s.gsub!(vowels, '')
+  s
+end
+
+s = 'leetcodeisacommunityforcoders'
+puts(remove_vowels(s))
+# => "ltcdscmmntyfrcdrs"
+s = 'aeiou'
+puts(remove_vowels(s))
+# => ""
+
+#
+# Approach 3: Using Ruby .delete() method
+#
+# Time Complexity: O(n)
+#
+def remove_vowels(s)
+  s.downcase.delete('aeiou')
+end
+
+s = 'leetcodeisacommunityforcoders'
+puts(remove_vowels(s))
+# => "ltcdscmmntyfrcdrs"
+s = 'aeiou'
+puts(remove_vowels(s))
+# => ""

data_structures/arrays/two_sum.rb

@@ -86,48 +86,3 @@ print(two_sum([3, 2, 4], 6))
 
 print(two_sum([3, 3], 6))
 # => [0,1]
-
-#
-# Approach 3: Using a Hash
-#
-
-# Complexity analysis
-
-# Time complexity: O(n). We traverse the list containing n elements exactly twice.
-# Since the hash table reduces the lookup time to O(1), the time complexity is O(n).
-
-# Space complexity: O(n). The extra space required depends on the number of items
-# stored in the hash table, which stores exactly n elements.
-
-def two_sum(nums, target)
-  hash = {}
-
-  # create a hash to store values and their indices
-  nums.each_with_index do |num, i|
-    hash[num] = i
-  end
-
-  # iterate over nums array to find the target (difference between sum target and num)
-  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
-  end
-end
-
-nums = [2, 7, 11, 15]
-target = 9
-print(two_sum(nums, target))
-# => [0,1]
-
-nums = [3, 2, 4]
-target = 6
-print(two_sum(nums, target))
-# => [1,2]
-
-nums = [3, 3]
-target = 6
-print(two_sum(nums, target))
-# => [0,1]

data_structures/hash_table/find_all_duplicates_in_an_array.rb

@@ -0,0 +1,61 @@
+# Find All Duplicates in an Array
+#
+# Given an array of integers, 1 ≤ a[i] ≤ n (n = size of array),
+# some elements appear twice and others appear once.
+#
+# Find all the elements that appear twice in this array.
+#
+# Could you do it without extra space and in O(n) runtime?
+#
+# Example:
+# Input:
+# [4,3,2,7,8,2,3,1]
+#
+# Output:
+# [2,3]
+
+require 'benchmark'
+
+array = [4, 3, 2, 7, 8, 2, 3, 1]
+long_array = [4, 3, 2, 7, 8, 2, 3, 1] * 100
+
+#
+# Approach: Hash table
+#
+
+#
+# Complexity Analysis
+#
+# Time complexity: O(n) average case.
+#
+
+def find_duplicates(array)
+  result_hash = {}
+  result_array = []
+
+  # loop through array and build a hash with counters
+  # where the key is the array element and the counter is the value
+  # increase counter when duplicate is found
+  array.each do |num|
+    if result_hash[num].nil?
+      result_hash[num] = 1
+    else
+      result_hash[num] += 1
+    end
+  end
+
+  # loop through hash and look for values > 1
+  result_hash.each do |k, v|
+    result_array.push(k) if v > 1
+  end
+
+  # return keys
+  result_array
+end
+
+Benchmark.bmbm do |x|
+  x.report('execute algorithm 3') do
+    print(find_duplicates(array))
+    print(find_duplicates(long_array))
+  end
+end

data_structures/hash_table/richest_customer_wealth.rb

@@ -0,0 +1,59 @@
+# Challenge name: Richest Customer Wealth
+#
+# You are given an m x n integer grid accounts where accounts[i][j]
+# is the amount of money the i​​​​​​​​​​​th​​​​ customer has in the j​​​​​​​​​​​th​​​​ bank.
+#
+# Return the wealth that the richest customer has.
+# A customer's wealth is the amount of money they have in all
+# their bank accounts. The richest customer is the customer that
+# has the maximum wealth.
+#
+# Example 1:
+# Input: accounts = [[1,2,3],[3,2,1]]
+# Output: 6
+# Explanation:
+# 1st customer has wealth = 1 + 2 + 3 = 6
+# 2nd customer has wealth = 3 + 2 + 1 = 6
+# Both customers are considered the richest with a wealth of 6
+# each, so return 6.
+#
+# Example 2:
+# Input: accounts = [[1,5],[7,3],[3,5]]
+# Output: 10
+# Explanation:
+# 1st customer has wealth = 6
+# 2nd customer has wealth = 10
+# 3rd customer has wealth = 8
+# The 2nd customer is the richest with a wealth of 10.
+#
+# Example 3:
+# Input: accounts = [[2,8,7],[7,1,3],[1,9,5]]
+# Output: 17
+
+#
+# Approach: Hash
+#
+# Time Complexity: O(n)
+#
+def find_richest_customer_wealth(accounts)
+  result_hash = {}
+  accounts.each_with_index do |customer, i|
+    result_hash[i] = customer.sum
+  end
+
+  highest_value = 0
+  result_hash.each do |k, v|
+    if v > highest_value
+      highest_value = v
+    end
+  end
+
+  highest_value
+end
+
+puts find_richest_customer_wealth([[1,2,3],[3,2,1]])
+# => 6
+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]])
+# => 17

data_structures/hash_table/two_sum.rb

@@ -0,0 +1,70 @@
+# Challenge name: Two Sum
+#
+# Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.
+#
+# You may assume that each input would have exactly one solution, and you may not use the same element twice.
+#
+# You can return the answer in any order.
+#
+#
+# Examples
+#
+# Input: nums = [2, 7, 11, 15], target = 9
+# Output: [0,1]
+# Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].
+#
+# Input: nums = [3, 2, 4], target = 6
+# Output: [1,2]
+#
+# Input: nums = [3, 3], target = 6
+# Output: [0,1]
+# Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].
+#
+# @param {Integer[]} nums
+# @param {Integer} target
+# @return {Integer[]}
+
+#
+# Approach: Using Hash table
+#
+
+# Complexity analysis
+
+# Time complexity: O(n). We traverse the list containing n elements exactly twice.
+# Since the hash table reduces the lookup time to O(1), the time complexity is O(n).
+
+# Space complexity: O(n). The extra space required depends on the number of items
+# stored in the hash table, which stores exactly n elements.
+
+def two_sum(nums, target)
+  hash = {}
+
+  # create a hash to store values and their indices
+  nums.each_with_index do |num, i|
+    hash[num] = i
+  end
+
+  # iterate over nums array to find the target (difference between sum target and num)
+  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
+  end
+end
+
+nums = [2, 7, 11, 15]
+target = 9
+print(two_sum(nums, target))
+# => [0,1]
+
+nums = [3, 2, 4]
+target = 6
+print(two_sum(nums, target))
+# => [1,2]
+
+nums = [3, 3]
+target = 6
+print(two_sum(nums, target))
+# => [0,1]

maths/prime_number.rb

@@ -0,0 +1,34 @@
+# A ruby program to check a given number is prime or not
+# Mathematical explanation: A number which has only 2 factors i.e., 1 (one) and itself
+
+# 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
+
+  if !non_prime_flag
+    puts "The given number #{number} is a Prime."
+  else
+    puts "The given number #{number} is not a Prime."
+  end
+end
+
+# Non-prime input
+prime_number(1)
+
+# prime input
+# Number 2 is an even prime number
+prime_number(2)
+
+# Non-prime input
+prime_number(20)
+
+# Negative input
+prime_number(-21)