╓──────────────────────────────────────────╖
║     Структурированная программа:         ║
╙──────────────────────────────────────────╜

Alg Primes;
arg x;
  t = 2;
  while t < x do
    i = 2;
    while i < t do
      flag = 0;
      j = 2;
      while j * j < i do
        if i % j = 0 then
          flag = 1;
        end;
        j = s(j);
      end;
      if flag = 0 then
        if t % i = 0 then
          k = t / i;
          flag = 0;
          j = 2;
          while j * j < k do
            if k % j = 0 then
              flag = 1;
            end;
            j = s(j);
          end;
          if flag = 0 then
            res = s(res);
          end;
        end;
      end;
      i = s(i);
    end;
    t = s(t);
  end;
  Primes = res;
end;


╓─────────────────────────────╖
║   Объяснение на словах:     ║
╙─────────────────────────────╜

Требуется программа, находящая КОЛИЧЕСТВО чисел, меньших x, являющихся
произведением двух простых чисел. Принцип поиска количества таков: Для
всех чисел t от 2 до x выполняется подбор такого числа i, чтобы оно было
простым и при этом t / i тоже было бы простым. Тогда t = (t / i) * i, что
очевидно, то i и (t / i) -- простые по условию, а следовательно t есть
произведение двух простых. Если такое число найдено, счётчик res
увеличивается, и поиск продолжается. После выполнения внешнего цикла --
то есть перебора всех чисел-"кандидатов", результатом выполнения
становится значение счётчика res, то есть результат -- количество
найденных чисел, что и требуется по условию.

╓────────────────────────────────────────────╖
║   Оценки сложности по времени и памяти:    ║
╙────────────────────────────────────────────╜

Память: Никакие переменные не принимают значений больших, чем входное x,
так что формально это, очевидно, O(n), но зная теорему о простой программе
и видя в тестах выражения вида i * i в качестве оценки сверху дадим ответ
O(n^2) ("о-большое от эн в квадрате")
Время: проверка на простоту в цикле -- это O(sqr(n)) ("о-большое от корень
из эн"). В теле промежуточного цикла их две, но это не влияет на сложность
(следование). Промежуточный цикл имеет линейную сложность, а его тело, как
мы выяснили -- O(sqr(n)), таким образом сложность промежуточного цикла --
O(n * sqr(n)) ("о-большое от эн на корень из эн"). Внешний цикл также
линеен, и получаем общую сложность алгоритма по времени O(n^2*sqr(n))
("о-большое от эн квадрат на корень из эн"). (Если нигде не облажались.)

╓─────────────────────────────────────────────────────────────╖
║   Функциональная программа, реализующая ту же функцию:      ║
╙─────────────────────────────────────────────────────────────╜

Sub isPrime;
arg x, i;
  if i * i < x then
    if x % i = 0 then
      isPrime = 0;
    else
      isPrime = isPrime(x, s(i));
    end;
  else
    isPrime = 1;
  end;
end;

Sub cyckle;
arg x, i;
  if i * i < x  then
    if x % i = 0 then
      if isPrime(i, 2) = 1 then
        if isPrime(x / i, 2) = 1 then
          cyckle = 1;
        else
          cyckle = cyckle(x, s(i));
        end;
      else
        cyckle = cyckle(x, s(i));
      end;
    else
      cyckle = cyckle(x, s(i));
    end;
  else
    cyckle = 0;
  end;
end;

Sub doIt;
arg x, t, res;
  if t < x then
    doIt = doIt(x, s(t), res + cyckle(t, 2));
  else
    doIt = res;
  end;
end;

Alg Primes;
arg x;
  Primes = doIt(x, 2, 0);
end;