Sorting algorithms are some of the earliest that you typically get exposed to in Computer Science. It may not be immediately obvious how important they are, but it shouldn’t be hard to think of some examples where your computer needs to sort some massive datasets during everyday operations.
One of the simpler (but more processor-intensive) ways of sorting a group of items in an array is bubble sort, where each element is compared to the one next to it and they are swapped if the one on the left is larger than the one on the right. This continues until the array is eventually sorted.
There’s also an entry on Bubble Sort on Wikipedia that’s worth taking a look at.
#bubble_sortthat takes an array and returns a sorted array. It must use the bubble sort methodology (using
#sortwould be pretty pointless, wouldn’t it?).
> bubble_sort([4,3,78,2,0,2]) => [0,2,2,3,4,78]
#bubble_sort_bywhich sorts an array by accepting a block. Remember to use yield inside your method definition to accomplish this. The block will have two arguments that represent the two elements of the array that are currently being compared. The block’s return will be similar to the spaceship operator you learned about before: If the result of the block execution is negative, the element on the left is “smaller” than the element on the right.
0means both elements are equal. A positive result means the left element is greater. Use the block’s return value to sort your array. Test your method with the example below.
> bubble_sort_by(["hi","hello","hey"]) do |left,right| > left.length - right.length > end => ["hi", "hey", "hello"]
You learned about the Enumerable module that gets mixed into the Array and Hash classes (among others) and provides you with lots of handy iterator methods. To prove that there’s no magic to it, you’re going to rebuild those methods.
module Enumerable def my_each # your code here end end
#my_each, a method that is identical to
#eachbut (obviously) does not use
#each. You’ll need to remember the
yieldstatement. Make sure it returns the same thing as
#my_each_with_indexin the same way.
#my_selectin the same way, though you may use
#my_eachin your definition (but not
#my_all?(continue as above)
#my_injectby creating a method called
#multiply_elswhich multiplies all the elements of the array together by using
multiply_els([2,4,5]) #=> 40
#my_mapmethod to take a proc instead.
#my_mapmethod to take either a proc or a block. It won’t be necessary to apply both a proc and a block in the same
#my_mapcall since you could get the same effect by chaining together one
#my_mapcall with the block and one with the proc. This approach is also clearer, since the user doesn’t have to remember whether the proc or block will be run first. So if both a proc and a block are given, only execute the proc.
Submit a link to the github repo with your files in it here with a pull request. Please include your partner’s github handle somewhere in the description if they would like attribution.
This section contains helpful links to other content. It isn’t required, so consider it supplemental for if you need to dive deeper into something.