Ре­ше­ние. Оче­вид­но, из числа 1 нель­зя по­лу­чить чет­ное число. Пусть n  — не­чет­ное число, не пре­вос­хо­дя­щее 31. Обо­зна­чим R(n) ко­ли­че­ство про­грамм, ко­то­рые пре­об­ра­зу­ют число 1 в число n. Обо­зна­чим t(n) наи­боль­шее не­чет­ное число, крат­ное трем, не пре­вос­хо­дя­щее n. Обе ко­ман­ды ис­пол­ни­те­ля уве­ли­чи­ва­ют ис­ход­ное число, по­это­му общее ко­ли­че­ство ко­манд в про­грам­ме не может пре­вос­хо­дить 31.

Верны сле­ду­ю­щие со­от­но­ше­ния.

1.  Если n не де­лит­ся на 3, то тогда R(n)  =  R(t(n)), так как су­ще­ству­ет един­ствен­ный спо­соб по­лу­че­ния n из t(n)  — при­бав­ле­ни­ем двоек.

2.  Пусть n де­лит­ся на 3. Тогда R(n)  =  R(n : 3) + R(n – 2) (если n > 3).

При n  =  3 R(n)  =  2 (два спо­со­ба: при­бав­ле­ни­ем двой­ки или од­но­крат­ным умно­же­ни­ем на 3). По­это­му до­ста­точ­но по ин­дук­ции вы­чис­лить зна­че­ния R(n) для всех не­чет­ных чисел, крат­ных трем и не пре­вос­хо­дя­щих 31.

Имеем:

R(1)= 1;

R(3) = 2 = R(5)=R(7);

R(9) = R(3)+R(7) = 2+2 = 4 = R(11) = R(13);

R(15) = R(5)+R(13) = 2+4 = 6 = R(17) = R(19);

R(21) = R(7)+R(19) = 2+6 = 8 = R(23) = R(25);

R(27) = R(9)+R(25) = 4+8 =12 = R(29) = R(31).

Ответ: 12.

Дру­гой спо­соб ре­ше­ния.

Оче­вид­но, из числа 1 нель­зя по­лу­чить чет­ное число. Будем ре­шать по­став­лен­ную за­да­чу по­сле­до­ва­тель­но для чисел 1, 3, 5, …, 31 (то есть для каж­до­го из таких чисел опре­де­лим, сколь­ко про­грамм ис­пол­ни­те­ля су­ще­ству­ет для его по­лу­че­ния). Ко­ли­че­ство про­грамм, ко­то­рые пре­об­ра­зу­ют число 1 в число n, обо­зна­чим R(n). Число 1 у нас уже есть, зна­чит, его можно по­лу­чить с по­мо­щью «пу­стой» про­грам­мы. Любая не­пу­стая про­грам­ма уве­ли­чит ис­ход­ное число, то есть даст число боль­ше 1. Зна­чит, R(1)  =  1. Для каж­до­го сле­ду­ю­ще­го числа рас­смот­рим, из ка­ко­го числа оно может быть по­лу­че­но за одну ко­ман­ду ис­пол­ни­те­ля. Если число не де­лит­ся на три, то оно может быть по­лу­че­но толь­ко из преды­ду­ще­го не­чет­но­го числа с по­мо­щью ко­ман­ды при­бавь 2. Зна­чит, ко­ли­че­ство ис­ко­мых про­грамм для та­ко­го числа равно ко­ли­че­ству про­грамм для преды­ду­ще­го не­чет­но­го числа: R(i)  =  R(i – 2). Если число на 3 де­лит­ся, то ва­ри­ан­тов по­след­ней ко­ман­ды два: при­бавь 2 и умножь на 3, тогда R(i)  =  R(i – 2) + R(i : 3). За­пол­ним со­от­вет­ству­ю­щую таб­ли­цу по при­ве­ден­ным фор­му­лам слева на­пра­во:

При­ведём дру­гое ре­ше­ние на языке Python.

Ре­ше­ние. Для сло­же­ния спра­вед­лив пе­ре­ме­сти­тель­ный (ком­му­та­тив­ный) закон, зна­чит, по­ря­док ко­манд в про­грам­ме не имеет зна­че­ния для ре­зуль­та­та.

Обе ко­ман­ды уве­ли­чи­ва­ют ис­ход­ное число, по­это­му ко­ли­че­ство ко­манд не может пре­вос­хо­дить 15 − 2  =  13. При этом ми­ни­маль­ное ко­ли­че­ство ко­манд  — 5 (так как (15 − 2) : 3  =  4 с остат­ком 1). При этом за­ме­тим, что 15  — не­чет­ное, а 2  — чет­ное. А так как обе ко­ман­ды уве­ли­чи­ва­ют ис­ход­ное число на не­чет­ное число, то ко­ли­че­ство ко­манд долж­но быть не­чет­ным.

Иначе го­во­ря, ко­манд может быть 5, 7, 9, 11 или 13. По­сколь­ку, как было ска­за­но выше, по­ря­док ко­манд не имеет зна­че­ния, каж­до­му числу ко­манд со­от­вет­ству­ет один набор ко­манд, ко­то­рые можно рас­по­ло­жить в любом по­ряд­ке. Пяти ко­ман­дам со­от­вет­ству­ет набор 22221 (5 воз­мож­ных ва­ри­ан­тов рас­по­ло­же­ния), 7 ко­ман­дам  — набор 2221111 (здесь по­лу­ча­ет­ся 35 воз­мож­ных ва­ри­ан­тов рас­по­ло­же­ния: это число пе­ре­ста­но­вок с по­вто­ре­ни­я­ми P₇(3,4)=7! / (3! · 4!)), 9 ко­ман­дам  — 22111111 (здесь по­лу­ча­ет­ся 36 воз­мож­ных ва­ри­ан­тов рас­по­ло­же­ния), 11 ко­ман­дам  — 21111111111 (11 воз­мож­ных ва­ри­ан­тов рас­по­ло­же­ния), 13 ко­ман­дам  — 11111111111111 (1 ва­ри­ант рас­по­ло­же­ния). Всего имеем 88 про­грамм.

Ответ: 88.

При­ведём дру­гое ре­ше­ние на языке Python.

Ре­ше­ние. Обо­зна­чим R(n)  — ко­ли­че­ство про­грамм, ко­то­рые пре­об­ра­зу­ют число 1 в число n.

Верны сле­ду­ю­щие со­от­но­ше­ния.

1.  Если n не де­лит­ся на 2 или на 3, то тогда R(n)  =  R(n – 1), так как су­ще­ству­ет един­ствен­ный спо­соб по­лу­че­ния n из n−1  — при­бав­ле­ни­ем еди­ниц.

2.  Пусть n де­лит­ся на 2 и на 3.

Тогда R(n)  =  R(n : 2) + R(n : 3) + R(n – 1).

До­ста­точ­но вы­чис­лить все зна­че­ния R(n).

Имеем:

R(2)  =  2 (можно умно­жить еди­ни­цу на 2 или при­ба­вить 1);

