Minimize Length of Array Using Operations

Minimize Length of Array Using Operations - Problem

Challenge: You're given an array of positive integers and need to minimize its length using a special operation. In each operation, you can:

1. Pick any two distinct elements nums[i] and nums[j]
2. Replace both elements with their modulo: nums[i] % nums[j]
3. This reduces the array size by 1

The goal is to find the minimum possible length after performing this operation optimally. This problem combines number theory with greedy algorithms - you'll need to understand when the modulo operation helps reduce numbers and how to apply it strategically.

Key insight: The modulo operation is essentially the remainder after division, which can help us find patterns similar to the Euclidean algorithm for GCD.

Input & Output

example_1.py — Basic Case

$ Input: [1, 4, 3, 1]

› Output: 1

💡 Note: We can perform operations: (1,4) → 1%4=1, (3,1) → 3%1=0. Array becomes [1,0], then (1,0) → 1%0 is undefined, but 0%1=0, so we get [0]. Final length is 1.

example_2.py — Two Groups

$ Input: [5, 5, 5, 10, 5]

› Output: 2

💡 Note: All 5s can be reduced together (5%5=0), and 10%5=0. However, we need to be strategic about the operations to achieve minimum length of 2.

example_3.py — Single Element

$ Input: [2]

› Output: 1

💡 Note: With only one element, no operations can be performed. The minimum length remains 1.

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Start with array [6, 4, 8, 2] - we need to find the minimum possible length

Find Optimal Pairs

Look for pairs where modulo operation reduces the numbers effectively

Apply Operations

Perform modulo operations: 6%4=2, 8%2=0, continuing the reduction

Iterate Until Minimal

Continue until no more beneficial operations possible

Key Takeaway

🎯 Key Insight: The modulo operation behaves like the Euclidean GCD algorithm, creating equivalence classes that determine the final minimum length.

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each operation can lead to multiple new states, creating an exponential search tree

⚠ Quadratic Growth

Space Complexity

O(2^n)

Memoization table stores exponential number of different array states

⚠ Quadratic Space

Constraints

1 ≤ nums.length ≤ 20
1 ≤ nums[i] ≤ 10³
All elements in nums are positive integers
You can perform the operation any number of times (including zero)

Asked in

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

The optimal approach uses number theory insights to recognize that the modulo operation creates equivalence classes based on GCD relationships. Instead of trying all possible operations, we can simulate the reduction process greedily by always choosing operations that minimize the largest elements first. The key insight is that numbers will eventually reduce to their greatest common divisors, and the final answer depends on counting distinct equivalence classes.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(2^n)	O(2^n)	Try all possible operations and track minimum length achieved
Greedy GCD-based Approach (Optimal)	O(n²)	O(n)	Use number theory insight: elements reduce to their GCD equivalence classes

Brute Force Simulation — Algorithm Steps

For current array state, try all pairs (i,j) where i != j
For each pair, create new array with nums[i] % nums[j] added and nums[i], nums[j] removed
Recursively solve for the new array state
Return minimum length among all possibilities
Use memoization to avoid recomputing same states

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original array [6, 3, 8]

Try All Pairs

For each pair (i,j), create two branches: i%j and j%i

Recursive Exploration

Continue exploring all possibilities from each new state

Track Minimum

Keep track of minimum length found across all branches

Code -

solution.c — C

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

#define MAX_SIZE 20

int memo[1000][MAX_SIZE];
int memo_len[1000];
int memo_count = 0;

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

int findMemo(int* arr, int len) {
    for (int i = 0; i < memo_count; i++) {
        if (memo_len[i] == len) {
            int match = 1;
            for (int j = 0; j < len; j++) {
                if (memo[i][j] != arr[j]) {
                    match = 0;
                    break;
                }
            }
            if (match) return memo[i][MAX_SIZE-1];
        }
    }
    return -1;
}

void addMemo(int* arr, int len, int result) {
    if (memo_count < 1000) {
        memo_len[memo_count] = len;
        for (int i = 0; i < len; i++) {
            memo[memo_count][i] = arr[i];
        }
        memo[memo_count][MAX_SIZE-1] = result;
        memo_count++;
    }
}

int solve(int* arr, int len) {
    qsort(arr, len, sizeof(int), compare);
    
    int cached = findMemo(arr, len);
    if (cached != -1) return cached;
    
    if (len <= 1) {
        addMemo(arr, len, len);
        return len;
    }
    
    int minLen = len;
    for (int i = 0; i < len; i++) {
        for (int j = i + 1; j < len; j++) {
            // Try arr[i] % arr[j]
            int newArr1[MAX_SIZE];
            int newLen1 = 0;
            int remainder1 = arr[i] % arr[j];
            for (int k = 0; k < len; k++) {
                if (k != i && k != j) {
                    newArr1[newLen1++] = arr[k];
                }
            }
            if (remainder1 > 0) {
                newArr1[newLen1++] = remainder1;
            }
            if (newLen1 < minLen) {
                minLen = (minLen < solve(newArr1, newLen1)) ? minLen : solve(newArr1, newLen1);
            }
            
            // Try arr[j] % arr[i]
            int newArr2[MAX_SIZE];
            int newLen2 = 0;
            int remainder2 = arr[j] % arr[i];
            for (int k = 0; k < len; k++) {
                if (k != i && k != j) {
                    newArr2[newLen2++] = arr[k];
                }
            }
            if (remainder2 > 0) {
                newArr2[newLen2++] = remainder2;
            }
            if (newLen2 < minLen) {
                minLen = (minLen < solve(newArr2, newLen2)) ? minLen : solve(newArr2, newLen2);
            }
        }
    }
    
    addMemo(arr, len, minLen);
    return minLen;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[MAX_SIZE];
    int count = 0;
    char* token = strtok(input, " \n");
    while (token != NULL && count < MAX_SIZE) {
        nums[count++] = atoi(token);
        token = strtok(NULL, " \n");
    }
    
    printf("%d\n", solve(nums, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each operation can lead to multiple new states, creating an exponential search tree

⚠ Quadratic Growth

Space Complexity

O(2^n)

Memoization table stores exponential number of different array states

⚠ Quadratic Space

Constraints

1 ≤ nums.length ≤ 20
1 ≤ nums[i] ≤ 10³
All elements in nums are positive integers
You can perform the operation any number of times (including zero)

28.0K Views

Medium Frequency

~25 min Avg. Time

850 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler