Minor changes

data_structures/arrays/find_all_duplicates_in_an_array.rb

@@ -14,52 +14,90 @@
 # Output:
 # [2,3]
 
-def find_duplicates(array) 
+require 'benchmark'
-  current_num = array[0]
-  result_array = []
-  array.each_with_index do |num, i|
-    array.each_with_index do |num, j|
-      if i != j && current_num == array[j]
-        result_array.push(current_num)
-      end
-    end
-    current_num = array[i+1]
-  end
-  result_array.uniq
-end
 
 array = [4, 3, 2, 7, 8, 2, 3, 1]
 long_array = [4, 3, 2, 7, 8, 2, 3, 1] * 100
 
-require 'benchmark'
+#
+# Approach 1: Brute force
+#
+
+#
+# Complexity Analysis
+#
+# Time complexity: O(n^2) average case.
+#
+
+def find_duplicates(array)
+  current_num = array[0]
+  result_array = []
+
+  array.count.times do |i|
+    array.count.times do |j|
+      result_array.push(current_num) if i != j && current_num == array[j]
+    end
+
+    current_num = array[i + 1]
+  end
+
+  result_array.uniq
+end
+
 Benchmark.bmbm do |x|
-  x.report('execute algorithm') do
+  x.report('execute algorithm 1') do
-    print find_duplicates(long_array)
+    print(find_duplicates(array))
+    print(find_duplicates(long_array))
   end
 end
 
+#
+# Approach 2: Sort and Compare Adjacent Elements
+#
+
+# Intuition
+
+# After sorting a list of elements, all elements of equivalent value get placed together.
+# Thus, when you sort an array, equivalent elements form contiguous blocks.
+
+#
+# Complexity Analysis
+#
+# Time complexity: O(n log n)
+#
+
 def find_duplicates_2(array)
   sorted_array = array.sort
   result_array = []
 
   (1..sorted_array.count).each do |i|
-    if sorted_array[i] == sorted_array[i-1]
+    result_array.push(sorted_array[i]) if sorted_array[i] == sorted_array[i - 1]
-      result_array.push(sorted_array[i])
-    end
   end
+
   result_array.uniq
 end
 
-require 'benchmark'
 Benchmark.bmbm do |x|
-  x.report('execute algorithm') do
+  x.report('execute algorithm 2') do
-    print find_duplicates_2(long_array)
+    print(find_duplicates(array))
+    print(find_duplicates(long_array))
   end
 end
 
+#
+# Approach 3: Hash map
+#
+
+#
+# Complexity Analysis
+#
+# Time complexity: O(n) average case.
+#
+
 def find_duplicates_3(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
@@ -70,19 +108,19 @@ def find_duplicates_3(array)
       result_hash[num] += 1
     end
   end
+
   # loop through hash and look for values > 1
   result_hash.each do |k, v|
-    if v > 1
+    result_array.push(k) if v > 1
-      result_array.push(k)
-    end
   end
+
   # return keys
   result_array
 end
 
-require 'benchmark'
 Benchmark.bmbm do |x|
-  x.report('execute algorithm') do
+  x.report('execute algorithm 3') do
-    print find_duplicates_3(array)
+    print(find_duplicates(array))
+    print(find_duplicates(long_array))
   end
 end