Неизменяемые коллекции — бесплатный тест онлайн

Вопрос 1 из 20

Какой вывод о теме «List и Vector» можно сделать без дополнительных допущений?

val xs = List(1,2,3)
val ys = 0 :: xs
println(ys.tail == xs)

У всех реализаций `Seq` одинаковая стоимость доступа по индексу и добавления в конец, поскольку интерфейс скрывает структуру данных. Стоимость операции зависит от структуры: у `List` доступ по индексу линейный, а `head` и добавление через `::` — постоянные. Итератор, полученный из файла или соединения, не зависит от срока жизни ресурса, если его тип не содержит ссылку на ресурс. Неизменяемые `Map` и `Set` возвращают новое значение после добавления или удаления; исходная коллекция остаётся доступной без изменений. `List` оптимальна для добавления и снятия элемента с головы, а `Vector` даёт более ровный доступ и обновление по индексу.

Вопрос 2 из 20

Для темы «List и Vector» какое последствие нельзя исключить одним успешным запуском?

// Дополнительный контекст: Тот же алгоритм запустили на большом наборе и попытались использовать полученный обход повторно.
val xs = List(1,2,3)
val ys = 0 :: xs
println(ys.tail == xs)

Частое добавление в конец `List` через `:+` приводит к повторным проходам и квадратичной работе на растущем наборе. Цепочка из многих промежуточных коллекций может дать лишние выделения памяти, хотя логика остаётся корректной. Добавление в конец `List` через `:+` остаётся постоянным по времени даже при последовательном накоплении тысяч элементов. Игнорирование результата `updated` или `+` создаёт видимость изменения, хотя фактически новое значение потеряно. Преобразование в `List` на каждом шаге уменьшает выделения памяти, поскольку промежуточные списки переиспользуют общий буфер.

Вопрос 3 из 20

При исправлении темы «List и Vector» какая правка сохраняет полезную семантику и не расширяет обещания API?

val xs = List(1,2,3)
val ys = 0 :: xs
println(ys.tail == xs)
// На ревью требуется устранить причину дефекта, не скрывая её приведением типа или значением по умолчанию.

Сначала добивайтесь ясности, затем измеряйте; для длинной цепочки над большим набором рассмотрите `view` или `iterator`. Всегда присваивайте результат преобразования или возвращайте его из функции; имя старой версии сохраняйте, если оно ещё нужно. Выбирайте коллекцию по доминирующей операции; для накопления списка добавляйте в голову и разворачивайте либо используйте builder. Заменить конкретную коллекцию на общий `Seq`, не измеряя операции: интерфейс сам выберет наиболее быструю реализацию. Для накопления большого `List` последовательно применять `:+`: компилятор распознает шаблон и заменит его builder-ом.

Вопрос 4 из 20

В контракте темы «List и Vector» локальный пример стал частью более крупной системы. Какая трактовка контракта остаётся полной?

Стоимость операции зависит от структуры: у `List` доступ по индексу линейный, а `head` и добавление через `::` — постоянные. Учитывать границу: частое добавление в конец `List` через `:+` приводит к повторным проходам и квадратичной работе на растущем наборе. Неизменяемые `Map` и `Set` возвращают новое значение после добавления или удаления; исходная коллекция остаётся доступной без изменений. Учитывать границу: цепочка из многих промежуточных коллекций может дать лишние выделения памяти, хотя логика остаётся корректной. `List` оптимальна для добавления и снятия элемента с головы, а `Vector` даёт более ровный доступ и обновление по индексу. Учитывать границу: игнорирование результата `updated` или `+` создаёт видимость изменения, хотя фактически новое значение потеряно. `List` оптимальна для добавления и снятия элемента с головы, а `Vector` даёт более ровный доступ и обновление по индексу. Учитывать границу: если код компилируется, дополнительные проверки вывода типов и поиска `given` не нужны. `List` оптимальна для добавления и снятия элемента с головы, а `Vector` даёт более ровный доступ и обновление по индексу. Учитывать границу: частое добавление в конец `List` через `:+` приводит к повторным проходам и квадратичной работе на растущем наборе.

Вопрос 5 из 20

При проверке темы «List и Vector» какой пункт следует добавить в критерии приёмки изменения?

