Как найти результат выполнения программы

✎ Способ 1 (программный):
Pascalabc.net:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

begin var s0 := 1; while true do // внешний цикл, бесконечный begin var s := s0; // --- код из условия задания --- // var n := 1; while s <= 45 do // внутренний цикл из задания begin s := s + 4; n := n * 2; end; // --- конец кода из условия задания --- // if n = 256 then // если найдено, то выводим соответствующее s begin print(s0); break; // выход из бесконечного цикла end; s0 := s0 + 1; // end; end.

Пояснение:

• Поскольку в цикле s увеличивается, а по условию задания следует найти наименьшее значение s, то можно начать с s=1, постоянно увеличивая значение s на единицу во внешнем цикле.
• Важно для внешнего цикла использовать другую переменную, т.к. во внутреннем цикле переменная s меняется, а нам следует каждый шаг внешнего цикла сохранить предыдущее значение s, увеличив его всего на 1. Используем переменную S1 для этих целей.

Бейсик:	Python: s1 = 1 while True: # внешний цикл, бесконечный s = s1 # --- код из условия задания --- n = 1 while s <= 45: s = s + 4 n = n * 2 # --- конец кода из условия задания --- if n == 256: print(s1) break s1 += 1
С++:

✎ Способ 1 (программный):

Pascalabc.net:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

begin
  var s1 := 50;
  while true do // внешний цикл, бесконечный
  begin
    var s := s1;
    // --- код из условия задания --- //
    var n := 3;
    while s <= 51 do // внутренний цикл из задания
    begin
      s := s + 7;
      n := n * 2;
    end;
    // --- конец кода из условия задания --- //
    if n = 96 then // если найдено, то выводим соответствующее s
    begin 
        print(s1); 
        break;  // выход из бесконечного цикла 
    end;
    s1 := s1 - 1; // 
  end;
end.

Пояснение:

s1 = 50
while True:  # внешний цикл, бесконечный
    s = s1
    # --- код из условия задания --- 
    n = 3
    while s <= 51:
        s = s + 7
        n = n * 2
    # --- конец кода из условия задания --- 
    if n == 96:
        print(s1)
        break
    s1 -= 1

✎ Способ 1 (программный):
Pascalabc.net:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

begin var counter:=0; var d1:=1; while true do begin var d := d1; // из условия задачи var s := 15; var n := 10; while s <= 2400 do begin s := s + d; n:=n + 5; end; // проверка условий: увеличение счетчика if (d mod 10 = 8) and (n = 50) then begin counter+=1;; end; d1 += 1; // выход из бесконечного цикла if d1 = 2400 then break; end; print (counter) end.

• Вывод:

4

Бейсик:	Python: counter = 0 d1 = 1 while True: s = 15 n = 10 d = d1 # --- код из условия задания --- while s <= 2400: s = s + d n = n + 5 if d%10==8 and n==50: counter+=1 d1=d1+1 if d1 == 2400: break print (counter)
С++:

✎ Способ 1 (программный):
PascalAbc.NET:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

begin var s_ := -100; while true do begin var n := 600; var s := s_; while n > s do begin s := s + 3; n := n - 6 end; if n = 210 then print(s_); s_ += 1; if s > 1000 then break; end; end.

Вывод:

15 16 17 18 19 20 21 22 23

Записываем в порядке убывания:

2315

Python:

1 2 3 4 5 6 7 8 9 10 11 12 13 14

s_ = -100 while True: # внешний цикл, бесконечный s = s_ n = 600 # --- код из условия задания --- while n > s: s = s + 3 n = n - 6 # --- конец кода из условия задания --- if n == 210: print(s_) s_ += 1 if s > 1000: break

✎ Способ 1 (программный):
PascalAbc.NET:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

begin var s_ := 1000; while true do begin var n := 200; var s := s_; while s div n >= 2 do begin s := s + 5; n := n + 5 end; if (s > 99) and (s<1000) then begin print(s_); break; end; s_ -= 1; end; end.

Python:

1 2 3 4 5 6 7 8 9 10 11 12 13

