Wataru

По уму, надо выделять последовательность нулей в цикле и там смотреть, а не с начала ли дня она идет и не до конца ли дня.

Но можно проще. Считайте вообще все последовательности нулей. до какой-то пары (это значит сейчас 0 - а следующаяя ячейка не ноль.). Но так посчитаются недо-окна перед первыми парами. Вы можете эти недо-окна подсчитать. Это просто те дни, в которых в начале стоит 0. Но тут, вы правильно заметили, проблема. День в котором одни нули посчитается недо-окном и вычтется, но ничего к ответу не прибавит. Поэтому вам надо отдельно прибавить количество дней из одних только нулей.

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

Если счетчик открытых скобок стал где-то отрицательным, или в конеце цикла он не ноль - то строка не сбалансирована.

Решение самое быстрое (O(n)) и самое заумное: построить суффиксное дерево, потом снизу вверх для каждой вершины найти индекс минимального и максимального по индексу листа в поддереве. Потом найти любую вершину, глубже 5, в которой минимальный и максимальный листы отстоят по крайней мере на глубину вершины (надо еще аккуратно обработать все вершины на ребре к отцу)

Более простое но и более медленное решение (за O(n^2)) - считайте полиномиальный хеш всех подстрок и храните в хешмапе минимальный индекс для каждого хеша. Оптять же, как только встретили подстроку, которую уже видели и ее первый индекс такой, что нет пересечения с текущей строкой - вы нашли ответ.

Еще за O(n^2) же есть решение через динамическое программирование: считайте F(i,j) - максимальная длина совпадающих строк, начинающихся с символов i и j (F(i,j) = 1 + F(i+1, j+1), если s[i] == s[j] и 0 иначе). Потом для каждой пары начал берите минимум из f(i,j), abs(j-i) - это и будет максимальная длина непересекающихся фрагментов с этих индексов. Если где-то нашли больше 5 - это ответ.

Ну и самое простое и медленное решение (за куб) - три цикла. Переберите 2 начала строк и сравнивайте их в цикле, пока они совпадают, не пересекаются и не выходят за границы строки. Если насчитали больше 5 символов - вы нашли ответ. Это почти как предыдущее решение, только без динамического программирования.

У вас одно уравнение с двумя неизвестными (x и y).
Что вы с ним ни делайте, оно так и останется одно, с двумя неизвестными. Оно дает вам какую-то связь неизвестных, но, само по себе, не даст их найти.

Уравнение линейное.
Вы или можете его привести или к виду x= Ay+B (A=-p, B=zp-n) или к виду y=Cx+D (C=-1/p, D=z-n/p)

Больше ничего и никак вы из этого уравнения не получите.

Комментарии в коде вроде //4 значение по адресу однозначно говорят, в чем проблема. Вы хотите работать с четверкой чисел, а в строке их у вас всего 2.

Перебирается число, которого еще нет в массиве. Ставится на следеющее место и рекурсивно запускается для каждого варианта.

Как и на 3 ваших предыдущих вопроса, ответ - нет.

Подсказка: в c++ в цикле for не обязательно использовать i++. Можно, например, i+=10.

Повороты вдоль какой-то оси на 90 градусов все выглядят одинаково: 2 координаты меняются местами и одна из них меняет знак. Осталось только порисовать и сформулировать правила.

Так, поворот против часовой стрелке вдоль оси Z, меняяет местами X, Y и делает меняет знак у X, т.е. X' = -Y, Y' = X, Z' = Z. Вам надо все тройки вот таким побразом поизменять. Поворот по часовой стрелки вдоль Z делает наоборот. Опять же меняет X и Y и меняет знак Y.

Повороты вдоль других осей придумайте сами. Меняются местами две другие оси, и какая-то из них меняет знак. Представьте, куда двигаются (1,0,0), (0, 1, 0) и (0, 0, 1), что бы понять правила.

При реализации только аккуратно делайте. Если помене на месте, то надо именно swap делать, ведь если выполнить x=-y; y=x, то у вас изначальная x координата затрется в первом выражении и потеряется навсегда.

Раз уж я в коментариях к вопросу и так код привел (ради доказательства, что кто-то в интернете неправ), то приведу его и в качестве ответа. Код был на коленке ради быстрой проверки написан, поэтому в продакшн его так не пихайте. Глобальные переменные, константы - все это надо бы причесать.

const int BE = 900000000;
const int N = 1000000000;

std::vector<int> small_primes;

bool DivisibleBySmallPrimes(int x) {
	for (int i = 0; i < (int)small_primes.size() && small_primes[i]*small_primes[i] <= x; ++i) {
		if (x % small_primes[i] == 0) return true;
	}
	return false;
}

void ComputeSmallPrimes() {
	int n = sqrt(N);
	for (int i = 2; i <= n; ++i) {
		if (!DivisibleBySmallPrimes(i)) {
			small_primes.push_back(i);
		}
	}
}

void ComputeSieve() {
	ComputeSmallPrimes()
	std::vector<bool> sieve(N-BE+1);
	std::vector<int> primes;
	for (auto &x : small_primes) {
		int i = (BE-1) - (BE-1) % x + x;
		while (i <= N) {
			sieve[i-BE] = true;
			i += x;
		}
	}
	for (int i = BE; i <= N; ++i) {
		if(!sieve[i-BE]) {
			primes.push_back(i);
		}
	}
}

upd:
ComputeSmallPrimes можно переписать простым решетом - будет еще быстрее.

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

s/i=delta/gamma

Вторую часть не совсем понял, вы хотите подставить s из первого уравнения во второе и обособить i?

Тогда Result1= (d/i+1)*gamma/delta

Upd: ответ на отредактированный вопрос - никак. i всегда будет входить в выражение в степени -1.

Тут есть 5 подзадач:
1) разбить строку на слова
2) определить по слову, является ли оно числом в десятичной системе счисления
3) Перевести слово в число
4) перевести число из десятичной системы счисления в 16-ричную
5) Записать число в 16-ричной системе в строку

1,3,4 и 5 - стандартны и гуглятся.
2 - подсказка: проверьте, что слово состоит только из символов '0'-'9' и не начинается с '0'. По идее, надо бы еще разрешить слово "0", но ноль, он и в 16-ричной системе будет ноль, поэтому такое слово можно не учитывать в вашей задаче. Символы 0..9 имеют коды ascii подряд, поэтому в программе достаточно записать с >= '0' && c <= '9'.