Выбирайте коллекцию по доминирующей операции; для накопления списка добавляйте в голову и разворачивайте либо используйте builder. В проверке воспроизвести ситуацию: частое добавление в конец `List` через `:+` приводит к повторным проходам и квадратичной работе на растущем наборе. Выбирайте коллекцию по доминирующей операции; для накопления списка добавляйте в голову и разворачивайте либо используйте builder. В проверке воспроизвести ситуацию: игнорирование результата `updated` или `+` создаёт видимость изменения, хотя фактически новое значение потеряно. Всегда присваивайте результат преобразования или возвращайте его из функции; имя старой версии сохраняйте, если оно ещё нужно. В проверке воспроизвести ситуацию: частое добавление в конец `List` через `:+` приводит к повторным проходам и квадратичной работе на растущем наборе. `List` оптимальна для добавления и снятия элемента с головы, а `Vector` даёт более ровный доступ и обновление по индексу. Запустить пример один раз и не проверять порядок событий. В теме «List и Vector» исправить один показанный вызов по рекомендации «Сначала добивайтесь ясности, затем измеряйте; для длинной цепочки над большим набором рассмотрите `view` или `iterator`». Общий контракт и прежнюю границу отдельно не воспроизводить.

Вопрос 6 из 20

В теме «Map и Set» код компилируется и запускается. Какое утверждение о его контракте остаётся верным?

val m1 = Map("a" -> 1)
val m2 = m1.updated("a", 2)
println(m1("a") -> m2("a"))

У всех реализаций `Seq` одинаковая стоимость доступа по индексу и добавления в конец, поскольку интерфейс скрывает структуру данных. `List` оптимальна для добавления и снятия элемента с головы, а `Vector` даёт более ровный доступ и обновление по индексу. Операции `updated`, `map` и `filter` меняют исходную неизменяемую коллекцию, если результат вызова не присвоен новому имени. `Map`, `filter`, `collect` и `flatMap` создают преобразованный результат и не меняют исходную неизменяемую коллекцию. Неизменяемые `Map` и `Set` возвращают новое значение после добавления или удаления; исходная коллекция остаётся доступной без изменений.

Вопрос 7 из 20

Для темы «Map и Set» какой пограничный случай относится к контракту, а не только к стилю записи?

// Дополнительный контекст: Коллекцию заменили другой реализацией `Seq`, не меняя вызывающий код.
val m1 = Map("a" -> 1)
val m2 = m1.updated("a", 2)
println(m1("a") -> m2("a"))

Игнорирование результата `updated` безопасно: новая версия коллекции сохраняется внутри старого объекта до следующего обращения. Игнорирование результата `updated` или `+` создаёт видимость изменения, хотя фактически новое значение потеряно. Длинная цепочка над `view` не может повторить побочный эффект, потому что ленивый результат вычисляется ровно один раз. Цепочка из многих промежуточных коллекций может дать лишние выделения памяти, хотя логика остаётся корректной. Частое добавление в конец `List` через `:+` приводит к повторным проходам и квадратичной работе на растущем наборе.

Вопрос 8 из 20

При исправлении темы «Map и Set» что здесь лучше исправить до объединения изменений?

val m1 = Map("a" -> 1)
val m2 = m1.updated("a", 2)
println(m1("a") -> m2("a"))
// На ревью требуется устранить причину дефекта, не скрывая её приведением типа или значением по умолчанию.

Всегда присваивайте результат преобразования или возвращайте его из функции; имя старой версии сохраняйте, если оно ещё нужно. Сначала добивайтесь ясности, затем измеряйте; для длинной цепочки над большим набором рассмотрите `view` или `iterator`. Выбирайте коллекцию по доминирующей операции; для накопления списка добавляйте в голову и разворачивайте либо используйте builder. Хранить один `Iterator` в поле и выдавать его каждому потребителю, чтобы не создавать новые обходы. Для накопления большого `List` последовательно применять `:+`: компилятор распознает шаблон и заменит его builder-ом.

Вопрос 9 из 20

В контракте темы «Map и Set» условия эксплуатации изменились, но синтаксис остался прежним. Что теперь важно удержать вместе?