s_ = 1000 while True: # внешний цикл, бесконечный s = s_ n = 200 # --- код из условия задания --- while s // n >=2: s = s + 5 n = n + 5 # --- конец кода из условия задания --- if 99 < s < 1000: print(s_) break s_ -= 1

✎ Способ 1 (программный):
PascalAbc.NET:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

begin var x := 1; var count := 0; while true do begin var s := 6 * (x div 15); var n := 1; while s < 300 do begin s := s + 18; n := n * 2 end; if (n >= 2) and (n <= 500) then count += 1; x += 1; if x > 1000 then break; end; print(count) end.

Python:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

x = 1 count = 0 while True: # внешний цикл, бесконечный s = 6 * (x // 15) n = 1 while s <300: s = s + 18 n = n * 2 # --- конец кода из условия задания --- if 1 < n < 501: count+=1 x += 1 if x > 1000: break print (count)

Определите, где и какое число в формуле пропущено?

Паскаль:

• Рассмотрим формулу:


Фактически она обозначает: сумма xk/ k! для всех k, начиная от 1 до n.

• Рассмотрим алгоритм программы:
• Основные действия происходят в цикле, в котором k изменяется от 1 до n (n вводится в начале программы):

For k:=1 to n do

• В следующей строке кода происходит вычисление факториала числа k (в первой итерации цикла 1!, во второй итерации 2! и т.д.):

p:=p * k;

• Следующее выражение служит для подсчета x в степени k (переменной l в начале программы присваивается значение введенного x):

l:=l*x;

• Основная же формула сумматора заключена в строке:

s:=s + 3*l/p;

• Видим, что в исходной заданной формуле в числителе отсутствует число 3.
• Т.е. исходная формула должна была выглядеть так:

Рассмотрим алгоритм программы:

• В цикле k увеличивается на единицу (k — счетчик). Соответственно, k будет равно количеству итераций (повторов) цикла. После завершения работы цикла k выводится на экран, т.е. это и есть результат работы программы.
• В цикле s увеличивается на 64. Для простоты расчетов возьмем начальное s не 512, а 0. Тогда условие цикла поменяется на s < 1536 (2048 — 512 = 1536):

s:=0;
k:=0;
while s < 1536 do
   begin
   ...

• Цикл будет выполняться пока s<1536, а s увеличивается на 64, отсюда следует что итераций цикла (шагов) будет:

1536 / 64 = 24

• Соответственно, k = 24.

• Рассмотрим алгоритм. Цикл зависит от переменной s, которая уменьшается каждую итерацию цикла на 2.
• В цикле также присутствует счетчик — переменная i, которая увеличится на единицу ровно столько раз, сколько итераций (проходов) цикла. Т.е. в результате выполнения программы распечатается значение, равное количеству итераций цикла.
• Поскольку условие цикла зависит от s, нам необходимо посчитать, сколько раз сможет s уменьшиться на 2 в цикле. Для удобства подсчета изменим условие цикла на while s > 0; так как мы s уменьшили на 5, соответственно, изменим и 4-ю строку на s:=100 (105-5):

...
s := 100;
while s > 0 do
begin
...

• Для того чтобы посчитать, сколько раз выполнится цикл, необходимо 100 разделить на 2, т.к. s каждый шаг цикла уменьшается на 2:

  100 / 2 = 50 -> количество итераций цикла
  

• В 3-й строке видим, что начальным значением i является 1, т.е. в первую итерацию цикла i = 2. Значит, нам необходимо к результату (50) прибавить 1.

50 + 1 = 51

• Это значение и будет выведено на экран.

Рассмотрим алгоритм:
• Цикл зависит от значения переменной s, которая изначально равна 260. В цикле переменная s постоянно меняет свое значение, уменьшаясь на 15.
• Цикл завершит свою работу когда s <= 0. Значит, необходимо посчитать сколько чисел 15 «войдет» в число 260, иными словами:

260 / 15 ~ 17,333...

• Эта цифра должна соответствовать количеству шагов (итераций) цикла. Так как условие цикла строгое — s > 0, то увеличим полученное число на единицу:

17 + 1 = 18 итераций цикла

Проверим:
17 * 15 = 255  (< 260)
18 * 15 = 270 (> 260)

