Таблицы как универсальная структура — бесплатный тест онлайн

Вопрос 1 из 20

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

local a = {10, 20, nil, 40}
print(#a, a[4])

Наблюдаемый результат в разделе «Массивная часть» опирается на правило: Добавление и удаление ключей во время pairs может привести к пропускам или неожиданному обходу. Наблюдаемый результат в разделе «Массивная часть» опирается на правило: Безопаснее сначала собрать изменения либо обходить устойчивый список ключей. Наблюдаемый результат в разделе «Массивная часть» опирается на правило: Требуемый порядок нужно задавать отдельно. Наблюдаемый результат в разделе «Массивная часть» опирается на правило: Последовательная часть таблицы обычно использует целые ключи от 1. Наблюдаемый результат в разделе «Массивная часть» опирается на правило: Ключом таблицы может быть любое значение кроме nil и NaN.

Вопрос 2 из 20

Что следует изменить во входе, чтобы проверить скрытое ограничение? Ищется граничное следствие правила из раздела «Массивная часть».

local function reproduce_case()
  local a = {10, 20, nil, 40}
  print(#a, a[4])
end
reproduce_case()

Второй запуск раздела «Массивная часть» нужен, чтобы увидеть: Ключом таблицы может быть любое значение кроме nil и NaN; числа 1 и 1.0 обозначают один ключ там, где они равны, а изменяемое содержимое таблицы не влияет на её идентичность как ключа. Второй запуск раздела «Массивная часть» нужен, чтобы увидеть: Добавление и удаление ключей во время pairs может привести к пропускам или неожиданному обходу; безопаснее сначала собрать изменения либо обходить устойчивый список ключей. Второй запуск раздела «Массивная часть» нужен, чтобы увидеть: Последовательная часть таблицы обычно использует целые ключи от 1; оператор # определён надёжно только для последовательности без дыр, поэтому nil посередине делает длину неоднозначной. Второй запуск раздела «Массивная часть» нужен, чтобы увидеть: Числа 1 и 1.0 обозначают один ключ там, где они равны, а изменяемое содержимое таблицы не влияет на её идентичность как ключа. Второй запуск раздела «Массивная часть» нужен, чтобы увидеть: pairs не обещает порядок обхода, ipairs идёт по целым индексам от 1 до первого отсутствующего значения; требуемый порядок нужно задавать отдельно.

Вопрос 3 из 20

Что здесь является частью контракта, а не случайностью текущей записи? Нужен основной контракт раздела «Массивная часть».

do
  local a = {10, 20, nil, 40}
  print(#a, a[4])
end

Новая реализация раздела «Массивная часть» обязана соблюдать: Ключом таблицы может быть любое значение кроме nil и NaN. Новая реализация раздела «Массивная часть» обязана соблюдать: Последовательная часть таблицы обычно использует целые ключи от 1. Новая реализация раздела «Массивная часть» обязана соблюдать: Добавление и удаление ключей во время pairs может привести к пропускам или неожиданному обходу. Новая реализация раздела «Массивная часть» обязана соблюдать: Требуемый порядок нужно задавать отдельно. Новая реализация раздела «Массивная часть» обязана соблюдать: Безопаснее сначала собрать изменения либо обходить устойчивый список ключей.

Вопрос 4 из 20

Код по разделу «Массивная часть» уходит в эксплуатацию. Какое ограничение нельзя прятать внутри реализации? Выберите практическое следствие раздела «Массивная часть».

Код и тесты раздела «Массивная часть» должны выражать правило: Добавление и удаление ключей во время pairs может привести к пропускам или неожиданному обходу; безопаснее сначала собрать изменения либо обходить устойчивый список ключей. Код и тесты раздела «Массивная часть» должны выражать правило: Ключом таблицы может быть любое значение кроме nil и NaN; числа 1 и 1.0 обозначают один ключ там, где они равны, а изменяемое содержимое таблицы не влияет на её идентичность как ключа. Код и тесты раздела «Массивная часть» должны выражать правило: pairs не обещает порядок обхода, ipairs идёт по целым индексам от 1 до первого отсутствующего значения; требуемый порядок нужно задавать отдельно. Код и тесты раздела «Массивная часть» должны выражать правило: Последовательная часть таблицы обычно использует целые ключи от 1; оператор # определён надёжно только для последовательности без дыр, поэтому nil посередине делает длину неоднозначной. Код и тесты раздела «Массивная часть» должны выражать правило: Числа 1 и 1.0 обозначают один ключ там, где они равны, а изменяемое содержимое таблицы не влияет на её идентичность как ключа.

Вопрос 5 из 20

Что в разделе «Массивная часть» является гарантией, а не привычкой конкретного проекта? Выберите описание, объединяющее механизм и границу раздела «Массивная часть».

Раздел «Массивная часть» корректно описывает утверждение: pairs не обещает порядок обхода, ipairs идёт по целым индексам от 1 до первого отсутствующего значения; требуемый порядок нужно задавать отдельно. Раздел «Массивная часть» корректно описывает утверждение: Ключом таблицы может быть любое значение кроме nil и NaN; числа 1 и 1.0 обозначают один ключ там, где они равны, а изменяемое содержимое таблицы не влияет на её идентичность как ключа. Раздел «Массивная часть» корректно описывает утверждение: Последовательная часть таблицы обычно использует целые ключи от 1; оператор # определён надёжно только для последовательности без дыр, поэтому nil посередине делает длину неоднозначной. Раздел «Массивная часть» корректно описывает утверждение: Добавление и удаление ключей во время pairs может привести к пропускам или неожиданному обходу; безопаснее сначала собрать изменения либо обходить устойчивый список ключей. Раздел «Массивная часть» корректно описывает утверждение: Числа 1 и 1.0 обозначают один ключ там, где они равны, а изменяемое содержимое таблицы не влияет на её идентичность как ключа.

Вопрос 6 из 20

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

local key = {}
local t = {[key] = "object", [1.0] = "number"}
print(t[key], t[1])

Наблюдаемый результат в разделе «Ключи» опирается на правило: Последовательная часть таблицы обычно использует целые ключи от 1. Наблюдаемый результат в разделе «Ключи» опирается на правило: Ключом таблицы может быть любое значение кроме nil и NaN. Наблюдаемый результат в разделе «Ключи» опирается на правило: Требуемый порядок нужно задавать отдельно. Наблюдаемый результат в разделе «Ключи» опирается на правило: Безопаснее сначала собрать изменения либо обходить устойчивый список ключей. Наблюдаемый результат в разделе «Ключи» опирается на правило: Добавление и удаление ключей во время pairs может привести к пропускам или неожиданному обходу.

Вопрос 7 из 20

Какой риск останется незамеченным, если выполнить код только один раз? Ищется граничное следствие правила из раздела «Ключи».

local function reproduce_case()
  local key = {}
  local t = {[key] = "object", [1.0] = "number"}
  print(t[key], t[1])
end
reproduce_case()

На другом входе раздела «Ключи» нужно проверить: pairs не обещает порядок обхода, ipairs идёт по целым индексам от 1 до первого отсутствующего значения. На другом входе раздела «Ключи» нужно проверить: pairs не обещает порядок обхода, ipairs идёт по целым индексам от 1 до первого отсутствующего значения; требуемый порядок нужно задавать отдельно. На другом входе раздела «Ключи» нужно проверить: Добавление и удаление ключей во время pairs может привести к пропускам или неожиданному обходу; безопаснее сначала собрать изменения либо обходить устойчивый список ключей. На другом входе раздела «Ключи» нужно проверить: Числа 1 и 1.0 обозначают один ключ там, где они равны, а изменяемое содержимое таблицы не влияет на её идентичность как ключа. На другом входе раздела «Ключи» нужно проверить: Добавление и удаление ключей во время pairs может привести к пропускам или неожиданному обходу.

Вопрос 8 из 20

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

do
  local key = {}
  local t = {[key] = "object", [1.0] = "number"}
  print(t[key], t[1])
end

Эквивалентный рефакторинг раздела «Ключи» сохраняет следующее: Ключом таблицы может быть любое значение кроме nil и NaN. Эквивалентный рефакторинг раздела «Ключи» сохраняет следующее: Требуемый порядок нужно задавать отдельно. Эквивалентный рефакторинг раздела «Ключи» сохраняет следующее: Добавление и удаление ключей во время pairs может привести к пропускам или неожиданному обходу. Эквивалентный рефакторинг раздела «Ключи» сохраняет следующее: Последовательная часть таблицы обычно использует целые ключи от 1. Эквивалентный рефакторинг раздела «Ключи» сохраняет следующее: Безопаснее сначала собрать изменения либо обходить устойчивый список ключей.

Вопрос 9 из 20

Что стоит зафиксировать до расширения функциональности раздела «Ключи»? Нужна эксплуатационная граница раздела «Ключи».

Код и тесты раздела «Ключи» должны выражать правило: Добавление и удаление ключей во время pairs может привести к пропускам или неожиданному обходу. Код и тесты раздела «Ключи» должны выражать правило: Добавление и удаление ключей во время pairs может привести к пропускам или неожиданному обходу; безопаснее сначала собрать изменения либо обходить устойчивый список ключей. Код и тесты раздела «Ключи» должны выражать правило: pairs не обещает порядок обхода, ipairs идёт по целым индексам от 1 до первого отсутствующего значения. Код и тесты раздела «Ключи» должны выражать правило: Числа 1 и 1.0 обозначают один ключ там, где они равны, а изменяемое содержимое таблицы не влияет на её идентичность как ключа. Код и тесты раздела «Ключи» должны выражать правило: pairs не обещает порядок обхода, ipairs идёт по целым индексам от 1 до первого отсутствующего значения; требуемый порядок нужно задавать отдельно.

Вопрос 10 из 20

Какой вариант точнее всего передаёт смысл раздела «Ключи»? Ответ должен охватывать весь раздел «Ключи».

Надёжное понимание раздела «Ключи» опирается на правило: Добавление и удаление ключей во время pairs может привести к пропускам или неожиданному обходу; безопаснее сначала собрать изменения либо обходить устойчивый список ключей. Надёжное понимание раздела «Ключи» опирается на правило: Ключом таблицы может быть любое значение кроме nil и NaN; числа 1 и 1.0 обозначают один ключ там, где они равны, а изменяемое содержимое таблицы не влияет на её идентичность как ключа. Надёжное понимание раздела «Ключи» опирается на правило: pairs не обещает порядок обхода, ipairs идёт по целым индексам от 1 до первого отсутствующего значения. Надёжное понимание раздела «Ключи» опирается на правило: pairs не обещает порядок обхода, ipairs идёт по целым индексам от 1 до первого отсутствующего значения; требуемый порядок нужно задавать отдельно. Надёжное понимание раздела «Ключи» опирается на правило: Последовательная часть таблицы обычно использует целые ключи от 1; оператор # определён надёжно только для последовательности без дыр, поэтому nil посередине делает длину неоднозначной.

Вопрос 11 из 20

Какое утверждение объясняет результат без скрытых допущений? Ответ должен описывать основной механизм раздела «Обход».

local t = {b=2, a=1, c=3}
for k, v in pairs(t) do print(k, v) end

При разборе раздела «Обход» здесь действует условие: Безопаснее сначала собрать изменения либо обходить устойчивый список ключей. При разборе раздела «Обход» здесь действует условие: Добавление и удаление ключей во время pairs может привести к пропускам или неожиданному обходу. При разборе раздела «Обход» здесь действует условие: Последовательная часть таблицы обычно использует целые ключи от 1. При разборе раздела «Обход» здесь действует условие: Числа 1 и 1.0 обозначают один ключ там, где они равны, а изменяемое содержимое таблицы не влияет на её идентичность как ключа. При разборе раздела «Обход» здесь действует условие: pairs не обещает порядок обхода, ipairs идёт по целым индексам от 1 до первого отсутствующего значения.

Вопрос 12 из 20

Что должен поймать отрицательный тест для этого фрагмента? Нужен отрицательный сценарий для раздела «Обход».

local function reproduce_case()
  local t = {b=2, a=1, c=3}
  for k, v in pairs(t) do print(k, v) end
end
reproduce_case()

Отрицательный сценарий для раздела «Обход» фиксирует: Добавление и удаление ключей во время pairs может привести к пропускам или неожиданному обходу; безопаснее сначала собрать изменения либо обходить устойчивый список ключей. Отрицательный сценарий для раздела «Обход» фиксирует: Последовательная часть таблицы обычно использует целые ключи от 1; оператор # определён надёжно только для последовательности без дыр, поэтому nil посередине делает длину неоднозначной. Отрицательный сценарий для раздела «Обход» фиксирует: Числа 1 и 1.0 обозначают один ключ там, где они равны, а изменяемое содержимое таблицы не влияет на её идентичность как ключа. Отрицательный сценарий для раздела «Обход» фиксирует: Ключом таблицы может быть любое значение кроме nil и NaN; числа 1 и 1.0 обозначают один ключ там, где они равны, а изменяемое содержимое таблицы не влияет на её идентичность как ключа. Отрицательный сценарий для раздела «Обход» фиксирует: pairs не обещает порядок обхода, ipairs идёт по целым индексам от 1 до первого отсутствующего значения; требуемый порядок нужно задавать отдельно.

Вопрос 13 из 20

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

Внешнее поведение раздела «Обход» сохраняется при условии: Добавление и удаление ключей во время pairs может привести к пропускам или неожиданному обходу. Внешнее поведение раздела «Обход» сохраняется при условии: Последовательная часть таблицы обычно использует целые ключи от 1. Внешнее поведение раздела «Обход» сохраняется при условии: Числа 1 и 1.0 обозначают один ключ там, где они равны, а изменяемое содержимое таблицы не влияет на её идентичность как ключа. Внешнее поведение раздела «Обход» сохраняется при условии: Безопаснее сначала собрать изменения либо обходить устойчивый список ключей. Внешнее поведение раздела «Обход» сохраняется при условии: pairs не обещает порядок обхода, ipairs идёт по целым индексам от 1 до первого отсутствующего значения.

Вопрос 14 из 20

Что стоит зафиксировать до расширения функциональности раздела «Обход»? Ответ должен выражать проверяемое следствие раздела «Обход».

Код и тесты раздела «Обход» должны выражать правило: Добавление и удаление ключей во время pairs может привести к пропускам или неожиданному обходу; безопаснее сначала собрать изменения либо обходить устойчивый список ключей. Код и тесты раздела «Обход» должны выражать правило: Последовательная часть таблицы обычно использует целые ключи от 1; оператор # определён надёжно только для последовательности без дыр, поэтому nil посередине делает длину неоднозначной. Код и тесты раздела «Обход» должны выражать правило: pairs не обещает порядок обхода, ipairs идёт по целым индексам от 1 до первого отсутствующего значения; требуемый порядок нужно задавать отдельно. Код и тесты раздела «Обход» должны выражать правило: Ключом таблицы может быть любое значение кроме nil и NaN; числа 1 и 1.0 обозначают один ключ там, где они равны, а изменяемое содержимое таблицы не влияет на её идентичность как ключа. Код и тесты раздела «Обход» должны выражать правило: Числа 1 и 1.0 обозначают один ключ там, где они равны, а изменяемое содержимое таблицы не влияет на её идентичность как ключа.

Вопрос 15 из 20

Какое описание раздела «Обход» выдерживает и обычный, и граничный сценарий? Ответ должен охватывать весь раздел «Обход».

Рабочее правило всего раздела «Обход»: pairs не обещает порядок обхода, ipairs идёт по целым индексам от 1 до первого отсутствующего значения; требуемый порядок нужно задавать отдельно. Рабочее правило всего раздела «Обход»: Ключом таблицы может быть любое значение кроме nil и NaN; числа 1 и 1.0 обозначают один ключ там, где они равны, а изменяемое содержимое таблицы не влияет на её идентичность как ключа. Рабочее правило всего раздела «Обход»: Числа 1 и 1.0 обозначают один ключ там, где они равны, а изменяемое содержимое таблицы не влияет на её идентичность как ключа. Рабочее правило всего раздела «Обход»: Последовательная часть таблицы обычно использует целые ключи от 1; оператор # определён надёжно только для последовательности без дыр, поэтому nil посередине делает длину неоднозначной. Рабочее правило всего раздела «Обход»: Добавление и удаление ключей во время pairs может привести к пропускам или неожиданному обходу; безопаснее сначала собрать изменения либо обходить устойчивый список ключей.

Вопрос 16 из 20

Что нельзя заменить привычкой из другого языка при чтении этого кода? Ответ должен описывать основной механизм раздела «Изменение структуры».

local t = {a=1, b=2, c=3}
for k in pairs(t) do
  if t[k] % 2 == 1 then t[k] = nil end
end
print(t.a, t.b, t.c)

Строку из раздела «Изменение структуры» нужно читать так: Числа 1 и 1.0 обозначают один ключ там, где они равны, а изменяемое содержимое таблицы не влияет на её идентичность как ключа. Строку из раздела «Изменение структуры» нужно читать так: Ключом таблицы может быть любое значение кроме nil и NaN. Строку из раздела «Изменение структуры» нужно читать так: Последовательная часть таблицы обычно использует целые ключи от 1. Строку из раздела «Изменение структуры» нужно читать так: Добавление и удаление ключей во время pairs может привести к пропускам или неожиданному обходу. Строку из раздела «Изменение структуры» нужно читать так: pairs не обещает порядок обхода, ipairs идёт по целым индексам от 1 до первого отсутствующего значения.

Вопрос 17 из 20

Где этот код может повести себя иначе на границе? Ищется граничное следствие правила из раздела «Изменение структуры».

local function reproduce_case()
  local t = {a=1, b=2, c=3}
  for k in pairs(t) do
    if t[k] % 2 == 1 then t[k] = nil end
  end
  print(t.a, t.b, t.c)
end
reproduce_case()

Для раздела «Изменение структуры» отдельным тестом подтверждают: Ключом таблицы может быть любое значение кроме nil и NaN. Для раздела «Изменение структуры» отдельным тестом подтверждают: Требуемый порядок нужно задавать отдельно. Для раздела «Изменение структуры» отдельным тестом подтверждают: Последовательная часть таблицы обычно использует целые ключи от 1. Для раздела «Изменение структуры» отдельным тестом подтверждают: pairs не обещает порядок обхода, ipairs идёт по целым индексам от 1 до первого отсутствующего значения. Для раздела «Изменение структуры» отдельным тестом подтверждают: Безопаснее сначала собрать изменения либо обходить устойчивый список ключей.

Вопрос 18 из 20

Что нельзя считать деталью реализации в этом коде? Выберите гарантию, определяющую раздел «Изменение структуры».

После правки раздела «Изменение структуры» должно оставаться верным: Числа 1 и 1.0 обозначают один ключ там, где они равны, а изменяемое содержимое таблицы не влияет на её идентичность как ключа. После правки раздела «Изменение структуры» должно оставаться верным: pairs не обещает порядок обхода, ipairs идёт по целым индексам от 1 до первого отсутствующего значения. После правки раздела «Изменение структуры» должно оставаться верным: Добавление и удаление ключей во время pairs может привести к пропускам или неожиданному обходу. После правки раздела «Изменение структуры» должно оставаться верным: Последовательная часть таблицы обычно использует целые ключи от 1. После правки раздела «Изменение структуры» должно оставаться верным: Ключом таблицы может быть любое значение кроме nil и NaN.

Вопрос 19 из 20

Команда меняет раздел «Изменение структуры» в рабочем модуле. На какое решение можно опереться при повторном запуске и отказе зависимости? Выберите практическое следствие раздела «Изменение структуры».

В рабочем решении раздела «Изменение структуры» учитывают: Ключом таблицы может быть любое значение кроме nil и NaN. В рабочем решении раздела «Изменение структуры» учитывают: Требуемый порядок нужно задавать отдельно. В рабочем решении раздела «Изменение структуры» учитывают: pairs не обещает порядок обхода, ipairs идёт по целым индексам от 1 до первого отсутствующего значения. В рабочем решении раздела «Изменение структуры» учитывают: Последовательная часть таблицы обычно использует целые ключи от 1. В рабочем решении раздела «Изменение структуры» учитывают: Безопаснее сначала собрать изменения либо обходить устойчивый список ключей.

Вопрос 20 из 20

Какое утверждение о разделе «Изменение структуры» точно и не обещает лишнего? Ответ должен охватывать весь раздел «Изменение структуры».

Для раздела «Изменение структуры» верно: pairs не обещает порядок обхода, ipairs идёт по целым индексам от 1 до первого отсутствующего значения; требуемый порядок нужно задавать отдельно. Для раздела «Изменение структуры» верно: Числа 1 и 1.0 обозначают один ключ там, где они равны, а изменяемое содержимое таблицы не влияет на её идентичность как ключа. Для раздела «Изменение структуры» верно: Последовательная часть таблицы обычно использует целые ключи от 1; оператор # определён надёжно только для последовательности без дыр, поэтому nil посередине делает длину неоднозначной. Для раздела «Изменение структуры» верно: Ключом таблицы может быть любое значение кроме nil и NaN; числа 1 и 1.0 обозначают один ключ там, где они равны, а изменяемое содержимое таблицы не влияет на её идентичность как ключа. Для раздела «Изменение структуры» верно: Добавление и удаление ключей во время pairs может привести к пропускам или неожиданному обходу; безопаснее сначала собрать изменения либо обходить устойчивый список ключей.