# FAQ: Methods, Blocks, & Sorting - Sorting

This community-built FAQ covers the “Sorting” exercise from the lesson “Methods, Blocks, & Sorting”.

Paths and Courses
This exercise can be found in the following Codecademy content:

## FAQs on the exercise Sorting

There are currently no frequently asked questions associated with this exercise – that’s where you come in! You can contribute to this section by offering your own questions, answers, or clarifications on this exercise. Ask or answer a question by clicking reply () below.

If you’ve had an “aha” moment about the concepts, formatting, syntax, or anything else with this exercise, consider sharing those insights! Teaching others and answering their questions is one of the best ways to learn and stay sharp.

## Join the Discussion. Help a fellow learner on their journey.

Agree with a comment or answer? Like () to up-vote the contribution!

Found a bug? Report it!

Have a question about your account or billing? Reach out to our customer support team!

None of the above? Find out where to ask other questions here!

I need some help with understanding the descending order with combined operator.

Why it will sort it in descending order if I use the {} brackets and not the sort method?

``````fruits = ["orange", "apple", "banana", "pear", "grapes"]

print fruits.sort! do |b, a|
a <=> b
end

print fruits.sort! { |b, a| a <=> b }
``````

the result is

``````["apple", "banana", "grapes", "orange", "pear"]
["pear", "orange", "grapes", "banana", "apple"]
``````

thanks

1 Like

The exercise suggests as an alternative, sorting with an if/else statement. I succeeded with the following:

``````fruits = ["orange", "apple", "banana", "pear", "grapes"]

fruits.sort! do |fruit1, fruit2|
if fruit1 <= fruit2
fruit1 = 1
else fruit1 = 0
end
end

puts fruits
``````

But I don’t really understand how this works (just as I don’t really understand how it works with <=>) Specifically, I haven’t wrapped my head around how the 2 “comparison values” (fruit1, fruit2) are then applied to an array of more than 2 values. I guess this is about the inner workings of the .sort! method & I’ll probably come to understand it better with time.

2 Likes

PS I’m also curious about melina84’s question (#2). Does puts / print only take the block if it’s on a single line? It worked when I modified melina84’s code as follows, running the puts after the sort block.

``````fruits = ["orange", "apple", "banana", "pear", "grapes"]

fruits.sort! do |b, a|
a <=> b
end
puts fruits

fruits.sort! {|b, a| a <=> b }
puts fruits
``````

The following use of parentheses also works, and seems to kinda support my theory:

``````puts (
fruits.sort! do |b, a|
a <=> b
end
)
``````
2 Likes

Also curious how fruitTwo <=> fruitOne can be applied to this array since this array has 5 fruits (not 2).

3 Likes

Will it be because of the “Do” statement kind of a while loop it will do it until all of the iterations are evaluated?

same as above comments. Why did the block method not work but curly braces worked?

Hi everyone,

I know the point of the exercise might have just been to teach us <=>
I’m wondering if anyone can explain why we would want to use the curly braces at all when fruits.sort! sorts it alphabetically, and then fruits.reverse! reverses it. Nothing extra needed. I’m just looking for some context to it
Thanks!

``````fruits = ["orange", "apple", "banana", "pear", "grapes"]

fruits1 = ["orange", "apple", "banana", "pear", "grapes"]

fruits.sort!
fruits.reverse!
fruits.each {|x| puts x}

puts ""

fruits1.sort! do |firstFruit, secondFruit|
secondFruit <=> firstFruit
end
fruits1.each {|x| puts x}
``````
1 Like

Hi p0nd3r,

I believe, rereading the instructions/explanation on the “Foundations” exercise (13/19) and “The Combined Comparison Operator” (14/19), the answer to your question about 2 values compared in an array of more than 2 values has to do with how the algorithms work. From my understanding, I believe the .sort! method is comparing each of the values in the array to each of the others. So for each comparison that it runs, there are two values being compared. The algorithm doesn’t compare all 5 values at once, but two at a time.

So for each of those comparison that it runs, we’re telling it how to compare those two items. In order to do this, we are calling the two values being compared at each given step fruit1 and fruit2.

Crazy that they dropped “Try it with an if/else statement!” in there without any guidance or an example of the correct answer. That’s what I came to the forums to find. Thanks for posting yours.

1 Like

For the following code:

fruits.sort! { |fruit1, fruit2|
if fruit1 > fruit2
-1
elsif fruit1 < fruit2
1
else
0
end
}
puts fruits

does this mean:
if fruit 1 comes after fruit 2 alphabetically, put it before.
elsif fruit 2 comes before fruit 1 alphabetically, but it after.
else when they are the same word then they can appear either before or after the other

If so, that means -1 is indicating what should come first
But doesn’t that contradict what we saw in the beginning of this lesson:

def capitalize(string)
puts “#{string[0].upcase}#{string[1…-1]}”
end

The -1 here indicated the last element

Integers like -1 aren’t reserved keywords, so you can’t say that they should hold a single meaning regardless of how and where they are being used. In your fruits example, -1 is being used as a return value for the sort method. In your capitalize example, -1 is being used to index a string. If you use -1 in a calculation, it will have a different use. If you use -1 to initialize a loop variable, it will have a different meaning. If you use -1 to set the loop step, it will have a different meaning. So, you must look at the situation to understand how it is being used.

As for using the return values in a sort, have a look at this post. In particular, I would encourage you to look at the stackoverflow link in that post. It gives a detailed explanation of the sort method and return values. But, yes basically a return value in a sort method of 1 means we should swap the elements, while 0 and -1 leave the elements in their existing position. After reading the stackoverflow post, if you still have questions, share your thoughts on what you find confusing.

In your capitalize example, -1 is not being used as a return value in a sort. Instead, it is being used as an index for a string. With strings and arrays, we can use 0, 1, 2 etc. to select the first, second, third element/character etc. If we want to target an element/character from the end, we can use negative indices.
For example,
name = “Frodo Baggins”
name[0] will be ‘F’
name[1] will be ‘r’
name[2] will be ‘o’
If we want to select characters from the end, then instead of counting from the start, we can use negative indices.
name[-1] will be ‘s’
name[-2] will be ‘n’
name[-3] will be ‘i’

In your example, `string[0`] will target the first element of the string.
`..` is used to specify a range, so `string[1..-1]` says select all the characters starting from the second character of the string up to and including the last character of the string.

I know the instructions say to use <=> or an if elsif else statement but I found this much cleaner and more intuitive. Any reason we shouldn’t be using this?

fruits = ["orange", "apple", "banana", "pear", "grapes"] fruits = fruits.sort! fruits = fruits.reverse! puts fruits

Since you are using the bang operator, you don’t need to assign the results. They mutate the object in place.
So, instead of `fruits = fruits.sort!` and `fruits = fruits.reverse!`, you can simply use` fruits.sort!` and` fruits.reverse!`
If you omit the bang operator, then you will need to do assignments e.g. `fruits = fruits.sort`
If you want to simply sort an array of strings in reverse order, then your approach is all that is needed. You don’t need to bother with elsiif statements or the <=> operator.
I have shared my thoughts on how we are being introduced to the <=> operator, so that we can gradually tackle more complex sorting logic with our own custom code. I have shared my thoughts in this post. It is just my opinion and I may well be wrong.

1 Like
``````fruits = ["orange", "apple", "banana", "pear", "grapes"]

fruits.sort! do |a, b|
b <=> a
end
``````

For those not understanding how the comparison operator can compare more than two items:

As it sorts through the array, it grabs the first two and compares them, then grabs the third and compares it with the second, then grabs the fourth and compares with the third, and so on. If you simply compare ‘b’ before ‘a’ instead, it does the process in reverse.

Thanks that is actually helpful. A couple months on and getting more into algorithms and data structures I can see the value of the approach. (but for lazy programmers like myself it might be helpful to make it explicit that that’s why we are learning it!)