Опираться на семантику «неизменяемые `Map` и `Set` возвращают новое значение после добавления или удаления; исходная коллекция остаётся доступной без изменений», но отдельно проверять ограничение «штатный пример доказывает корректность порядка событий при любой нагрузке». Опираться на семантику «`List` оптимальна для добавления и снятия элемента с головы, а `Vector` даёт более ровный доступ и обновление по индексу», но отдельно проверять ограничение «игнорирование результата `updated` или `+` создаёт видимость изменения, хотя фактически новое значение потеряно». Опираться на семантику «неизменяемые `Map` и `Set` возвращают новое значение после добавления или удаления; исходная коллекция остаётся доступной без изменений», но отдельно проверять ограничение «игнорирование результата `updated` или `+` создаёт видимость изменения, хотя фактически новое значение потеряно». Опираться на семантику «`map`, `filter`, `collect` и `flatMap` создают преобразованный результат и не меняют исходную неизменяемую коллекцию», но отдельно проверять ограничение «частое добавление в конец `List` через `:+` приводит к повторным проходам и квадратичной работе на растущем наборе». Опираться на семантику «неизменяемые `Map` и `Set` возвращают новое значение после добавления или удаления; исходная коллекция остаётся доступной без изменений», но отдельно проверять ограничение «цепочка из многих промежуточных коллекций может дать лишние выделения памяти, хотя логика остаётся корректной».

Вопрос 10 из 20

При проверке темы «Map и Set» что поможет соседнему модулю не повторить ту же ошибку?

Выбирайте коллекцию по доминирующей операции; для накопления списка добавляйте в голову и разворачивайте либо используйте builder. В проверке воспроизвести ситуацию: игнорирование результата `updated` или `+` создаёт видимость изменения, хотя фактически новое значение потеряно. Всегда присваивайте результат преобразования или возвращайте его из функции; имя старой версии сохраняйте, если оно ещё нужно. В проверке воспроизвести ситуацию: игнорирование результата `updated` или `+` создаёт видимость изменения, хотя фактически новое значение потеряно. Неизменяемые `Map` и `Set` возвращают новое значение после добавления или удаления; исходная коллекция остаётся доступной без изменений. Проверить только новую реализацию, не воспроизводя прежний дефект. В теме «Map и Set» исправить один показанный вызов по рекомендации «Сначала добивайтесь ясности, затем измеряйте; для длинной цепочки над большим набором рассмотрите `view` или `iterator`». Общий контракт и прежнюю границу отдельно не воспроизводить. Всегда присваивайте результат преобразования или возвращайте его из функции; имя старой версии сохраняйте, если оно ещё нужно. В проверке воспроизвести ситуацию: цепочка из многих промежуточных коллекций может дать лишние выделения памяти, хотя логика остаётся корректной.

Вопрос 11 из 20

В теме «Преобразования» на ревью спорят о причине наблюдаемого результата. Какое объяснение корректно?

val result = List(1,2,3,4).filter(_ % 2 == 0).map(_ * 10)
println(result.mkString("/"))

Операции `updated`, `map` и `filter` меняют исходную неизменяемую коллекцию, если результат вызова не присвоен новому имени. `List` оптимальна для добавления и снятия элемента с головы, а `Vector` даёт более ровный доступ и обновление по индексу. `Map`, `filter`, `collect` и `flatMap` создают преобразованный результат и не меняют исходную неизменяемую коллекцию. Неизменяемые `Map` и `Set` возвращают новое значение после добавления или удаления; исходная коллекция остаётся доступной без изменений. `View` вычисляет всю цепочку при создании и кеширует результат, поэтому повторное чтение не запускает функции снова.

Вопрос 12 из 20

Для темы «Преобразования» тот же алгоритм запустили на большом наборе и попытались использовать полученный обход повторно. Какой дефект остаётся возможным при корректном синтаксисе?

Преобразование в `List` на каждом шаге уменьшает выделения памяти, поскольку промежуточные списки переиспользуют общий буфер. Игнорирование результата `updated` или `+` создаёт видимость изменения, хотя фактически новое значение потеряно. Цепочка из многих промежуточных коллекций может дать лишние выделения памяти, хотя логика остаётся корректной. Длинная цепочка над `view` не может повторить побочный эффект, потому что ленивый результат вычисляется ровно один раз. Частое добавление в конец `List` через `:+` приводит к повторным проходам и квадратичной работе на растущем наборе.

Вопрос 13 из 20

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

val result = List(1,2,3,4).filter(_ % 2 == 0).map(_ * 10)
println(result.mkString("/"))
// На ревью требуется устранить причину дефекта, не скрывая её приведением типа или значением по умолчанию.

