Ruby/Подробнее о массивах: различия между версиями

Массив создаётся как минимум тремя способами. Первый способ:

 

 

Вы просто перечисляете элементы массива через запятую, а границы массива обозначаете квадратными скобками. С таким методом создания массива мы уже встречались. А теперь попробуем второй способ, через вызов метода <code>.new</code> класса <code>Array</code>:

 

 

Параметром метода <code>.new</code> является количество элементов будущего массива (в данном случае это число 6). В фигурных скобках указано, как мы будем заполнять массив. В данном случае значение элемента массива будет больше на единицу его индекса. Третий способ заключается в создании объекта типа <code>Range</code> (диапазон) и вызове метода <code>.to_a</code>:

 

 

Есть ещё много способов, но эти три используются чаще всего.

Методом <code>to_a</code> очень удобно создавать из диапазона массив, содержащий упорядоченные элементы данного диапазона.

 

 

Раз уж речь зашла о диапазонах, то давайте посмотрим, как они позволяют получать подмассивы. И насколько изящно у них это получается. Рассмотрим массив:

 

 

Традиционно нумерация массива начинается с нуля и возрастает по одному:

Плюсы расставлены лишь для красоты. Но вернёмся к отрицательной индексации. Каков её смысл? Чтобы его пояснить, давайте решим задачку: дан массив, требуется получить предпоследний элемент.

 

 

В данном случае мы использовали метод <code>.size</code>, который возвращает размер массива. Разработчики заметили, что вызов <code>array.size</code> приходится писать довольно часто, и решили от него избавиться. Вот что получилось:

 

 

Индекс <code>-2</code> значит «второй с конца элемент массива». Вот так и появилась отрицательная индексация. Теперь давайте разберёмся с диапазонами. Оказывается, в них тоже можно использовать отрицательную индексацию. Вот как можно получить все элементы массива кроме первого и последнего:

 

 

Или так:

 

 

Второй вариант с тремя точками, что автоматически приближает правую границу диапазона на одну позицию влево.

Для Ruby ''двумерный массив'' — это не более чем массив, содержащий одномерные массивы. Вот несколько примеров двумерных массивов:

 

[[1, 2], [3, 4]] # одинаковая длина

[["прива", "Привет"], ["пока", "Всего хорошего"]] # двумерный массив (классика)

 

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

В Ruby массивы динамические: в каждый конкретный момент времени неизвестно, сколько в нём элементов. Чтобы не плодить тайн подобного рода и был реализован метод <code>.size</code>:

 

 

Мы явно указали массив, но на его месте могла стоять переменная:

 

 

Метод <code>.size</code> есть у многих классов. Например, у ассоциативных массивов и строк. И даже у целых чисел.

Вспомните сколько усилий вам приходилось прилагать, чтобы найти максимальный элемент? А сколько раз вы повторяли этот кусок кода в своих программах? Ну а в Ruby поиск максимального элемента осуществляется при помощи метода <code>.max</code>, а в более сложных случаях при помощи метода <code>.max_by</code>. Вот как это выглядит:

 

 

Методы <code>.min</code> и <code>.min_by</code> работают аналогично:

 

 

Ну как? А в Ruby эти методы уже давно.

Чтобы упорядочить массив, нужно вызвать метод <code>.sort</code> или <code>.sort_by</code> (начиная с версии 1.8).

 

#=> ["была", "попа", "собака", "у"] сортировка по значению

["у", "попа", "была", "собака"].sort_by{ |elem| elem.size }

 

Для двумерных массивов:

#=> [[1, 0], [4, 0], [2, 1], [4, 5], [16, 6], [5, 6]] сортировка "внешних" элементов по значению "внутренних"

[[1,0], [16,6], [2,1], [4,5],[4,0],[5,6]].sort_by {|elem| elem[0]}

Остается только добавить, что массивы упорядочиваются по возрастанию. Если вам надо по убыванию, то придётся писать собственный метод [[w:Сортировка пузырьком|сортировки пузырьком]]. Шутка! По правде же, есть много способов выстроить массив по убыванию. Пока мы будем использовать метод <code>.reverse</code>, обращающий массив.

 

