Prime In Diagonal

Prime In Diagonal - Problem

You are given a 0-indexed two-dimensional integer array nums.

Return the largest prime number that lies on at least one of the diagonals of nums. In case no prime is present on any of the diagonals, return 0.

Note that:

An integer is prime if it is greater than 1 and has no positive integer divisors other than 1 and itself.
An integer val is on one of the diagonals of nums if there exists an integer i for which nums[i][i] = val or an i for which nums[i][nums.length - i - 1] = val.

Input & Output

Example 1 — Basic Case

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

› Output: 7

💡 Note: Main diagonal: [1,5,9], Anti-diagonal: [3,5,7]. Prime numbers: 3, 5, 7. Largest prime is 7.

Example 2 — No Primes

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

› Output: 3

💡 Note: Main diagonal: [1,6,15], Anti-diagonal: [3,6,9]. Prime numbers on diagonals: 3. Largest prime is 3.

Example 3 — All Non-Prime

$ Input: nums = [[1,2,3],[5,4,6],[7,8,9]]

› Output: 7

💡 Note: Main diagonal: [1,4,9], Anti-diagonal: [3,4,7]. Prime numbers on diagonals: 3, 7. Largest is 7.

Constraints

1 ≤ nums.length ≤ 300
nums.length == nums[i].length
1 ≤ nums[i][j] ≤ 4*10⁶

Visualization

Tap to expand

Asked in

A Amazon 12 M Microsoft 8 G Google 6

The key insight is that we only need to check elements on the main diagonal (i,i) and anti-diagonal (i,n-1-i). Best approach is direct diagonal access which achieves Time: O(n√m), Space: O(1) where n is matrix size and m is maximum element value.

Common Approaches

✓ Brute Force - Check All Positions

⏱️ Time: O(n²√m) Space: O(1)

Iterate through all positions in the matrix, check if each position is on either diagonal, then verify if the value is prime. Keep track of the maximum prime found.

Optimized - Direct Diagonal Access

⏱️ Time: O(n√m) Space: O(1)

Instead of checking all matrix positions, directly access only the diagonal elements. Traverse the main diagonal and anti-diagonal separately, checking each value for primality.

Brute Force - Check All Positions — Algorithm Steps

Step 1: Iterate through all matrix positions (i,j)
Step 2: Check if position is on main diagonal (i==j) or anti-diagonal (i+j==n-1)
Step 3: If on diagonal, check if value is prime and update maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Check All Positions

Iterate through every (i,j) position

Test Diagonal

Check if i==j or i+j==n-1

Check Prime

If on diagonal, test if value is prime

Code -

solution.c — C

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

int isPrime(int n) {
    if (n < 2) return 0;
    if (n == 2 || n == 3) return 1;
    if (n % 2 == 0 || n % 3 == 0) return 0;
    for (long long i = 5; i * i <= n; i += 6) {
        if (n % i == 0 || n % (i + 2) == 0) return 0;
    }
    return 1;
}

int main() {
    // Read all input
    char* input = malloc(1000000);
    int len = 0;
    int c;
    while ((c = getchar()) != EOF) {
        input[len++] = c;
    }
    input[len] = '\0';

    // Extract all integers
    int* allNums = malloc(100000 * sizeof(int));
    int count = 0;
    char* p = input;
    while (*p) {
        if (*p == '-' || (*p >= '0' && *p <= '9')) {
            allNums[count++] = atoi(p);
            if (*p == '-') p++;
            while (*p >= '0' && *p <= '9') p++;
        } else {
            p++;
        }
    }

    // Determine matrix size (n x n)
    // Find n by counting elements in first row: count numbers before second '['
    // Simpler: n = sqrt(count) since it's n x n
    int n = 1;
    while (n * n < count) n++;

    // Build matrix
    int maxPrime = 0;

    // Main diagonal: nums[i][i] = allNums[i * n + i]
    for (int i = 0; i < n; i++) {
        int val = allNums[i * n + i];
        if (isPrime(val) && val > maxPrime)
            maxPrime = val;
    }

    // Anti-diagonal: nums[i][n-1-i] = allNums[i * n + (n-1-i)]
    for (int i = 0; i < n; i++) {
        int val = allNums[i * n + (n - 1 - i)];
        if (isPrime(val) && val > maxPrime)
            maxPrime = val;
    }

    printf("%d\n", maxPrime);

    free(input);
    free(allNums);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²√m)

n² to check all positions, √m for prime checking where m is max value

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

340 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

Brute Force - Check All Positions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler