# Leetcode – Lucky Numbers in a Matrix Solution

The “Lucky Numbers in a Matrix” problem is a relatively straightforward yet intriguing problem commonly seen on Leetcode. It challenges you to work with 2D arrays, also known as matrices, in Python. This article provides a detailed guide to solving this problem efficiently, including multiple approaches, time and space complexity analyses, and coding best practices.

1. Understanding the Problem Statement
2. Initial Thoughts and Pseudocode
3. Using Nested Loops to Find Lucky Numbers
4. Optimizing Using List Comprehensions
5. Time and Space Complexity Analysis
6. Testing and Edge Cases
7. Conclusion

## 1. Understanding the Problem Statement

In this problem, you are given an m x n matrix of distinct integers. A “lucky” number is defined as an integer that is the minimum in its row and the maximum in its column. Your task is to return a list of all lucky numbers in the matrix.

### Constraints and Assumptions

• m and n are integers where 1 <= m, n <= 50.
• The matrix will have distinct integers in the range [1, 10^5].

## 2. Initial Thoughts and Pseudocode

The key to this problem lies in identifying the minimum numbers in each row and then checking if any of them are also the maximum number in their respective columns.

Pseudocode for basic approach:

1. Initialize an empty list called lucky_numbers
2. For each row in the matrix:
- Find the minimum number in the row
- Find its column index
- Check if it's the maximum number in the column
- If yes, add it to lucky_numbers
3. Return lucky_numbers

## 3. Using Nested Loops to Find Lucky Numbers

Here’s Python code that follows the basic approach using nested loops.

def luckyNumbers(matrix):
lucky_numbers = []
for row in matrix:
row_min = min(row)
col_idx = row.index(row_min)

col = [matrix[i][col_idx] for i in range(len(matrix))]
if row_min == max(col):
lucky_numbers.append(row_min)

return lucky_numbers

## 4. Optimizing Using List Comprehensions

We can make the code more compact and Pythonic by using list comprehensions.

def luckyNumbers(matrix):
return [min(row) for row in matrix if max([matrix[i][row.index(min(row))] for i in range(len(matrix))]) == min(row)]

## 5. Time and Space Complexity Analysis

• Time Complexity: Finding the minimum number in each row takes O(n) time for each row, making it O(m * n) overall. The subsequent check for the maximum in the column also takes O(m) time for each row. So, the total time complexity is O(m * n).
• Space Complexity: We are not using any additional data structures that grow with the input, so the space complexity is O(1).

## 6. Testing and Edge Cases

It’s essential to test the code on various test cases to ensure it handles all edge cases. This includes:

• Matrices with only one row or column
• Matrices where the lucky number is at a corner
• Larger matrices to test performance

## 7. Conclusion

The “Lucky Numbers in a Matrix” problem serves as an excellent exercise in handling 2D arrays in Python. We discussed two approaches to solve this problem, one using nested loops and the other using list comprehensions. Both methods have the same time complexity of O(m * n) but differ in terms of readability and style.