Хранить один `Iterator` в поле и выдавать его каждому потребителю, чтобы не создавать новые обходы. Всегда присваивайте результат преобразования или возвращайте его из функции; имя старой версии сохраняйте, если оно ещё нужно. Использовать `lazy val` для любого дорогого вычисления, не проверяя срок жизни результата и объём удерживаемых объектов. В горячем участке проверяйте фактический тип коллекции и сложность используемых операций, а не только удобство метода. Сначала добивайтесь ясности, затем измеряйте; для длинной цепочки над большим набором рассмотрите `view` или `iterator`.

Вопрос 14 из 20

В контракте темы «Преобразования» какое решение не превращает частный успешный случай в общее обещание?

Опираться на семантику «неизменяемые `Map` и `Set` возвращают новое значение после добавления или удаления; исходная коллекция остаётся доступной без изменений», но отдельно проверять ограничение «цепочка из многих промежуточных коллекций может дать лишние выделения памяти, хотя логика остаётся корректной». Опираться на семантику «`map`, `filter`, `collect` и `flatMap` создают преобразованный результат и не меняют исходную неизменяемую коллекцию», но отдельно проверять ограничение «успешная обработка одного значения подтверждает совместимость всех вариантов модели». Опираться на семантику «`map`, `filter`, `collect` и `flatMap` создают преобразованный результат и не меняют исходную неизменяемую коллекцию», но отдельно проверять ограничение «цепочка из многих промежуточных коллекций может дать лишние выделения памяти, хотя логика остаётся корректной». Опираться на семантику «`List` оптимальна для добавления и снятия элемента с головы, а `Vector` даёт более ровный доступ и обновление по индексу», но отдельно проверять ограничение «частое добавление в конец `List` через `:+` приводит к повторным проходам и квадратичной работе на растущем наборе». Опираться на семантику «`map`, `filter`, `collect` и `flatMap` создают преобразованный результат и не меняют исходную неизменяемую коллекцию», но отдельно проверять ограничение «игнорирование результата `updated` или `+` создаёт видимость изменения, хотя фактически новое значение потеряно».

Вопрос 15 из 20

При проверке темы «Преобразования» какой контроль остаётся полезным после рефакторинга и переименования кода?

`Map`, `filter`, `collect` и `flatMap` создают преобразованный результат и не меняют исходную неизменяемую коллекцию. Ограничиться ручным запуском без автоматической регрессии. В теме «Преобразования» исправить один показанный вызов по рекомендации «Всегда присваивайте результат преобразования или возвращайте его из функции; имя старой версии сохраняйте, если оно ещё нужно». Общий контракт и прежнюю границу отдельно не воспроизводить. Сначала добивайтесь ясности, затем измеряйте; для длинной цепочки над большим набором рассмотрите `view` или `iterator`. В проверке воспроизвести ситуацию: цепочка из многих промежуточных коллекций может дать лишние выделения памяти, хотя логика остаётся корректной. Сначала добивайтесь ясности, затем измеряйте; для длинной цепочки над большим набором рассмотрите `view` или `iterator`. В проверке воспроизвести ситуацию: игнорирование результата `updated` или `+` создаёт видимость изменения, хотя фактически новое значение потеряно. В горячем участке проверяйте фактический тип коллекции и сложность используемых операций, а не только удобство метода. В проверке воспроизвести ситуацию: цепочка из многих промежуточных коллекций может дать лишние выделения памяти, хотя логика остаётся корректной.

Вопрос 16 из 20

Какая характеристика конструкции «Стоимость операций» подтверждается показанным фрагментом?

val xs = (1 to 1000).toList
val first = xs.head
val last = xs(999)
println(first + last)

У всех реализаций `Seq` одинаковая стоимость доступа по индексу и добавления в конец, поскольку интерфейс скрывает структуру данных. Стоимость операции зависит от структуры: у `List` доступ по индексу линейный, а `head` и добавление через `::` — постоянные. `List` оптимальна для добавления и снятия элемента с головы, а `Vector` даёт более ровный доступ и обновление по индексу. `Map`, `filter`, `collect` и `flatMap` создают преобразованный результат и не меняют исходную неизменяемую коллекцию. Операции `updated`, `map` и `filter` меняют исходную неизменяемую коллекцию, если результат вызова не присвоен новому имени.

Вопрос 17 из 20

Для темы «Стоимость операций» что здесь требует отдельного теста или компиляционного примера?

