From f39304e5f81721e2cfcafbec307ed9c06f364f9b Mon Sep 17 00:00:00 2001
From: Leah Scott-Zechlin <scottzec@gmail.com>
Date: Wed, 23 Sep 2020 21:22:00 +0200
Subject: [PATCH] methods and complexity levels

---
 lib/using_restricted_array.rb | 109 +++++++++++++++++++++++++++-------
 1 file changed, 88 insertions(+), 21 deletions(-)

diff --git a/lib/using_restricted_array.rb b/lib/using_restricted_array.rb
index 90fe0d1..8e4f08a 100644
--- a/lib/using_restricted_array.rb
+++ b/lib/using_restricted_array.rb
@@ -6,56 +6,123 @@
 
 # Calculates the length of the restricted array. All values are integers.
 # The restricted_array is terminated by 'nil' i.e. array[length] = nil
-# Time complexity: ?
-# Space complexity: ?
+# Time complexity: O(n)
+# Space complexity: O(1)
 def length(array)
-  raise NotImplementedError
+  i = 0
+  until array[i] == nil
+    i += 1
+  end
+
+  return i
 end
 
 # Prints each integer values in the array
-# Time complexity: ?
-# Space complexity: ?
+# Time complexity: O(n)
+# Space complexity: O(n)
 def print_array(array)
-  raise NotImplementedError
+  printed_list = ""
+
+  (length(array)).times do |i|
+    if i + 1 == length(array)
+      printed_list << "#{array[i]}"
+    else
+      printed_list << "#{array[i]} "
+    end
+    i += 1
+  end
+
+  return printed_list
 end
 
+
+
 # For an unsorted array, searches for 'value_to_find'.
 # Returns true if found, false otherwise.
-# Time complexity: ?
-# Space complexity: ?
+# Time complexity: O(n)
+# Space complexity: O(1)
 def search(array, length, value_to_find)
-  raise NotImplementedError
+
+  length.times do |i|
+    if array[i] == value_to_find
+      return true
+    end
+  end
+
+  return false
 end
 
+
 # Finds and returns the largest integer value the array
 # Assumes that the array is not sorted.
-# Time complexity: ?
-# Space complexity: ?
+# Time complexity: O(n)
+# Space complexity: O(1)
 def find_largest(array, length)
-  raise NotImplementedError
+  largest_value = 0
+  i = 0
+  while i < length
+    largest_value = array[i] if array[i] > largest_value
+    i += 1
+  end
+
+  return largest_value
 end
 
+
 # Finds and returns the smallest integer value in the array
 # Assumes that the array is not sorted.
-# Time complexity: ?
-# Space complexity: ?
+# Time complexity: O(n)
+# Space complexity: O(1)
 def find_smallest(array, length)
-  raise NotImplementedError
+  smallest_value = array[0]
+  i = 0
+  # Why doesn't until i = length work here?
+  while i < length
+    smallest_value = array[i] if array[i] < smallest_value
+    i += 1
+  end
+
+  return smallest_value
 end
 
+
 # Reverses the values in the integer array in place
-# Time complexity: ?
-# Space complexity: ?
+# Time complexity: O(n)
+# Space complexity: O(1)
 def reverse(array, length)
-  raise NotImplementedError
+  i = 0
+  while i < (length/2)
+    pp i
+    temp_holder = array[i]
+    array[i] = array[length - (i + 1)]
+    array[length - (i + 1)] = temp_holder
+    i += 1
+  end
+
+  return array
 end
 
+
 # For an array sorted in ascending order, searches for 'value_to_find'.
 # Returns true if found, false otherwise.
-# Time complexity: ?
-# Space complexity: ?
+# Time complexity: O(log n)
+# Space complexity: O(1)
 def binary_search(array, length, value_to_find)
-  raise NotImplementedError
+  index_low = 0
+  index_high = length - 1
+
+  while index_low <= index_high
+    middle = (index_low + index_high) / 2
+    if array[middle] == value_to_find
+      return true
+    elsif value_to_find < middle
+      index_high = middle - 1
+    elsif value_to_find > middle
+      index_low = middle + 1
+    end
+  end
+
+  return false
 end
 
 # Helper method provided to sort the array in ascending order