Prime In Diagonal - Practice Coding Problems

Prime In Diagonal - Problem

You are given a 2D square matrix of integers. Your mission is to find the largest prime number that appears on either of the matrix's two main diagonals.

The Two Diagonals:

Main diagonal: Elements where row == column (top-left to bottom-right)
Anti-diagonal: Elements where row + column == n-1 (top-right to bottom-left)

Return the largest prime found on these diagonals, or 0 if no prime exists.

Remember: A prime number is greater than 1 and has exactly two divisors: 1 and itself.

Example: In matrix [[1,2,3],[5,6,7],[9,10,11]], the main diagonal is [1,6,11] and anti-diagonal is [3,6,9]. The largest prime among [1,6,11,3,9] is 11.

Input & Output

example_1.py — Basic Matrix

$ Input: nums = [[1,2,3],[5,6,7],[9,10,11]]

› Output: 11

💡 Note: Main diagonal: [1,6,11], Anti-diagonal: [3,6,9]. All diagonal elements: {1,3,6,9,11}. Prime numbers: {3,11}. The largest prime is 11.

example_2.py — No Prime Case

$ Input: nums = [[1,2,3],[5,6,7],[9,10,12]]

› Output: 0

💡 Note: Main diagonal: [1,6,12], Anti-diagonal: [3,6,9]. All diagonal elements: {1,3,6,9,12}. Prime numbers: {3}. The largest prime is 3.

example_3.py — Single Element

$ Input: nums = [[2]]

› Output: 2

💡 Note: Only one element in the matrix which is on both diagonals. Since 2 is prime, the answer is 2.

Constraints

1 ≤ n ≤ 300 where n = nums.length = nums[i].length
1 ≤ nums[i][j] ≤ 4 × 10⁶
Matrix is always square (n × n)

Visualization

Tap to expand

Understanding the Visualization

Map the Paths

Identify the two diagonal paths: main (↘) and anti (↙) diagonals

Collect Treasures

Walk both paths simultaneously, collecting all unique treasures

Test for Prime Value

Examine each treasure to determine if it's a prime number

Find Maximum Prime

Select the most valuable (largest) prime treasure found

Key Takeaway

🎯 Key Insight: We only need to examine diagonal elements (at most 2n-1 unique values) rather than the entire n² matrix, making this problem much more efficient than it initially appears.

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 6

The optimal solution traverses both matrix diagonals in a single pass, collecting unique elements using a hash set. For each element, we perform optimized primality testing by checking divisibility only up to √n and skipping even numbers. The time complexity is O(n + k√m) where k is the number of unique diagonal elements and m is the maximum value.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Single Pass (Optimal)	O(n + k*√m)	O(n)	Single traversal with efficient prime checking and maximum tracking
Brute Force Diagonal Traversal	O(n + k*√m)	O(n)	Extract all diagonal elements and check each for primality

Optimized Single Pass (Optimal) — Algorithm Steps

Single loop to traverse both diagonals simultaneously
Use set to store unique diagonal elements
Optimized prime checking with early termination
Track maximum prime during the process

Visualization

Tap to expand

Step-by-Step Walkthrough

Single Loop Setup

Initialize loop to traverse both diagonals simultaneously

Collect Elements

Add both diagonal elements to set in each iteration

Prime Check & Track

Check primality and track maximum prime found

Return Result

Return the maximum prime or 0 if none found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

bool isPrime(int num) {
    if (num < 2) return false;
    if (num == 2) return true;
    if (num % 2 == 0) return false;
    for (int i = 3; i * i <= num; i += 2) {
        if (num % i == 0) return false;
    }
    return true;
}

int diagonalPrime(int** nums, int numsSize, int* numsColSize) {
    int n = numsSize;
    int maxPrime = 0;
    bool checked[4000001] = {false};  // Assuming max value constraint
    
    for (int i = 0; i < n; i++) {
        // Check main diagonal element
        int mainDiag = nums[i][i];
        if (!checked[mainDiag]) {
            checked[mainDiag] = true;
            if (isPrime(mainDiag) && mainDiag > maxPrime) {
                maxPrime = mainDiag;
            }
        }
        
        // Check anti-diagonal element
        int antiDiag = nums[i][n-1-i];
        if (!checked[antiDiag]) {
            checked[antiDiag] = true;
            if (isPrime(antiDiag) && antiDiag > maxPrime) {
                maxPrime = antiDiag;
            }
        }
    }
    
    return maxPrime;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + k*√m)

O(n) for single diagonal traversal, O(k*√m) for optimized prime checks where k≤2n

✓ Linear Growth

Space Complexity

O(n)

O(n) for set of unique diagonal elements

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~12 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Optimized Single Pass (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler