Wataru

Вам надо не делать break. А сохранить куда-то текущее значения счетчика kol и также установить флаг, что вы встретили u. После цикла, который заканчивается чтением точки, надо, если флаг u был не встречен, вернуть значение счетчика kol. Иначе - сохраненное значение.

Ваш первый вариант работал бы сразу, если бы вы сначала читали всю строчку в память и циклом по ней проходились. Но, поскольку надо всю строку всегда прочитать, то break ломает работу функции.

Открывайте файл в бинарном режиме "wb" и пишите туда через fwrite (лучше побайтово, чтобы не мучиться с переносимостью из-за порядком байтов в int).

Читайте, соответственно, через fread.

Для шифрования лучше всего, во-первых, байты в разном порядке писать, (не 0,1,2,3, а, скажем, 2,0,3,1) и, во-вторых, xor-ить их с какими-то константами. А еще лучше не с константами, а со случайными данными, которые тоже записываются в файл рядом. Или не рядом, так будет закономерность меньше видна.

Но все это может спасти только от людей незнакомых с reverse engineering'ом и отладкой. Более менее осведомленный ползователь посмотрит в ассемблерный код и поймет, что и как там читается и где и что надо поменять. Но да, это посложнее просто редактирования txt файла.

Ну и, artmoney с cheat engine никто не отменял.

std::vector<int> DistributeExtraObjectsFairly(std::vector<int> objects, int extra_objects) {
    std::vector<int> permutation;
    permutation.reserve(objects.size()+1);
    permutation.resize(objects.size());
    std::iota(permutation.begin(), permutation.end(), 0);
    std::sort(permutation.begin(), permutation.end(),
        [&objects](const int &a, const int &b) {return objects[a] < objects[b];});
    int num_increased = 1;
    permutation.push_back(0);
    int step = (objects[permutation[num_increased]] - objects[permutation[num_increased-1]]) * num_increased;
    while (extra_objects >= step && num_increased < objects.size()) {
        extra_objects -= step;
        ++num_increased;
        step = (objects[permutation[num_increased]] - objects[permutation[num_increased-1]]) * num_increased; 
    }
    int final_value = objects[permutation[num_increased-1]] + extra_objects / num_increased;
    int num_bigger_values = extra_objects % num_increased;
    for (int i = 0; i < num_bigger_values; ++i) {
        objects[permutation[i]] = final_value + 1;
    }
    for (int i = num_bigger_values; i < num_increased; ++i) {
        objects[permutation[i]] = final_value;
    }
    return objects;
}

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

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

Edit: работает за O(n log n), где n - количество элементов в списке. Быстрее, я подозреваю, никак. Есть еще решение за O(n log M) - где М - максимально возможное число во входных данных. Это через бинпоиск по минимальному числу в конце.

Я так понимаю, у вас проблема со строчкой
aobj1[0] = a(2);

Тут вызывается конструктор для временного значения a. Потом оператор копирования из временной переменной в *aobj. Потом вызывается деструктор временного значения.

А потом где-то в конце произойдет и деструктор aobj.

У aobj delete_counter после этой строчки равен 1 (ведь он скопирован у временного значения, которое сделало delete_counter единицей в констукторе). В конце при вызове деструктора aobj там delete_counter будет 1 в начале.

Вы смотрите на адрес this в дебагере в деструкторе. Два вызваных деструктора будут для двух разных объектов (для временного значения и для aobj).

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

Вам надо проверять, что вернет fscanf. Если оно у вас вернет что-то меньшее 2, то значит оно не смогло прочитать обе строки. В этом случае надо выходить из цикла и не класть новую запись в таблицу

Может в этом быть смысл, только если у вас большой длинный массив, и вы его тип уменьшаете. К скорости прибавки почти не будет - в основном из-за локальности данных только. Ну съедите поменьше памяти - это да.

Оптимизировать же переменные смысла нет никакого. Сэкономите пару байт буквально.

Знаки в условиях перепутаны.

Вы сети скармливаете какие-то 2 картинки. У нее 2 input'а

print(model.predict([image,image2]))

Втавьте вот в этот код выше перед вызовом predict вывод размеров image и image2.

Сдается мне, что вы одну картинку как-то на 2 куска порезали и так и скормили сети. Если это не ваш код, то он возможно ожидает на вход картинку 128x64.

Глобальные переменные должны быть определены выше фкнкций их использующих. А что-то, например buff, у вас вообще локальные переменные, которые вы пытаетесь использовать в других функциях. Или сделайте и ее глобальной, или передавайте ее везде, где надо, как параметр.

И так по каждой ошибке от компилятора в вашем вопросе. Смотрите на какое имя он ругается и где эта функция/переменная определена.

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

В особо запущенных случаях придется какие-то функции или классы дробить.

Ну и Include guard'ы используйте

Как обычно в вопросах про олимпиадные задачи, ответ тут - код не соптимизировать никак. Надо его переписать с нуля с более быстрым алгоритмом.

Смотрите на ограничания - n и m до 100000. Обычно такой порядок чисел означает, что вам нужно решение за O(n+m) или что-то вроде O(n+m log (n+m)). У вас же решение "в лоб" за O(nm), что никак не ускорить принципиально. Даже переписыванием на си со всякими хитростями вы ускорите его в 10, ну в 100 раз. А вам надо ускорить его в 10000 раз.

Могу дать подсказки:
Во-первых, если и там и там есть положительные элементы, то взяв максимальные в двух массивах вы точно получите элемент больше всех a и b. То же, если и там и там есть отрицательные элементы - надо взять два минимальных.

Остался случай - что если один массив целиком отрицателен, а второй - целиком положителен. Пусть a положителен, а b отрицателен. Что будет, если взять минимальные по модулю элементы и там и там? Посмотрите внимательно - вам дано, что ни одно из чисел не 0. Это поможет.