• Проверим на более простом примере. Допустим, изначально s=32. Два прохождения цикла даст нам s = 32/15 = 2,133... Число 2 больше 0, соответственно, цикл будет работать еще третий раз.
• В результате работы программа распечатывает значение переменной n (искомый результат). В цикле переменная n, изначально равная 0, увеличивается на 2. Так как цикл включает 18 итераций, то имеем:

n = 18 * 2 = 36

• с каждым шагом цикла значение s увеличивается на 36, пока не станет больше 365; а значение n увеличивается в 2 раза, так что n=2^k, где k – это число итераций цикла;
• поскольку s увеличивается на 36, конечное значение s должно быть равно 0+36*k , достигается при k=11 (и s=36*11=396);
• тогда n = 2^k = 2¹¹ = 2048.

• В алгоритме присутствует цикл. Для того, чтобы разобраться в алгоритме, выполним трассировку начальных итераций цикла:

№ шага	условие цикла	s	n
1	522-400=122 122 > 0	522-20=502	400-15=385
2	502-385=117 117 > 0	502-20=482	385-15=370
3	482-370=112 112 > 0	…	…

• Видим, что в условии разница между значениями составляет 5:

122 - 117 = 5
117 - 112 = 5
...

• Таким образом, чтобы определить количество итераций (шагов) цикла, необходимо значение условия цикла, полученное в первой итерации, разделить на 5:

122 / 5 = 24,4

24 * 5 = 120 (120 + 2 = 122)

Это значит, что на 24-й итерации цикла переменные s и n получили такие значения, после которых условие еще осталось истинным: 2 > 0. На 25-м шаге выполняется это условие:

№ шага	условие цикла	s	n
25	2 > 0	s-20=…	n-15=…

• В конце выполнения 25-й итерации, получаем условие для 26-й итерации:

25 * 5 = 125 (125 - 3 = 122)

№ шага	условие цикла	s	n
25	2 > 0	s-20=…	n-15=…
26	3 < 0	не выполняется	не выполняется

• Значит, всего в цикле присутствует 25 итераций, в каждой из которых s уменьшается на 20. Посчитаем, на сколько уменьшится значение s в общем:

25 * 20 = 500 (за 25 итераций)

522 - 500 = 22 (вычитаем из исходных данных)

Результат: 22

• Для условия цикла — перенесем влево:

n - s > 0

• Согласно начальным значениям, имеем:

55 - 10 = 45

• Запишем, как будет изменяться условие цикла в каждой итерации (в каждом шаге):

n - 1 > s + 1 =>
n - s - 2 > 0

• Т.е. условие цикла будет истинным пока возможно вычитать 2. Сколько раз можно вычесть два из 45?

для 22 итераций:
2 * 22 = 44
в условии цикла имеем 45 > 44, т.е. условие еще истинно
для 23 итераций:
2 * 23 = 46
в условии цикла имеем 45 > 46 - условие ложно, т.е. цикл прекращает работу

• Соответственно, получили 23 итерации цикла.
• Изначально n = 55. С каждой итерацией выполнялось n-1. Посчитаем n:

n = 55 - 23 = 32

При каком наименьшем целом введенном числе d после выполнения программы будет напечатано число 192?

Паскаль:

Рассмотрим алгоритм программы:

• Цикл зависит от переменной k, которая каждую итерацию цикла увеличивается на значение d (вводимое). Цикл закончит «работу», когда k сравняется с 200 или превысит его (k >= 200).
• Результатом программы является вывод значения переменной s. В цикле s увеличивается на 64.
• Так как по заданию необходимо, чтобы вывелось число 192, то число повторов цикла определим так:

64 * x = 192
число повторов: x = 192 / 64 = 3  

• Так как в цикле k увеличивается на значение d, а повторов цикла 3 (при этом цикл завершается при k>=200), составим уравнение:

3 * d = 200 
d = 200/3 ~ 66,66

• Поскольку число получилось нецелое, то проверим и 66 и 67. Если мы возьмем 66, то:

66 + 66 + 66  = 198  (< 200)

т.е. цикл после трех прохождений еще продолжит работу, что нам не подходит.

• Для 67:

67 + 67 + 67 = 201 (>200)

• Данное число 67 нас устраивает, оно наименьшее из возможных, что и требуется по заданию.

Разберем листинг программы:

• Цикл программы зависит от значения переменной s, которая в цикле постоянно увеличивается на значение d (d вводится пользователем в начале программы).
• Кроме того, в цикле переменная n увеличивается на 8. Значение переменной n выводится на экран в конце программы, т.е. по заданию n к концу программы должно n = 153.
• Необходимо определить количество итераций цикла (прохождений). Так как начальное значение n = 33, а в конце оно должно стать 153, в цикле увеличиваясь на 8, то сколько раз 8 «поместится» в 120 (153 — 33)? :

120 / 8 = 15 раз (количество итераций цикла)

• Как мы определили, цикл зависит от s, которая в начале программы s = 4. Для простоты работы примем, что s = 0, тогда изменим и условие цикла: вместо s <= 1725 сделаем s <= 1721 (1725-1721)

...
 s := 0;
 while s <= 1721 do begin
...

• Найдем d. Так как цикл выполняется 15 раз, то необходимо найти такое целое число, которое при умножении на 15 возвращало бы число большее 1721:

1721 / 15 = 114,733 - не целое, не подходит
1722 / 15 = 114,8 - не целое, не подходит
...
берем кратное 5:
1725 / 15 = 115 - целое, подходит!

• 115 — это наименьшее d при котором n станет равным 153 (за 15 шагов цикла).
• Найдем наибольшее d. Для этого надо найти такое число, которое соответствует неравенствам:

14 * d <= 1721
при этом:
15 * d > 1721

• Найдем:

14 * 122 = 1708 (<=1721)
15 * 122 = 1830 (>1721)

• Наибольшее d=122

Разберем листинг программы:

• В цикле переменная s постоянно увеличивается на единицу (работает как счетчик), а переменная n в цикле увеличивается на 2.
• В результате работы программы на экран выводится значение n.
• Цикл зависит от s, причем работа цикла завершится когда 2 * s² >= 123.
• Необходимо определить количество прохождений цикла (итераций цикла): для этого определим такое наименьшее возможное s, чтобы 2 * s² >= 123:

1 шаг: s = 2*12=2
2 шаг: s = 2*22=8
3 шаг: s = 2*32=18
...
7 шаг: s = 2*72=98 (меньше 123, т.е. цикл еще работает)
8 шаг: s = 2*82=128 (больше 123, цикл не работает! )

Либо просто нужно было бы найти такое наименьшее возможное четное число >= 123, которое при делении на 2 возвращало бы вычисляемый корень числа:

s=124/2 = √62 - не подходит!
s=126/2 = √63 - не подходит!
s=128/2 = √64 = 8 - подходит!

• Таким образом, программа выполнит 8 итераций цикла.
• Определим n, которая увеличивается каждый шаг цикла на 2, значит:

n = 2 * 8 = 16

Разберем листинг программы:

• Результатом программы является вывод значения s.
• В цикле s меняется, увеличиваясь на k, при начальном значении s = 3.
• Цикл зависит от k. Выполнение цикла завершится при k >= 25. Начальное значение k = 1.
• В цикле k постоянно увеличивается на 2 -> значит, можно найти количество итераций цикла.
• Количество итераций цикла равно:

n = 25 / 2 ~ 12 

(т.к. k изначально равнялось 1, то в последнее, 12-е прохождение цикла, k = 25; условие цикла ложно)

• В s накапливается сумма арифметической прогрессии, последовательность элементов которой удобней начать с 0 (а не с 3, как в программе). Поэтому представим, что в начале программы s = 0. Но при этом не забудем, что в конце нам необходимо будет к результату прибавить 3!

s:=0;
k:=1;
while k < 25 do begin
 ...

• Тогда арифметическая прогрессия будет выглядеть:

1 + 3 + 5 + 7 ... 
количество членов прогрессии - 12, т.к. 12 итераций цикла

• Существует формула вычисления суммы арифметической прогрессии:

s = ((2 * a1 + d * (n — 1)) / 2) * n

где a1 — первый член прогрессии,
d — разность,
n — количество членов прогрессии (в нашем случае — кол-во итераций цикла)

• Подставим значения в формулу:

(2 * 1 + 2 * 11) / 2 * 12 = 144

• Не забудем, что мы к результату должны прибавить 3:

144+3 = 147

• Это и есть значение s, которое выводится в результате работы программы.

Рассмотрим алгоритм:

• Условие цикла зависит от переменной n, которая изменяется в цикле согласно получению степеней двойки:

1  2  4  8  16  32  64  128  256  512  1024

• Когда переменная n принимает значение 1024 (11-й шаг цикла), условие цикла становится ложным и цикл перестает работать. На экран выводится значение s.
• Переменная s — это сумма элементов геометрической прогрессии, т.к. в ней аккумулируются значения n (числовой ряд, представляющий собой геометрическую прогрессию).
• Вспомним формулы суммы геометрической прогрессии:

1.

[ S_{n} = frac {b_1-b_{n}*q}{1-q} ]

2.

[ S_{n} = b_{1} * frac {1-q^n}{1-q} ]

• В нашем случае знаменатель q = 2, первый элемент прогрессии b₁ = 1. Обратим внимание, что на последнем шаге к сумме добавляется значение 512, т.е. n = 10, а b_n = 512. Только после этого n еще раз увеличивается в 2 раза и становится = 1024.
• Вычислим s по формуле, подставив необходимые значения:

[ S_{n} = frac {1-512*2}{1-2} =1023 ]

• Проверим по второй формуле:

[ S_{n} = 1 * frac {1-2^{10}}{1-2}=1023 ]

• Так как в результате на экран выводится s, то ответ 1023.

s := 0;
n := 1;
for i := 0 to 11 do
 if A[i] > A[n] then
  s := s + A[i] + i
 else
  A[n] := A[i];

s:=0;
n:=10;
for i:=0 to n-1 do begin
  s:= s + A[i] + A[i+1]
end;

В начале выполнения этого фрагмента в массиве находились двухзначные четные натуральные числа.

  
Какое наибольшее значение может иметь переменная s после выполнения данной программы?

Рассмотрим алгоритм фрагмента программы:

• Цикл выполняется 10 раз: от 0 до 9 (т.к. n-1).
• В цикле повторяется операция, суммирующая два подряд идущих элемента массива, — текущего и следующего:

A[i] + A[i+1]

• Данная сумма накапливается в переменной s, значение которой требуется узнать в задаче.
• Поскольку по заданию необходимо найти наибольшее значение переменной s, и по заданию элементы массива — двухзначные четные натуральные числа, то представим, что все элементы равны самому большому двухзначному четному числу — 98. Это будет оптимальным вариантом.
• В первый проход цикла получим:

s = 0 + 98 + 98 = 196

• Полученная сумма будет каждый проход цикла увеличиваться на то же самое число (196):

s = 196 + 98 + 98

• Так как проходов (итераций) цикла 10, то получим:

196 * 10 = 1960

s:=1;
n:=10;
for i:=1 to 5 do begin
  s:= s * A[i] * A[n-i+1]
end;

В начале выполнения этого фрагмента в массиве находились однозначные четные натуральные числа.

  
Какое наименьшее значение может иметь переменная s после выполнения данной программы?

Рассмотрим алгоритм фрагмента программы:

• Цикл выполняется 5 раз: от 1 до 5.
• В цикле повторяется операция произведения двух элементов массива:

A[i] * A[n-i+1]

• Определим, какие элементы перемножаются, подставив для n и i конкретные значения:

1 шаг: A[1]*A[10]
2 шаг: A[2]*A[9]
3 шаг: A[3]*A[8]
4 шаг: A[4]*A[7]
5 шаг: A[5]*A[6]

• Результат каждой операции умножения накапливается в переменной s, значение которой и требуется найти.
• Поскольку в s накапливается произведение элементов массива, а по заданию элементы — однозначные четные натуральные числа, то представим, что в массиве все элементы равны самому малому однозначному четному числу — 2. Это будет оптимальным вариантом, т.к. по заданию, необходимо определить наименьшее значение.
• В первый проход цикла получим:

s = 1 * 2 * 2 = 4

• Полученное произведение будет каждый проход цикла перемножаться на предыдущее значение (4 — в первом шаге, 16 — во втором шаге и т.п.):

