Mercury13

Связано, вероятно, с особенностями перевода дробных чисел в текст. Я попробовал повторить на Си++, ничего интересного не вышло. Зато методы перевода дробного в текст 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.

1. Если из класса можно вытащить какую-то абстракцию. Например, из объекта «файл» можно вытащить абстракцию «поток». Личное — объект Project реализует интерфейс Modifiable с двумя функциями: modify() и isModified().

2. Для упрощения юнит-тестирования при условии владения.
Предположим, у нас есть класс «класс» (школьный) и класс «ученик». Ученик знает, в каком он классе.
В такой ситуации получается «клубок»: если надо делать ученика, то надо делать и класс.
Этот замкнутый круг можно разорвать, сделав интерфейс ISchoolClass и унаследовав от него класс. При юнит-тестировании заменяем класс на какую-то заглушку.

Попробуйте Brush.Color := $FF000000 or clBlue;. Велика вероятность, что механизмы работы с 32-битными изображениями тут слабоваты.

Потребуется специальная антенная решётка. По предварительным расчётам, она будет по размеру с коробку от пиццы. Пока выведены два спутника, она вряд ли где-то продаётся.
И предварительная стоимость — 50$/мес — негуманная для страны, где интернет один из лучших в мире (ой, если бы ещё не роскомнадзоры и их украинские аналоги).

(Долго вспоминал, как называется крупная спутниковая сеть голосовой связи — Iridium. Удивительно, что она ещё работает и для работы полагается именно что на Маска.)

Нашёл.
https://www.reddit.com/r/Starlink/comments/7zqm2c/...

Есть три специфичных вида алгоритмов.
• Математические. Из них я могу припомнить геометрические (выпуклая оболочка) и вычислительные (метод Рунге-Кутты).
• Связанные с особыми структурами данных.
• Параллельные.

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

Из общего — те части математики, которые служат основополагающими принципами работы компьютеров. Теория множеств, булева алгебра, комбинаторика, теория автоматов… Также важно изучить символы Ландау и понятие «асимптотическая сложность алгоритма».

Для параллельных важно понимать архитектуру параллельных систем.