Переведем числа в десятичную систему счисления:

BC₁₆ + 20₈ = 11·16+12 + 2·8 = 188 + 16 = 204₁₀.

Переведем полученное число в двоичную систему счисления:

204₁₀ = 1⋅2⁷ + 1⋅2⁶ + 0⋅2⁵ + 0⋅2⁴ + 1⋅2³ + 1⋅2² + 0⋅2 + 0 = 11001100₂.

Сравним его с данными нам в условии двоичными числами:

10001011 — меньше, чем 11001100;

10111000 — меньше, чем 11001100;

10011011 — меньше, чем 11001100;

10110100 — меньше, чем 11001100.

Среди заданных чисел нет больших, чем BC₁₆ + 20₈.

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

Рассмотрим данное выражение. Логическая функция принимает значение 1, когда обе части выражения принимают значения 1 или 0. Первая часть выражения принимает значение 1 при наборах переменных x, z, w равных соответственно 011, 101, 111. Вторая часть выражения принимает значение 1 при наборах переменных x, y, z равных соответственно 000, 100, 110, 111. Первая часть выражения принимает значение 0 при наборах переменных x, z, w равных соответственно 000, 001, 010, 100, 110. Вторая часть выражения принимает значение 0 при наборах переменных x, y, z равных соответственно 001, 010, 011, 101. Заметим, что y соответствует первому столбцу таблицы истинности, а w и x третьему и четвёртому столбцам таблицы истинности. Значит, второму столбцу таблицы истинности соответствует z.

Ответ: yzwx. ((x ∧ w) ∨ (w ∧ z)) ≡ ((z → y) ∧ (y → x)).

Составим маршрут следующим образом: стартуя из пункта А, будем всегда выбирать тот пункт, расстояние до которого наименьшее. Получим маршрут А—Б—В—Д—Г—К, его длина равна 16 км. Теперь, начиная с конца маршрута, будем изменять населённые пункты:

А—Б—В—Д—Е—К: длина маршрута 15 км,

A—Б—Г—Д—Е—К: длина маршрута 14 км.

A—Б—Г—К: длина маршрута 13 км.

Дальнейшее изменение населённых пунктов, через которые проходит маршрут, бессмысленно, поскольку длины маршрутов будут более 13 км. Следовательно, длина кратчайшего маршрута равна 13 км.

Из первой таблицы ясно, что ID Притулы П. И. 3021. Найдем этот номер во второй таблице в графе «ID_ребенка» видим, что этому номеру соотвествует два значения «ID_родителя» 2278 и 2849. Из второй таблицы также видно, что у родителей с этими ID помимо Притулы П. И. есть ребёнок с ID 2487, значит это брат или сестра Притулы П. И. Теперь найдём ID 2487 в первой таблице этому ID соответствует женщина — Брик А. И.

Букву С закодируем кодовым словом 10, поскольку буква С повторяется в слове АБСЦИССА 3 раза. Букву А закодируем кодовым словом 011, поскольку буква А повторяется в слове АБСЦИССА 2 раза. Буквы Ц и И закодируем кодовыми словами 1101 и 1100 соответственно. Тогда наименьшее количество двоичных знаков, которые потребуются для кодирования слова АБСЦИССА равно 3 + 2 + 2 + 4 + 4 + 2 + 2 + 3 = 22.

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

Заметим, что пары команд «вверх-вниз» и «влево-вправо» дают нулевой эффект, то есть, не перемещают Робота, поэтому все такие пары можно выкинуть из программы, вдобавок, поскольку стенок нет, все равно где стоят парные команды в программе. Вычеркнув все пары, видим, что остались только команды вверх, вверх. Их две.

Формулу перенесли на 2 строку вниз и на 2 столбца вправо. Значит, в формуле все строки также сдвинутся на 1 вниз, а столбцы на 1 влево. Кроме тех, что обозначены знаком $. После копирования формулы из ячейки D3 в ячейку F5 получится формула = F$1 + $A5 = 5 + 40 = 45.

Цикл while выполняется до тех пор, пока истинно условие s <= 249, т. е. переменная s определяет, сколько раз выполнится цикл.

Заметим, что  На 11 шаге s станет равной 264 и условие s <= 249 окажется невыполненным, цикл прервется. Следовательно, значение n будет равно 10 + 11·3 = 43.

Способ А. Общее время складывается из времени сжатия, распаковки и передачи. Время передачи t рассчитывается по формуле t = Q / q, где Q — объём информации, q — cкорость передачи данных.

Найдём сжатый объём: 10 * 0,3 = 3 Мбайта

Переведём Q из Мбайт в биты: 3 Мбайта = 3 * 2²⁰ байт = 3 * 2²³ бит.