Для обращения массива существует метод <code>.reverse</code>. Применим его к предыдущим примерам, чтобы получить сортировку по убыванию:

 

["у", "попа", "была", "собака"].sort.reverse #=> ["у", "собака", "попа", "была"]

 

Метод <code>.reverse</code> мы просто прицепили в конец предыдущего примера. Так можно выстроить произвольную цепочку допустимых методов; выполняться они будут по очереди, начиная с самого левого, то есть самого первого в цепочке.

Для сложения массивов, строк и чисел используется метод <code>+</code>:

 

 

Плюс берёт массив справа и, будто это железнодорожный состав, прицепляет его к хвосту первого массива. Это называется [[w:Конкатенация|конкатенацией]].

Вычитаются массивы методом <code>-</code>, но происходит это сложнее, чем расцепление вагонов:

 

 

Из первого массива удаляются все элементы, имеющиеся во втором, независимо от их количества. Остальные элементы остаются без изменений, сохраняют относительные позиции.

Рассмотрим объединение множеств в действии:

 

 

Объединение получается вот так. Сначала массивы сцепляются:

 

 

Затем, начиная с первого вагона, инспектор идёт от вагона к вагону, удаляя элементы, которые уже встречались. После зачистки получается настоящее логическое объединение.

На деле это выглядит так:

 

 

Зачёркнутые числа — это удаленные элементы (дубликаты). Переходим от слов к делу:

 

 

При пересечении двух массивов, из первого удаляются все элементы, отсутствующие во втором. А из второго, отсутствующие в первом. При этом относительный порядок остающихся элементов первого массива сохраняется.

 

 

Всё просто. Важно лишь помнить, что <code>|</code> и <code>&</code> не изменяют ни первый, ни второй исходные массивы. Они через описанные процедуры создают новый массив. Чтобы тот не уехал от вас, нужно присвоить его; но не себе, а переменной, приготовленной слева от <code>=</code>.

Для удаления дубликатов (повторяющихся элементов массива) в Ruby используется метод <code>.uniq</code>:

 

 

Процесс зачистки массива от дубликатов такой же, как и в объединении.

 

 

Поэтому объединение массивов можно записать как

 

 

Но проще, конечно, объединять палкой.

Метод <code>.flatten</code> делает из многомерного массива простой, длинный одномерный массив. Он как бы расплющивает его. Например, чтобы найти в двумерном массиве наибольший элемент, мы сперва расплющим массив, а потом найдём максимум методом <code>.max</code>:

 

 

Расплющивание происходит в несколько этапов. Сначала происходит удаление всех квадратных скобок.

 

 

А потом, две квадратные скобки добавляются слева и справа. Но делать это надо быстро, чтобы элементы не успели разбежаться.

 

 

Вот и всё! У нас они разбежаться не успели. Повторите данное упражнение на других массивах (двумерных, трёхмерных и так далее).

Функцию удаления элементов <code>nil</code> массива выполняет метод <code>.compact</code> например:

 

 

==== [[w:Транспонированная матрица|Транспонирование]] двумерного массива ====

Задача: дан двумерный массив. Вывести одномерный массив с максимумами каждого из столбцов. Хм… посмотрим сперва, как эта задача решается для строчек, а не столбцов:

 

 

Метод <code>.map </code> — это итератор, который позволяет нам делать что-нибудь с каждым объектом, на который указывает массив. Подробнее о них ниже в этой главе.

Чтобы решить задачу в первоначальном варианте, нам надо лишь предварительно транспонировать массив (поменять местами строки и столбцы):

 

 

Метод <code>.transpose</code> как раз и занимается транспонированием. Это позволяет с лёгкостью решать задачи про столбцы приёмами, схожими с задачами про строки.

Речь пойдёт не о почковании, а о методе, который позволяет умножать массив на целое число. В результате такого умножения мы получим массив, состоящий из нескольких копий элементов исходного массива.

 

 

Того же самого эффекта можно добиться сцепив массив необходимое количество раз:

 

 

Заметили, что есть некоторая параллель с целыми числами? Умножение можно заменить сложением и наоборот!

Часто и во многих алгоритмах надо добавить элемент в конец массива:

 

array[array.size] = 6

 

И если уж добавили, то надо как-то его и удалить. Делается это примерно так:

 

 

