Rsa97

Здесь вы получаете вещественное значение $m:
$m = floor(($l + $h) / 2);
А здесь пытаетесь использовать вещественное значение в качестве индекса:

$freq[ord($strdata[$i - $m]) - ord('a')] -= 1; 
$freq[ord($strdata[$i]) - ord('a')] += 1;

Используйте intdiv, а не floor:
$m = intdiv(($l + $h), 2);

'абвгдеёжзийклмнопрстуфхцчшщъыьэюя' => 'бавгдеёжзийклмнопрстуфхцчшщъыьэюя'
Результат должен быть 0, у вас 1.
Фокус в том, что если есть цикл замен (а => б => а), то должна быть хоть одна свободная буква для того, чтобы разорвать этот цикл. При этом цикл может быть из произвольного количества замен (а => б => в => г => а). Учитывайте, что буква может освободиться при предыдущих заменах.

Случайные данные - это наихудший вариант для сжатия. Практически все алгоритмы сжатия данных без потерь основаны на поиске закономерностей и повторяющихся последовательностей. В случайной последовательности нет ни того, ни другого.

Питона не знаю, пишу псевдокодом:

delta = arr[1] - arr[0]
max_count = 2
count = 2
for (i = 1; i < length(arr)-1; i += 1) {
  if (arr[i+1] - arr[i] == delta) {
    count += 1
  } else {
    delta = arr[i+1] - arr[i]
    count = 2
  }
  if (count > max_count) {
    max_count = count
  }
}

Бинарный поиск работает только по упорядоченному массиву.

Поскольку речь о делителях, то надо рассматривать только простые числа.
999 < x * (91 * x) < 10000
999/91 < x² < 10000/91
3.313 < x < 10.483
x - простое число
Решениями будут 5 и 7
5 * (91 * 5) = 2275
7 * (91 * 7) = 4459

Смотрите, подаём на вход массив [1, 2, 3]
fundam = Math.round(3 / 2) = 2.
arr[2] = 3
less = [1, 2, 3], так как в него попадают все элементы, меньшие или равные 3
greater = []
И снова вызываем сортировку массива [1, 2, 3]. Всё повторяется заново. При этом само число 3 будет добавлено в результат ещё раз.

Во-первых, брать надо не round, а floor.
Во-вторых, должно быть три массива - меньше опорного числа, равные ему и больше него.

const qSort = (arr) => {
  if (arr.length < 2) {
    return arr;
  }
  const fund = arr[Math.floor(arr.length / 2)]
  let less = []
  let equal = []
  let greater = []
  for (let i = 0; i < 0; i += 1) {
    if (arr[i] < fund) {
      less.push(arr[i])
    }
    if (arr[i] === fund) {
      equal.push(arr[i])
    }
    if (arr[i] > fund) {
      greater.push(arr[i])
    }
  }
  return qSort(less) + equal + qSort(greater)
}

x = rand(1, 97);
y = rand(1, 98-x);
z = rand(1, 99-x-y);
result = sort([x, y, z, 100-x-y-z]);

Один поезд начинает движение влево, второй вправо, какой именно куда - неважно. Если не встретились, то через время t меняют направление движения. Потом через время 2t, 3t, 4t и т.д. Как вариант t, 2t, 4t, 8t.

Находим разбиение числа путей на простые множители. Строим между точками A и B дополнительные слои, в каждом из которых количество точек соответствует следующему множителю. Соединяем точку A со всеми точками первого слоя, каждую из точек первого слоя со всеми точками второго слоя и т.д., все точки последнего слоя с точкой B.

Оценка сложности алгоритма O() - это то, как меняется время вполнения алгоритма от изменения объёма обрабатываемых этим алгоритмом данных.
O(1) - время не зависит от объёма данных.
O(n) - время растёт пропорционально объёму данных.
O(n²) - время растёт пропорционально квадрату объёма данных.
и т.д.

Получение длины строки может иметь разную сложность в зависимости от языка программирования. Если используется хранение строк с префиксом длины, как в Паскале, то сложность будет O(1), так как достаточно только прочитать хранящееся значение. Если же строка хранится как в C/C++, с нулевым байтом в конце, то сложность будет O(n), так как надо в цикле перебрать все байты строки, пока не найдём ноль.

А что вам дадут секунды?
Вот у вас есть две программы, обрабатывающие одни и те же данные и получающие одни и те же результаты по разным алгоритмам. Первая программа делает это за 10 секунд, вторая за 20. Как оценить, насколько вырастет время обработки при увеличении объёма данных в 10 раз?
Никак, пока мы не знаем сложности алгоритма. Если первый имеет сложность O(n²), а второй - O(n), то время работы первого вырастет в 100 раз и составит 1000 секунд, а второго - всего в 10 раз (200 секунд). То есть, программа, которая была быстрее на малом наборе данных, внезапно становится гораздо медленнее на большом наборе. И определяющим параметром здесь становится именно вычислительная сложность алгоритма.

Предположим, что мы бросили n-1 монет и получили какое-то количество единиц (орлов). Бросаем следующую монету (n). Если выпадет ноль (решка), то количество единиц не изменится, и чётность останется той же. Если выпадет единица, то чётность изменится.
P^odd_n = P^odd_n-1*P⁰_n + P^even_n-1*P¹_n
P^even_n = P^even_n-1*P⁰_n + P^odd_n-1*P¹_n
Но, поскольку события P^even_n и P^odd_n образуют полный набор вариантов (либо чёт, либо нечет), то P^even_n + P^odd_n = 1.
Аналогично, P⁰_n + P¹_n = 1.
Отсюда, P^odd_n = P^odd_n-1*(1-P¹_n) + (1-P^odd_n-1)*P¹_n

var Podd = 0;
var Peven = 1;
for (var i = 1; i <= 100; i++) {
  P1 = 1 / (2 * i + 1);
//  P0 = 1 - P1;
//  Po = Podd * P0 + Peven * P1;
//  Peven = Podd * P1 + Peven * P0;
//  Podd = Po;
// Всё, что выше, ужимается в
  Podd = Podd * (1 - P1) + (1 - Podd) * P1;
}
console.log(Podd);
// 0.49751243781094556

Логарифмическая шкала.