s = 4 * 2 * 2 = 16
...

• Так как проходов цикла 5, то получим:

45 = 1024

• Рассмотрим изменение всех переменных и элементов массива для каждой итерации (прохода) цикла:

№	1	2	3	4	5	6	7	8	9
i	1	2	3	4	5	6	7	8	9
if	3>4 true	4>6 false	7>6 true	2>14 false	9>14 false	1>14 false	2>14 false	3>14 false	0>14 false
c	1	—	2	—	—	—	—	—	—
t	3	—	7	—	—	—	—	—	—
A[i]	1		6
A[0]	6	—	14	—	—	—	—	—	—

• В задании используется цикл while — с предусловием. Такой цикл выполняется пока условие истинно.
• В условии цикла сумма каждого элемента массива с предыдущим, начиная с девятого (j=9), сравнивается с числом 4: если сумма элементов больше 4 то цикл выполняется.

Для первой итерации цикла имеем:
while A[9] + A[8] > 4 do
...

• Как только встретится сумма элементов, которая меньше либо равна четырем, цикл прекратит свою работу.
• В цикле происходит обмен значений двух элементов массива, сумма которых рассматривается в условии цикла (через переменную t). Кроме того, происходит уменьшение счетчика цикла, чтобы осуществился переход к следующему элементу массива (j:=j-1).
• Таким образом, надо узнать сумму элементов, начиная с элементов A[9]+A[8], затем A[8]+A[7] и т.д.:

A[9]+A[8] = 3+6 > 4 - да, значит обмен: A[9]=6 A[8]=3, j=8
A[8]+A[7] = 3+9 > 4 - да, значит обмен: A[8]=9 A[7]=3, j=7
A[7]+A[6] = 3+8 > 4 - да, значит обмен: A[7]=8 A[6]=3, j=6
A[6]+A[5] = 3+1 > 4 - нет, цикл прекращает свою работу

• Последнее значение счетчика j было равно 6.

• Рассмотрим алгоритм. Построим трассировочную таблицу, каждая строка которой — очередная итерация цикла.

i	<= ?	0	1	2	3	4	5	6	7	8	9	s	n
		21	16	7	12	18	3	8	13	11	17	0	4
0	21<=18 нет	21				18
1	16<=18 да		16 18			18 16						16	1 mod 3 = 1
2	7<=18 да		18 7	7 18								16+7=23	2 mod 3 = 2
3	12<=18 да			18 12	12 18							23+12=35	3 mod 3 = 0
4	16<=21 да	21 16				16 21						35+16=51	4 mod 3 = 1
5	3<=7 да		7 3				3 7					51+3=54	5 mod 3 = 2
6	8<=12 да			12 8				8 12				54+8=62	6 mod 3 = 0
7	13<=16 да	16 13							13 16			62+13=75	7 mod 3 = 1
8	нет		3							11
9	нет	13										17

• При последнем изменении s стало равным 75.

Рассмотрим алгоритм.
• В конце программы видим, что на экран выводится значение переменной m. То есть после выполнения всего алгоритма m станет равным 5. Запомним это.
• Изначально переменная N равна значению 5:
• В первом цикле формируются значения для пяти элементов массива:

  for k := 1 to N do      
    readln(Dat[k]);

• Во втором цикле видим условие, в котором каждый из пяти элементов массива будет сравниваться с m. Если элемент больше m, то в m сохранится значение этого элемента:

   if  Dat[k]>m then
      begin
        m := Dat[k]
      end

• Исходя из первого нашего пункта имеем, что наибольшее значение из пяти элементов массива — это значение 6. Так как в результате m = 6.
• В цикле помимо условия находится сумматор, который суммирует 2 * Dat[k]. В задании необходимо определить наибольшее значение S, значит, выгодно, чтобы элементы массивов имели максимальное возможное значение.
• Предположим, что все пять элементов массива равны 6. Тогда m после прохождения цикла останется равной 6. То есть результат будет верным.
• Посчитаем S в цикле:

S := 0 + 2 * 6 + 2 * 6 + 2 * 6 + 2 * 6 + 2 * 6 = 12 * 5 = 60