Mercury13

В 2021 используйте LLD.

В конце концов перешёл на собственный порт MiniZip.

Это так называемый «универсальный инициализатор» Си++11. Иногда это действительно initializer_list, но не сейчас. Здесь он эквивалентен вызову конструктора
std::vector<char>(data.get(), data.get() + size)

Ваш код решает одну задачу, постоянно выводя 38 — и ту через какую-то задницу.
Во-первых, надо ВВЕСТИ информацию, а не пережёвывать цифры 12 и 126 непонятно каким раком.
Во-вторых, вам надо получить x = n % 50. Если он 0, то и вывести 0 — иначе вывести 50 − x.

Первый способ: создаётся initializer_list, вызывается конструктор. Наиболее эффективен для простых тупых объектов.

Второй способ эквивалентен push_back(string("vec1")) и сильно полагается на оптимизацию передаваемых параметров. Наименее эффективен.

Третий способ гарантированно не создаёт промежуточные объекты (вызывает конструктор string(const char*) уже на месте). Вместе с reserve(3) наиболее эффективен для управляемых объектов.

UPD. 2 и 3 для string() не очень сильно различаются из-за эффективного переноса. А вот для более крупных объектов 3 лучше.

UPD2. Начиная с Си++20, 1 лучше, но только из-за того, что Си++ научился делать полноценные string’и при компиляции — то есть управляемый объект string обзавёлся некоторыми чертами тупого.

UPD3. Ни один компилятор пока constexpr string пока не поддерживает. Но ведь ни у кого стабильного 20 пока нет, правильно?

Я бы предложил поискать в коде ошибку, есть большое подозрение — первым множителем так и просится size. Ну или деление size %/ msize — невозможно сказать. Ну или условием будет не меньше, а больше или больше-равно. Но будем работать как есть.

int v = msize / size;
if (i < msize % size) ++v;
int teqportion = msize * v;

Почему подозреваю ошибку? Тут очень похоже на сильно поломанное округление вверх или вниз до кратного, в зависимости от условия.

Если вы узнали, что символ — цифра, просто вычтите из него '0'.
meow[i] = gug[i] - '0';

if (digit == true) не рекомендую писать, надо просто if (digit).

Это не Паскаль, это типизированный Бейсик.
Вот мой рабочий код — каждый вызов читает одну кодовую позицию, перемещая первый указатель на нужное кол-во слов вперёд. Переведёшь в нужные тебе соглашения по работе? — например, ты можешь читать информацию не из памяти, а из файла или ещё откуда-то.

enum {
    SURROGATE_MIN = 0xD800,
    SURROGATE_MAX = 0xDFFF,
    SURROGATE_LO_MIN = SURROGATE_MIN,
    SURROGATE_HI_MIN = 0xDC00,
    SURROGATE_LO_MAX = SURROGATE_HI_MIN - 1,
    SURROGATE_HI_MAX = SURROGATE_MAX,
    UNICODE_MAX = 0x10FFFF,
    U8_1BYTE_MAX = 0x7F,
    U8_2BYTE_MIN = 0x80,
    U8_2BYTE_MAX = 0x7FF,
    U8_3BYTE_MIN = 0x800,
    U8_3BYTE_MAX = 0xFFFF,
    U8_4BYTE_MIN = 0x10000,
    U8_4BYTE_MAX = UNICODE_MAX,
    U16_1WORD_MAX = 0xFFFF,
    U16_2WORD_MIN = 0x10000,
    U16_2WORD_MAX = UNICODE_MAX,
};

#define CHAR_BOM L'\uFEFF'

#define UNICODE_NONE (0xFFFFFFFFUL)
#define UNICODE_BAD  (0xFFFFFFFEUL)

unsigned long str::getCp(const uint16_t*& aCurr, const uint16_t* aEnd)
{
    if (aCurr == aEnd)
        return UNICODE_NONE;
    unsigned long cp = *(aCurr++);
    if (cp < SURROGATE_HI_MIN) {
        if (cp < SURROGATE_MIN) { // Low BMP char => OK
            return cp;
        } else {  // Leading surrogate
            if (aCurr == aEnd)
                return UNICODE_BAD;
            unsigned long trailing = *aCurr;
            if (trailing < SURROGATE_HI_MIN || trailing > SURROGATE_HI_MAX)
                return UNICODE_BAD;
            ++aCurr;
            return (((cp & 0x3FF) << 10) | (trailing & 0x3FF)) + 0x10000;
        }
    } else {
        if (cp <= SURROGATE_MAX) { // Trailing surrogate
            return UNICODE_BAD;
        } else { // High BMP char => OK
            return cp;
        }
    }
}

Параметры: первый (передан по сцылке) — подвижная «каретка», второй указывает за конец строки.
Возвращает: NONE, если читать больше нечего, BAD, если считал херню, и кодовую позицию — если таковая всё-таки считалась.

Алгоритм: читаем слово. Двумя сравнениями относим его к одному из четырёх диапазонов: 1) нижний диапазон базовой плоскости, 2) нижний суррогатный символ; 3) верхний суррогатный символ; 4) верхний диапазон базовой плоскости. Если 1 или 4, так его и возвращаем, если 3 — видим херню.

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

1. Округление к чётному. Это стандартное округление к ближайшему; если расстояние одинаково — то к чётному.
4,4 → 4
4,5 → 4
4,6 → 5
−4,4 → −4
−4,5 → −4
−4,6 → −5
5,4 → 5
5,5 → 6
5,6 → 6
−5,4 → −5
−5,5 → −6
−5,6 → −6

2. Округление вниз к −∞. Округление к меньшему.
4,xxx → 4 (при любой дробной части)
−4,xxx → −5

3. Округление вверх к +∞. Округление к бóльшему.
4,xxx → 5
−4,xxx → −4

4. Отбрасывание дробной части. Округление к 0. Округление к меньшему по модулю.
4,xxx → 4
−4,xxx → −4

Столько много знаков у double — так что где-то в недрах библиотеки float стал double’ом. Знаков у float не точно 7, а чуть больше семи. И это число действительно не тройка: тройка имеет 16-й вид 4040.0000, а ваше число — 403F.FFFF. Как вы видите, величина единицы младшего разряда (ULP) на таких величинах будет около 2,4·10⁻⁷ — поболее семи знаков будет, но до восьми не дотягивает.

Механизмы округления IEEE 754 не имеют никакого отношения к десятичному округлению, прописанному в библиотеке языка. Округление IEEE на самом деле двоичное и используется при переводе из более точного типа в менее точный, или чтобы округлить результат умножения/деления.

Спецификаторы определения — слова typedef, inline, friend, constexpr, constinit, register, static, thread_local, extern, mutable.
Спецификаторы типа — что угодно, что полностью определяет тип: начиная от int и заканчивая vector<int>::const_iterator.
Модификаторы типа — слова short, long, signed, unsigned.
Квалификаторы — слова const, volatile.
Спецификаторы доступа — слова private, protected, public.
Идентификатор — имя объекта, подчиняющееся определённым правилам.
Объявитель — это часть объявления переменной или функции, и если ты не лезешь с головой в тонкости синтаксиса Си, тебе не надо.
Инициализатор — это int i = 1 или int i {1}.

std::sort(thrusters.begin(), thrusters.end(), 
    [](const calcThrusterType& x, const calcThrusterType& y) {
        return (x.angle < y.angle);
    });

Вы используете typedef и в вашем компиляторе нет Си++11?

bool angleLess(const cTT& x, const cTT& y) { return x.angle < y.angle; }

std::sort(thrusters.begin(), thrusters.end(), angleLess);

Обсуждение было в комментах, и ключевая причина — при comp_a < 0 корни не сортируются.

Побочные проблемы кода.
1. Можно было интеграл разности, а не разность интегралов.
2. Лучше не использовать vector и pair на месте struct { a, b, c } — кроме случаев, когда есть важная автоматизация.

Вы тут что-то ухитрились написать, но всё равно n². Потому и TL.

Пусть для каждого поддона длина — большее из измерений, ширина — меньшее. Теперь условие «поддон А можно поставить на поддон Б» упрощается.

Очевидно, что поддоны, которые нельзя поставить друг на друга, будут возрастать по одному измерению и убывать по другому. (Иначе мы сортанём по длине, по ширине тоже обнаруживаем неубывание — и, сюрприз, эти поддоны становятся!)

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

Нам приходит новый поддон. Упорядочиваем координаты, затем ищем в списке equal_range по длине.

Для «БОЛЬШЕЙ» части списка [LOWER_bound, end): наш поддон можно поставить на все эти поддоны по длине, и только на первые из них — по ширине. Если l_b=end, или наш поддон не встаёт на *l_b — добавляем поддон в список. Но не сразу, а после проверки меньшей части.

Для «МЕНЬШЕЙ» части списка [begin, UPPER_bound): все эти поддоны можно поставить на наш поддон по ДЛИНЕ, и только некоторый хвост [some_pallet, upper_bound) — по ширине. Находим этот кусок и исключаем из дерева.

А теперь вопрос: как хакнуть наш set, чтобы можно было проводить поиск за log n и по длине, и по ширине?
А для этого пишем свой объект-сравниватель, который можно переключать между двумя вариантами: length1<length2, либо width1>width2;

P.S. Не очень понятно условие «один поддон становится на другой» — ни из описания, ни из примера. Мой алгоритм — length1 <= length2, width1 <= width2. Если, например, оба строго меньше (length1 < length2, width1 < width2) — то большая часть будет [u_b, end), меньшая — [begin, l_b), и из-за непересечения этих частей не обязательно добавлять в список отложенно.

Начнём с 2. Структуры, используемые как формат файла, применяй в прикладном коде с большой осторожностью. Если хочешь, чтобы формат расширялся, придумай простенький блочный формат.
Для 1 — приходится использовать какую-то сигнатуру и находить её в файле.
Например: после собственно EXE-файла идут данные, потом сигнатура и положение данных в файле. Сигнатуры нет или смещение странное — значит, просто приклеивай всю эту дрянь в конец файла. Сигнатура есть и смещение правдоподобное — идём по указанному смещению, пишем новые данные вместе с новой сигнатурой, а потом усекаем файл (на случай, если старые данные были длиннее).
На этом принципе, кстати, основаны самоизвлекающиеся архивы RAR и RARJPEG — только сигнатура в начале, а не в конце RAR-данных.
Ещё нужно проверить, в какой кодировке ifstream принимает данные — UTF-8 или Win-1251. Начиная с Си++17 появилась поддержка юникодных имён файлов, но я с нею не работал.

Тетрис. Питончик. Морской бой.

const — чтобы исключить попытки писать в него.
volatile — каждый раз при обращении проходить по адресу и брать данные , а не кэшировать.
Если какая-то ячейка в памяти (в данном случае по адресу 0x30) меняется другим потоком или, например, железом, она volatile.
Лучше было бы писать

const volatile char* const port = (const volatile char *) 0x30;

Ещё лучше (Си++11 и непортабельно)

constexpr const volatile char *port = (const volatile char *) 0x30;

А ещё лучше сделал Паскаль

var
  SomePort : byte absolute $30;