Найдём общее время: t = 7 с + 1 с + 3 * 2²³ бит / 2¹⁸ бит/с = 8 + 3 * 2⁵ с = 104 с.

Способ Б. Общее время совпадает с временем передачи: t = 10 * 2²³ бит / 2¹⁸ бит/с = 10 * 2⁵ с = 320 с.

Видно, что способ A быстрее на 320 - 104 = 216 с.

Заменим буквы К, О, Р на 0, 1, 2 (для них порядок очевиден – по возрастанию).

Выпишем начало списка, заменив буквы на цифры:

1. 00000

2. 00001

3. 00002

4. 00010

...

Полученная запись есть числа, записанные в троичной системе счисления в порядке возрастания. Тогда на 182 месте будет стоять число 181 (т. к. первое число 0). Переведём число 181 в троичную систему (деля и снося остаток справа налево):

181 / 3 = 60 (1)

60 / 3 = 20 (0)

20 / 3 = 6 (2)

6 / 3 = 2 (0)

2 / 3 = 0(2)

В троичной системе 181 запишется как 20201. Произведём обратную замену и получим РКРКО.

Последовательно находим:

F(1) = 1;

F(2) = 2;

F(3) = 2 + 3 = 5;

F(4) = 5 + 6 = 11;

F(5) = 11 + 15 = 26;

F(6) = 26 + 33 = 59.

Таким образом, ответ F(6) = 59.

1. Запишем числа маски сети в двоичной системе счисления:

2. Адрес сети получается в результате поразрядной конъюнкции чисел маски и чисел адреса узла (в двоичном коде). Так как конъюнкция 0 с чем-либо всегда равна 0, то на тех местах, где числа маски равны 0, в адресе узла стоит 0. Аналогично, там, где числа маски равны 255, стоит само число, так как конъюнкция 1 с любым числом всегда равна этому числу.

3. Рассмотрим конъюнкцию числа 224 с числом 208:

Результатом конъюнкции является число 11000000₂ = 192₁₀.

4. Сопоставим варианты ответа получившимся числам: 32, 128, 192, 0.

Таким образом, ответ: BDEA.

Известно, что с помощью N бит можно закодировать 2^N различных чисел. Поскольку 2⁸ < 459 < 2⁹ и для каждого спортсмена число бит одинаково, то для записи каждого из 459 номеров необходимо 9 бит памяти. Поэтому сообщение о 160 номерах имеет объем 160 · 9 = 1440 бит = 180 байт.

За время работы программы Чертёжник сдвинется на вектор .

По условию также известно, что этот вектор равен (0, 0).

Таким образом имеем:

Ответом будет наибольший общий делитель чисел -72 и -360 — 72.

Начнем считать количество путей с конца маршрута – с города E. N_X — количество различных путей из города А в город X, N — общее число путей.

В "Е" можно приехать из В, Е, или G, поэтому N = N_E = N_B + N_A + N _G(1)

Аналогично:

N_B = N_A = 1;

N_A = 1;

N_G = N_A + N_K = 2;

Подставим в формулу (1):

N = N_К = 1 + 1 + 2 = 4.

Запрос М & И также выдаёт и результаты по запросу М & И & Ф, так как второй является более узким запросом и подмножеством первого. Также и в случае с М & Ф.

То есть М & И = М & И & ¬Ф + М & И & Ф. (¬Ф — отсутствие Ф в запросе)

Также М & Ф = М & Ф & ¬И + М & Ф & И.

M & (И | Ф) = M & И & ¬Ф + М & Ф & ¬И + М & И & Ф.

Теперь можно заметить, что М & И & Ф = М & И + М & Ф - M & (И | Ф).

То есть М & И & Ф = 330 + 270 - 520 = 80.

Введем обозначения: (x ∈А) ≡ A; (x ∈ P) ≡ P; (x ∈ Q) ≡ Q.

Применив преобразование импликации, получаем:

Применив закон де Моргана и правило упрощения, получаем:

Логическое ИЛИ истинно, если истинно хоть какое-то из утверждений. Выражение ¬P истинно тогда, когда x∈(- ∞,17)U(40,∞), а выражение ¬Q истинно тогда, когда x∈(–∞,20)U(57,∞). Следовательно, A должно быть истинно как минимум на отрезке [20;40]. Длина отрезка равна 40 − 20 = 20.

Данный алгоритм меняет местами элементы с номером i и i-1, если A[i-1] > A[i], при каждой такой перестановке c увеличивается на единицу.

Сначала тройка сравнивается с нулем, поскольку тройка больше нуля они меняются местами. Аналогично шестерка меняется местами с пятёркой и единицей. Затем восьмерка меняется местами с двойкой, а девятка — с семеркой. Всего было 5 перестановок, следовательно, после исполнения данного фрагмента программы c станет равным пяти.

Рассмотрим цикл, число шагов которого зависит от изменения переменной x:

while x > 0 do begin

...

x:= x div 10;

end;

Т. к. оператор div оставляет только целую часть от деления, то при делении на 10 это равносильно отсечению последней цифры.

Из приведенного цикла видно, что на каждом шаге от десятичной записи x отсекается последняя цифра до тех пор, пока все цифры не будут отсечены, то есть x не станет равно 0; поэтому цикл выполняется столько раз, сколько цифр в десятичной записи введенного числа.

При этом, если число x кратно двум, переменная a увеличивается на единицу, в противном случае — переменная b. Поскольку требуется ,чтобы программа напечатала сначала 3, а потом 2, необходимо, чтобы число x имело пять разрядов. Три цифры в этом числе должны быть чётные, а две — нечётные. Минимальным числом, удовлетворяющим данным условиям является число 10001.

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

При k = 10, программа выведет число 3.

Запишем неравенство:  отсюда получим, что наименьшее значение k = 3.

Выполним программу:

a := 30,

b := 6,

a := a * 3 / b = 30 · 3/6 = 15.

Условие a < b не выполняется, поэтому далее выполним: c := 3*a + 5 * (b+2) = 45 + 40 = 85.

Заметим, что первое и второе уравнения не связаны между собой ни через какие переменные.

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

Рассмотрим второе уравнение. Чтобы равенство выполнялось, необходимо, чтобы каждая скобка была истинной. Дерево для решения этого уравнения будет выглядеть так:

Теперь рассмотрим третье уравнение. Конъюнкция истинна только, если все операнды истинны. Каждое уравнения вида ¬xN ∨ yN = 1 имеет три решения: 01, 00, 11. То есть для каждой пары xN, yN запрещены решения вида 10.

Будем представлять решения уравнений в виде набора нулей и единиц, например, решение x1 = 0, x2 = x3 =x4, = x5= x6 = 1 имеет вид 011 111. Заметим, что для первых двух уравнений в наборах решений после единицы могут стоять только единицы. То есть разрешены решения вида 001 111.

Также заметим, что если yN = 0, то xN обязательно равно единице.

Таким образом, получаем, что набору yN 111 111, могут соответствовать наборы xN: 111 111, 011 111, 001 111, 000 111, 000 011, 000 001, 000 000. Всего семь наборов.

Аналогично, набору yN 011 111 соответствует шесть наборов и так далее. Всего получаем:

Элементы ответа:

Возможная доработка (Паскаль, отдельно рассматриваем области, лежащие по разные стороны от прямой x=0):

if (y>=x*x) and (y<=1) and (x>=0) or (x<=0) and (x>=-1) and (y>=0) and (y<=1) then

write('принадлежит')

else write('не принадлежит')

Возможная доработка (Си, отдельно рассматриваем области, лежащие по разные стороны от параболы):

if((y>=x*x) && (y<=1) || (y<=x*x) && (x>=-1) && (y>=0))

cout << "принадлежит";

else

cout << "не принадлежит";

Обратите внимание! При разделении области вдоль какой-либо линии точки, которые лежат на этой линии внутри области, могут быть причислены к одной части, к другой или к обеим (то есть, например, в приведённом решении на языке Паскаль одно из условий (x>=0 или x<=0) может быть строгим). Могут быть и другие верные способы доработки.

1. а) Петя может выиграть, если S = 22, ... 43. Во всех этих случаях достаточно удвоить количество камней. При меньших значениях S за один ход нельзя получить кучу, в которой больше 43 камней.

б) Ваня может выиграть первым ходом (как бы ни играл Петя), если исходно в куче будет S = 21 камней. Тогда после первого хода Пети в куче будет 22, 23 или 42 камня. Во всех случаях Ваня удваивает количество камней и выигрывает первым ходом.

2. Возможные значения S: 19, 20. В этих случаях Петя, очевидно, не может выиграть первым ходом. Однако он может получить кучу из 21 камня: в первом случае добавлением двух камней, во втором добавлением одного камня. Эта позиция разобрана в п. 16. В ней отрок, который будет ходить (теперь это Ваня), выиграть не может, а его противник (то есть Петя) следующим ходом выиграет.

3. Возможное значение S: 18. После первого хода Пети в куче будет 19, 20 или 36 камней. Если в куче станет 38 камней. Ваня удвоит количество камней и выиграет первым ходом. Ситуация, когда в куче 19 или 20 камней, уже разобрана в п. 2. В этих ситуациях игрок, который будет ходить (теперь это Ваня), выигрывает своим вторым ходом.

В таблице изображено дерево возможных партий при описанной стратегии Ванн. Заключительные позиции (в них выигрывает Ваня) подчёркнуты. На рисунке это же дерево изображено в графическом виде (оба способа изображения дерева допустимы).

Произведение двух чисел делится на 29, если хотя бы один из сомножителей делится на 29.

При вводе чисел можно подсчитывать количество чисел, кратных 29, не считая четырёх последних. Обозначим их n29.

Примечание для проверяющего. Сами числа, кроме четырёх последних, при этом можно не хранить.

Очередное считанное число будем рассматривать как возможный правый элемент искомой пары. Если очередное считанное число делится на 29, то к ответу следует прибавить количество чисел до него, не считая четырёх последних (включая считанное). Если очередное считанное число на 29 не делится, то к ответу следует прибавить n29.

Чтобы построить программу, эффективную по памяти, заметим, что, поскольку при обработке очередного элемента входных данных используются значения, находящиеся на четыре элемента ранее, достаточно хранить только четыре последних элемента или информацию о них. Ниже приведена реализующая описанный алгоритм программа на языке Паскаль (использована версия PascalABC).

Пример 1. Программа на языке Паскаль. Программа эффективна по времени и памяти.

const s = 4; {требуемое расстояние между элементами}
var
    n: longint;
    a: array[1..s] of longint; {хранение последних s значений}
    a_: longint; {очередное значение}
    n29: longint; {количество делящихся на 29 элементов, не считая s последних}
    cnt: longint; {количество искомых пар}
    i, j: longint;
begin
    readln(n); {Ввод первых s чисел}
    for i:=1 to s do
        readln(a[i]); {Ввод остальных значений, подсчет искомых пар}
    cnt := 0;
    n29 := 0;
    for i := s + 1 to n do
    begin
        if a[1] mod 29 = 0 then
            n29 := n29 + 1;
        readln(a_);
        if a_ mod 29 = 0 then
            cnt := cnt + i - s
        else
            cnt := cnt + n29;
{сдвигаем элементы вспомогательного массива влево}
        for j := 1 to s - 1 do
            a[j] := a[j + 1];
        a[s] := a_ {записываем текущий элемент в конец массива}
    end;
    writeln(cnt)
end.

Пример 2. Программа на языке Python. Программа эффективна по времени и памяти.

s = 4
a = [0]*s
n = int(input())
for i in range(s):
    a[i] = int(input())
cnt = 0
n29 = 0
for i in range(s, n):
    k = i % s
    if a[k] % 29 == 0:
        n29 = n29 + 1
    a_ = int(input())
    if a_ % 29 == 0:
        cnt = cnt + i - s + 1
    else:
        cnt = cnt + n29
    a[i % s] = a_
print(cnt)

Пример 3. Программа на языке С++. Программа эффективна по времени и памяти.

    #include 
    using namespace std;
    int main()
    {
        int s = 4; //требуемое расстояние между элементами
        int n;
        int n1 = 0, n2 = 0, n3 = 0, n4 = 0;
        //хранение последних s счетчиков
        int a_; // очередное значение
        int cnt; // количество искомых пар
        cin >> n;
        cnt = 0;
        for (int i = 0; i < n; ++i)
        {
            cin >> a_; // считано очередное значение
            if (i >= s)
            {
                if (a_ % 29 == 0)
                    cnt += i - s + 1;
                else
                    cnt += n4;
            }
            //сдвигаем элементы счетчиков
            n4 = n3;
            n3 = n2;
            n2 = n1;
            //обновляем счетчик кратных 29
            if (a_ % 29 == 0)
                n1 += 1;
        }
        cout << cnt;
        return 0;
    }

Пример 4. Программа на языке Паскаль. Программа эффективна по времени и неэффективна по памяти.

const s = 4; {требуемое расстояние между элементами}
var
    n: longint;
    a: array[1..1000] of longint;
    n29: longint;
    {количество делящихся на 29 элементов, не считая s последних}
    cnt: longint; {количество искомых пар}
    i, j: longint;
begin
    readln(n);
    {Ввод первых s чисел}
    for i:=1 to s do
        readln(a[i]);
    {Ввод остальных значений, подсчет искомых пар}
    cnt := 0;
    n29 := 0;
    for i := s + 1 to n do
    begin
        readln(a[i]);
        if a[i - s] mod 29 = 0 then
            n29 := n29 + 1;
        if a[i] mod 29 = 0 then
            cnt := cnt + i - s
        else
            cnt := cnt + n29;
    end;
    writeln(cnt)
end.