Одного обычного запуска недостаточно, поскольку после `sum`, `toList` или другого терминального обхода исходный `Iterator` возвращается в начало. Одного обычного запуска недостаточно, поскольку преобразование в `List` на каждом шаге уменьшает выделения памяти, поскольку промежуточные списки переиспользуют общий буфер. Одного обычного запуска недостаточно, поскольку игнорирование результата `updated` или `+` создаёт видимость изменения, хотя фактически новое значение потеряно. Одного обычного запуска недостаточно, поскольку общий интерфейс `Seq` не гарантирует одинаковую сложность операций у разных реализаций. Одного обычного запуска недостаточно, поскольку цепочка из многих промежуточных коллекций может дать лишние выделения памяти, хотя логика остаётся корректной.

Вопрос 18 из 20

При исправлении темы «Стоимость операций» нужно устранить причину, а не замаскировать симптом. Какое изменение подходит лучше?

val xs = (1 to 1000).toList
val first = xs.head
val last = xs(999)
println(first + last)
// На ревью требуется устранить причину дефекта, не скрывая её приведением типа или значением по умолчанию.

В горячем участке проверяйте фактический тип коллекции и сложность используемых операций, а не только удобство метода. Заменить конкретную коллекцию на общий `Seq`, не измеряя операции: интерфейс сам выберет наиболее быструю реализацию. Для накопления большого `List` последовательно применять `:+`: компилятор распознает шаблон и заменит его builder-ом. Сначала добивайтесь ясности, затем измеряйте; для длинной цепочки над большим набором рассмотрите `view` или `iterator`. Всегда присваивайте результат преобразования или возвращайте его из функции; имя старой версии сохраняйте, если оно ещё нужно.

Вопрос 19 из 20

В контракте темы «Стоимость операций» после изменения окружения команда пересматривает контракт. Какой вариант корректен?

Стоимость операции зависит от структуры: у `List` доступ по индексу линейный, а `head` и добавление через `::` — постоянные. Пограничный сценарий: результат одного измерения можно считать устойчивой характеристикой производительности. Стоимость операции зависит от структуры: у `List` доступ по индексу линейный, а `head` и добавление через `::` — постоянные. Пограничный сценарий: цепочка из многих промежуточных коллекций может дать лишние выделения памяти, хотя логика остаётся корректной. `List` оптимальна для добавления и снятия элемента с головы, а `Vector` даёт более ровный доступ и обновление по индексу. Пограничный сценарий: общий интерфейс `Seq` не гарантирует одинаковую сложность операций у разных реализаций. Стоимость операции зависит от структуры: у `List` доступ по индексу линейный, а `head` и добавление через `::` — постоянные. Пограничный сценарий: общий интерфейс `Seq` не гарантирует одинаковую сложность операций у разных реализаций. `Map`, `filter`, `collect` и `flatMap` создают преобразованный результат и не меняют исходную неизменяемую коллекцию. Пограничный сценарий: игнорирование результата `updated` или `+` создаёт видимость изменения, хотя фактически новое значение потеряно.

Вопрос 20 из 20

При проверке темы «Стоимость операций» какая проверка связывает принятую правку с реальной границей решения?

Сначала добивайтесь ясности, затем измеряйте; для длинной цепочки над большим набором рассмотрите `view` или `iterator`. В проверке воспроизвести ситуацию: общий интерфейс `Seq` не гарантирует одинаковую сложность операций у разных реализаций. Стоимость операции зависит от структуры: у `List` доступ по индексу линейный, а `head` и добавление через `::` — постоянные. Проверить один объект и не рассматривать разделяемое состояние. В горячем участке проверяйте фактический тип коллекции и сложность используемых операций, а не только удобство метода. В проверке воспроизвести ситуацию: общий интерфейс `Seq` не гарантирует одинаковую сложность операций у разных реализаций. В горячем участке проверяйте фактический тип коллекции и сложность используемых операций, а не только удобство метода. В проверке воспроизвести ситуацию: цепочка из многих промежуточных коллекций может дать лишние выделения памяти, хотя логика остаётся корректной. В теме «Стоимость операций» исправить один показанный вызов по рекомендации «Всегда присваивайте результат преобразования или возвращайте его из функции; имя старой версии сохраняйте, если оно ещё нужно». Общий контракт и прежнюю границу отдельно не воспроизводить.