Hướng dẫn anti diagonals in python assignment expert - chống đường chéo trong chuyên gia phân công python

Xem thảo luận

Cải thiện bài viết

Lưu bài viết

Xem thảo luận

Cải thiện bài viết

Lưu bài viết

ĐọcN*N, return an array of its anti-diagonals. For better understanding let us look at the image given below:

Examples:  

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Bàn luận
To solve the problem mentioned above we have two major observations. 

• Cho một ma trận vuông có kích thước n*n, trả lại một mảng các đường chéo của nó. Để hiểu rõ hơn, chúng ta hãy nhìn vào hình ảnh được đưa ra dưới đây:column >= 0 or start row < N.
• Cách tiếp cận 1: Để giải quyết vấn đề được đề cập ở trên, chúng tôi có hai quan sát chính. & NBSP;row < N or start column >= 0.

Cái đầu tiên là, một số đường chéo bắt đầu từ hàng zeroth cho mỗi cột và kết thúc khi bắt đầu cột> = 0 hoặc hàng bắt đầu

C++

#include

using namespace std;

Dưới đây là việc thực hiện phương pháp trên: & nbsp;

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

using namespace std;

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

1 
2 4 
3 5 7 
6 8 
9

1 
2 4 
3 5 7 
6 8 
9

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1 
2 4 
3 5 7 
6 8 
9

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

1 
2 4 
3 5 7 
6 8 
9

1 
2 4 
3 5 7 
6 8 
9

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

Input :

Input :

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):     """Prints antidiagonals one per line of MxN matrix represented         by 1-dimantional array     >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])     1     5 2     5 7     8     >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])     1     2 5     3 6 9     4 7 10     8 11     12     """     antidiagonals = [[] for _ in range(M+N-1)]     for i in range(M*N):         adindex = (i // N) + (i % N)         antidiagonals[adindex].append(matrix[i])     for d in antidiagonals:         print(*d) # Driver code M, N = list(map(int, input('M N: ').split())) A = [] for i in range(1, M+1):     A += map(int, input('A[%d]: ' % i).split()) antidiagonals(M, N, A) if __name__ == '__main__':   import doctest   doctest.testmod(verbose=True)5def antidiagonals(M, N, matrix):     """Prints antidiagonals one per line of MxN matrix represented         by 1-dimantional array     >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])     1     5 2     5 7     8     >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])     1     2 5     3 6 9     4 7 10     8 11     12     """     antidiagonals = [[] for _ in range(M+N-1)]     for i in range(M*N):         adindex = (i // N) + (i % N)         antidiagonals[adindex].append(matrix[i])     for d in antidiagonals:         print(*d) # Driver code M, N = list(map(int, input('M N: ').split())) A = [] for i in range(1, M+1):     A += map(int, input('A[%d]: ' % i).split()) antidiagonals(M, N, A) if __name__ == '__main__':   import doctest   doctest.testmod(verbose=True)2 using8

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Java

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

namespace5 namespace6

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Python3

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Input :

Input :

Input :

Input :

Input :

Input :

Input :

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Input :

Input :

Input :

Input :

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Input :

Input :

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Input :

Input :

Input :

Input :

Input :

Input :

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Input :

Input :

Input :

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Input :

Input :

Input :

Input :

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Input :

Input :

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Input :

Input :

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

C#

Input :

Input :

Input :

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

using

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

namespace5

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1 
2 4 
3 5 7 
6 8 
9

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1 
2 4 
3 5 7 
6 8 
9

Input :

1 
2 4 
3 5 7 
6 8 
9

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :9def antidiagonals(M, N, matrix):     """Prints antidiagonals one per line of MxN matrix represented         by 1-dimantional array     >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])     1     5 2     5 7     8     >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])     1     2 5     3 6 9     4 7 10     8 11     12     """     antidiagonals = [[] for _ in range(M+N-1)]     for i in range(M*N):         adindex = (i // N) + (i % N)         antidiagonals[adindex].append(matrix[i])     for d in antidiagonals:         print(*d) # Driver code M, N = list(map(int, input('M N: ').split())) A = [] for i in range(1, M+1):     A += map(int, input('A[%d]: ' % i).split()) antidiagonals(M, N, A) if __name__ == '__main__':   import doctest   doctest.testmod(verbose=True)2 1 2 5 3 6 9 4 7 10 13 8 11 14 12 15 162

1 
2 4 
3 5 7 
6 8 
9

Input :

Input :

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1 
2 4 
3 5 7 
6 8 
9

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1 
2 4 
3 5 7 
6 8 
9

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

1 
2 4 
3 5 7 
6 8 
9

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

1 
2 4 
3 5 7 
6 8 
9

1 
2 4 
3 5 7 
6 8 
9

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1 
2 4 
3 5 7 
6 8 
9

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

1 
2 4 
3 5 7 
6 8 
9

JavaScript

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

1 
2 4 
3 5 7 
6 8 
9

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

1 
2 4 
3 5 7 
6 8 
9

1 
2 4 
3 5 7 
6 8 
9

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

1 
2 4 
3 5 7 
6 8 
9

namespace0

1 
2 4 
3 5 7 
6 8 
9

Output:

1 
2 4 
3 5 7 
6 8 
9

1 
2 4 
3 5 7 
6 8 
9

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Input :

1 
2 4 
3 5 7 
6 8 
9

Input :

1 
2 4 
3 5 7 
6 8 
9

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

1 
2 4 
3 5 7 
6 8 
9

Độ phức tạp về thời gian: O (n*n), trong đó n là số lượng hàng hoặc cột của ma trận đã cho.AUXILIARY: O (1)

• Cách tiếp cận 2: Đơn giản hơn nhiều và ngắn gọn & nbsp; (cùng thời gian phức tạp)2*N – 1 for holding unique sums from sum = 0 to sum = 2*N – 2.
• Trong phương pháp này, chúng tôi sẽ sử dụng tổng số chỉ số của bất kỳ phần tử nào trong ma trận. & nbsp; Đặt các chỉ số của bất kỳ phần tử nào được biểu diễn bởi i (hàng) một j (cột).

Nếu chúng ta tìm thấy tổng số chỉ số của bất kỳ phần tử nào trong & nbsp; ma trận n*n, chúng ta sẽ quan sát rằng tổng số chỉ số cho bất kỳ phần tử nào nằm giữa 0 (khi i = j = 0) và 2*n - 2 (khi tôi = j = n-1). & nbsp;

C++

#include

1 
2 4 
3 5 7 
6 8 
9

Vì vậy, chúng tôi sẽ làm theo các bước sau: & nbsp;

Khai báo một vectơ của các vectơ có kích thước 2*n - 1 để giữ các khoản tiền duy nhất từ ​​sum = 0 đến sum = 2*n - 2.

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Bây giờ chúng ta sẽ lặp qua vectơ và đẩy lùi các phần tử tương tự vào cùng một hàng trong vectơ của vectơ.

Dưới đây là việc thực hiện phương pháp trên: & nbsp;

using namespace std;

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1 
2 4 
3 5 7 
6 8 
9

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1 
2 4 
3 5 7 
6 8 
9

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1 
2 4 
3 5 7 
6 8 
9

Input :

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

Input :

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Java

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

namespace5

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

Input :

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

Các

Các

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Các

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Các

Các

Các

Các

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Python3

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Input :

Input :

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Input :

Input :

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Các

Các

Các

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

C#

using

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

using namespace00

namespace5

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

namespace74

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

namespace74

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

JavaScript

1 
2 4 
3 5 7 
6 8 
9

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1 
2 4 
3 5 7 
6 8 
9

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

1 
2 4 
3 5 7 
6 8 
9

1 
2 4 
3 5 7 
6 8 
9

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Output :
 1
 2  5
 3  6  9
 4  7  10  13
 8  11 14
 12 15
 16

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

Input :

Input :

Input :

def antidiagonals(M, N, matrix):
    """Prints antidiagonals one per line of MxN matrix represented
        by 1-dimantional array

    >>> antidiagonals(2, 3, [1, 5, 5, 2, 7, 8])
    1
    5 2
    5 7
    8
    >>> antidiagonals(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
    1
    2 5
    3 6 9
    4 7 10
    8 11
    12
    """
    antidiagonals = [[] for _ in range(M+N-1)]
    for i in range(M*N):
        adindex = (i // N) + (i % N)
        antidiagonals[adindex].append(matrix[i])
    for d in antidiagonals:
        print(*d)

# Driver code
M, N = list(map(int, input('M N: ').split()))
A = []
for i in range(1, M+1):
    A += map(int, input('A[%d]: ' % i).split())

antidiagonals(M, N, A)

if __name__ == '__main__':
  import doctest
  doctest.testmod(verbose=True)

1 
2 4 
3 5 7 
6 8 
9

Đầu ra: & nbsp;

1  
2 5  
3 6 9  
4 7 10 13  
8 11 14  
12 15  
16

Độ phức tạp về thời gian: O (n*n), trong đó n là số lượng hàng hoặc cột của ma trận đã cho. O(N*N), Where N is the number of rows or columns of given matrix.
Auxiliary Space:O(N*N)