R(3)  =  3 (можно умно­жить еди­ни­цу на 3 или при­ба­вить 1 к двой­ке, ко­то­рую, в свою оче­редь, можно по­лу­чить двумя спо­со­ба­ми (см. выше);

R(4)  =  R(2) + R(3)  =  5;

R(5)  =  R(4)  =  5;

R(6)  =  R(2) + R(3) + R(5)  =  10;

R(7)  =  R(6)  =  10;

R(8)  =  R(4) + R(7)  =  5 + 10  =  15;

R(9)  =  R(3) + R(8)  =  3 + 15  =  18;

R(10)  =  R(5) + R(9)  =  5 + 18  =  23;

R(11)  =  R(10)  =  23;

R(12)  =  R(11) + R(4) + R(6)  =  23 + 5 + 10  =  38;

R(13)  =  R(12)  =  38.

Ответ: 38.

При­ведём дру­гое ре­ше­ние на языке Python.

Ре­ше­ние. Обе ко­ман­ды уве­ли­чи­ва­ют ис­ход­ное число. Стар­шая цифра  — 3. Сле­до­ва­тель­но, ис­поль­зо­вать ко­ман­ду 2 более двух раз бес­смыс­лен­но.

Вы­пи­шем про­грам­мы, в ко­то­рых ко­ман­да 2 ис­поль­зу­ет­ся два раза: 1122, 2211, 1212, 2121, 2112, 1221. Итого 6 про­грамм.

Вы­пи­шем про­грам­мы, в ко­то­рых ко­ман­да 2 ис­поль­зу­ет­ся один раз. Ис­поль­зо­вав эту ко­ман­ду в пер­вой по­зи­ции, мы по­лу­чим из числа 35 число 45. Сле­до­ва­тель­но, после этого не­об­хо­ди­мо будет до­пи­сать ещё 12 ко­манд 1, чтобы по­лу­чить число 57. Таким об­ра­зом, по­лу­ча­ем про­грам­мы: 211...1, 121...1 и так далее. Итого имеем 13 про­грамм (двой­ка по­бы­ва­ла в каж­дой по­зи­ции).

Су­ще­ству­ет всего одна про­грам­ма, в ко­то­рой ко­ман­да 2 не ис­поль­зу­ет­ся: 111....1.

Таким об­ра­зом, имеем 6 + 13 + 1  =  20 про­грамм.

Ответ: 20.

При­ведём дру­гое ре­ше­ние на языке Python.

Ре­ше­ние. Обо­зна­чим R(n)  — ко­ли­че­ство про­грамм, ко­то­рые пре­об­ра­зу­ют число 2 в число n. Обо­зна­чим t(n) наи­боль­шее крат­ное 2, не пре­вос­хо­дя­щее n.

Верны сле­ду­ю­щие со­от­но­ше­ния.

1.  Если n не де­лит­ся на 2, то тогда R(n)  =  R(t(n)), так как су­ще­ству­ет един­ствен­ный спо­соб по­лу­че­ния n из t(n)  — при­бав­ле­ни­ем еди­ниц.

2.  Пусть n де­лит­ся на 2. Тогда R(n)  =  R(n : 2) + R(n – 1)  =  R(n : 2) + R(n – 2) (если n > 2). При n  =  2 R(n)  =  2 (два спо­со­ба: при­бав­ле­ни­ем еди­ни­цы и удво­е­ни­ем). По­это­му до­ста­точ­но по­сте­пен­но вы­чис­лить зна­че­ния R(n) для всех чисел, крат­ных 2 и не пре­вос­хо­дя­щих 20.

Имеем:

R(3)  =  1;

R(4)  =  2  =  R(5);

R(6)  =  R(3) + R(4)  =  1 + 2  =  3  =  R(7);

R(8)  =  R(4) + R(6)  =  2 + 3  =  5  =  R(9);

R(10)  =  R(5) + R(8)  =  2 + 5  =  7  =  R(11);

R(12)  =  R(6) + R(10)  =  3 + 7  =  10  =  R(13);

R(14)  =  R(7) + R(12)  =  3 + 10  =  13  =  R(15);

R(16)  =  R(8) + R(14)  =  5 + 13  =  18  =  R(17);

R(18)  =  R(9) + R(16)  =  5 + 18  =  23  =  R(19);

R(20)  =  R(10) + R(18)  =  7 + 23  =  30  =  R(21);

R(22)  =  R(11) + R(20)  =  7 + 30  =  37.

Ответ: 37.

При­ведём дру­гое ре­ше­ние на языке Python.

Ре­ше­ние. Обо­зна­чим R(n)  — ко­ли­че­ство про­грамм, ко­то­рые пре­об­ра­зу­ют число 2 в число n.

Верны сле­ду­ю­щие со­от­но­ше­ния.

1.  Если n нечётное, то тогда R(n)  =  R(n – 1) + R((n – 1) : 2) (если n > 5), так как есть два спо­со­ба по­лу­че­ния n: при­бав­ле­ни­ем еди­ни­цы или ис­поль­зо­ва­ни­ем ко­ман­ды 3.

2.   Если n чётное, то тогда R(n)  =  R(n – 1) + R(n : 2) (если n > 4), так как есть два спо­со­ба по­лу­че­ния n: при­бав­ле­ни­ем еди­ни­цы или ис­поль­зо­ва­ни­ем ко­ман­ды 2.

До­ста­точ­но вы­чис­лить зна­че­ния R(n) для всех чисел, не пре­вос­хо­дя­щих 16.

Имеем:

R(3)  =  1;

R(4)  =  2;

R(5)  =  3;

R(6)  =  R(5) + R(3)  =  3 + 1  =  4;

R(7)  =  R(6) + R(3)  =  4 + 1  =  5;

R(8)  =  R(7) + R(4)  =  5 + 2  =  7;

R(9)  =  R(8) + R(4)  =  7 + 2  =  9;

R(10)  =  R(9) + R(5)  =  9 + 3  =  12;

R(11)  =  R(10) + R(5)  =  12 + 3  =  15;

R(12)  =  R(11) + R(6)  =  15 + 4  =  19;

R(13)  =  R(12) + R(6)  =  19 + 4  =  23;

R(14)  =  R(13) + R(7)  =  23 + 5  =  28;

R(15)  =  R(14) + R(7)  =  28 + 5  =  33;

R(16)  =  R(15) + R(8)  =  33 + 7  =  40.

Ответ: 40.

При­ведём дру­гое ре­ше­ние на языке Python.

Ре­ше­ние. Обо­зна­чим R(n)  — ко­ли­че­ство про­грамм, ко­то­рые пре­об­ра­зу­ют число 2 в число n.

Верны сле­ду­ю­щие со­от­но­ше­ния.

1.  Если n нечётное, то тогда R(n)  =  R(n – 1) + R((n − 1) : 2) (если n > 3), так как есть два спо­со­ба по­лу­че­ния n: при­бав­ле­ни­ем еди­ни­цы или ис­поль­зо­ва­ни­ем ко­ман­ды 3.

2.   Если n чётное, но не де­лит­ся на 10, то тогда R(n)  =  R(n – 1) + R(n : 2) (если n > 2), так как есть два спо­со­ба по­лу­че­ния n: при­бав­ле­ни­ем еди­ни­цы или ис­поль­зо­ва­ни­ем ко­ман­ды 2.

3.   Если n чётное и де­лит­ся на 10, то тогда R(n)  =  R(n – 1) + R(n : 2) + R(n : 10), так как есть три спо­со­ба по­лу­че­ния n: при­бав­ле­ни­ем еди­ни­цы, ис­поль­зо­ва­ни­ем ко­ман­ды 2 или ис­поль­зо­ва­ни­ем ко­ман­ды 4.

До­ста­точ­но вы­чис­лить зна­че­ния R(n) для всех чисел не пре­вос­хо­дя­щих 15.

Имеем:

R(2)  =  2;

R(3)  =  3;

R(4)  =  R(3) + R(2)  =  5;

R(5)  =  R(4) + R(2)  =  5 + 2  =  7;

R(6)  =  R(5) + R(3)  =  7 + 3  =  10;

R(7)  =  R(6) + R(3)  =  10 + 3  =  13;

R(8)  =  R(7) + R(4)  =  13 + 5  =  18;

R(9)  =  R(8) + R(4)  =  18 + 5  =  23;

R(10)  =  R(9) + R(5) + R(1)  =  23 + 7 +1  =  31;

R(11)  =  R(10) + R(5)  =  31 + 7  =  38;

R(12)  =  R(11) + R(6)  =  38 + 10  =  48;

R(13)  =  R(12) + R(6)  =  48 + 10  =  58;

R(14)  =  R(13) + R(7)  =  58 + 13  =  71;

R(15)  =  R(14) + R(7)  =  71 + 13  =  84.

Ответ: 84.

При­ведём дру­гое ре­ше­ние на языке Python.

Ре­ше­ние. За­ме­тим, что все опе­ра­ции толь­ко лишь при­бав­ля­ют не­ко­то­рую кон­стан­ту к числу. По­это­му не важно, в каком по­ряд­ке вы­пол­нять не­ко­то­рый дан­ный набор ко­манд. Пусть x  — ко­ли­че­ство пер­вых ко­манд, y  — вто­рых, а z  — тре­тьих. Со­ста­вим урав­не­ние:

А имен­но  — найдём с его по­мо­щью все на­бо­ры ко­манд, ко­то­рые под­хо­дят под усло­вие. И уже для каж­до­го на­бо­ра в от­дель­но­сти под­счи­та­ем ко­ли­че­ство воз­мож­ных пе­ре­ста­но­вок.

Найдём все ре­ше­ния урав­не­ния: (0, 5, 0), (4, 2, 0), (1, 3, 1), (5, 0, 1), (2, 1, 2), (0, 0, 4).

Ко­ли­че­ство пе­ре­ста­но­вок для дан­но­го на­бо­ра по­счи­та­ем по фор­му­ле подсчёта пе­ре­ста­но­вок с по­вто­ре­ни­я­ми:

Пусть каж­до­го вида ко­манд a, b и с. Тогда всего пе­ре­ста­но­вок из этих ко­манд будет

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

Ответ: 73.

При­ведём дру­гое ре­ше­ние на языке Python.

Ре­ше­ние. Пусть R(x)  — ко­ли­че­ство про­грамм, ко­то­ры­ми можно из 2 по­лу­чить x.

За­ме­тим, что чётное число нель­зя по­лу­чить с ис­поль­зо­ва­ни­ем ко­ман­ды 3, по­сколь­ку в её про­цес­се скла­ды­ва­ет­ся чётное и нечётное число. Также за­ме­тим, что для того, чтобы по­лу­чить x с по­мо­щью ко­ман­ды 3, нужно при­ме­нять её к числу

Вы­чис­лим по­сле­до­ва­тель­но зна­че­ние R:

R(0)  =  0;

R(1)  =  0;

R(2)  =  1;

R(3)  =  R(2) + R(0) + R(2)  =  1 + 0 + 1  =  2;

R(4)  =  R(3) + R(1)  =  2 + 0  =  2;

R(5)  =  R(4) + R(2) + R(3)  =  2 + 1 + 2  =  5;

R(6)  =  R(5) + R(3)  =  5 + 2  =  7;

R(7)  =  R(6) + R(4) + R(4)  =  7 + 2 + 2  =  11;

R(8)  =  R(7) + R(5)  =  11 + 5  =  16;

R(9)  =  R(8) + R(6) + R(5)  =  16 + 7 + 5  =  28;

R(10)  =  R(9) + R(7)  =  28 + 11  =  39.

Ответ: 39.

При­ведём дру­гое ре­ше­ние на языке Python.

Ре­ше­ние. Для от­ве­та на за­да­чу нужно найти ко­ли­че­ство про­грамм, ко­то­рые из 2 по­лу­ча­ют 14, ко­ли­че­ство про­грамм, ко­то­рые из 14 по­лу­ча­ют 29, не про­хо­дя при этом через 25, и пе­ре­мно­жить най­ден­ные зна­че­ния. Сна­ча­ла найдём ко­ли­че­ство про­грамм, по­лу­ча­ю­щих 14.

Обо­зна­чим R(n) ко­ли­че­ство про­грамм, ко­то­рые пре­об­ра­зу­ют число 2 в число n.

Верны сле­ду­ю­щие со­от­но­ше­ния.

1.  Если n не де­лит­ся на 2, то тогда R(n)  =  R(n – 1), так как су­ще­ству­ет един­ствен­ный спо­соб по­лу­че­ния n из n – 1  — при­бав­ле­ние еди­ни­цы.

2.  Пусть n де­лит­ся на 2.

Тогда R(n)  =  R(n : 2) + R(n – 1).

Те­перь можно по­сте­пен­но вы­чис­лить все зна­че­ния:

R(4)  =  R(2) + R(3)  =  1 + 1  =  2  =  R(5);

R(6)  =  R(3) + R(5)  =  1 + 2  =  3  =  R(7);

R(8)  =  R(4) + R(7)  =  2 + 3  =  5  =  R(9);

R(10)  =  R(5) + R(9)  =  2 + 5  =  7  =  R(11);

R(12)  =  R(6) + R(11)  =  3 + 7  =  10  =  R(13);

R(14)  =  R(7) + R(13)  =  3 + 10  =  13.

Про­грам­ма, по­лу­ча­ю­щая из числа 14 число 29, не про­хо­дя­щих через 25, одна: 21.

Таким об­ра­зом, всего про­грамм 13 · 1  =  13.

Ответ: 13.

При­ведём дру­гое ре­ше­ние на языке Python.

Ре­ше­ние. Ис­поль­зу­ем метод ди­на­ми­че­ско­го про­грам­ми­ро­ва­ния. Возь­мем мас­сив dp, где dp[i]  — ко­ли­че­ство спо­со­бов по­лу­чить число i из еди­ни­цы с по­мо­щью дан­ных ко­манд.

База ди­на­ми­ки:

dp[1]  =  1.

Пе­ре­ход:

dp[i]  =  dp[i – 2] + dp[i – 5].

Тогда зна­че­ния в нашем мас­си­ве будут сле­ду­ю­щие (от 1 до 20): 1 0 1 0 1 1 1 2 1 3 2 4 4 5 7 7 11 11 16 18.

Ответ: 18.

При­ведём дру­гое ре­ше­ние на языке Python.

Ре­ше­ние. Пусть   — ко­ли­че­ство спо­со­бов по­лу­чить из числа 1 число х. За­ме­тим, что для x > 2:

Ответ: 89.

При­ведём дру­гое ре­ше­ние на языке Python.

Ре­ше­ние. Пусть R(n)  — ко­ли­че­ство про­грамм, ко­то­рые число 23 пре­об­ра­зу­ют в число n.

Верны сле­ду­ю­щие со­от­но­ше­ния.

1.  R(n)  =  R(n + 2)  — если n < 22.

2.  R(n)  =  R(n + 2) + R(n + 5)  — если n < 19.

R(23)  =  1;

R(22)  =  0;

R(21)  =  R(23)  =  1;

R(20)  =  R(22)  =  0;

R(19)  =  R(21)  =  1;

R(18)  =  R(20) + R(23)  =  1;

R(17)  =  R(19) + R(22)  =  1;

R(16)  =  R(18) + R(21)  =  2;

R(15)  =  R(17) + R(20)  =  1;

R(14)  =  R(16) + R(19)  =  3;

R(13)  =  R(15) + R(18)  =  2;

R(12)  =  R(14) + R(17)  =  4;

R(11)  =  R(13) + R(16)  =  4;

R(10)  =  R(12) + R(15)  =  5;

R(9)  =  R(11) + R(14)  =  7;

R(8)  =  R(10) + R(13)  =  7;

R(7)  =  R(9) + R(12)  =  11;

R(6)  =  R(8) + R(11)  =  11;

R(5)  =  R(7) + R(10)  =  16;

R(4)  =  R(6) + R(9)  =  18;

R(3)  =  R(5) + R(8)  =  23;

R(2)  =  R(4) + R(7)  =  29.

Таким об­ра­зом, ответ  — 29.

Ответ: 29.

При­ведём дру­гое ре­ше­ние на языке Python.

Ре­ше­ние. Решим за­да­чу с по­мо­щью языка про­грам­ми­ро­ва­ния PascalABC. На­пи­шем ре­кур­сив­ную функ­цию, под­счи­ты­ва­ю­щую не­об­хо­ди­мое ко­ли­че­ство про­грамм. Учтём, что в про­грам­ме не долж­но по­вто­рять­ся две ко­ман­ды умно­же­ния под­ряд. Для этого введём бу­ле­вую пе­ре­мен­ную multiplied. При­ведём код ре­ше­ния:

Таким об­ра­зом, ко­ли­че­ство про­грамм, удо­вле­тво­ря­ю­щих усло­вию за­да­чи и вы­ве­ден­ное на экран, равно 77.

Ответ: 77.

При­ведём ре­ше­ние на языке Python.

При­ведём ре­ше­ние Ти­му­ра Ва­си­лье­ва на языке Python.

Ре­ше­ние. При­ведём ре­ше­ние на языке Python.

Ответ: 18.

Ре­ше­ние. При­ведём ре­ше­ние на языке Python.

Здесь k   и с  — пе­ре­мен­ные, ко­то­рые от­ве­ча­ют за то, чтобы не по­вто­ря­лись умно­же­ние и сло­же­ние более двух раз под­ряд.

Ответ: 5.

При­ведём ре­ше­ние Ксе­нии Ель­цо­вой на языке Python.

Ре­ше­ние. При­ведём ре­ше­ние на языке Python.

Таким об­ра­зом, ко­ли­че­ство про­грамм, удо­вле­тво­ря­ю­щих усло­вию за­да­чи и вы­ве­ден­ное на экран, равно 9.

Ответ: 9.

При­ведём ре­ше­ние Аль­берт К. на языке Python.

При­ведём ре­ше­ние Юрия Кра­силь­ни­ко­ва на языке Python.

Ре­ше­ние. При­ведём ре­ше­ние на языке Python.

Здесь k  — счет­чик, ко­то­рый от­ве­ча­ет за то, сколь­ко раз было ис­поль­зо­ва­но умно­же­ние.

Ответ: 96.

При­ведём ре­ше­ние Юрия Кра­силь­ни­ко­ва на языке Python.

Ре­ше­ние. При­ведём ре­ше­ние на языке Python.

Ответ: 76.

Ре­ше­ние. При­ведём ре­ше­ние на языке Python.

Ответ: 6.

Ре­ше­ние. При­ведём ре­ше­ние на языке Python.

Ответ: 4.

При­ведём ре­ше­ние Ар­те­ма Мар­ко­ва на языке Python.

Ре­ше­ние. При­ведём ре­ше­ние на языке Python.

Ответ: 35.

Ре­ше­ние. При­ведём ре­ше­ние на языке Python.

Ответ: 34.

При­ведём ре­ше­ние Бо­ри­са Са­ве­лье­ва на языке Python.

Ре­ше­ние. При­ведём ре­ше­ние на языке Python.

Ответ: 34.

Ре­ше­ние. При­ведём ре­ше­ние на языке Python.

Ответ: 16.