Wataru

IndentationError: unexpected unindent

означает, что форматирование файла кривое. Скорее всего, табы вместо пробелов или наоборот в 22 строке. При форматировании не то вставили. Выглядеть оно может правильно, но питону важно, чтобы все было идентично.

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

Поэтому рекомендуется во всем файле использоваать или только табы, или только пробелы.

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

Это получается задача квадратичного программирования. Ищите специализированный метод в scipy. Может вот это сработает.

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

Все индивидуально. Чего этот sleep в коде ждет?
Может, тут он ждет отклика от сервера, и там действительно надо 200мс ждать. И просто заменой time sleep на что-то вы ничего не исправите. Или это анимация чего-то на экране, и тут можно в 0 все убирать.

Но вообще гуглите simulated time python.
Посмотрите, может simpy вам тут поможет.

Ваш алгоритм работает за O(n^2). Вы для каждого числа в массиве считатете, сколько раз оно туда входит проходя по массиву через nums.count(i). Оптимальное же решение работает O(n). Надо в хеш-таблице подсчитать, сколько раз каждое число встречается, потом через алгоритм QuickSelect выбрать k-ый c конца элемент.

Ну, или можно за O(n log n) отсортировать массив и потом за один проход подсчитать сколько раз каждое число встречается. Дальше можно второй раз отсортировать по количеству вхождений и выдать k-ый элемент. Это решение тоже пройдет.

Тут надо сделать из графа на N вершин граф на N^2 вершин. Граф-то совсем маленький. Каждая вершина нового графа соответствует паре вершин изначалного графа (x, y) и обозначает, что фишки стоят в вершинах x и y соответственно. Переходы в новом графе делаются из переходов в изначальном: из (x, y) можно перейти в (x, z), если в изначальном графе есть дуга y->z и ее цвет совпадает с вершиной x. Аналогично из (x,y) можно перейти в (z,y), если есть дуга x->z и ее цвет совпадает с y.

В этом графе уже можно любым известным вам способом искать путь. Только тут конечных вершин будет сразу много: это все пары (x,y), где x или у - конечная вершина в графе. Можно или добавить новую конечную вершину и соединить с ней все вот эти вот, или прямо в алгоритме исправить условие останова.

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

Т.е. вам надо сгенерировать перестановку заданных слов? Ну без разницы же, что перемешивать: числа или слова.
Получите массив из ваших слов, разбив строку по пробелам. Потом перемешайте массив стандартным алгоритмом. Потом выведите их через пробел.

Стандартный алгоритм перемешивания таков:

for i in range(len(a)):
  j = random.randint(0, i);
  a[i], a[j] = a[j], a[i]

Тут поддерживается инвариант, что первые i элементов равномерно и случайно перемешаны. На каждой итерации выбирается случайная позиция для нового элемента (возможно последняя и элемент никуда не переместится). Дальше достаточно только лишь поменять новый элемент со стоящим на его месте. Ведь по инварианту все остальные элементы уже случайно перемешаны и в итоге случайно перемешанными оказываются N+1 элементов.

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

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 можно переписать простым решетом - будет еще быстрее.

Код в вопросе найдет такое i, что result станет равен 1, если цикл сделать до N. Для любых дельта и гамма. (но там цикл не нужен вообще).

И наоборот. Какие бы вы дельта и гамма не взяли, может прийти такой Input, что result станет 1, только для очень большого i.

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

result = (input / delta) / (i / gamma) = input * (gamma / delta) / i

Если result = 1, то получается i = input * (gamma / delta) (естественно, умножение и деление по модулю N).
Цикла не надо. Можно сразу вычислить искомое i.
Решение единственно (если N простое. А если оно не простое, то делить по модулю нельзя).

И это самое i может оказаться очень большим. Не всегда N-1, потому что у вас ограничение на Input есть дополнительное, Но даже в самом лучшем случае подбора гамма и дельта (обе по 1), вам может прийти input такой, что i будет равно 2^120.

Ну и, во-вторых, вам не нужны две константы дельта и гамма. Тут есть ровно одна степень свободы - значение gamma / delta. Это должна быть единственная константа в вашем коде. В итоге оно все упрощается до:

beta = 0x42
i = beta * input % N
result = 1

И вообще тут, очевидно, проблема XY. У вас есть какая-то задача X, вы придумали какую-то фигню, как-то сформулировали вот эту вот задачу в вопросе (У), но вы ошиблись. Решение вот этой фигни в вопросе вам никак не поможет решить вашу изначальную задачу, пототму что вам не хватает знаний (теории групп, например, да и математики в целом). Вы задаете практически бессмысленные вопросы (уже не первый раз). Если хотите, чтобы вам тут действительно помогли - давайте вашу изначальную задачу. Я подозреваю, что это взлом криптографии и вам тут популярно объяснят, что вы зря тратите время.

Я так понял, надо подобрать константы a,b,c,d?
Вообще, можно a, b1, c считать равными 1 и менять только d.

Но у вас там умножение и деление по модулю. Так что все очень сложно.

Вообще, ваша задача не имеет решения.

Модуль у вас в вопросе порядка 10^78. А X может быть 10^119-10^120. Если x взять по модулю N, то там может получится вообще любой остаток (потому что 10^120-10^119 = 9*10^119 > N)

А дальше, умножая эти числа на константу, если N простое (а оно должно быть простым, иначе деление по модулю не определено), то можно получить любой остаток до N. Не только до 2^60 - 2^70.