Mercury13

Берём НОК. При расчёте НОКа случилось переполнение ((a · b) div b ≠ a) → нет такого.
Дальше (MAX_UNSIGNED_LONG div НОК) · НОК.

UPD. Поставил новый код обнаружения переполнений при умножении; старый явно ошибочный: 11·11 = 121, и при двух десятичных знаках будет 21 > 11.
UPD2. В курсе, как считают переполнение-устойчивый НОК? НОК(x,y) = (x div НОД(x,y)) * y

Это дело сложное. И я бы разделил его на три перекрывающихся этапа.
1. Увидеть в строке уравнение от одной переменной. Например, в таком виде.

2. Увидеть в том, что получилось, линейное уравнение.
3. Запустить модуль «Линейное уравнение», который приведёт подобные слагаемые и высчитает ответ.

Есть способы, но они периодически меняются.
Это политика Microsoft: программы не должны засирать эти экраны.
https://blogs.msdn.microsoft.com/oldnewthing/20030...

ВНИМАНИЕ: У вас есть пара тонких мест.
РАЗ. не забудьте, что строковые литералы в Си — это нуль-терминированные строки, и "\0" по факту будет пустой строкой. Строку из одного нулевого символа можно загнать в string — например, конструктором string(begin, end) или s += '\0', но не конструктором string(const char*).
ДВА. Этот static будет инициализирован при первом вызове. Второй вызов вернёт тот же массив.
ТРИ. Строчку лучше передавать как string *func(const string& s) {}

К делу. Массив — это довольно сложный объект, и возникает вопрос: кто этим массивом будет владеть после того, как он покинет пределы функции?
1. Владеет система времени выполнения. Это отлично ответил Роман, дам только ключевую строчку.
string* arr = func(exp);
НЕЛЬЗЯ ИСПОЛЬЗОВАТЬ: если массив используется в чьих-то «конских» конструкторах-деструкторах статических объектов (из-за отсутствия модулей Си++ не позволяет установить на уровне языка порядок создания/уничтожения статических объектов).

2. Владеет какой-то объект.

string *func(string s) {
    static string* ar = nullptr;
    if (ar) delete[] ar;
    ar = new ar[3];
    ar[0] = "qwe";
    ar[1] = s;
    ar[2].clear();
    return ar;
}

НЕЛЬЗЯ ИСПОЛЬЗОВАТЬ: ну, это уж разбирайтесь сами с этим объектом, сколько он будет жить и насколько долго он будет держать массив. В данном случае каждый новый вызов уничтожает старый массив. (Код корявый, потому что последний массив не уничтожается.)

3. Владеет тот, кто вызывает. Лучше для таких целей использовать какой-нибудь std::vector.

vector<string> func(string s) {
    vector<string> r;
    r.reserve(3);
    r.push_back("qwe");
    r.push_back(s);
    r.push_back(std::string());
    return r;
}

Обычно для этого используют скриптовый движок. Наиболее известный — Lua.

Также используют триггеры, эталонный пример — StarCraft.
Но, работая с триггерами, надо разделять «условие» и «повод». Повод — это событие-импульс, которое МОЖЕТ спровоцировать срабатывание триггера. Условия — это уже дополнительные вещи, которые проверяются потом.

Третья возможность — движок, основанный на данных. Например, задаём тип атаки, количество HP, тип движения и прочее, и вся эта библиотека уже записана в коде. Эталонный пример — Doom (самый ещё первый, 1993 года). Кстати, в его последователе Hexen появились скрипты.

А это значит, что манипулируя членами b я буду редактировать память a?

Нет, конечно.

Type& Type::operator=(const Type& x);
Задача операции присваивания — сделать, чтобы объект слева (он же *this) стал копией объекта справа (он же x).

Почему операция присваивания берёт Type& по ссылке? Да потому, что взять по копии — это вызвать конструктор копирования. Вполне можно написать
BigInt& BigInt::operator = (int x);
когда слева «большой» тип, а справа — «маленький», и его конструктор копирования незначителен (а то и равняется накладным расходам на ссылку, как у того же int). Но когда с обеих сторон один и тот же тип — это часто бездумный вызов конструктора копирования (собственные конструктор копирования и операцию = обычно пишут, когда нужна хитрая логика, а не тривиальное копирование).

