Andrey Dugin

class Sheet:
    def __init__(self, width, length, thickness=1, count=0):
        self.width, self.length = sorted([width, length])
        self.thickness = thickness
        self.count = count
        
    @property
    def foldable(self):
        return self.length >= 2 * self.thickness
    
    def fold_once(self):
        if self.foldable:
            self.width, self.length = sorted([self.width, self.length/2])
            self.thickness *= 2
            self.count += 1
            return True
        else:
            return False
        
    def fold(self):
        while self.fold_once():
            pass
        return self


def run_test_cases():
    assert Sheet(82, 18).fold().count == 4
    assert Sheet(404, 279).fold().count == 6
    assert Sheet(10, 26).fold().count == 3


if __name__ == '__main__':
    # run_test_cases()
    with open('input.txt', 'rt') as fi, open('output.txt', 'wt') as fo:
        dimensions = map(float, next(fi).split())
        answer = Sheet(*dimensions).fold().count
        print(answer, file=fo)

Посмотрите в эту сторону: scipy.optimize

from scipy.optimize import minimize
import numpy as np

def func(x):
    return np.abs(np.sin(x)-x)

minimize(func, -1)

Результат:

fun: 1.3390927663600727e-08
 hess_inv: array([[ 109.41685172]])
      jac: array([ -9.30984970e-06])
  message: 'Optimization terminated successfully.'
     nfev: 36
      nit: 11
     njev: 12
   status: 0
  success: True
        x: array([-0.00431507])

Извлечение значений:

result = minimize(func, -1)
print(result.fun)  # => 1.3390927663600727e-08
print(result.x[0])  # => -0.0043150659686

То есть найдено приблизительное решение x=-0.00431507. Проверка:

x = -0.00431507
sin(x) - x  # => 1.3390965196077853e-08

Методы можно менять, это влияет на точность:
result = minimize(func, -1, method='Nelder-Mead')
Там ещё есть куча интересных аргументов, изучайте.

P.S. Но вообще странно искать очевидное решение программно.

Чем обоснован выбор именно JSON? Почему не SQLite, например?

import os

with open('task2.in', 'rt') as fi, open('task2.out', 'wt') as fo:
    num = int(next(fi).strip())
    out = (line.strip()[-1] for _, line in zip(range(num), fi))
    fo.write(os.linesep.join(out))

Потому что экспозицию можно задать только в момент съёмки. А в пост-обработке (и ФШ, в частности) её можно только эмулировать, но эмуляция не добавит утраченные детали (отмечу, что в RAW деталей больше, чем в JPEG). Суть в том, что фотоаппарат не может одновременно сохранить детали и в светах, и в тенях (это определяется динамическим диапазоном фотоаппарата, а также количеством бит на пиксель). HDR - это способ искусственного расширения динамического диапазона. Недоэкспонированные фотографии сохраняют детали в светах, а переэкспонированные - в тенях. При сборке получается франкенштейн, который содержит детали и там, и там.

На Python так не пишут. Вот как правильно:

class Solution:
    
    def two_sum(self, numbers, target):
        buffer = {}
        for index, number in enumerate(numbers):
            try:
                return [buffer[number], index]
            except KeyError:
                buffer[target - number] = index
        return False

Learn X in Y minutes where X=Python

Профилировщик Вам в руки. Например:

python -m cProfile -s time z:\test.py > z:\profile.txt

Вот топ самых медленных мест:

ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     3188    0.609    0.000    1.730    0.001 test.py:71(suggest_coord)
    39844    0.422    0.000    0.902    0.000 test.py:164(check_fit_score)
   128340    0.223    0.000    0.223    0.000 test.py:254(get_cell)
    67237    0.223    0.000    0.338    0.000 test.py:257(check_if_cell_clear)
     3188    0.130    0.000    1.063    0.000 test.py:108(sort_coordlist)
    64378    0.094    0.000    0.094    0.000 {method 'append' of 'list' objects}
34372/34369    0.052    0.000    0.052    0.000 {built-in method builtins.len}
      108    0.034    0.000    0.062    0.001 test.py:23(clear_grid)
     3188    0.032    0.000    1.827    0.001 test.py:123(fit_and_add)
     3297    0.027    0.000    0.058    0.000 random.py:260(shuffle)
     3299    0.023    0.000    0.035    0.000 {method 'sort' of 'list' objects}
     2160    0.022    0.000    0.056    0.000 test.py:336(__init__)
     1193    0.020    0.000    0.035    0.000 test.py:236(set_word)

Начинайте оптимизировать с самой верхней строки.

P.S. А вообще это кривой говнокод. Надо переписать заново с нуля.

