Wataru

Скобки вокруг *arr расставьте. И еще, вы зря делаете malloc() для самих строк - вы потом присваеваете адрес строковой константы. Или делайте strcopy, или не выделяйте память под (*arr)[i].

Можно считать экспоненту через ряд тейлора. Правда, тут только e возводится в степень. Если вам надо возводить произвольное число, то надо отдельно считать натуральный логарифм от основания и домножать на него степень. Тоже рядом (смотрите секцию "Вариации и обобщения").

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

Можно в тестах требовать совпадение с некоторой абсолютной или относительной погрешностью.

Если нужна максимальная точность, то нужно использовать длинную арифметику или с плавающей или фиксированной точкой. Или считать в рациональных числах (тоже придется самим писать тип или использовать библиотеку).

Еще можно использовать более устойчивые к ошибкам округления методы. Метод гаусса не лучший выбор.

Перепишите этот ужас с нуля. Там невозможно найти ошибку.

Советую воспользоваться тем, что условные операторы вычисляются лениво: Если написать A && B и A окажется false, то B даже не будет вычисляться.

Так, проверка на клетку сверху может быть написана так:
if (i > 0 && a[i-1][j] - мина)

Так вся ваша простыня выродится в 8 последовательных проверок. Если меняются обе координаты, то надо через && объединить 3 условия - 2 на проверку невыхода за границы массива, и последнее - проверка значения массива.

Еще можно завести массив на SIZE+2 x SIZE+2 и заполнять его с (1, 1). Фактически, создается каемка вокруг исходного массива. И пробегаться по нему надо от 1 до SIZE. Так, вокруг всегда будут все 8 соседей. В этом подходе не придется проверять на выход за границы массива.

А еще можно вместо 8 if-ов сделать цикл на 8 итераций, если завести константы для приращений:

const int kDx[] = {1, 1, 1, 0, -1, -1, -1, 0};
const int kDy[] = {1, 0, -1, -1, -1, 0, 1, 1};

Теперь всех соседей можно перебрать как (i + kDx[k], j + kDy[k])

В смысле, как читать? Слева направо, соблюдая порядок операций.

Вот первая формула r= ... - это значит, что значение переменной r вычисляется по выражению справа. Там участвуют переменные p, g, значения которых вам даны.

Там дробь, в числителе стоит сумма p и g. В знаменателе один плюс значение логарифма в квадрате от суммы корня pg+p и g^2. Расставьте скобки и получите (p+g)/(1+log(...)*log(...))

Аналогично вторая формула для y через p,g,r и z ( три из них вам даны, r вычисляется в предыдущем действии).

Возведение в квадрат - зависит от языка программирования. Или функция sqr(), или **2, или просто написать (выражение)*(выражение). lg() - вызов встроенной функции логарифма. Опять же, зависит от языка, как именно она называется у вас. Квадратный корень - функция sqrt().

Возможно там переполнение. Убедитесь, что у вас все хеши везде считаются только с участием unsigned типов. Переполнение в signed - это Undefined behavior.

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

Вам придется писать руками ввод и вывод типа из файла.

Вы поняли, что это динамическое программирование. Опишите, что у вас за функция ДП, дайте формулу пересчета, базу и где ответ.

Вам поможет std::bind.

Передавайте в partition

std::bind(predicate, item.first, std::placeholders::_1)

в качестве предиката.

Edit:

Но тут у вас будет другая проблема. set - не vector. Вы не сможете его передать stable_partition. Вместо ручного применения stable_partition, используйте erase_if. Предикат туда также через std::bind передавайте.

Похоже практически все встроенные функции ожидают '\0' на конце входного буфера, что не ваш случай.

Единственное исключение, которое я нашел - std::from_chars. Только оно далеко не везде доступно и надо подключать charconv.

Еще можно руками, если точно известно, что никаких ошибок в числе нет:

unsigned int vtoi(const std::vector<char> &a) {
  unsigned int res = 0;
  for (const auto& c: a) {
    res = 10*res + static_cast<unsigned int>(c) - static_cast<unsigned int>('0');
  }
  return res;
}

Проверки на переполнение и левые символы добавьте сами, если надо.

Странное задание. Какая польза от этого сокращения сравнений, если всего в результате вставки переместится до O(log n) элементов?

Но, если так надо, то вам нужно для каждого числа сначала узнать номер старшего ненулевого бита (most significat bit - MSB), и потом сдвинуть верхнее число вправо на половину разницы в позициях старших битов.

1 = 0000001b, msb = 0
18 = 0010010b, msb = 4

Разность - 4 разряда. Значит, надо сдвигать на 2 разряда вправо:
18 >> 2= 0010010b >> 2 = 00100b = 4

Еще пример: для 4 и 18 msb были бы 2 и 4, разность -2. Сдвинув 18 на 2/2=1 разряд вправо, вы бы получили 9.

Чтобы эта оптимизация давала хоть какую-то пользу, надо находить msb очень быстро. Или предподсчитайте их для всех возможных индексов, или надейтесь, что в вашем языке есть встроенная функция, которая вызывает нужную инструкцию процессора, типа __builtin_clz.

Еще можно подсчитать msb только один раз для правой границы бинпоиска, а потом просто помнить его, ведь у средней точки - это среднее арифметическое (левая граница изначально 1 - у нее msb = 0). А потом в процессе бинпоиска надо просто хранить msb для двух границ и заменять известным значением середины один из концов.

Для предподсчета просто в цикле задавайте msb[i] = msb[i/2] + 1;