Но как всегда, эти задачи возникали слишком часто и их решили реализовать в виде методов. Методы назвали <code>.push</code> («втолкнуть» в конец массива) и <code>.pop</code> («вытолкнуть» элемент из массива):

 

array = [1, 2, 3, 4, 5]

array.push(6)

array << 7 #=> [1, 2, 3, 4, 5, 6, 7], другой синтаксис

array.pop #=> 7

 

==== Функциональность очереди и списка ====

Чтобы можно было использовать массив в качестве [[w:Очередь (программирование)|очереди]] и/или [[w:Линейный список|списка]], потребуется сделать всего лишь пару методов. Первый из них добавляет элемент в начало массива, а второй удаляет элемент из начала. Давайте посмотрим, как это делается универсальными методами <code>[]</code>, <code>[]=</code> и <code>+</code>:

 

array = [1, 2, 3, 4, 5]

 

# удалим элемент из начала массива

array = array[1..-1]

 

Теперь посмотрим, какие методы реализуют точно такую же функциональность:

 

array = [1, 2, 3, 4, 5]

 

# удаляем из начала массива

array.shift #=> 6

 

Удаляющий метод — <code>.shift</code> («сдвинуть»), а метод, добавляющий элемент в начало массива, называется <code>.unshift</code> (непереводимое слово, означающее нечто противоположное «сдвинуть обратно»).

Мнемограмма для методов <code>.shift</code>, <code>.unshift</code>, <code>.pop</code> и <code>.push</code>:

 

[1, 2, 3, 4, 5]

 

Методы с параметром (сверху) добавляют элемент в массив, а методы без параметра (снизу) — удаляют. По желанию можно дорисовать стрелочки.

''Замечание.'' Имена методов <code>unshift</code>/<code>shift</code> неинтуитивны. Во-первых, они не напоминают о том, что работа идёт с головой массива, а не с хвостом, во-вторых ничего не говорят о том, идёт заполнение или опустошение стека. Можно создать для этих методов псевдонимы с говорящими именами, например, <code>feed</code>/<code>spit</code> (кормить/выплевывать):<br/>

 

alias feed :unshift

alias spit :shift

 

==== Создание своих классов, работающих как массивы ====

По японской традиции, имена логических методов принято заканчивать <code>?</code> (вопросительным знаком). Это позволяет также получить список логических методов, вызываемых в данном случае: просто отобрать из всех имеющихся методов те, что кончаются на <code>?</code>. Делается это при помощи небольшой вспомогательной программы:

 

 

Для удобства, можно упорядочить полученный список:

 

 

==== Есть ли элемент в массиве? ====

Как узнать, есть ли некоторый элемент в массиве? Попробуем решить эту задачу при помощи метода <code>.size</code> и итератора <code>.find_all</code>:

 

array = [1, 2, 3, 4, 5, 6, 7]

required = 5 # число, которое мы будем искать

array.find_all{ |elem| elem == required }.size != 0 #=> true

 

Использование связки из трёх методов (<code>!=</code>, <code>.find_all</code> и <code>.size</code>) для такой задачи — возмутительно! Разработчики не могли с этим долго мириться и реализовали метод специально для этой задачи. Имя ему — <code>.include?</code>. Перепишем нашу задачу, но на этот раз будем использовать правильный метод:

 

array = [1, 2, 3, 4, 5, 6, 7]

required = 5 # число, которое мы будем искать

array.include?(required) #=> true

 

Мутный горизонт скрывает берег,<br/>

Методом логическим <code>.include?</code>.

 

 

Опытным путём мы доказали, что акулы в озере не водятся.

Если вы хотите задать массиву вопрос «пуст ли ты?», но боитесь обидеть, то можете пойти окружным путём. Например, спросить у него: ты равен пустому массиву?

 

filled_array = [1, 2, 2, 3]

 

empty_array == [] #=> true

 

Ещё можно задать вопрос: твой размер равен нулю?

 

filled_array = [1, 2, 2, 3]

 

empty_array.size == 0 #=> true

 

Но наш вам совет: не стоит искать обходных путей. Спросите его напрямую: <code>.empty?</code> («пуст?»):

 

filled_array = [1, 2, 2, 3]

 

