From 8d8308bdc5690930af59a79f426abaec69488889 Mon Sep 17 00:00:00 2001 From: gessica Date: Fri, 30 Oct 2020 21:13:10 -0700 Subject: [PATCH 1/2] wrote the first 5 recursion problems with passing tests --- .idea/.gitignore | 6 +++++ .idea/misc.xml | 4 ++++ .idea/modules.xml | 8 +++++++ .idea/recursion-writing.iml | 27 +++++++++++++++++++++++ .idea/vcs.xml | 6 +++++ Gemfile.lock | 36 ++++++++++++++++++++++++++++++ lib/recursive-methods.rb | 40 +++++++++++++++++++++++++--------- test/recursion_writing_test.rb | 2 +- 8 files changed, 118 insertions(+), 11 deletions(-) create mode 100644 .idea/.gitignore create mode 100644 .idea/misc.xml create mode 100644 .idea/modules.xml create mode 100644 .idea/recursion-writing.iml create mode 100644 .idea/vcs.xml create mode 100644 Gemfile.lock diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..8bf4d45 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,6 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..510e7fc --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..8457255 --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/recursion-writing.iml b/.idea/recursion-writing.iml new file mode 100644 index 0000000..a1a27da --- /dev/null +++ b/.idea/recursion-writing.iml @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..94a25f7 --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/Gemfile.lock b/Gemfile.lock new file mode 100644 index 0000000..630ea95 --- /dev/null +++ b/Gemfile.lock @@ -0,0 +1,36 @@ +GEM + remote: https://rubygems.org/ + specs: + ansi (1.5.0) + builder (3.2.4) + coderay (1.1.3) + method_source (1.0.0) + minitest (5.14.2) + minitest-reporters (1.4.2) + ansi + builder + minitest (>= 5.0) + ruby-progressbar + minitest-skip (0.0.3) + minitest (~> 5.0) + minitest-spec (0.0.2.1) + minitest (>= 3.0) + pry (0.13.1) + coderay (~> 1.1) + method_source (~> 1.0) + rake (13.0.1) + ruby-progressbar (1.10.1) + +PLATFORMS + ruby + +DEPENDENCIES + minitest + minitest-reporters + minitest-skip + minitest-spec + pry + rake + +BUNDLED WITH + 2.1.4 diff --git a/lib/recursive-methods.rb b/lib/recursive-methods.rb index fbf6faa..147781c 100644 --- a/lib/recursive-methods.rb +++ b/lib/recursive-methods.rb @@ -3,47 +3,67 @@ # Time complexity: ? # Space complexity: ? def factorial(n) - raise NotImplementedError, "Method not implemented" + + raise ArgumentError if n < 0 + return 1 if n == 0 + return n * factorial(n - 1) + end # Time complexity: ? # Space complexity: ? def reverse(s) - raise NotImplementedError, "Method not implemented" + if s.length <= 1 + return s + end + + return s[-1] + reverse(s[1..-2]) + s[0] end + # Time complexity: ? # Space complexity: ? -def reverse_inplace(s) - raise NotImplementedError, "Method not implemented" +def reverse_inplace(s, i = 0, j = s.length - 1) + return s if s.length == 0 || s.length == 1 + return s if i >= j + temp = s[i] + s[i] = s[j] + s[j] = temp + + return reverse_inplace(s, i + 1, j - 1) end + # Time complexity: ? # Space complexity: ? def bunny(n) - raise NotImplementedError, "Method not implemented" + return 0 if n <= 0 + return 2 + bunny(n - 1) end # Time complexity: ? # Space complexity: ? -def nested(s) - raise NotImplementedError, "Method not implemented" +def nested(s, i = 0, j = s.length - 1) + return true if s.empty? || i > j && s[i] != s[j] + return false if s.length == 1 || s[i] == s[j] + return nested(s, i + 1, j - 1) + end # Time complexity: ? # Space complexity: ? def search(array, value) - raise NotImplementedError, "Method not implemented" + end # Time complexity: ? # Space complexity: ? def is_palindrome(s) - raise NotImplementedError, "Method not implemented" + end # Time complexity: ? # Space complexity: ? def digit_match(n, m) - raise NotImplementedError, "Method not implemented" + end \ No newline at end of file diff --git a/test/recursion_writing_test.rb b/test/recursion_writing_test.rb index 3b30725..ba7bc41 100644 --- a/test/recursion_writing_test.rb +++ b/test/recursion_writing_test.rb @@ -167,7 +167,7 @@ end end -xdescribe "nested" do +describe "nested" do it "will return true for empystring" do # Arrange string = "" From 99222fb6ace77bbdc7fd19c83b0289c54183d881 Mon Sep 17 00:00:00 2001 From: gessica Date: Mon, 2 Nov 2020 21:35:22 -0800 Subject: [PATCH 2/2] wrote the last 4 recusion problems with passing tests --- lib/recursive-methods.rb | 62 +++++++++++++++++++++++----------- test/recursion_writing_test.rb | 33 ++++++++++++++++-- 2 files changed, 72 insertions(+), 23 deletions(-) diff --git a/lib/recursive-methods.rb b/lib/recursive-methods.rb index 147781c..68a9416 100644 --- a/lib/recursive-methods.rb +++ b/lib/recursive-methods.rb @@ -1,17 +1,16 @@ # Authoring recursive algorithms. Add comments including time and space complexity for each method. -# Time complexity: ? -# Space complexity: ? +# Time complexity: O(n) it depends on the size of n to run +# Space complexity: O(n) it creates a stack every time it calls the recursive method def factorial(n) - raise ArgumentError if n < 0 return 1 if n == 0 return n * factorial(n - 1) end -# Time complexity: ? -# Space complexity: ? +# Time complexity: O(n^2) - the slice method in the reverse method creates another array so that counts for O(n) and then the method runs n times depending on the size of array, O(n). Total of O(n^2). +# Space complexity: O(n^2) - because we are creating a new array when using the slice method and it creates a stack to run the recursion method. def reverse(s) if s.length <= 1 return s @@ -21,8 +20,8 @@ def reverse(s) end -# Time complexity: ? -# Space complexity: ? +# Time complexity: O(n) it depends on the size of s to run +# Space complexity: O(n) it creates a stack every time if calls the recursive method def reverse_inplace(s, i = 0, j = s.length - 1) return s if s.length == 0 || s.length == 1 return s if i >= j @@ -34,15 +33,15 @@ def reverse_inplace(s, i = 0, j = s.length - 1) end -# Time complexity: ? -# Space complexity: ? +# Time complexity: O(n) it depends on the size of n to run +# Space complexity: O(n) it creates a stack every time if calls the recursive method def bunny(n) return 0 if n <= 0 return 2 + bunny(n - 1) end -# Time complexity: ? -# Space complexity: ? +# Time complexity: O(n) it depends on the size of s to run +# Space complexity: O(n) it creates a stack every time if calls the recursive method def nested(s, i = 0, j = s.length - 1) return true if s.empty? || i > j && s[i] != s[j] return false if s.length == 1 || s[i] == s[j] @@ -50,20 +49,43 @@ def nested(s, i = 0, j = s.length - 1) end -# Time complexity: ? -# Space complexity: ? -def search(array, value) - +# Time complexity: O(n) it depends on the size of the array to run +# Space complexity: O(n) it creates a stack every time if calls the recursive method +def search(array, value, index = 0) + return false if index >= array.length + return true if array[index] == value + return search(array, value, index + 1) end -# Time complexity: ? -# Space complexity: ? -def is_palindrome(s) +# Time complexity: O(n) it depends on the size of s to run +# Space complexity: O(n) it creates a stack every time if calls the recursive method +def is_palindrome(s, i = 0, j = s.length - 1) + return true if s.empty? || i >= j + return false if s[i] != s[j] + return is_palindrome(s, i + 1, j - 1) end -# Time complexity: ? -# Space complexity: ? +# Time complexity: O(log n) +# Space complexity: O(log n) def digit_match(n, m) + return 1 if n == 0 && m == 0 + return 0 if n <= 1 || m <= 1 + + if n % 10 == m % 10 + return 1 + digit_match(n / 10, m / 10) + else + return digit_match(n / 10, m / 10) + end +end + + + +# Time complexity: O(2^n) it depends on the size of n to run +# Space complexity: O(2^n) it creates a stack every time if calls the recursive method +def fibonacci(n) + return 0 if n == 0 + return 1 if n == 1 + return fibonacci(n - 1) + fibonacci(n - 2) end \ No newline at end of file diff --git a/test/recursion_writing_test.rb b/test/recursion_writing_test.rb index ba7bc41..fde7481 100644 --- a/test/recursion_writing_test.rb +++ b/test/recursion_writing_test.rb @@ -213,7 +213,7 @@ end end -xdescribe "search" do +describe "search" do it "will return false for empty array" do # Arrange item = "a" @@ -263,7 +263,7 @@ end end -xdescribe "is_palindrome" do +describe "is_palindrome" do it "will return true for emptystring" do # Arrange string = "" @@ -298,7 +298,7 @@ end end -xdescribe "digit_match" do +describe "digit_match" do it "returns 4 for 1072503891 and 62530841" do # Arrange num1 = 1072503891 @@ -359,3 +359,30 @@ expect(answer).must_equal 1 end end + +describe "fib" do + it "returns 0 for fib(0)" do + n = 0 + answer = fibonacci(n) + expect(answer).must_equal 0 + end + + it "returns 1 for fibonnaci(1)" do + + n = 1 + answer = fibonacci(n) + expect(answer).must_equal 1 + end + + it "returns 3 for fibonnaci(4)" do + n = 4 + answer = fibonacci(n) + expect(answer).must_equal 3 + end + + it "returns 34 for (9)" do + n = 9 + answer = fibonacci(n) + expect(answer).must_equal 34 + end +end