Most Frequent Prime - Practice Coding Problems

Most Frequent Prime - Problem

Array Hash Table Math Matrix Counting Enumeration Number Theory Medium

Most Frequent Prime

You're given an m × n 2D matrix of digits. Your task is to explore this matrix like a digital treasure hunter! From every cell, you can travel in any of the 8 directions (east, south-east, south, south-west, west, north-west, north, and north-east) and collect digits to form numbers.

Here's the exciting part: as you travel in a chosen direction, you create multiple numbers at each step. For example, if you encounter digits 1, 9, 1 along your path, you generate three numbers: 1, 19, and 191.

Your mission: Find the most frequent prime number greater than 10 from all possible paths. If multiple primes tie for highest frequency, return the largest one. If no such prime exists, return -1.

Remember: Once you pick a direction, you must stick to it - no zigzagging allowed!

Input & Output

example_1.py — Basic Matrix

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

› Output: 19

💡 Note: From position (0,0), going south-east: 1→19→191. From position (1,0), going east: 9→99. The prime 19 appears multiple times from different paths, making it the most frequent prime > 10.

example_2.py — No Valid Primes

$ Input: mat = [[1]]

› Output: -1

💡 Note: The only number we can generate is 1, which is not greater than 10, so we return -1.

example_3.py — Tie-Breaking

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

› Output: 11

💡 Note: Multiple primes might have the same frequency, but we return the largest one among those with the highest frequency. Here 11 is a prime that can be formed and is the answer.

Constraints

m == mat.length
n == mat[i].length
1 ≤ m, n ≤ 6
1 ≤ mat[i][j] ≤ 9
Numbers can grow large during path traversal

Visualization

Tap to expand

Understanding the Visualization

Choose Starting Position

Start mining from any cell in the matrix

Pick Mining Direction

Choose one of 8 possible directions to mine

Collect Digits

As you mine deeper, collect digits to form numbers

Identify Prime Gems

Check if each number > 10 is a prime

Count Frequencies

Track how often each prime appears

Find Most Valuable

Return the most frequent prime (largest if tied)

Key Takeaway

🎯 Key Insight: By combining path generation with immediate prime checking and frequency tracking, we can solve this efficiently in one pass through the matrix, avoiding the need to store all generated numbers.

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal solution uses a one-pass hash table approach to generate all possible numbers from matrix paths while simultaneously tracking prime frequencies. Key insights: traverse all 8 directions from each cell, build numbers incrementally, check for primality immediately when number > 10, and maintain frequency counts in a hash map. Time complexity: O(m × n × max(m,n) × √N) where N is the largest number formed.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Paths)	O(m × n × max(m,n) × √N)	O(m × n × max(m,n))	Generate all possible numbers from every cell in all directions, then find the most frequent prime
One-Pass Hash Table (Optimal)	O(m × n × max(m,n) × √N)	O(P)	Generate numbers and track prime frequencies simultaneously in one efficient pass

Brute Force (Generate All Paths) — Algorithm Steps

For each cell in the matrix, try all 8 directions
For each direction, traverse as far as possible, generating numbers at each step
Store all generated numbers in a list
Filter numbers > 10 and check each for primality
Count frequencies of prime numbers
Return the most frequent prime (largest if tie), or -1 if none found

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Starting Cell

Start from any cell in the matrix

Pick Direction

Choose one of 8 possible directions

Generate Numbers

Create numbers at each step along the path

Check Primality

Filter for primes > 10 and count frequencies

Code -

solution.c — C

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

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

int mostFrequentPrime(int** mat, int m, int n) {
    int directions[8][2] = {{0,1}, {1,1}, {1,0}, {1,-1}, {0,-1}, {-1,-1}, {-1,0}, {-1,1}};
    int* allNumbers = (int*)malloc(m * n * (m + n) * 8 * sizeof(int));
    int count = 0;
    
    // Generate all possible numbers
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            for (int d = 0; d < 8; d++) {
                int num = 0;
                int x = i, y = j;
                while (x >= 0 && x < m && y >= 0 && y < n) {
                    num = num * 10 + mat[x][y];
                    allNumbers[count++] = num;
                    x += directions[d][0];
                    y += directions[d][1];
                }
            }
        }
    }
    
    // Simple frequency counting (for demonstration)
    int maxPrime = -1, maxFreq = 0;
    
    for (int i = 0; i < count; i++) {
        if (allNumbers[i] > 10 && isPrime(allNumbers[i])) {
            int freq = 0;
            for (int j = 0; j < count; j++) {
                if (allNumbers[j] == allNumbers[i]) freq++;
            }
            if (freq > maxFreq || (freq == maxFreq && allNumbers[i] > maxPrime)) {
                maxFreq = freq;
                maxPrime = allNumbers[i];
            }
        }
    }
    
    free(allNumbers);
    return maxPrime;
}

int main() {
    int mat[2][2] = {{1,1},{9,9}};
    int* rows[2] = {mat[0], mat[1]};
    printf("%d\n", mostFrequentPrime(rows, 2, 2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n × max(m,n) × √N)

For each cell (m×n), we explore 8 directions up to max(m,n) steps, generating numbers up to N digits, then check primality (√N)

✓ Linear Growth

Space Complexity

O(m × n × max(m,n))

Store all generated numbers in the worst case

⚡ Linearithmic Space

28.7K Views

Medium Frequency

~25 min Avg. Time

847 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 Paths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler