Help me please

№1.

представить фрагмент алгоритма в виде блок-схемы. составить программу, соответствующую данной блок-схеме.

a: = 18

b: = 10

a: = b - a/3

b: = 12/a*2

№2.

представить фрагмент алгоритма в виде блок-схемы. составить программу, соответствующую данной блок-схеме.

a: =3

b: =10

a: =b - 24/a

b: =12/a*3

№ 3. представить фрагмент алгоритма в виде блок-схемы. составить программу, соответствующую данной блок-схеме.

a: =50

b: =33

a: =(b-11)/2*7

b: =2*(a-b)+3*(a+b)

№ 4. представить фрагмент алгоритма в виде блок-схемы. составить программу, соответствующую данной блок-схеме.

a: =24

b: =12

a: =a*b/32

b: =8*a+4*b

Алгоритм. Отсортируем массив за O(nlogn). Запустим цикл по всем k, в теле цикла будем искать индексы i <= j, такие, что A[i] + A[j] = -A[k]. Понятно, что этот поиск надо делать за O(n), чтобы общее время работы было квадратичным.

Искать будем с двух указателей. Рассмотрим кусок массива, в котором ищем ответ A[l..r] (первоначально l = 1, r = n). Посмотрим на A[l] + A[r]. Если эта сумма больше, чем нужно, уменьшим на 1 число r, если меньше - увеличим на 1 число l, если равно -A[k] - победа, выводим ответ (l, r, k). Будем повторять это в цикле, пока l не станет больше r.

Если после выполнения цикла по k искомая тройка так и не нашлась, пишем "нет".

Корректность. Пусть в какой-то момент A[l] + A[r] < -A[k]. Тогда, чтобы иметь возможность получить A[i] + A[j] = -A[k], надо сумму увеличить. A[l] оказалось настолько мало, что даже если прибавить к нему самое большое возможное число (а это как раз A[r] - массив-то отсортирован!), то всё равно получается слишком мало. Значит, A[l] в ответе не будет, и можно безбоязненно выкинуть его из рассмотрения. Аналогично будет и в случае, когда A[l] + A[r] > -A[k].
Осталось показать, что если такая тройка индексов существует, то наш алгоритм не выдаст неверный ответ "нет". Но это очевидно: если ответ (I, J, K), то уж при k = K алгоритм что-нибудь да найдёт.

Время работы. Внутренний цикл выдает ответ не более чем за линейное время: всякий раз размер массива уменьшается на 1, всего элементов в массиве n, а на каждом шаге тратится константное время; пусть время выполнения внутреннего цикла T'(n) < an. Тогда все n проходов внешнего цикла затратят время T1(n) <= n T'(n) < an^2.
Сортировку можно сделать за время T2(n) < b nlogn < bn^2
Общее время работы T(n) = T1(n) + T2(n) < an^2 + bn^2 = cn^2

Программа

 {

покажись;

в_точку ( -125 ,-100 );

опусти_перо;

вперед ( 100 );

вправо ( 90 );

вперед ( 50 );

вправо ( 90 );

вперед ( 100 );

подними_перо;

в_точку ( -55 ,-50 );

опусти_перо;

вперед ( 50 );

влево ( 90 );

вперед ( 27 );

влево ( 90 );

вперед ( 50 );

влево ( 90 );

вперед ( 27 );

подними_перо;

 в_точку ( -10 ,-100 );

 опусти_перо;

 вправо ( 105 );

 вперед ( 52 );

 вправо ( 150 );

 вперед ( 52 );

 вправо ( 15 );

 подними_перо;

 в_точку ( 35 ,-50 );

 опусти_перо;

 вперед ( 50 );

 влево ( 150 );

 вперед ( 54 );

 вправо ( 150 );

 вперед ( 50 );

 подними_перо;

 в_точку ( 80 ,-50 );

 опусти_перо;

 вперед ( 50 );

 влево ( 180 );

 вперед ( 25 );

 вправо ( 90 );

 вперед ( 27 );

 влево ( 90 );

 вперед ( 25 );

 влево ( 180 );

 вперед ( 50 );

 подними_перо;

 в_точку ( 125 ,-100 );

 опусти_перо;

 вправо ( 195 );

 вперед ( 52 );

 вправо ( 150 );

 вперед ( 52 );

 вправо ( 15 );

 влево ( 90 );

 подними_перо;

 в_точку ( 125 ,-75 );

 опусти_перо;

 вперед ( 27 );

 подними_перо;

 в_точку ( 175 ,-100 );

 }