Почему операция присваивания возвращает Type&? Просто чтобы работали конструкции типа a = b = c. Может и void возвращать, если хочешь.

class C
{
public:
    C() {}
    C (const C&) { std::cout << "Copy ctor" << std::endl; }
    C & operator = (const C&) { std::cout << "Assign" << std::endl; return *this; }
};

int main()
{
    C a;
    C b = a;

Выведет «Copy ctor». То есть ответ на первый вопрос — конструктор копирования.

В литературе что я читаю это называется присваиванием

Не присваивание, а инициализация. Присваиванием было бы…

Type b;
b = a;

Type b = Type(a);

В идеале тут два конструктора копирования и один деструктор, однако компилятору даётся воля уменьшать их количество. Потому только «copy ctor».

Код

int a = 10;
C b = C(a);

также даёт один вызов C(int). А C(const C&) не вызывается ни разу.

UPD. Одно из нововведений Си++11 — чтобы даже без этих негарантированных оптимизаций, когда один объект исчезает, а второй появляется, можно было вместо копирования проводить нечто более простое, не требующее отвода-возврата памяти. Я-то экспериментировал в режиме Си++03, но в Си++11 уже были бы конструктор копирования, конструктор перемещения и деструктор.

Связано, вероятно, с особенностями перевода дробных чисел в текст. Я попробовал повторить на Си++, ничего интересного не вышло. Зато методы перевода дробного в текст G++ и GRISU дают несколько разные результаты.

Несмотря на то, что массив часто отождествляют с указателем, массив — это НЕ указатель. У него, например, другие операции приводят к неопределённому поведению.

И самое противное в Си — это то, что в коде
void sort(int x[5]);
x — это не массив, а именно что указатель. Чтобы был массив, надо Си++
void sort(int (&x)[5]);
И компилятор даже подсвечивает, что параметр функции, отмеченный как массив — всегда указатель.

typedef int Arr[SIZE];
int sum(Arr arr, int n)
// warning: 'sizeof' on array function parameter 'arr' will return size of 'int *' [-Wsizeof-array-argument]|

longclaps написал, как всё это дело должно выглядеть внешне.
Внутренне это реализуется просто.
1. В OnPaint какого-нибудь компонента (PaintBox, скажем) при определённых условиях выводим визуализацию.
2. Блокируем весь пользовательский интерфейс (кроме какой-нибудь кнопки «Стоп»).
3. Каждый раз, когда надо что-то увидеть, делаем paintBox.Repaint, Application.ProcessMessages и небольшую задержку.
4. При нажатии кнопки «Стоп» ставим какую-то переменную в true. Сортировка реагирует на эту переменную и останавливает цикл: либо простым Exit, либо аварией Abort и последующей реакцией на EAbort.

Если есть желание сравнить несколько алгоритмов сортировки, стоит сделать функцию типа DoSwap(i, j : integer), которая меняет местами элементы, устанавливает всё, что надо для визуализации, инициирует перерисовку и делает задержку.

1. Что такое Container и для чего он нужен? Возможно, от этого дела удастся избавиться или заменить интерфейсом?
2. Не должен конструктор Graph брать в параметры Parser. Наоборот, Parser функцией parse() должен возвращать Graph.
3. Config стоит разбить на несколько частей: одна специфична для Graph, вторая для Parser. Как их объединять — зависит от того, кому какие настройки нужны.

Из такого вопроса видно, что человек всё ещё нетвёрдо знает программирование, а уже пытается программить игру.
И тут есть два варианта.

1. Движок с нуля. Тонкая графическая прослойка наподобие SDL, оставляющая 100%-ю свободу движкописателям — это тоже «с нуля» и всячески рекомендуется даже продвинутым (не нужно писать всякие там Alt-Tab’ы и прочую дрянь, далёкую от игры). Тогда пусть начнёт с «питончика» (https://ru.wikipedia.org/wiki/Snake_(игра) ) или текстового квеста.
А потом, когда доберётся до платформера или CRPG, он поймёт, каким образом привязать к монстру характеристики.

Первое приближение (не слишком удобное для скриптования и подходящее для платформеров/action-RPG, но негодное в настоящих RPG) — сделать каждому компьютерному персонажу «класс» (не путать с классом ООП), включающий кол-во HP, внешний вид и прочее. А также «набор скриптов» — для поведения в диалогах, запрограммированного передвижения, превращения из «болванчика» в компьютерного врага, и т.д. Без набора скриптов он просто компьютерный враг, тупо нападающий на ПиСя.

Если скриптовый движок чужой (тут уже не зазорно брать чужое) — вы уж смотрите, что он может и куда его впихнуть. А если хотите написать сами — лучше делайте триггеры, как в StarCraft.

2. На чужом движке. Это уж смотрите, что движок может, какие возможности в нём «в коробке», а какие придётся дописывать своим кодом и чужими модулями. Не знаком ни с одним. Чужой движок — довольно противное дело для начинающего программиста: он автоматически формирует какую-то структуру программы, и программисту приходится не столько творить, сколько разбираться с этой структурой. С одной стороны, можно быстро написать довольно сложную игру, с другой — не так много радости «а у меня заработало».

Вот мой действующий код на «Си с крестами». Индексы — ВНИМАНИЕ — начинаются с нуля. Сумеете перевести на Яву, и из второго оставить одни буквы? Первое действует для любой длины, второе — для длины до 3 символов, присущей Excel’ю.

std::wstring xl::colNameW(
        size_t aIndex)
{
    wchar_t q[21];  // more than enough even for 64-bit system :)
    wchar_t* ptr = q + 20;
    *ptr = 0;   // debug

    // Getting size
    size_t n = 1;
    unsigned long long pw = 26;
    while (aIndex>=pw && n<20)
    {
        aIndex -= static_cast<size_t>(pw);
        pw *= 26;
        ++n;
    }

    FOR_S(i, 0, n)  // макрос, означающий for (size_t i = 0; i < n; ++i)
    {
        *(--ptr) = static_cast<wchar_t>(L'A' + (aIndex % 26));
        aIndex /= 26;
    }
    return std::wstring(ptr, n);
}

namespace {

    bool isCap(const char* x, const char* aEnd)
    {
        return (x != aEnd && *x >= 'A' && *x <= 'Z');
    }

    bool isDig(const char* x, const char* aEnd)
    {
        return (x != aEnd && *x >= '0' && *x <= '9');
    }

}   // anon namespace


xl::CellCoords xl::parseCellCoords(
        const char* aStart, const char* aEnd)
{
    enum {
        AA = 26,
        AAA = 26 + 26 * 26
    };
    xl::CellCoords r;
    // Letter
    r.col = 0;
    if (!isCap(aStart, aEnd))
        return CellCoords::bad();
    r.col = *(aStart++) - 'A';
    if (isCap(aStart, aEnd)) {
        r.col = (r.col * 26) + *(aStart++) - 'A';
        if (isCap(aStart, aEnd)) {
            r.col = AAA + (r.col * 26) + *(aStart++) - 'A';
        } else {
            r.col += AA;
        }
    }
    // Number
    r.row = 0;
    while (isDig(aStart, aEnd)) {
        size_t r0 = r.row;
        r.row = r.row * 10 + *(aStart++) - '0';
        if (r.row < r0)
            return CellCoords::bad();
    }
    if (r.row == 0 || aStart != aEnd)
        return CellCoords::bad();
    --r.row;
    return r;
}

Принцип действия перевода цифра → буква.
Находим, сколько букв в нашей колонке. Допустим, три. Вычитаем из цифры номер колонки AAA (т.е. 26 + 26·26, если нумеровать с нуля, и 1 + 26 + 26·26 — если с единицы), и оставшееся переводим в 26-ичную систему счисления (A=0, B=1, C=2…).

Принцип действия перевода буква → цифра аналогичен. Находим количество букв. Если их три, то переводим из 26-ичной системы счисления в цифру и прибавляем номер колонки AAA.