Wataru

Вы сети скармливаете какие-то 2 картинки. У нее 2 input'а

print(model.predict([image,image2]))

Втавьте вот в этот код выше перед вызовом predict вывод размеров image и image2.

Сдается мне, что вы одну картинку как-то на 2 куска порезали и так и скормили сети. Если это не ваш код, то он возможно ожидает на вход картинку 128x64.

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

Смотрите на ограничания - n и m до 100000. Обычно такой порядок чисел означает, что вам нужно решение за O(n+m) или что-то вроде O(n+m log (n+m)). У вас же решение "в лоб" за O(nm), что никак не ускорить принципиально. Даже переписыванием на си со всякими хитростями вы ускорите его в 10, ну в 100 раз. А вам надо ускорить его в 10000 раз.

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

Остался случай - что если один массив целиком отрицателен, а второй - целиком положителен. Пусть a положителен, а b отрицателен. Что будет, если взять минимальные по модулю элементы и там и там? Посмотрите внимательно - вам дано, что ни одно из чисел не 0. Это поможет.

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

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

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

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)

Я предполагаю, что условие вашей задачи такое - дано куча запросов вида <начало отрезка, конец, значение>. Все ячейки в этом отрезке заполняются заданным значением, если они меньше его. Надо найти сумму всех ячеек в конце.

Тут есть два решения. Первое - через дерево отрезков с отложенным изменением. Само дерево немного странное получается, потому что оно ничего не считает в промежуточных вершинах, а будет только хранить отложенное изменение. Физический смысл отложенного изменения - "все ячейки в этом поддереве должны быть не меньше этого значения". Релаксация (спуск вниз) отложенного изменения происходит так: отложенное изменение в детях заменяется на максимум из того, что там лежит и отложенного значения в родителе. Значение в родителе заменяется на 0. При запросе спускайтесь рекурсивно по дереву, релаксируя изменения, пока текущее поддерево не будет целиком лежать в запросе. Тогда перезаписывайте отложенное значение в текущей вершине, если оно меньше. В конце обработки запросов релаксируйте все вершины сверху вниз и просуммируйте значения в листьях.

Второе решение - через метод сканирующей прямой может быть проще в реализации из-за наличия встроенных структур данных. Я думаю, в питоне должна быть структура, которая умеет быстро добавлять число, удалять число и брать максимум из всех чисел. В C++ есть std::set или std::priority_queue.
Для каждого отрезка-запроса создайте два события вида <координата, отрезок открылся/закрылся, значение> (разберитесь, где там +-1 поставить так, чтобы длина отрезка по координатам равнялась количеству покрытых ячеек). Засуньте их все в один массив и отсортируйте по координате. Потом проходитесь слева-на-право. Применяйте текущее событие - или добавляйте число в вашу структуру данных, или удаляйте оттуда. Между текущим и следующим событием по координатам все ячейки покрыты одним и тем же множеством отрезков, поэтому можно их все быстро посчитать, ведь ваша структура умеет брать максимум. Добавляйте к ответу разность координат между текущим и следующим событиями, умноженную на значение максимума из структуры. Все.

Это не задача на программирование, а задача на математику. Решение - одна формула.

Сначала решите уравнение, при какой величине вклада X доход от бумаги и от банковского вклада будет одинаков?

1.1X+2000 = 1.12X

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

От питона вам надо уметь выполнять действие 4 раза:
for i in range(0, 4):

Сравнивать 2 значения и делать в зависимости от этого разные действия.

if a < b:
  foo
else:
  bar

Ну, вряд ли вы не знаете, еще надо уметь присваивать переменные и выполнять арифметику - умножение и сложение.

Нельзя суммой проверять. Ведь если чисел в массиве четно, то сумма всегда будет нечетно (буть четным одно или n-1 в массиве).

Можно сравнить первые три числа, понять не лежит ли ваше исключение там или понять какой четности оно должно быть и дальше найти его как у вас.

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

Увеличте размер сортруемых массивов до 100 000 или до миллиона и квиксорт должен стать быстрее.

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

Обход в ширину. Сначала поместите в очередь ваши начальные точки с расстоянием 0 и пометьте эти клетки в какой-то матрице как обработанные. Потом, пока очередь не пуста, доставайте из нее одну клетку, смотрите 4 соседние клетки и, если они пока не обработаны, кладите их в конец очереди с расстоянием +1 к текущей клетке. Также всегда помечайте клетки обработанными когда помещаете их в очередь.

Работать это будет O(nm) - быстрее никак.

Смотрите внимательно - какие переменные вы выводите и как они меняются в коде. Нормальные названия кстати упростили бы вам поиск ошибки.

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

Т.е. вам надо найти путь из одной клетки в другую, пройдя по как можно меньшему количеству клеток. Можно ходить в 8 направлений - если пересечь угол, то можно за одну точку на ломаной перейти по диагонали.

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

Надо только аккуратно разобрать случаи, если начальная или конечная точка лежит на границе клетки.