Краткий ответ

Она зависит от конкретного типа коллекции, а не только от протокола Collection. Для RandomAccessCollection переход по смещению и вычисление расстояния между индексами гарантированно имеют константную сложность, тогда как для обычного Collection такой переход может последовательно пройти несколько элементов и занять O(n).

Исторический контекст

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

Такое обобщение решает проблему универсального обхода, но скрывает стоимость операций. Поэтому Swift использует уточняющие протоколы: BidirectionalCollection добавляет движение назад, а RandomAccessCollection сообщает, что движение и вычисление расстояния не зависят от числа пропускаемых элементов.

Постановка проблемы

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

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

Подробное решение

Метод index(_:offsetBy:) перемещает индекс на заданное число позиций. Для произвольного Collection реализация может выполнять переход по одному элементу за шаг, поэтому смещение на k позиций может стоить O(k). Метод distance(from:to:) имеет аналогичное ограничение: без гарантии случайного доступа он может последовательно подсчитывать элементы.

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

func element<C: Collection>(at offset: Int, in collection: C) -> C.Element? {
    guard offset >= 0 else { return nil }
    guard let index = collection.index(
        collection.startIndex,
        offsetBy: offset,
        limitedBy: collection.endIndex
    ), index != collection.endIndex else {
        return nil
    }
    return collection[index]
}

Функция корректна для любой коллекции, но её производительность зависит от фактического типа. Если она вызывается много раз с возрастающими смещениями, для обычного Collection возможен повторный проход от начала; итеративное продвижение одного сохранённого индекса обычно устраняет эту проблему. Преобразование к массиву может дать быстрый случайный доступ, но потребует дополнительной памяти и времени на копирование элементов.

Ситуация из практики

Сервис получает коллекцию результатов и должен обработать элементы с фиксированным шагом. Первый вариант для обобщённого Collection каждый раз вычисляет индекс от startIndex с новым большим смещением. Для массива это обычно эффективно, но для коллекции без случайного доступа может привести к квадратичному числу шагов.

Рассматривались два решения. Преобразование в массив упрощает доступ и даёт предсказуемую стоимость индексации, но увеличивает потребление памяти. Повторный вызов перехода от начала не требует памяти, однако плохо масштабируется.

Выбран последовательный обход с одним текущим индексом: он использует O(1) дополнительной памяти и не посещает уже обработанные элементы повторно. Если бизнес-логике действительно нужен произвольный доступ к элементам, коллекцию заранее материализуют в массив и явно принимают стоимость этого решения.

Что кандидаты часто упускают

Вопрос: Гарантирует ли тип параметра Collection, что его индексы можно складывать и вычитать как целые числа?

Ответ: Нет. Индекс — это отдельный тип, определённый коллекцией; он может кодировать позицию в строке, узел структуры или внутреннее состояние обхода. Для перемещения нужно использовать методы коллекции, например index(_:offsetBy:), а не арифметику над предполагаемым целочисленным индексом.
Вопрос: Что меняется, если обобщённый параметр ограничить протоколом RandomAccessCollection?

Ответ: Функция сможет опираться на константную сложность перемещения индексов и вычисления расстояния. Это не означает, что сама обработка элемента всегда дёшева, но позволяет строить алгоритмы бинарного поиска, разбиения и произвольной выборки без скрытого линейного обхода.
Вопрос: Зачем нужен вариант index(_:offsetBy:limitedBy:), если границы можно проверить отдельно?

Ответ: Он ограничивает перемещение заданным индексом и возвращает nil, если движение должно пересечь этот предел. Это позволяет безопасно выполнять переход в обобщённом коде, не предполагая, что смещение находится внутри коллекции; отдельная проверка числа элементов не всегда достаточна, особенно когда операция выполняется в обратном направлении или коллекция имеет нетривиальные индексы.