Minimum Deletions to Make Array Divisible

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.

Constraints

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

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.

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
✓ 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)	O(n * m * k)	O(n)	For each unique element in nums, check if it can divide all elements in numsDivide

Sorting + GCD Optimization — Algorithm Steps

Calculate GCD of all elements in numsDivide
Sort the nums array
Iterate through sorted nums to find first element that divides the GCD
Return the count of elements before this position

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate GCD

Find GCD of numsDivide = [9,6,9,3,15] → GCD = 3

Sort nums

Sort nums = [2,3,2,4,3] → [2,2,3,3,4]

Find First Divisor

Check each element: 2 doesn't divide 3, but 3 divides 3 ✅

Code -

solution.c — C

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

int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int minimumDeletions(int* nums, int numsSize, int* numsDivide, int numsDivideSize) {
    // Calculate GCD of all elements in numsDivide
    int gcdDivide = numsDivide[0];
    for (int i = 1; i < numsDivideSize; i++) {
        gcdDivide = gcd(gcdDivide, numsDivide[i]);
    }
    
    // Sort nums
    qsort(nums, numsSize, sizeof(int), compare);
    
    // Find first element that divides the GCD
    for (int i = 0; i < numsSize; i++) {
        if (gcdDivide % nums[i] == 0) {
            return i;
        }
    }
    
    return -1;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n + m log(max(numsDivide)))

O(n log n) for sorting nums, O(m log(max)) for computing GCD of numsDivide

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Sorting + GCD Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler