Most Frequent Prime

Most Frequent Prime - Problem

Array Hash Table Math Matrix Counting Enumeration Number Theory Medium

You are given an m x n 0-indexed 2D matrix mat. From every cell, you can create numbers by traveling in up to 8 directions: east, south-east, south, south-west, west, north-west, north, and north-east.

Select a path from any cell and append digits in this direction to form numbers. Numbers are generated at every step - for example, if digits along a path are 1, 9, 1, then three numbers are generated: 1, 19, and 191.

Return the most frequent prime number greater than 10 from all numbers created, or -1 if no such prime exists. If multiple primes have the highest frequency, return the largest among them.

Note: You cannot change direction during movement along a path.

Input & Output

Example 1 — Basic Matrix

$ Input: mat = [[1,1],[9,9]]

› Output: 11

💡 Note: From cell (0,0): paths generate numbers 1, 11, 19, 99. From other cells we get similar numbers. Prime 11 appears most frequently in various directions.

Example 2 — No Valid Primes

$ Input: mat = [[1]]

› Output: -1

💡 Note: Single cell can only generate number 1, which is not > 10, so no valid primes exist.

Example 3 — Multiple Directions

$ Input: mat = [[7,1,3],[9,7,1],[2,3,1]]

› Output: 13

💡 Note: Various paths generate primes like 71, 13, 37. Prime 13 appears in multiple directions making it most frequent.

Constraints

1 ≤ m, n ≤ 6
1 ≤ mat[i][j] ≤ 9

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Meta 12

The key insight is to systematically generate all possible numbers by traversing the matrix in all 8 directions from each cell, then efficiently count prime frequencies. Best approach uses optimized prime checking with overflow prevention. Time: O(m × n × max_path × √max_num), Space: O(unique_primes)

Common Approaches

✓ Brute Force - Generate All Numbers

⏱️ Time: O(m × n × max_path × √max_num) Space: O(total_numbers)

For each cell, explore all 8 directions and generate numbers by appending digits. Check if each number > 10 is prime and track frequencies. Return the most frequent prime, breaking ties by largest value.

Optimized with Efficient Prime Checking

⏱️ Time: O(m × n × max_path × √max_num) Space: O(unique_primes)

Generate all numbers systematically while using efficient prime checking. Use early termination when numbers become too large and implement optimized prime testing.

Brute Force - Generate All Numbers — Algorithm Steps

Step 1: For each cell, start paths in all 8 directions
Step 2: Generate numbers incrementally along each path
Step 3: Check primality for numbers > 10 and count frequencies
Step 4: Return most frequent prime (largest if tied)

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from Cell

Begin from each cell in the matrix

Explore 8 Directions

Move in all 8 directions, building numbers

Count Prime Frequencies

Track frequency of each prime > 10

Code -

solution.c — C

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

#define MAX_PRIMES 10000
#define MAX_SIZE 100

static int mat[MAX_SIZE][MAX_SIZE];

struct PrimeCount {
    int prime;
    int count;
};

static struct PrimeCount primes[MAX_PRIMES];

int isPrime(int num) {
    if (num < 2) return 0;
    if (num == 2) return 1;
    if (num % 2 == 0) return 0;
    int i = 3;
    while (i * i <= num) {
        if (num % i == 0) return 0;
        i += 2;
    }
    return 1;
}

void generateNumbers(int m, int n, int startR, int startC, int* primeCount) {
    int directions[8][2] = {{0,1}, {1,1}, {1,0}, {1,-1}, {0,-1}, {-1,-1}, {-1,0}, {-1,1}};
    
    for (int d = 0; d < 8; d++) {
        int dr = directions[d][0], dc = directions[d][1];
        int r = startR, c = startC;
        int currentNum = 0;
        
        while (r >= 0 && r < m && c >= 0 && c < n) {
            currentNum = currentNum * 10 + mat[r][c];
            
            if (currentNum > 10 && isPrime(currentNum)) {
                int found = -1;
                for (int i = 0; i < *primeCount; i++) {
                    if (primes[i].prime == currentNum) {
                        found = i;
                        break;
                    }
                }
                
                if (found != -1) {
                    primes[found].count++;
                } else {
                    primes[*primeCount].prime = currentNum;
                    primes[*primeCount].count = 1;
                    (*primeCount)++;
                }
            }
            
            r += dr;
            c += dc;
        }
    }
}

int solution(int m, int n) {
    if (m == 0 || n == 0) {
        return -1;
    }
    
    int primeCount = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            generateNumbers(m, n, i, j, &primeCount);
        }
    }
    
    if (primeCount == 0) {
        return -1;
    }
    
    int maxFreq = 0;
    for (int i = 0; i < primeCount; i++) {
        if (primes[i].count > maxFreq) {
            maxFreq = primes[i].count;
        }
    }
    
    int result = -1;
    for (int i = 0; i < primeCount; i++) {
        if (primes[i].count == maxFreq && primes[i].prime > result) {
            result = primes[i].prime;
        }
    }
    return result;
}

void parseMatrix(const char* input, int* m, int* n) {
    *m = 0;
    *n = 0;
    
    const char* p = input;
    int rows = 0;
    int cols = 0;
    int inMatrix = 0;
    int inRow = 0;
    
    while (*p) {
        if (*p == '[') {
            p++;
            if (!inMatrix) {
                inMatrix = 1;
                rows = 0;
                if (*p == ']') {
                    *m = 0;
                    *n = 0;
                    return;
                }
            }
            inRow = 1;
            cols = 0;
        } else if (*p == ']') {
            if (inRow) {
                if (*n == 0) *n = cols;
                rows++;
                inRow = 0;
            }
            p++;
        } else if (*p == ',' || isspace(*p)) {
            p++;
        } else if (isdigit(*p)) {
            int num = 0;
            while (isdigit(*p)) {
                num = num * 10 + (*p - '0');
                p++;
            }
            if (inRow) {
                mat[rows][cols] = num;
                cols++;
            }
        } else {
            p++;
        }
    }
    
    *m = rows;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    int m, n;
    
    parseMatrix(input, &m, &n);
    
    printf("%d\n", solution(m, n));
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n × max_path × √max_num)

For each cell (m×n), explore paths up to max_path length, check primality with √max_num complexity

✓ Linear Growth

Space Complexity

O(total_numbers)

Hash map stores all unique numbers generated with their frequencies

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

856 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 - Generate All Numbers — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler