Rsa97

prev < cur || prev == 4 && cur == 0 - по часовой.
иначе против часовой.
Ваш К.О.

Если у вас заранее определённый список призов и их количество известно (100 ручек, 10 блокнотов, 1 телефон), то можно создать общий массив, сделать shuffle и выдавать призы из полученного случайного массива по порядку.

Самое простое - в лоб

exit:
for (let l = 1; l < 10; l += 1) {
  for (let f = 1; f < 10; f += 1) {
    if (f === l) {
      continue;
    }
    for (let i = 0; i < 10; i += 1) {
      if (i === l || i === f) {
        continue;
      }
      for (let r = 0; r < 10; r += 1) {
        if (r === l || r === f || r === i) {
          continue;
        }
        for (let k = 0; k < 10; k += 1) {
          if (k === l || k === f || k === i || k === r) {
            continue;
          }
          for (let z = 0; z < 10; z += 1) {
            if (z === l || z === f || z === i || z === r || z === k) {
              continue;
            }
            for (let a = 0; a < 10; a += 2) {
              if (a === l || a === f || a === i || a === r || a === k || a === z) {
                continue;
              }
                const lirik = l * 10000 + i * 1010 + r * 100 + k;
                const fizika = f * 100000 + i * 10100 + z * 1000 + k * 10 + a;
                if (lirik * 2 === fizika) {
                  console.log(`lirik = ${lirik}`);
                  console.log(`fizika = ${fizika}`);
                  break exit;
                }
            }
          }
        }
      }
    }
  }
}

Вариант на JS.

Можно. Рекурсивный перебор 19 неубывающих слагаемых, 20-е как разница 465 и накопленной суммы. Если промежуточная сумма стала больше 465 или 20-е слагаемое получилось меньше 19-го, то вариант отбрасываем.
P.S. А вообще, учитывая отрицательные слагаемые, все варианты перебрать невозможно, их бесконечное количество.

x * y = 4608000
x² + y² = [6.73 * 522]² = 12341169

y = 4608000 / x
x² + 4608000² / x² = 12341169

x⁴ - 12341169 * x² + 21233664000000 = 0
D = 12341169² - 4 * 21233664000000 = 67369796286561
x² = (12341169 + sqrt(D)) / 2 = 10274539
x = 3205.392, y = 1437.578

Дальше можно посмотреть ближайшие стандартные разрешения и выбрать подходящее.

База асимметричного шифрования весьма проста. Для RSA:
Берём два простых числа p и s, например
p = 19
s = 13
Вычисляем их произведение n и функцию Эйлера f:
n = p * s = 247
f = (p - 1) * (s - 1) = 216
Подбираем коэффициент k и экспоненту e так, чтобы значение d = (k * f + 1)/e было целым
k = 9
e = 5
d = 389, целое
Пара (e, n) даёт нам ключ для шифрования, пара (d, n) - ключ для дешифрования.
crypted = message^e % n
decrypted = crypted^d % n
Очевидно, что из за операций по модулю мы можем шифровать сообщения в диапазоне [0, n - 1].
message = 200
crypted = 200⁵ % 247 = 174
decrypted = 174³⁸⁹ % 247 = 200
Основная сложность в том, что для защиты от подбора ключа нам нужны очень большие простые числа и значения n. Вот тут и возникают алгоритмы вычисления степеней, модулей и прочих операций с 1024-, 2048-, 4096-разрядными числами.

Решето Эратосфена всегда начинается с 2. Его принцип - на каждом шаге находим следующее невычеркнутое число, оно является простым. Для построения массива от 900000000 до 1000000000 необходимо вычеркнуть из этого массива все кратные простым числам от 2 до 500000000, а для этого надо эти простые найти.

function find(sum, n, m) {
  if (n === 1) {
    return [`${sum}`];
  }
  const result = [];
  const min = Math.max(m, Math.floor(sum - (n - 1) * 9));
  const max = Math.floor(sum / n);
  for (let i = min; i <= max; i += 1) {
    find(sum - i, n - 1, i).forEach((el) => result.push(`${i}${el}`));
  }
  return result;
}

function findAll(sum, n) {
  if (sum > n * 9 || sum < n) {
    return [];
  }
  const result = find(sum, n, 1);
  return [result.length, result[0], result.pop()];
}

На самом деле первый и последний элемент можно получить без формирования всех вариантов, но вот насчёт количества я не уверен.

O(1). У вас линейный код, циклов в нём нет.