Sockets - Shubha

lib/recursive-methods.rb

@@ -1,49 +1,116 @@
+require "pry"
 # Authoring recursive algorithms. Add comments including time and space complexity for each method.
 
-# Time complexity: ?
-# Space complexity: ?
+# Time complexity: O(n) where n recursive calls are made
+# Space complexity: O(n) where the stack is n levels deep
 def factorial(n)
-    raise NotImplementedError, "Method not implemented"
+  raise ArgumentError if n < 0
+  if (n == 1) || (n == 0)
+    return 1
+  else
+    return n * factorial(n - 1)
+  end
 end
 
-# Time complexity: ?
-# Space complexity: ?
+# Time complexity: O(n)^2 where n/2 recursive calls are made and each calls slice, which is O(n)
+# Space complexity: O(n)^2 where the max depth of the function is n/2, and each level creates a new string slice
 def reverse(s)
-    raise NotImplementedError, "Method not implemented"
+  if s.length == 1 || s.length == 0
+    return s
+  else
+    s[-1] + reverse(s[1...-1]) + s[0]
+  end
 end
 
-# Time complexity: ?
-# Space complexity: ?
+# Time complexity: O(n)^2 where n/2 recursive calls are made and each calls slice, which is O(n)
+# Space complexity: O(n) where the max depth of the function is n/2,
 def reverse_inplace(s)
-    raise NotImplementedError, "Method not implemented"
+  left = 0
+  right = s.length - 1
+  return swap(left, right, s)
 end
 
-# Time complexity: ?
-# Space complexity: ?
+def swap(left, right, str)
+  if right <= left
+    return str
+  else
+    temp = str[left]
+    str[left] = str[right]
+    str[right] = temp
+    swap(left + 1, right - 1, str)
+  end
+end
+
+# Time complexity: O(n) where n recursive calls are made
+# Space complexity: O(n) where the max depth is n
 def bunny(n)
-    raise NotImplementedError, "Method not implemented"
+  if n <= 0
+    return 0
+  else
+    return 2 + bunny(n - 1)
+  end
 end
 
-# Time complexity: ?
-# Space complexity: ?
+# Time complexity: O(n)^2 where n/2 recursive calls are made and each calls slice, which is O(n)
+# Space complexity: O(n)^2 where the max depth of the function is n/2
+
 def nested(s)
-    raise NotImplementedError, "Method not implemented"
+  return true if s.length == 0
+  left = 0
+  right = s.length - 1
+  return check_parens(left, right, s)
+end
+
+def check_parens(left, right, str)
+  if str[left] == str[right] || left == right
+    return false
+  elsif left > right
+    return true
+  else
+    check_parens(left + 1, right - 1, str)
+  end
 end
 
-# Time complexity: ?
-# Space complexity: ?
+# Time complexity: O(n)^2 because there are 2n-1 calls each time and each slices the array
+# Space complexity: O(n log n) because at most the algorithm goes log2 n levels deep, and each layer creates a slice
 def search(array, value)
-    raise NotImplementedError, "Method not implemented"
+  return false if array.length == 0
+  if array.length == 1
+    return true if array[0] == value
+  else
+    first_half = array[0...(array.length / 2)]
+    second_half = array[(array.length / 2)...array.length]
+    return true if search(first_half, value) || search(second_half, value)
+  end
+  return false
 end
 
-# Time complexity: ?
-# Space complexity: ?
+# Time complexity: O(n)^2 where n/2 recursive calls are made and each calls slice, which is O(n)
+# Space complexity: O(n)^2 where the max depth of the function is n/2
 def is_palindrome(s)
-    raise NotImplementedError, "Method not implemented"
+  return true if s.length == 0
+  left = 0
+  right = s.length - 1
+  return check_letters(left, right, s)
+end
+
+def check_letters(left, right, str)
+  if str[left] != str[right]
+    return false
+  elsif left >= right
+    return true
+  else
+    check_letters(left + 1, right - 1, str)
+  end
 end
 
-# Time complexity: ?
-# Space complexity: ?
+# Time complexity: If n < m, time complexity will be O(log10 n) since the number of calls is dependent on how many times the smaller number can be divided by 10
+# Space complexity: also O(log10 n) since the depth is proportional to the number of calls
 def digit_match(n, m)
