Wataru

Можно через new[] выделить массив:

cin >> n;
int *array = new int[n];
// ввод, и работа с массивом.

// не забудьте в конце удалить выделенную память.
delete[] array;

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

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

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

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

Потом, встает вопрос, а как дорого делать overdraw. Может быть быстрее одну и ту же клетку прорисовывать несколько раз, но зато меньше графических вызовов делать. А может быть наоборот нельзя ни одну клетку прорисовывать более одного раза, даже если можно сократить так количество прямоугольников. Это две разные задачи, вам надо решить, что на вашей системе работает быстрее.

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

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

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

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

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

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

Сортировка очень больших файлов - тоже стандартная тема. Лучше всего, наверно, подойдет radix sort. Правда, нужно будет свободного места на диске чтобы копии файлов тоже помещались, да лучше с запасом. Тут надо будет 3 раза (или какая там у вас длина строки) прочитать файл. Прочитанные строки надо распихивать по 256 (или сколько там символов различных может быть) файлам. Потом все эти файлы надо собрать воедино в нужном порядке.

Надо только хорошо порыться в документации - нужны функции php которые читают файл построчно и не грузят его весь целиком в память. Если, конечно, у вас не ~128гб оперативки. Тогда лучше каждый файл загрузить в память целиком и сортировать quick sort'ом.

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

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

В вашем случае arr[i] + abs(min), очевидно, может запрасто выйти за границы 0.. temp_arr_length-1.

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

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

Код исправляется элементарно. Надо внутренний цикл по j гнать не до 0, а до 1. Что бы не вылезать за границу массива, вы же там к j-1 -ому элементу обращаетесь. А поскольку вы делаете swap, то вы меняете элементы массива с памятью перед ним. Массив - локальная переменая, а значит он лежит на стеке и вот это вот затирание памяти рядом с массивом и есть это самое "Stack around the variable 'arr' was corrupted".

Ну и по стилю - вместо i > -1 обычно пишут i >= 0.

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

Еще, естественно, надо передавать в функцию массив массивов строк - ваши исходные данные.

Надо обязательно массив массивов? Или подойдут кортежи? Так-то есть zip.

А дальше можно через np.asarray и map преобразовать массив touples в массив массивов.

Подсчитайте, сколько каждого символа встречается в первой строке и убедитесь, что во второй - их не больше.
Самый простой способ сделать это - это завести массив счетчиков на 256 элементов. Для символов первой строки увеличивайте счетчик по индексу static_cast<int>(s[i]) на 1, для второй строки - вычитайте 1. Если где-то получили -1, то составить нельзя.

И еще, это же у вас C++, судя по тегам и cin? Ну так используйте std::string. Зачем вы сишные строки выделяете?