From e4c60debf2811eee4be4c6d4043ca2a1284d0d00 Mon Sep 17 00:00:00 2001 From: C Gutierrez Date: Sun, 22 Sep 2019 19:50:17 -0700 Subject: [PATCH 1/7] sort_by_length initial completed --- lib/sort_by_length.rb | 41 +++++++++++++++++-- ...rt_by_length.rb => sort_by_length_test.rb} | 4 +- 2 files changed, 40 insertions(+), 5 deletions(-) rename test/{sort_by_length.rb => sort_by_length_test.rb} (99%) diff --git a/lib/sort_by_length.rb b/lib/sort_by_length.rb index a5713ad..0d757e2 100644 --- a/lib/sort_by_length.rb +++ b/lib/sort_by_length.rb @@ -1,7 +1,42 @@ # A method which will return an array of the words in the string # sorted by the length of the word. -# Time complexity: ? -# Space complexity: ? +# Time complexity: O(n2) +# Space complexity: O(1) + def sort_by_length(my_sentence) - raise NotImplementedError, "Method not implemented" +# splits the sentence + array_of_sentence = my_sentence.split + + #short-cirtcuit retunn statement for empty strings + if array_of_sentence.length == 0 + return [] + end + + i = 0 #internal counter + + e = 1 #external counter + + # bubble sort :) + until e == array_of_sentence.length - 1 + + until i == array_of_sentence.length - 1 + + if array_of_sentence[i].length > array_of_sentence[i + 1].length + array_of_sentence[i], array_of_sentence[i + 1] = array_of_sentence[i + 1], array_of_sentence[i] + i += 1 + else + i += 1 + end + + end + + e += 1 + + end + + #returns transformed, digested, sorted array + return_statement = array_of_sentence + + return return_statement + end diff --git a/test/sort_by_length.rb b/test/sort_by_length_test.rb similarity index 99% rename from test/sort_by_length.rb rename to test/sort_by_length_test.rb index c38d976..1eb292f 100644 --- a/test/sort_by_length.rb +++ b/test/sort_by_length_test.rb @@ -8,11 +8,11 @@ it "will return an array of words, by length" do expect(sort_by_length("I love Ada")).must_equal ["I", "Ada", "love"] end - + it "will return an array of words by length, words that are of equal length will appear in the order they appear" do expect(sort_by_length("words of equal length")).must_equal ["of", "words", "equal", "length"] end - + it "will return an array of words by length, words that are of equal length will appear in the order they appear" do expect(sort_by_length("I love great awesome words")).must_equal ["I", "love", "great", "words", "awesome"] end From ed362bc864145728fb946c2ee58d7e0e139658dc Mon Sep 17 00:00:00 2001 From: C Gutierrez Date: Sat, 28 Sep 2019 16:22:29 -0700 Subject: [PATCH 2/7] new attempt at reverse_sentence currently debugging --- lib/reverse_sentence.rb | 211 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 210 insertions(+), 1 deletion(-) diff --git a/lib/reverse_sentence.rb b/lib/reverse_sentence.rb index 3fe7cac..ac9cab7 100644 --- a/lib/reverse_sentence.rb +++ b/lib/reverse_sentence.rb @@ -1,6 +1,215 @@ +# # A method to reverse the words in a sentence, in place. +# # Time complexity: ? +# # Space complexity: ? + +# require'pry' + +# def reverse_sentence(my_sentence) + +# if !my_sentence.include?(" ") +# return my_sentence +# elsif my_sentence == nil +# return my_sentence +# end + +# loops = my_sentence.count(" ") + +# length_of_sentence = my_sentence.length + +# i = 0 + +# previous_captures = 1 + +# loops.times do +# markers = my_sentence.match(/([[:graph:]])*/) +# capture = markers[0].to_s + +# my_sentence.delete_prefix!(capture) + +# augmented_capture = capture.insert(0, " ") + +# location = length_of_sentence - (capture.length + 1) - ( previous_captures ) + +# my_sentence = my_sentence.insert(location, augmented_capture) + +# my_sentence.lstrip! + +# previous_captures = previous_captures + augmented_capture.length + +# end + + + + +# puts my_sentence + +# return my_sentence +# end + + +# 'hello'.match('(.)\1') #=> # + + # A method to reverse the words in a sentence, in place. # Time complexity: ? # Space complexity: ? + +# require'pry' + +# def reverse_sentence(my_sentence) + +# if my_sentence == nil || !my_sentence.include?(" ") +# return my_sentence +# end + +# my_sentence.reverse! + +# word = [] + +# start_marker = 0 +# end_marker = 0 + +# i = 0 # iterates over the entire sentence + +# until i == my_sentence.length do +# if my_sentence[i] != " " +# word << my_sentence[i] +# i += 1 +# end_marker += 1 +# else +# if word.length > 0 +# j = start_marker +# until j == end_marker +# puts my_sentence +# puts start_marker +# puts word.length +# puts word[word.length - start_marker - 1] +# my_sentence[start_marker + j] = word[word.length - j - 1] +# j += 1 +# end +# start_marker = 0 +# word = [] +# end +# i += 1 +# marker = 0 +# start_marker += 1 +# end + +# puts "#{word}" +# end +# return my_sentence +# end + + +# A method to reverse the words in a sentence, in place. +# Time complexity: ? +# Space complexity: ? + +require'pry' + def reverse_sentence(my_sentence) - raise NotImplementedError + + # short circuit if empty sentence + if my_sentence == nil || !my_sentence.include?(" ") + return my_sentence + end + + # initial digest of sentence + # reverses all characters + my_sentence.reverse! + + # creates and populates an array of all space characters + space_array = [] + i = 0 + my_sentence.each_char do |character| + if character == " " + space_array << i + i += 1 + else + i += 1 + end + end + + # determines the last index number that will be handled + last_index = my_sentence.length - 1 + + # determination of which methods are needed + if !space_array.include? (0) + puts "I am running first" + first(space_array[0], my_sentence) + end + + if !space_array.include? (last_index) + puts "I am running last" + last(space_array[-1], last_index, my_sentence,) + end + + if space_array.length > 1 + puts "I am running middle" + i = 0 + p = space_array.length - 1 + + if i + 1 == p + my_sentence[i], my_sentence[i+1] = my_sentence[i+1], my_sentence[i] + else + until i + 1 == p + middle(space_array[i], space_array[i+1], my_sentence) + i += 1 + end + end + + end + + return my_sentence + +end + +def first(first_space_index_number, my_sentence) + j = 0 + + last_index_to_swap = first_space_index_number - 1 + half_limit = last_index_to_swap / 2 + + until j == half_limit + my_sentence[last_index_to_swap - j], my_sentence[j] = my_sentence[j], my_sentence[last_index_to_swap - j] + j += 1 + end + +end + +def last(last_space_index_number, last_index, my_sentence) + first_index_to_swap = last_space_index_number + 1 + half_limit = (last_index - first_index_to_swap) / 2 + + j = 0 + + until j == half_limit + my_sentence[first_index_to_swap + j], my_sentence[last_index - j] = my_sentence[last_index - j], my_sentence[first_index_to_swap + j] + j += 1 + end +end + +def middle(first_space_index_number, last_space_index_number, my_sentence) + # short-circuit for one-letter words + + if last_space_index_number - first_space_index_number == 1 + return + # elsif last_space_index_number - first_space_index_number == 3 + # my_sentence[first_space_index_number + 1], my_sentence[last_space_index_number - 1] = my_sentence[last_space_index_number - 1], my_sentence[first_space_index_number + 1] + # return + end + + first_index_to_swap = first_space_index_number + 1 + last_index = last_space_index_number - 1 + half_limit = (last_space_index_number - first_space_index_number) / 2 + + j = 0 + + # if + + until j == half_limit + my_sentence[first_index_to_swap + j], my_sentence[last_index - j] = my_sentence[last_index - j], my_sentence[first_index_to_swap + j] + j += 1 + end + end From b6523004099499448c0fa00af40687363001d231 Mon Sep 17 00:00:00 2001 From: C Gutierrez Date: Sat, 28 Sep 2019 17:04:34 -0700 Subject: [PATCH 3/7] Passed more tests, still debugging --- lib/reverse_sentence.rb | 156 ++++++++++------------------------------ 1 file changed, 39 insertions(+), 117 deletions(-) diff --git a/lib/reverse_sentence.rb b/lib/reverse_sentence.rb index ac9cab7..2d5ed75 100644 --- a/lib/reverse_sentence.rb +++ b/lib/reverse_sentence.rb @@ -1,105 +1,3 @@ -# # A method to reverse the words in a sentence, in place. -# # Time complexity: ? -# # Space complexity: ? - -# require'pry' - -# def reverse_sentence(my_sentence) - -# if !my_sentence.include?(" ") -# return my_sentence -# elsif my_sentence == nil -# return my_sentence -# end - -# loops = my_sentence.count(" ") - -# length_of_sentence = my_sentence.length - -# i = 0 - -# previous_captures = 1 - -# loops.times do -# markers = my_sentence.match(/([[:graph:]])*/) -# capture = markers[0].to_s - -# my_sentence.delete_prefix!(capture) - -# augmented_capture = capture.insert(0, " ") - -# location = length_of_sentence - (capture.length + 1) - ( previous_captures ) - -# my_sentence = my_sentence.insert(location, augmented_capture) - -# my_sentence.lstrip! - -# previous_captures = previous_captures + augmented_capture.length - -# end - - - - -# puts my_sentence - -# return my_sentence -# end - - -# 'hello'.match('(.)\1') #=> # - - -# A method to reverse the words in a sentence, in place. -# Time complexity: ? -# Space complexity: ? - -# require'pry' - -# def reverse_sentence(my_sentence) - -# if my_sentence == nil || !my_sentence.include?(" ") -# return my_sentence -# end - -# my_sentence.reverse! - -# word = [] - -# start_marker = 0 -# end_marker = 0 - -# i = 0 # iterates over the entire sentence - -# until i == my_sentence.length do -# if my_sentence[i] != " " -# word << my_sentence[i] -# i += 1 -# end_marker += 1 -# else -# if word.length > 0 -# j = start_marker -# until j == end_marker -# puts my_sentence -# puts start_marker -# puts word.length -# puts word[word.length - start_marker - 1] -# my_sentence[start_marker + j] = word[word.length - j - 1] -# j += 1 -# end -# start_marker = 0 -# word = [] -# end -# i += 1 -# marker = 0 -# start_marker += 1 -# end - -# puts "#{word}" -# end -# return my_sentence -# end - # A method to reverse the words in a sentence, in place. # Time complexity: ? @@ -133,15 +31,19 @@ def reverse_sentence(my_sentence) # determines the last index number that will be handled last_index = my_sentence.length - 1 + puts "I am sentence before swaps:#{my_sentence}" + # determination of which methods are needed if !space_array.include? (0) puts "I am running first" first(space_array[0], my_sentence) + puts "I am sentence after first:#{my_sentence}" end if !space_array.include? (last_index) puts "I am running last" - last(space_array[-1], last_index, my_sentence,) + last(space_array[-1], last_index, my_sentence) + puts "I am sentence after last:#{my_sentence}" end if space_array.length > 1 @@ -170,11 +72,17 @@ def first(first_space_index_number, my_sentence) last_index_to_swap = first_space_index_number - 1 half_limit = last_index_to_swap / 2 - until j == half_limit - my_sentence[last_index_to_swap - j], my_sentence[j] = my_sentence[j], my_sentence[last_index_to_swap - j] - j += 1 + if last_index_to_swap.even? + until j == half_limit + my_sentence[last_index_to_swap - j], my_sentence[j] = my_sentence[j], my_sentence[last_index_to_swap - j] + j += 1 + end + else + until j == half_limit + 1 + my_sentence[last_index_to_swap - j], my_sentence[j] = my_sentence[j], my_sentence[last_index_to_swap - j] + j += 1 + end end - end def last(last_space_index_number, last_index, my_sentence) @@ -183,9 +91,16 @@ def last(last_space_index_number, last_index, my_sentence) j = 0 - until j == half_limit - my_sentence[first_index_to_swap + j], my_sentence[last_index - j] = my_sentence[last_index - j], my_sentence[first_index_to_swap + j] - j += 1 + if (last_index - first_index_to_swap).even? + until j == half_limit + my_sentence[first_index_to_swap + j], my_sentence[last_index - j] = my_sentence[last_index - j], my_sentence[first_index_to_swap + j] + j += 1 + end + else + until j == half_limit + 1 + my_sentence[first_index_to_swap + j], my_sentence[last_index - j] = my_sentence[last_index - j], my_sentence[first_index_to_swap + j] + j += 1 + end end end @@ -201,15 +116,22 @@ def middle(first_space_index_number, last_space_index_number, my_sentence) first_index_to_swap = first_space_index_number + 1 last_index = last_space_index_number - 1 - half_limit = (last_space_index_number - first_space_index_number) / 2 + half_limit = (last_index - first_index_to_swap) / 2 j = 0 - # if - - until j == half_limit - my_sentence[first_index_to_swap + j], my_sentence[last_index - j] = my_sentence[last_index - j], my_sentence[first_index_to_swap + j] - j += 1 + if (last_space_index_number - first_space_index_number).even? + until j == half_limit + puts my_sentence[first_index_to_swap] + puts my_sentence[last_index] + my_sentence[first_index_to_swap + j], my_sentence[last_index - j] = my_sentence[last_index - j], my_sentence[first_index_to_swap + j] + j += 1 + end + else + until j == half_limit + 1 + my_sentence[first_index_to_swap + j], my_sentence[last_index - j] = my_sentence[last_index - j], my_sentence[first_index_to_swap + j] + j += 1 + end + end - end From 88a5f685052971a66a75e8a8d18042483e1be600 Mon Sep 17 00:00:00 2001 From: C Gutierrez Date: Sat, 28 Sep 2019 17:18:37 -0700 Subject: [PATCH 4/7] basic functionality done, now to remove all the useless puts --- lib/reverse_sentence.rb | 21 ++++++++++++++------- 1 file changed, 14 insertions(+), 7 deletions(-) diff --git a/lib/reverse_sentence.rb b/lib/reverse_sentence.rb index 2d5ed75..0b4b2b0 100644 --- a/lib/reverse_sentence.rb +++ b/lib/reverse_sentence.rb @@ -48,11 +48,19 @@ def reverse_sentence(my_sentence) if space_array.length > 1 puts "I am running middle" + + i = 0 + p = space_array.length - 1 + puts "I am space_array #{space_array}" if i + 1 == p - my_sentence[i], my_sentence[i+1] = my_sentence[i+1], my_sentence[i] + puts "I am ln 59" + first_character = space_array[0] + 1 + second_character = space_array[1] - 1 + + my_sentence[first_character], my_sentence[second_character] = my_sentence[second_character], my_sentence[first_character] else until i + 1 == p middle(space_array[i], space_array[i+1], my_sentence) @@ -106,12 +114,11 @@ def last(last_space_index_number, last_index, my_sentence) def middle(first_space_index_number, last_space_index_number, my_sentence) # short-circuit for one-letter words - if last_space_index_number - first_space_index_number == 1 return - # elsif last_space_index_number - first_space_index_number == 3 - # my_sentence[first_space_index_number + 1], my_sentence[last_space_index_number - 1] = my_sentence[last_space_index_number - 1], my_sentence[first_space_index_number + 1] - # return + elsif last_space_index_number - first_space_index_number == 3 + my_sentence[first_space_index_number + 1], my_sentence[last_space_index_number - 1] = my_sentence[last_space_index_number - 1], my_sentence[first_space_index_number + 1] + return end first_index_to_swap = first_space_index_number + 1 @@ -122,8 +129,8 @@ def middle(first_space_index_number, last_space_index_number, my_sentence) if (last_space_index_number - first_space_index_number).even? until j == half_limit - puts my_sentence[first_index_to_swap] - puts my_sentence[last_index] + # puts my_sentence[first_index_to_swap] + # puts my_sentence[last_index] my_sentence[first_index_to_swap + j], my_sentence[last_index - j] = my_sentence[last_index - j], my_sentence[first_index_to_swap + j] j += 1 end From eb4cf41f0869026b40153abcd6a38c76ba51adc8 Mon Sep 17 00:00:00 2001 From: C Gutierrez Date: Sat, 28 Sep 2019 17:21:27 -0700 Subject: [PATCH 5/7] clean up --- lib/reverse_sentence.rb | 21 ++------------------- 1 file changed, 2 insertions(+), 19 deletions(-) diff --git a/lib/reverse_sentence.rb b/lib/reverse_sentence.rb index 0b4b2b0..db0f74f 100644 --- a/lib/reverse_sentence.rb +++ b/lib/reverse_sentence.rb @@ -31,35 +31,22 @@ def reverse_sentence(my_sentence) # determines the last index number that will be handled last_index = my_sentence.length - 1 - puts "I am sentence before swaps:#{my_sentence}" - # determination of which methods are needed if !space_array.include? (0) - puts "I am running first" first(space_array[0], my_sentence) - puts "I am sentence after first:#{my_sentence}" end if !space_array.include? (last_index) - puts "I am running last" last(space_array[-1], last_index, my_sentence) - puts "I am sentence after last:#{my_sentence}" end - if space_array.length > 1 - puts "I am running middle" - - + if space_array.length > 1 # this is run if there's more than 2 words, hence if there's more than 1 space i = 0 - p = space_array.length - 1 - puts "I am space_array #{space_array}" - if i + 1 == p - puts "I am ln 59" + if i + 1 == p # short-circuit for 1-letter words first_character = space_array[0] + 1 second_character = space_array[1] - 1 - my_sentence[first_character], my_sentence[second_character] = my_sentence[second_character], my_sentence[first_character] else until i + 1 == p @@ -67,9 +54,7 @@ def reverse_sentence(my_sentence) i += 1 end end - end - return my_sentence end @@ -129,8 +114,6 @@ def middle(first_space_index_number, last_space_index_number, my_sentence) if (last_space_index_number - first_space_index_number).even? until j == half_limit - # puts my_sentence[first_index_to_swap] - # puts my_sentence[last_index] my_sentence[first_index_to_swap + j], my_sentence[last_index - j] = my_sentence[last_index - j], my_sentence[first_index_to_swap + j] j += 1 end From bd9c6ca0ab55eab8f00161a59e5c6ba00f51b2de Mon Sep 17 00:00:00 2001 From: C Gutierrez Date: Sat, 28 Sep 2019 17:33:40 -0700 Subject: [PATCH 6/7] Space and time questions --- lib/reverse_sentence.rb | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/lib/reverse_sentence.rb b/lib/reverse_sentence.rb index db0f74f..c9780ab 100644 --- a/lib/reverse_sentence.rb +++ b/lib/reverse_sentence.rb @@ -1,7 +1,6 @@ - # A method to reverse the words in a sentence, in place. -# Time complexity: ? -# Space complexity: ? +# Time complexity: O(2n) The array is reviewed twice, once for spaces to populate the space array, and once more piecewise to do all the swaps +# Space complexity: O(1) require'pry' From c266e9a7d6b89fc89f7f843a605a167ca08cfbd4 Mon Sep 17 00:00:00 2001 From: C Gutierrez Date: Thu, 3 Oct 2019 11:14:38 -0700 Subject: [PATCH 7/7] Added a manual reverse for the entire phrase at the start of the method --- lib/reverse_sentence.rb | 20 +++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-) diff --git a/lib/reverse_sentence.rb b/lib/reverse_sentence.rb index c9780ab..5545c68 100644 --- a/lib/reverse_sentence.rb +++ b/lib/reverse_sentence.rb @@ -11,9 +11,19 @@ def reverse_sentence(my_sentence) return my_sentence end - # initial digest of sentence - # reverses all characters - my_sentence.reverse! + # determines the last index number that will be handled + last_index = my_sentence.length - 1 + + # reverses all the characters in the string + i = 0 + my_sentence[i] + half_swap_limit = last_index / 2 + 1 + + until i == half_swap_limit + my_sentence[i], my_sentence[last_index - i] = my_sentence[last_index - i], my_sentence[i] + + i += 1 + end # creates and populates an array of all space characters space_array = [] @@ -27,8 +37,7 @@ def reverse_sentence(my_sentence) end end - # determines the last index number that will be handled - last_index = my_sentence.length - 1 + # determination of which methods are needed if !space_array.include? (0) @@ -78,6 +87,7 @@ def first(first_space_index_number, my_sentence) end def last(last_space_index_number, last_index, my_sentence) + first_index_to_swap = last_space_index_number + 1 half_limit = (last_index - first_index_to_swap) / 2