Wataru

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

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

У вас решение за O(NM), когда как есть решение за O(N+M).

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

Если у вас в строке i символов выведено, а должно суммарно быть N символов, то осталось вывести N-i звездочек.

Можно. Для этого можно, например, пройтись циклом по словам формируя список-ответ. Если текущее слово не содержит символ параграфа, то его надо или добавить к списку ответа, или добавить к последнему слову там. Или проще может быть поддерживать переменную с текущим объединением слов. Если слово в списке не соедржит парагафа - добавляйте к переменной. Если встретили прагараф, то добавляйте в ответ переменную и слово с параграфом и отчищайте переменную.

Код работает ровно так, как написан.

Можете строчка за строчкой объяснить, что происходит в коде? Я начал, вы дополните в остальных строчках. Сразу должно стать понятно, где ошибка в логике:

numbers = input().split()               # получаем в numbers массив из отдельных слов в введенной строке
flag = 0                                # инициализируем счетчик нулем
for i in range(len(numbers)):           # проходимся по всей длине массива (по всем словам)
    if numbers[i].isdigit() == True:    # Если текущее слово состоит только из цифр (т.е. оно число)
        flag += 1                       # Увеличиваем счетчик
if flag == len(numbers):                # если все слова в строке - числа
    for i in range(len(numbers)-1):     # ???
        print(numbers[i], numbers[i+1]) # ???
        if numbers[i] < numbers[i+1]:   # ???
            mx = numbers[i+1]           # ???
print(mx)

Проблема в том, что вот эта вот ваша формула - она работает только на отрезке, где sinx*sgn(cos x) непрерывна. А она имеет разрывы в точках, где косинус меняет знак. Вы ее, видимо, подобрали методом тыка. И действительно, если взять ее производную в каждой точке, то получается |cos x|. Но эту производную не взять в точках, где косинус меняет знак, ведь там разрывы. Это не первообразная, хотя бы потому, что первообразная должна быть непрерывна. поэтому формула определенного интегралла тут и не работает.

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

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

Большой файл - гораздо менее вредно, чем нелогичная файловая структура проекта. Вот большие функции и класс с излишне большой ответственностью - это плохо. А файл - фигня. Строк от разбивки меньше не становится. Ну придется еще переключатся между файлами - только хуже станет.

Можно сделать так:

template <int a, int b>
class A {
    public:
    template<bool tmp = true>
    typename std::enable_if<a==b && tmp, int>::type F() {
       return 1;   
    }
};

...

A<1,1> a;
std::cout << a.F();  // OK.
A<2,100> b;
std::cout << b.F(); // Ошибка A<2,100> не имеет метода F().

Мне сложно объяснить, чтобы было понятно, почему работает именно это, но я попробую.

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

Далее, хотелось бы что бы просто работало вот это:

template<>
 typename std::enable_if<a==b, int>::type F()

Тут все понятно, enable_if не имеет type, если a неравно b. Шаблон никак не инстанциировать и метод не должен был бы генерироваться. Но это было бы слишком просто.

Вместо этого, надо там завести какой-то вообще ненужный как бы параметр шаблона tmp, и обязательно использовать его в enable_if. Это потому что если в этом шаблоне не будет никак использоваться параметр шаблона, то SFINAE не срабатывает, и вылезает ошибка компиляции.

В общем случае - будет.
std::swap работает за константу:

Complexity
1) Constant.

Присвоение за линию:

Complexity
1) Linear in the size of *this and other.

Edit: это если присваемые штуки - вектора. Или какие-то большие объекты с семантикой перемещения. Если у вас тупо числа, то одно присвоение будет быстрее swap.

Сначала каждую строку resize до размера size()+w0+w1. Потом сдвигайте элементы на w0 позиций вправо (цикл надо гнать с конца). Потом заполните пустые места нулями.

То же самое в самом векторе векторов. Только вместо чисел надо сдвигать вектора на h0 позиций. На пустые места надо будет записывать std::vector(n+w0+w1, 0);

Edit: А вообще, тут и добавлять в массив ничего не надо. Вы нужный вам ответ можете нулями прямо во время вывода добить.

Вообще тут есть другая проблема, с которой вы столкнетесь. Если у вас определение шаблона и реализация в разных файлах, то будут ошибки на этапе линковки. Компилятор, когда будет обрабатывать cpp файл не увидит никаких использований шаблона и с чистым сердцем не сгенерирует никаких его специализаций. Потом линкер не сможет найти нужную реализацию и ругнется.

Чтобы это исправить нужно или засунуть все в h файл, или в cpp файле прописать специализации шаблона со всеми типами, которые где-либо еще используются, вот так:

using A<int>;
using A<double>;
// etc

Далее, как именно и зачем вы хотите этот внутренний класс скрыть?
Иногда вам может быть достаточно сделать член этого типа private и все. Факт того, что кто-то где-то сможет завести переменную этого типа обычно не является проблемой. Для списка уж точно. Если же это проблема и внутренний класс является friend внешнего и что-то такое делает, что нарушает инкапсуляцию (например при учнитожении, что-то меняет в родительском классе), то просто сделав вложенный класс private, вы ничего не добъетесь. Переменные этого типа все-равно можно будет использовать и к ним обращатся (иногда через хаки). Обычно у внутренних классов просто делают приватным конструктор и нужные методы и прописывают внешний класс как friend. Тогда вы в самом классе сможете переменные этого типа создавать и использовать, но никто снаружи ничего с ним сделать не может.

И кстати, в вашем случае вам совсем нет смысла делать вложенный класс шаблоном. Он уже в шаблоне же, просто используйте внутри тип T.

Дельта x меньше лямбда по построению. Также, лямбда меньше дельта, так указано в насале строки. Весь этот переход - это замена каждого дельта x на большее его дельта и вынос его за скобки.

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

Ваша матрица с нулями при умножении как раз вычисляет уравнение. А раз вектор удовлетворяет уравнению, то получится 0.