-    raise NotImplementedError, "Method not implemented"
-end
+  match_value = (n % 10 == m % 10) ? 1 : 0
+  if n / 10 == 0 || m / 10 == 0
+    return match_value
+  else
+    return match_value + digit_match(n / 10, m / 10)
+  end
+end

specs/recursion_writing_spec.rb

@@ -1,7 +1,7 @@
-require 'minitest/autorun'
-require 'minitest/reporters'
+require "minitest/autorun"
+require "minitest/reporters"
 require "minitest/skip_dsl"
-require_relative '../lib/recursive-methods'
+require_relative "../lib/recursive-methods"
 
 describe "factorial" do
   it "will find the factorial of 0" do
@@ -23,8 +23,7 @@
     answer = factorial(num)
 
     # Assert
-    expect(answer).must_equal 5*4*3*2*1
-
+    expect(answer).must_equal 5 * 4 * 3 * 2 * 1
   end
 
   it "will raise an ArgumentError if given a number not >= 0" do
@@ -38,7 +37,7 @@
   end
 end
 
-xdescribe "reverse" do
+describe "reverse" do
   it "will reverse 'cat'" do
     # Arrange
     string = "cat"
@@ -83,8 +82,7 @@
   end
 end
 
-
-xdescribe "reverse_in_place" do
+describe "reverse_in_place" do
   it "will reverse 'cat'" do
     # Arrange
     string = "cat"
@@ -129,7 +127,7 @@
   end
 end
 
-xdescribe "bunny" do
+describe "bunny" do
   it "returns 0 for 0 bunnies" do
     # Arrange
     count = 0
@@ -164,7 +162,7 @@
   end
 end
 
-xdescribe "nested" do
+describe "nested" do
   it "will return true for empystring" do
     # Arrange
     string = ""
@@ -210,7 +208,7 @@
   end
 end
 
-xdescribe "search" do
+describe "search" do
   it "will return false for empty array" do
     # Arrange
     item = "a"
@@ -224,43 +222,43 @@
   end
 
   it "will return true when looking for something in the array" do
-  # Arrange
-  item = "a"
-  array = ["b", "c", "a"]
+    # Arrange
+    item = "a"
+    array = ["b", "c", "a"]
 
-  # Act
-  answer = search(array, item)
+    # Act
+    answer = search(array, item)
 
-  # Assert
-  expect(answer).must_equal true
+    # Assert
+    expect(answer).must_equal true
   end
 
   it "will return false when looking for something not in the array" do
     # Arrange
     item = "x"
     array = ["b", "c", "a"]
-  
+
     # Act
     answer = search(array, item)
-  
+
     # Assert
     expect(answer).must_equal false
-    end
-
-    it "will return true when finding something at the front of the array" do
-      # Arrange
-      item = "b"
-      array = ["b", "c", "a"]
-    
-      # Act
-      answer = search(array, item)
-    
-      # Assert
-      expect(answer).must_equal true
-    end      
+  end
+
+  it "will return true when finding something at the front of the array" do
+    # Arrange
+    item = "b"
+    array = ["b", "c", "a"]
+
+    # Act
+    answer = search(array, item)
+
+    # Assert
+    expect(answer).must_equal true
+  end
 end
 
-xdescribe "is_palindrome" do
+describe "is_palindrome" do
   it "will return true for emptystring" do
     # Arrange
     string = ""
@@ -295,7 +293,7 @@
   end
 end
 
-xdescribe "digit_match" do
+describe "digit_match" do
   it "returns 4 for 1072503891 and 62530841" do
     # Arrange
     num1 = 1072503891
@@ -304,8 +302,8 @@
     # Act
     answer = digit_match(num1, num2)
 
-     # Assert
-     expect(answer).must_equal 4
+    # Assert
+    expect(answer).must_equal 4
   end
 
   it "returns 0 for nonmatching numbers" do
@@ -316,8 +314,8 @@
     # Act
     answer = digit_match(num1, num2)
 
-     # Assert
-     expect(answer).must_equal 0
+    # Assert
+    expect(answer).must_equal 0
   end
 
   it "returns 3 for 841 and 62530841" do
@@ -328,7 +326,7 @@
     # Act
     answer = digit_match(num1, num2)
 
-     # Assert
-     expect(answer).must_equal 3
+    # Assert
+    expect(answer).must_equal 3
   end
-end
+end