Fraktaali

from itertools import product

# Deklaratiivinen rekursiivinen paradigma
def invert(f):
    f_c= {}
    for k, v in f.items():
        f_c[k]= not v
    return f_c

def G(n, g):
    n, f= 2** (n- 1), {}
    for i, j in product(range(2), range(2)):
        for k, v in g[i, j].items():
            f[i* n+ k[0], j* n+ k[1]]= v
    return f

def F(k):
    if k> 1:
        f= F(k- 1)
        return G(k- 1, {(0, 0): f, (0, 1): f, (1, 0): f, (1, 1): invert(f)})
    return {(0, 0): 1}

def p(k, g):
    o, s= {0: '.', 1: '#'}, ''
    for i in range(2** (k- 1)):
        for j in range(2** (k- 1)):
            s+= o[g[i, j]]
        s+= '\n'
    return s

# Objekti-orientoitunut iteratiivinen paradigma
def _add_c(g, n):
    for k, v in g.copy().items(): g[k[0], k[1]+ 2** (n- 1)]= v

def _add_r(g, n):
    for k, v in g.copy().items(): g[k[0]+ 2** (n- 1), k[1]]= v

def _add_rc_inv(g, n):
    for k, v in g.copy().items(): g[k[0]+ 2** (n- 1), k[1]+ 2** (n- 1)]= not v


class Fraktaali():
    def __init__(self):
        self._g, self._max_n= {(0, 0): 1}, True

    def __call__(self, n):
        self._n= n
        for k in range(self._max_n, n):
            self._create(k)
        self._max_n= n
        return self._g

    def __str__(self):
        print('called')
        return p(self._n, self._g)

    def _create(self, n):
        _add_c(self._g, n)
        _add_r(self._g, n)
        _add_rc_inv(self._g, n)
    
if __name__ == "__main__":
    n= int(input())
#    n= 4
#    print(p(n, F(n)))
#    print('---')
    print(p(n, Fraktaali()(n)))

Test 1

Group: 1

Verdict: ACCEPTED

Test 2

Group: 2

Verdict: ACCEPTED

Test 3

Group: 3

Verdict: ACCEPTED

Test 4

Group: 4

Verdict: ACCEPTED

Test 5

Group: 5

Verdict: ACCEPTED

Test 6

Group: 6

Verdict: ACCEPTED

Test 7

Group: 7

Verdict: ACCEPTED

Test 8

Group: 8

Verdict: ACCEPTED

Test 9

Group: 9

Verdict: ACCEPTED

Test 10

Group: 10

Verdict: TIME LIMIT EXCEEDED