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

Вопрос 1 из 20

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

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

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

Вопрос 2 из 20

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

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

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

Вопрос 3 из 20

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

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

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

Вопрос 4 из 20

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

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

Вопрос 5 из 20

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

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

Вопрос 6 из 20

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

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

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

Вопрос 7 из 20

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

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

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

Вопрос 8 из 20

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

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

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

Вопрос 9 из 20

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

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

Вопрос 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("/"))

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

Вопрос 12 из 20

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

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

Вопрос 13 из 20

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

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

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

Вопрос 14 из 20

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

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

Вопрос 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)

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

Вопрос 17 из 20

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

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

Вопрос 18 из 20

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

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

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

Вопрос 19 из 20

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

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

Вопрос 20 из 20

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

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