Wataru

Ошибка, если ее перевести, означает: вы вышли за границу массива arr.

Смотрите внимательно, где вы к нему обращаетесь. Особенно на arr[j + 1]. Какие значения может принимать j? Какой размер массива и, соответственно, к каким индексам можно обращаться?

(-1) % 3 = 2

Это математическое определение вычетов по модулю. Все числа, которые отличаются на n, имеют одинаковый остаток по модулю n. Конфуз происходит из-за того, что операция взятия по модулю во многих языках программирования работает не так. Для отрицательных чисел она выдаст отрицательное значение, правда к которому можно прибавить n, что бы получить правильный модуль - число от 0 до n-1.

Поэтому при реализации можно делать (a-b+3)%3 Или преобразовать, чтобы не было вычитания: b == (a+1)%3

Только если вам известен ПРЕДЫДУЩИЙ элемент. Иначе за честные О(1) вы из односвязного списка ничего не удалите.

Можно амортизационно удалить за О(1) просто пометив этот элемент удаленным. Но тогда все функции, которые проходятся по списку, должны такие помеченные элементы действительно удалять во время прохода.

Суммарное время работы алгоритма будет как если бы удаление было за О(1). Но некоторые отдельные операции могут быть сильно медленнее, чем при честной константе. Например, если вы кучу раз добавите элемент в начало списка и тут же удалите, то потом вывод списка будет медленным, несмотря на то, что список должен быть пустым.

Но на практике этот метод, наверно, не применяется. Потому что вы же где-то берете указатель на удаляемый элемент. Обычно можно вместе с ним получать и указатель на предыдущий. Или тупо использовать двусвязные списки.

Безопасно.

Еще комментарии. Это же С++, а не С?

Вместо набора функций, которые возвращают и принимают IntList1D, стоит завести класс, который содержит в себе указатель на начало списка. У этого класса должны быть методы initalize, is_initialized, pushBack, и т.д. Это сократит код немного и сделает его гораздо более логичным.

Тип элемента списка вы объявляете как приватный класс-член в классе списка, и он не будет засорять пространство имен пользователей вашей библиотеки. Им о нем вообще знать не надо, они хотят в ваш список класть int и получать назад int.

Далее, вы пишите контейнер, в идеале его стоит сделать по образу и подобию стандартных контейнеров. С итераторами и т.д. Чтобы с ними было можно работать точно также. Но, если не потянете, то хоть обзовите методы также, как у стандартных (push_back(), empty(), см std::vector, например).

Стек и очередь могут или наследоваться от списка, или (так наверное понятнее будет) держать внутри себя экземпляр списка.

Потом, часть функций называется частично большими буквами, частично строчными. Это вообще зачем? APPEND_FRONT_Link? Соблюдайте единый стиль хотябы в одном названии. Если они отличаются от appendFront тем, что они не предназначены для пользователей библиотек, ну так это как раз аргумент в пользу использования классов. Делаете эту функцию приватным методом. И такие обычно называются с суффиксом Impl (от implementation) - appendFrontImpl.

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

Выражение под суммой, отмеченное красным на картинке - это сумма арифметической прогрессии, вы же сами написали.

Первый член - 1 (при j=i+1), последний - n-i (при j=n). Всего их n-i. Ну а дальше - стандартная формула: среднее крайних членов, помноженное на их количество.

