Рубиновые блоки и сортировка [дубликаты]

Некоторые другие точки:

• x и y называются параметрами блока. Метод сортировки в основном говорит: «Я дам вам x и y, вы определяете, должен ли x или y быть первым, и я буду следить за скучными вещами в отношении сортировки»
• <=> называемый оператором космического корабля .

<=> - это метод ruby, который возвращает (self.<=>( argument ))

• -1, если self & lt; аргумент
• 0, если аргумент self ==
• 1, если self> argument

x и y являются элементами массива. Если никакой блок не предусмотрен, функция sort использует x<=>y, в противном случае результат блока говорит, что если x должен быть до y.

array.sort{|x, y| some_very_complicated_method(x, y) }

Здесь, если some_very_complicated_method (x, y) возвращает smth то есть & lt; 0, х считается & lt; чем у и т. д. ...

@OscarRyz ответ прояснил мне много вопросов о том, как работает сортировка, esp

 { |x, y| y <=> x }

Исходя из моего понимания, я предоставляю здесь, каково будет состояние массива после каждого сравнение для вышеописанных результатов блока.

Примечание. Получена ссылка на печать значений параметров блока e1, e2 из ruby-forum

1.9.3dev :001 > a = %w(d e a w f k)
1.9.3dev :003 > a.sort { |e1, e2| p [e2, e1]; e2 <=> e1 }
["w", "d"]
["k", "w"]
["k", "d"]
["k", "e"]
["k", "f"]
["k", "a"]
["f", "a"]
["d", "f"]
["d", "a"]
["d", "e"]
["e", "f"]
 => ["w", "k", "f", "e", "d", "a"]

Угаданное состояние массива во время выполнения после каждого сравнения:

 [e2, e1]    Comparsion Result       Array State
["w", "d"]      1                   ["w", "e", "a", "d", "f", "k"]
["k", "w"]     -1                   ["w", "e", "a", "d", "f", "k"]
["k", "d"]      1                   ["w", "e", "a", "k", "f", "d"]
["k", "e"]      1                   ["w", "k", "a", "e", "f", "d"]  
["k", "f"]      1                   ["w", "k", "a", "e", "f", "d"]    
["k", "a"]      1                   ["w", "k", "a", "e", "f", "d"]  
["f", "a"]      1                   ["w", "k", "f", "e", "a", "d"]  
["d", "f"]     -1                   ["w", "k", "f", "e", "a", "d"]  
["d", "a"]      1                   ["w", "k", "f", "e", "d", "a"]  
["d", "e"]     -1                   ["w", "k", "f", "e", "d", "a"]  
["e", "f"]     -1                   ["w", "k", "f", "e", "d", "a"] (Result)

Спасибо,

Jignesh

Я верю | x, y | y & lt; => x сравнивает два элемента за раз в порядке убывания, как показано в: http://www.ruby-doc.org/core-1.9.3/Array.html#method-i-3C -3D-3E Предположим, что сначала используются сравнения «d», «a», «e», «c», «b»], «d» и «a». Тогда, поскольку он нисходит, оба остаются в том же порядке, потому что d оценивается меньше, чем a. Затем оцениваются d и e. «e» перемещается в положение «d». Не зная внутренней работы кода c, невозможно узнать, где находится d, но я считаю, что этот процесс продолжается до тех пор, пока все элементы не будут отсортированы. Функции c:

           VALUE
rb_ary_cmp(VALUE ary1, VALUE ary2)
{
    long len;
    VALUE v;

    ary2 = rb_check_array_type(ary2);
    if (NIL_P(ary2)) return Qnil;
    if (ary1 == ary2) return INT2FIX(0);
    v = rb_exec_recursive_paired(recursive_cmp, ary1, ary2, ary2);
    if (v != Qundef) return v;
    len = RARRAY_LEN(ary1) - RARRAY_LEN(ary2);
    if (len == 0) return INT2FIX(0);
    if (len > 0) return INT2FIX(1);
    return INT2FIX(-1);
}

Когда у вас есть массив, скажем, целых чисел для сортировки, довольно просто для метода sort упорядочить элементы правильно - меньшие числа сначала, больше в конце. Это когда вы используете обычный sort, без блока.

Но когда вы сортируете другие объекты, может потребоваться предоставить возможность сравнить (каждый) два из них. Допустим, у вас есть массив объектов класса Person. Вероятно, вы не можете определить, больше ли объект bob больше, чем объект mike (т. Е. Класс Person не имеет метода <=>). В этом случае вам нужно будет предоставить некоторый код, чтобы объяснить, в каком порядке вы хотите, чтобы эти объекты отсортировались по методу sort. Вот где блочная форма срабатывает.

people.sort{|p1,p2| p1.age <=> p2.age}
people.sort{|p1,p2| p1.children.count <=> p2.children.count}

и т. Д. Во всех этих случаях метод sort сортирует их одинаково - используется один и тот же алгоритм. Другое дело - логика сравнения.

In:

a.sort {|x,y| y <=> x }   #=> ["e", "d", "c", "b", "a"]

Что такое x и y?

x и y являются элементы сравниваются алгоритмом сортировки.

Это полезно для определения пользовательских классов, элемент которых должен быть перед другим.

Для основных данных (числа, строки, дата и т. д.) естественный порядок предопределен, но для элемента клиента (т. е. Employee) вы определяете, кто идет до того, кто сравнивается. Этот блок дает вам возможность определить это.

и что происходит при y & lt; => x?

Там они сравнивают элементы в порядке убывания (те с «более высоким» значением будет первым), а не естественным порядком (x<=>y)

Метод <=> означает «compareTo» и возвращает 0, если элементы эквивалентны, или < 0 если x идет раньше y или > 0, если x идет после y