Codestin Search App

Minimum Deletions to Make Array Divisible - Problem

Array Math Sorting Heap (Priority Queue) Number Theory Hard

You are given two arrays: nums and numsDivide. Your goal is to find the minimum number of deletions from nums such that the smallest remaining element in nums can divide all elements in numsDivide.

Key Insight: An integer x divides y if y % x == 0 (no remainder).

For example, if nums = [2,3,2,4,3] and numsDivide = [9,6,9,3,15], we need to delete elements from nums until the smallest element can divide all numbers in numsDivide. The number 3 divides all elements in numsDivide, so we delete elements to make 3 the smallest.

Return -1 if it's impossible to achieve this goal.

Input & Output

example_1.py — Basic Case

$ Input: nums = [2,3,2,4,3], numsDivide = [9,6,9,3,15]

› Output: 2

💡 Note: We need to delete 2 elements from nums. The GCD of numsDivide is 3, and the smallest element in nums that divides 3 is 3 itself. We need to delete the two 2's to make 3 the smallest element.

example_2.py — Impossible Case

$ Input: nums = [4,3,6,8], numsDivide = [2,9,15,6]

› Output: -1

💡 Note: The GCD of numsDivide is 1, but none of the elements 4,3,6,8 can divide 1 (only 1 itself can divide 1). Therefore, it's impossible.

example_3.py — No Deletions Needed

$ Input: nums = [1,2,3], numsDivide = [2,4,6]

› Output: 0

💡 Note: The smallest element 1 can divide all elements in numsDivide [2,4,6], so no deletions are needed.

Visualization

Tap to expand

Understanding the Visualization

Find Master Pattern

Calculate GCD of all locks - this tells us what pattern any key must have

Sort Keys

Arrange keys from smallest to largest

Find First Match

The first key that matches the master pattern is our answer

Key Takeaway

🎯 Key Insight: The mathematical property that any common divisor must divide the GCD allows us to reduce the search space dramatically, turning a complex combinatorial problem into a simple sorting and searching problem.

Time & Space Complexity

Time Complexity

⏱️

O(n * m * k)

n unique elements in nums, m elements in numsDivide, k elements to check divisibility

✓ Linear Growth

Space Complexity

O(n)

Space for storing unique elements and counting

⚡ Linearithmic Space

Constraints

1 ≤ nums.length, numsDivide.length ≤ 10⁵
1 ≤ nums[i], numsDivide[i] ≤ 10⁹
All elements in arrays are positive integers

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 22

The optimal approach uses GCD (Greatest Common Divisor) insight: any element that can divide all numbers in numsDivide must divide their GCD. Calculate the GCD first, then sort nums and find the first element that divides this GCD. This reduces time complexity to O(n log n) instead of trying all possibilities.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Elements)	O(n * m * k)	O(n)	For each unique element in nums, check if it can divide all elements in numsDivide
Sorting + GCD Optimization	O(n log n + m log(max(numsDivide)))	O(1)	Sort nums and use GCD of numsDivide to find the optimal answer efficiently

Brute Force (Try All Elements) — Algorithm Steps

Get all unique elements from nums
For each unique element, check if it divides all elements in numsDivide
If it does, count how many elements need to be deleted to make it the smallest
Return the minimum deletions needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Elements

Count frequency of each element in nums

Try Candidates

For each unique element, check if it can divide all elements in numsDivide

Count Deletions

Count how many elements need to be deleted to make candidate the smallest

Code -

solution.c — C

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

int minimumDeletions(int* nums, int numsSize, int* numsDivide, int numsDivideSize) {
    // Simple approach using arrays for counting
    int maxVal = 0;
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] > maxVal) maxVal = nums[i];
    }
    
    int* count = (int*)calloc(maxVal + 1, sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        count[nums[i]]++;
    }
    
    int minDeletions = INT_MAX;
    
    for (int candidate = 1; candidate <= maxVal; candidate++) {
        if (count[candidate] == 0) continue;
        
        // Check if candidate can divide all elements
        int canDivideAll = 1;
        for (int i = 0; i < numsDivideSize; i++) {
            if (numsDivide[i] % candidate != 0) {
                canDivideAll = 0;
                break;
            }
        }
        
        if (canDivideAll) {
            int deletions = 0;
            for (int i = 1; i < candidate; i++) {
                deletions += count[i];
            }
            if (deletions < minDeletions) {
                minDeletions = deletions;
            }
        }
    }
    
    free(count);
    return minDeletions == INT_MAX ? -1 : minDeletions;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m * k)

n unique elements in nums, m elements in numsDivide, k elements to check divisibility

✓ Linear Growth

Space Complexity

O(n)

Space for storing unique elements and counting

⚡ Linearithmic Space

Constraints

1 ≤ nums.length, numsDivide.length ≤ 10⁵
1 ≤ nums[i], numsDivide[i] ≤ 10⁹
All elements in arrays are positive integers

52.0K Views

Medium Frequency

~25 min Avg. Time

1.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Elements) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler