5 Best Ways to Program in Python to Print the Boundary Elements of a Matrix

by

💡 Problem Formulation: A common matrix-related problem in programming is to print the boundary elements of a given matrix. The boundary elements are those which lie on the perimeter of the matrix – the first and the last rows, and the first and the last columns. For instance, if the input is a matrix of [[1, 2, 3], [4, 5, 6], [7, 8, 9]], the desired output should be the list [1, 2, 3, 6, 9, 8, 7, 4].

Method 1: Using Loops to Traverse the Boundary

This method involves using for loops to iterate over the rows and columns of the matrix, selectively printing the elements that constitute the boundary – the elements of the first and last row, and the first and last element of the intermediate rows.

Here’s an example:

def print_boundary(matrix):
    rows = len(matrix)
    columns = len(matrix[0]) if matrix else 0
    for i in range(rows):
        for j in range(columns):
            if i == 0 or i == rows - 1 or j == 0 or j == columns - 1:
                print(matrix[i][j], end=' ')
    print()

# Example usage:
print_boundary([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

Output: 1 2 3 6 9 8 7 4

This snippet defines a function print_boundary() that takes a 2D matrix as argument and prints the boundary elements. The nested loops and an if condition handle the traversal and selective printing of the boundary elements.

Method 2: Using Slicing to Extract Rows and Columns

Python’s slicing feature enables extracting rows and the first/last elements of those rows in a more concise way. This method takes advantage of slicing to get the top row, bottom row, and the first/last elements of the intermediate rows.

Here’s an example:

def print_boundary(matrix):
    if not matrix: return
    top_row = matrix[0]
    bottom_row = matrix[-1]
    for element in top_row:
        print(element, end=' ')
    for row in matrix[1:-1]:
        print(row[0], row[-1], end=' ')
    for element in bottom_row:
        print(element, end=' ')
    print()

# Example usage:
print_boundary([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

Output: 1 2 3 4 6 7 8 9

The print_boundary() function makes use of slicing to streamline the retrieval of the necessary elements without having to iterate over every element, thus making the code cleaner and potentially more readable.

Method 3: One Iteration with Conditions

This method opts for a single-pass iteration with conditions to identify whether an element is on the boundary. It uses only one loop and reduces the complexity in comparison with nested loops.

Here’s an example:

def print_boundary(matrix):
    rows = len(matrix)
    columns = len(matrix[0]) if matrix else 0
    for i in range(1, rows * columns + 1):
        row, col = divmod(i - 1, columns)
        if row == 0 or row == rows - 1 or col == 0 or col == columns - 1:
            print(matrix[row][col], end=' ')
    print()

# Example usage:
print_boundary([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

Output: 1 2 3 6 9 8 7 4

The print_boundary() function presented utilizes a single loop over the range of total elements in the matrix. Based on calculated row and column indices, it checks if the current element is a boundary element and prints it if true.

Method 4: Without Explicit Loops Using List Comprehensions

Python’s list comprehensions offer a succinct way to construct lists. We can use it to create a list of boundary elements and then print them, thus avoiding explicit loops.

Here’s an example:

def print_boundary(matrix):
    rows = len(matrix)
    columns = len(matrix[0]) if matrix else 0
    boundary = [matrix[i][j] 
                for k in range(2 * (rows + columns) - 4) 
                for i in [k if k < rows else rows - 1] 
                for j in [k - i] if (i == 0 or i == rows - 1) or (j == 0 or j == columns - 1)]
    print(' '.join(map(str, boundary)))

# Example usage:
print_boundary([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

Output: 1 2 3 6 9 8 7 4

This code uses a complex list comprehension to build a list of the boundary elements, then prints that list. It’s a more advanced example that can reduce the amount of explicit looping and conditionals, but it can be less readable to those not familiar with the technique.

Bonus One-Liner Method 5: Using NumPy for Boundary Extraction

For those already working within the scientific Python ecosystem, using the NumPy library can simplify matrix operations with just one line of code.

Here’s an example:

import numpy as np

def print_boundary(matrix):
    matrix = np.array(matrix)
    boundary = np.concatenate((matrix[0], matrix[1:-1, -1], matrix[-1, ::-1], matrix[1:-1, 0][::-1]))
    print(boundary)

# Example usage:
print_boundary([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

Output: [1 2 3 6 9 8 7 4]

This succinct function makes use of NumPy’s advanced slicing and concatenation functions to extract and print the boundary of the matrix. It demonstrates an elegant, high-level solution that enhances readability and performance, particularly for large matrices. However, it requires an external library.

Summary/Discussion

  • Method 1: Using loops with conditions. Strengths: Easy to understand logic. Weaknesses: Can be verbose for simple operations.
  • Method 2: Using slicing to extract rows and columns. Strengths: Pythonic and readable. Weaknesses: Slightly less efficient as it iterates through inner rows twice.
  • Method 3: One iteration with conditions. Strengths: Efficient single-pass solution. Weaknesses: The numerical approach may be less intuitive than directly iterating through matrix elements.
  • Method 4: Using list comprehensions. Strengths: Concise and Pythonic. Weaknesses: Can be hard to understand for beginners; complex comprehension.
  • Method 5: Using NumPy. Strengths: Extremely concise and fast for large datasets. Weaknesses: Requires additional dependency.