empty_array.empty? #=> true

 

==== И наоборот ====

В Ruby принято избегать отрицания условия. Например, если вам нужно сделать что-то, если массив ''не пуст'', можно воспользоваться методом, обратным <code>empty?</code>. Этот метод называется <code>any?</code>.

 

array.length > 0 #=> true

array.empty? #=> false

 

=== Итераторы ===

Изменить все элементы массива можно по-всякому. Начнём с обнуления:

 

 

В приведенном примере каждый элемент массива будет заменён нулем независимо от того, чем является этот элемент. Например, при попытке обнулить таким образом двумерный массив <code>[[1, 2], [3, 4]]</code>, в результате получим <code>[0, 0]</code>.

Можно дать элементу <code>.map</code> иное задание. Для этого зажимаем в фигурные скобы замыкания иной код:

 

 

Прежде, чем замыканию выдать квадрат очередного элемента, ему нужно знать этот элемент. Итератор <code>.map</code> даёт ему значение элемента, словно фотографию, обрамлённую слева и справа вертикальными чертами <code>|</code>. Чтобы замыкание смогло взять эту фотографию, обязательно нужно дать ей имя. В нашем случае это <code>elem</code>, но подходят и такие названия:

То имя, что показывается в раздвижных дверях, — это не сам элемент, это лишь его копия. Фотография. Голограмма. Это даже не другая переменная, это не переменная вообще. Бессмысленно присваивать новое значение фотографии:

 

array.map{ |elem| elem = elem**2 }

 

Из итератора <code>.map</code> выезжает другой поезд, у которого вместо соответствующего элемента первого поезда сидит результат вычисления замыкания. Используйте этот массив как-нибудь, иначе поезд уедет.

 

array.map{ |elem| elem**2 } #=> [1, 4, 9, 16, 25]

 

Можно присвоить его новой переменной <code>array_of_squares</code>. А можно заместить им существующую переменную <code>array</code>:

 

array = array.map{ |elem| elem**2 } #=> [1, 4, 9, 16, 25]

 

Это общее явление Ruby: методы (здесь — итераторы) не меняют объект (массив), с которым работают. Они лишь выдают результат, который потом можно использовать как аргумент или присвоить переменной.

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

 

array.map!{ |elem| elem**2 } #=> [1, 4, 9, 16, 25]

 

Такой приём работает и с многими другими методами в языке, которые только возвращают результат своего выполнения. Однако при использовании цепочек методов каждый должен быть с восклицательным знаком, иначе разорвётся цепочка копирований.

 

array = [1, 2, 3, 4, 5, nil]

array.compact.map!{ |elem| elem**2 } #=> [1, 4, 9, 16, 25]

array #=> [1, 2, 3, 4, 5, nil]

array.compact!.map!{ |elem| elem**2 } #=> [1, 4, 9, 16, 25]

 

В первом случае операция .compact создала копию массива, тогда как .compact! заменила первоначальные значения результатами, полученными от .map!

Вот как итератор <code>.find_all</code> выберет из массива все чётные элементы:

 

 

<code>elem % 2 == 0</code> — это вопрос «чётен ли <code>elem</code>?». Ответом, как всегда, будет <code>true</code> или <code>false</code>. Ведь «чётность» — это равенство нулю (<code>== 0</code>) остатка деления (<code>%</code>) на <code>2</code>.

Кстати, равенство нулю можно проверять и при помощи метода <code>.zero?</code>. А чётность тоже можно проверить разными способами:

 

(elem & 1).zero?

 

Если на вопрос, заданный в замыкании, ответ <code>true</code>, то <code>|elem|</code> (значение очередного элемента исходного массива), заносится в новый массив, который в итоге будет выводом из итератора <code>.find_all</code>.

Рассмотрим феномен, который мы наблюдали уже в итераторе <code>.map</code>:

 

array = [1, 2, 3, 4, 5]

array.find_all{ |elem| elem[0].zero? } #=> [2, 4]

 

{{info|Итератор <code>.find_all</code> лишь создаёт новый массив на базе старого. Он не изменяет исходный массив. Чтобы сохранить результат работы <code>.find_all</code>, надо его присвоить какой либо переменной.}}

