Problem:
 Score : 900 points    Problem Statement  We have a grid with (2^N - 1) rows and (2^M-1) columns.
You are asked to write 0 or 1 in each of these squares.
Let a_{i,j} be the number written in the square at the i -th row from the top and the j -th column from the left.  For a quadruple of integers (i_1, i_2, j_1, j_2) such that 1\leq i_1 \leq i_2\leq 2^N-1, 1\leq j_1 \leq j_2\leq 2^M-1 , let S(i_1, i_2, j_1, j_2) = \displaystyle \sum_{r=i_1}^{i_2}\sum_{c=j_1}^{j_2}a_{r,c} .
Then, let the oddness of the grid be the number of quadruples (i_1, i_2, j_1, j_2) such that S(i_1, i_2, j_1, j_2) is odd.  Find a way to fill in the grid that maximizes its oddness.      Constraints   N and M are integers between 1 and 10 (inclusive).         Input  Input is given from Standard Input in the following format:  N  M       Output  Print numbers to write in the grid so that its oddness is maximized, in the following format:  a_{1,1}a_{1,2}\cdots a_{1,2^M-1}  a_{2,1}a_{2,2}\cdots a_{2,2^M-1}  \vdots  a_{2^N-1,1}a_{2^N-1,2}\cdots a_{2^N-1,2^M-1}   If there are multiple solutions, you can print any of them.        Sample Input 1 1 2      Sample Output 1 111  For this grid, S(1, 1, 1, 1) , S(1, 1, 2, 2) , S(1, 1, 3, 3) , and S(1, 1, 1, 3) are odd, so it has the oddness of 4 .  We cannot make the oddness 5 or higher, so this is one of the ways that maximize the oddness.

Solution (Python):
N,M=map(int,input().split())

A=[]
for i in range(2**N):
    B=[]
    for j in range(2**M):
        B.append(bin(i&j).count("1")%2)
    A.append(B)

ANS=[[0]*(2**M) for i in range(2**N)]

for i in range(1,2**N):
    for j in range(1,2**M):
        if A[i][j]!=(A[i-1][j]+A[i][j-1]-A[i-1][j-1])%2:
            ANS[i][j]=1

for a in ANS[1:]:
    print("".join(map(str,a[1:])))

Solution (Python):
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
import numpy as np
def resolve():
    N, M = lr()
    rev = 0
    if N < M:
        M, N = N, M
        rev = 1
    T = np.zeros(1, dtype=np.int8)
    for i in range(N):
        T = np.tile(T, (2, 2))
        T[1<<i:, 1<<i:] ^= 1
    T = np.diff(T, axis=0)
    T = np.diff(T, axis=1)
    T = T[:, :(1<<M)-1]%2
    if rev:
        T = np.transpose(T)
    for t in T:
        print(''.join(t.astype(str)))
resolve()

Solution (Python):
n, m = map(int, input().split())
ans = [0, 1]
for i in range(1, min(n, m)):
    k = 1 << i
    x = (1 << k) - 1
    slide = [a << k for a in ans]
    new_ans = [s | a for s, a in zip(slide, ans)]
    new_ans.extend(s | (a ^ x) for s, a in zip(slide, ans))
    ans = new_ans
if n > m:
    ans *= 1 << (n - m)
elif n < m:
    for i in range(n, m):
        k = 1 << i
        ans = [(a << k) | a for a in ans]

ans = [a0 ^ a1 for a0, a1 in zip(ans, ans[1:])]
ans = [a ^ (a >> 1) for a in ans]

print('\n'.join(map(('{:0' + str(2 ** m - 1) + 'b}').format, ans)))

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    def hadamard(n):
        if mem[n] != None:
            return mem[n]
        h = hadamard(n-1)
        res = [[j for j in i] for i in h]
        res_ = [[j for j in i] for i in h]
        for i in range(len(res)):
            res[i] += [j for j in h[i]]
            res_[i] += [j^1 for j in h[i]]
        res += res_
        mem[n] = res
        return res

    n,m = LI()
    f = 0
    if m < n:
        n,m = m,n
        f = 1
    h,w = 1<<n, 1<<m
    mem = defaultdict(lambda : None)
    mem[0] = [[0]]
    s = hadamard(m)[:h]
    if f:
        s = [[s[j][i] for j in range(h)] for i in range(w)]
        h,w = w,h
    for x in range(w):
        for y in range(h-1)[::-1]:
            s[y+1][x] ^= s[y][x]
    for y in range(h):
        for x in range(w-1)[::-1]:
            s[y][x+1] ^= s[y][x]
    ans = [i[1:] for i in s[1:]]
    for i in ans:
        print(*i,sep="")
    return


if __name__ == "__main__":
    solve()

Solution (Python):
import sys

bitcnt = [0] * (1 << 10)
for i in range(1,1 << 10):
    bitcnt[i] = bitcnt[i//2] + i % 2
    bitcnt[i] %= 2

field = [[bitcnt[i & j] for j in range(1 << 10)] for i in range(1 << 10)]
    
n, m = map(int, input().split())
n = 1 << n
m = 1 << m
for i in range(1, n):
    for j in range(1, m):
        num = field[i][j] - field[i-1][j-1] - field[i-1][j] -field[i][j-1]
        sys.stdout.write(str(num%2))
    print()

Solution (Python):



import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
read = sys.stdin.read

n,m = [int(i) for i in read().split()]


def popcount(i): 
    i = i - ((i >> 1) & 0x55555555)
    i = (i & 0x33333333) + ((i >> 2) & 0x33333333)
    return (((i + (i >> 4) & 0xF0F0F0F) * 0x1010101) & 0xffffffff) >> 24

N = 2**n
M = 2**m
a = []
for k in range(N):
    a.append([popcount(x&k)&1 for x in range(M)])


for i in range(N-1,0,-1):
    for j in range(M-1,0,-1):
        a[i][j] ^= a[i-1][j]^a[i][j-1]^a[i-1][j-1]

for i in range(1,N):
    x = map(str,a[i][1:])
    print("".join(x))

Solution (Python):
n,m=map(int,input().split())
ans=[["1"]*(2**m-1) for _ in range(2**n-1)]
for k in range(1,11):
    for i in range(2**k,2**n,2**k):
        for j in range(2**k,2**m,2**k):
            if ans[i-1][j-1]=="1":
                ans[i-1][j-1]="0"
            else:
                ans[i-1][j-1]="1"
for i in range(2**n-1):
    print("".join(ans[i]))

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

import numpy as np

N,M = map(int,read().split())

def solve(N,M):
    if N > M:
        return solve(M,N).T
    H = np.array([[0]], np.int8)
    for i in range(M):
        H = np.tile(H, (2,2))
        H[1<<i:,1<<i:] ^= 1
    H = np.diff(H, axis=0)
    H = np.diff(H, axis=1)
    return (H % 2)[:(1<<N) - 1]

H = solve(N,M)
size = 0
for row in H:
    word = ''.join(row.astype(str))
    print(word)