Основная конструкция:

try:
    ...
except SomeException as e:
    ...
except AnotherException as e:
    ...
except (ThirdException, FourthException):
    ...
else:
    ...
finally:
    ...

Для явного замалчивания ошибок:

from contextlib import suppress

with suppress(SomeException):
    ...

Это эквивалентно следующей конструкции:

try:
    ...
except SomeException:
    pass

Для записи логов используйте модуль logging.

В Photoshop нужно сделать надпись в отдельном текстовом слое, развернуть её под необходимым углом, выделить полностью и меню "Редактирование -> Определить узор...". После этого можно будет делать заливку с использованием данного узора. Для упрощения обработки большого количества изображений имеет смысл записать макрос и сделать из него дроплет.

list(zip(*filter(any, zip(*filter(any, matrix)))))

UPD Вынесу из комментов окончательный вариант:

def trim(matrix):
    fltr = lambda matrix: zip(*filter(any, matrix))
    return [list(row) for row in fltr(fltr(matrix))]

matrix = trim(matrix)

Вам нужно использовать defaultdict и set:

from collections import defaultdict

dic = defaultdict(set)
dic[1].add(1)
dic[2].add(2)
dic[1].add(1)
dic[1].add(3)
print(dic)
print(dic[0])

В Python 3.6 словари и множества сохраняют оригинальный порядок элементов, в более ранних версиях порядок не гарантируется.

В последней строке написано, чего не хватает - модуля codecs. Читайте внимательно.

Вы серьёзно? Цикл по массиву в numpy?! Зачем???

img_contrast = (img - min_br) * (255 / (max_br - min_br))

dmitrylogvinov, Вы в корне неправильно подходите к обучению. Вам нужно больше времени проводить с учебником и изучать стандартные библиотеки (и в первую очередь - встроенные функции, обращая особое внимание на их параметры), а не пытаться решать задачи "в лоб", раз за разом городя конструкции в стиле Delphi из базового синтаксиса, примерно одинакового для каждого языка. "Батарейки" в Python присутствуют как раз для того, чтобы не изобретать велосипеды.

Задача решается просто и элегантно:

from itertools import count

def lastmax(*sequence):
    return max(zip(sequence, count()))

assert lastmax(1, 2, 3) == (3, 2)
assert lastmax(1, 2, 1, 2, 1) == (2, 3)
assert lastmax(1, 2, 3, 4, 5) == (5, 4)
assert lastmax(1, 1, 1, 1, 1) == (1, 4)

Те же самое, но без itertools:

def lastmax(*sequence):
    return max(zip(sequence, range(len(sequence))))

Ещё вариант:

from operator import itemgetter

def lastmax(*sequence):
    return max(enumerate(sequence), key=itemgetter(1, 0))[::-1]

И ещё:

def lastmax(*sequence):
    return max({v: i for i, v in enumerate(sequence)}.items())

Есть и ещё несколько более эзотерических вариантов - например, через heapq.

d = {1: [1, 2, 3, 4], 3: [5, 7, 9], 9: [9, 0, 5, 4, 6]}

Вариант #1.1 (21.7 µs per loop) - кстати, v.pop() было бы быстрее, чем v.pop(0):

while d:
    for k, v in d.copy().items():
        print(f'{k}:{v.pop(0)}') if v else d.pop(k)

Вариант #1.2 (32.2 µs per loop):

while d:
    for key, vals in tuple(d.items()):
        try:
            print(f'{key}:{vals.pop(0)}')
        except IndexError:
            del d[key]

Вариант #2 (15.7 µs per loop) - самый быстрый, т.к. нет try/except и модификации:

from itertools import chain, cycle, zip_longest

def solve(mapping, placeholder=None):
    keys = cycle(mapping.keys())
    vals = chain(*zip_longest(*mapping.values(), fillvalue=placeholder))
    for key, val in zip(keys, vals):
        if val is not placeholder:
            print(f'{key}:{val}')

solve({1: [1, 2, 3, 4], 3: [5, 7, 9], 9: [9, 0, 5, 4, 6]})

Вариант #3 (27.2 µs per loop):

from itertools import repeat, starmap

def solve(mapping):
    iterf = lambda key, vals: (repeat(key), iter(vals))
    items = tuple(starmap(iterf, mapping.items()))
    for _ in max(mapping.values(), key=len):
        for ikeys, ivals in items:
            try:
                print(f'{next(ikeys)}:{next(ivals)}')
            except StopIteration:
                pass

solve({1: [1, 2, 3, 4], 3: [5, 7, 9], 9: [9, 0, 5, 4, 6]})