Вот как будет выглядеть программа без феномена:

 

array = [1, 2, 3, 4, 5]

array = array.find_all{ |elem| elem[0].zero? } #=> [2, 4]

 

Если нужно элементы<br/>

Также есть методы <code>.odd?</code> и <code>.even?</code> для более наглядной реализации таких вещей, нечетный и четный соответственно.

 

 

==== Суммирование/произведение/агрегация элементов ====

Очень часто возникает задача найти сумму/произведение всех элементов массива. Для этих целей традиционно используется итератор <code>.inject</code>. Для демонстрации его работы, давайте найдем сумму элементов массива:

 

 

Рассмотрим все по порядку. Начнём с нуля. Его следует расшифровывать как <code>result = 0</code> перед началом работы итератора, то есть это начальное значение переменной <code>result</code> (переменной промежуточного результата).

Учитывая эти два замечания, напишем код, который является неправильным:

 

 

Имена переменных <code>result</code> и <code>elem</code> созданы богатым воображением автора. В ваших программах они могут называться иначе.

Для полноты картины решим ещё одну задачку. На этот раз будем искать произведение всех элементов массива:

 

 

А вот так можем вычислить факториал для заданного числа (n!):

 

 

Чтобы закрепить материал, решите задачу: найти произведение всех положительных элементов массива. Подсказка: используйте метод <code>.find_all</code>.

Итератор <code>.partition</code> делит массив на две части по некоторому бинарному признаку (чётности, положительности, наличию высшего образования и тому подобным). Вот как разделить массив на две части по признаку кратности трём:

 

 

В результате работы итератора получился массив, состоящий из двух элементов-массивов. Первый элемент-массив содержит все элементы, которые удовлетворяют условию, а второй, которые не удовлетворяют. Обратите внимание, как проверяется кратность трём. Ничего не напоминает? Например, итератор <code>.find_all</code>? Нет? Ну и ладно.

Есть интересная хитрость, позволяющая разместить массив, полученный <code>.partition</code>, в две разные переменные:

 

array = [1, 2, 3, 4, 5, 6, 7, 8, 9]

one, two = array.partition{ |x| (x % 3).zero? }

one #=> [3, 6, 9]

 

Этот метод называется ''множественным присваиванием'' (multiple assignment) и широко используется в ситуациях, когда из метода надо вернуть более одного значения. Но об этом позднее.

В [[w:Математическая логика|математической логике]] такой «итератор» называется [[w:Квантор|квантором]] общности, обозначается символом <math>\forall</math>. На языке Ruby он называется <code>.all?</code>. По сложившейся традиции, давайте посмотрим, как решалась бы эта задача до версии 1.8, то есть до появления логических итераторов:

 

array = [1, 2, 2, 3]

 

В примере используется так называемый механизм презумпции виновности. Переменной <code>result</code> присваивается значение <code>true</code>. Логическое умножение изменяет значение переменной <code>result</code> на <code>false</code>.

Ещё один вариант решения той же задачи:

 

 

Давайте решим эту же задачу при помощи новоявленного логического итератора:

 

 

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

Вслед за квантором общности (он же — логический итератор <code>.all?</code>), из математической логики был перенесён и квантор существования — <math>\exists</math>. На языке Ruby он называется <code>.any?</code>. Чтобы оценить его по достоинству, посмотрим решение задачи без его участия. Проверим, содержит ли <code>array</code> хотя бы один элемент больший двух:

 

 

В данном примере используется так называемый механизм презумпции невиновности. Переменной <code>result</code> присваивается значение <code>false</code>. В результате логического сложения, происходит изменение значения переменной <code>result</code> на <code>true</code>.

Теперь тоже самое, но через логический итератор <code>.any?</code>:

 

 

Естественно, что с появлением логических итераторов, реализация задач математической логики (в рамках языка Ruby) стала удобней.

Вот так можно сгенерировать «хороший пароль» — произвольную последовательность из чисел или латинских букв, общей длиной в 8 символов.

 

 

Метод sample возвращает случайный элемент из массива.

Перемешать упорядоченный массив:

 

 

Выстроить элементы массива по убыванию без использования <code>.reverse</code>:

 

 

=== Задачи про массивы ===