Как из этого получается O(n^3). По уму, надо раскрыть скобки и разложить на сумму трёх рядов, в зависимости от степени i в слагаемом. Дальше сумма i даст также O(n^2). Сумма по i^2 даст O(n^3). Тут уже нельзя арифметическую прогрессию применять, но это известная формула - сумма n квадратов даст n(n+1)(2n+1)/6. Ее можно вывести, если взять ряд f(x)=1+x+x^2+...+x^n = (1-x^{n+1})/(1-x) и найти (x*f'(x))'. Потом туда можно подставить x=1. Или есть визуальные доказательства. Каждый квадрат - это квадрат из кубиков. Их все можно сложить в пирамиду. 6 таких пирамид можно сложить в параллелепипед.

Если точка не на плоскости треугольника, то вам надо переформулировать задачу. Там вообще непонтяно, что значит внутри/снаружи.

Если же оно на плоскости, то введите там систему координат (например, орто-нормируйте вектора p2-p1 и p3-p1). Получите координаты всех точек (p1 можно назначить началом координат).

Потом придется применять формулу для плоскости. Можно воспользоваться векторными произведениями. Произведение пар векторов {p-p1, p2-p1}, {p-p2, p3-p2}, {p-p3, p1-p3} должны все давать одинаковый знак (или все <=0 или все >=0. Равенство 0 чего-то будет означать, что точка на границе).

Или можно посчитать площади, опять же через векторное произведение. |(p2-p1)(p3-p1)| = |(p1-p)(p2-p)+(p2-p)(p3-p)+(p3-p)(p1-p)|

Вы передаете в std::thread не статический метод класса. Его нельзя передавать как обычную функцию. Его же можно вызывать только у какого-то объекта. Где thread этот объект возьмет-то?

Есть 2 варианта - передавайте лямбду, которая будет захватывать this и вызывать у него метод объекта.
Или, как показано тут, передавайте туда &Matrix::findNumberInRow c первым аргументом this.

Пусть точка p=(x,y,z) принадлежит плоскости. Пусть 3 точки - p1, p2, p3.

Тогда вектор (p-p1) должен раскладываться на вектора p2-p1 и p3-p1.

Т.е. определитель матрицы 3x3 из этих трех векторов должен быть нулевым.

det {{x-p1x, p2x-p1x, p3x-p1x},
 {y-p1y, p2y-p1y, p3y-p1y},
 {z-p1z, p2z-p1z, p3z-p1z}} = 0

Раскрываете определитель по первому столбцу и получаете
A = det({{p2y-p1y, p3y-p1y}, {p2z-p1z, p3z-p1z}})
И т.д.
D = -p1x*A-p1y*B-p1z*C

Это ваше тождество хорошо бы доказать.

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

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

Заведите вы третью временную переменную и считайте через нее, чтобы в цикле всегда n было большим числом (m = 4*n+b; b=n; n=m). Или вообще воспользуйтесь фишками питона и делайте множественное присвоение:
b, n = n, 4*n+b;

Суперпозиция - это не сумма. Это когда в одну функцию в качестве аргумента подставляется другая функция.

Например, x*y*z вы в сумму никогда не разложите. Зато, если взять f(a,b) = a*b, то можно сделать f(x,f(y,z)).

Это хорошо для оптимизации

Эта суперпозиция не будет лучше для оптимизации ни с какой точки зрения.

Практически это можно сделать так - расставьте все скобки рядом со всеми операциями в выражении. Каждая операция - это своя функция. Вот у вас и суперпозиция.

Вот этот код создает кольцевую ссылку:

if (left) {
        tree->left = readElement(tree);
    }

Что вы там пытаетесь сделать? Если вы хотите прочитать элемент в дерево, то ваща readElement(tree) вернет указатель на новый корень. Если выхотите добавить в левое поддерево (и грантируете, что следующий элемент будет меньше корня), то надо добавлять в tree->left а не tree.

Обратный код: !x = 2^n-1 - x.
Дополнительный код - !x+1 = 2^n - x.

В дополнительном коде число -x записывается как 2^n-x. Поэтому его можно просто прибавлять/вычитать/умножать - лишнее 2^n не влезает в разрядность переменной и просто будет проигнорированно.

В обратном коде у вас есть лишнее -1, которое надо компенсировать. прибавлять при вычитании, вычитать при сложении и прибавлять множитель при умножении.

Еще, в обратном коде никак не записать 2^(n-1), потому что число 0 представимо 2 раза в виде 00000000 и 100000000.