Find Minimum Operations to Make All Elements Divisible by Three

Find Minimum Operations to Make All Elements Divisible by Three - Problem

Array Math Easy

You are given an integer array nums. Your goal is to make all elements in the array divisible by 3 using the minimum number of operations.

In one operation, you can either:

Add 1 to any element
Subtract 1 from any element

Return the minimum number of operations needed to make all elements divisible by 3.

Example: If you have [1, 2, 4], you need 1 operation for each element: change 1→0 or 1→3, change 2→3, and change 4→3. Total: 3 operations.

Input & Output

example_1.py — Basic Case

$ Input: [3, 1, 4]

› Output: 2

💡 Note: 3 is already divisible by 3 (0 operations). 1 needs 1 operation (1→0 or 1→3). 4 needs 1 operation (4→3). Total: 0 + 1 + 1 = 2 operations.

example_2.py — All Divisible

$ Input: [0, 3, 6, 9]

› Output: 0

💡 Note: All numbers are already divisible by 3, so no operations are needed.

example_3.py — Mixed Cases

$ Input: [1, 2, 4, 5]

› Output: 4

💡 Note: 1 % 3 = 1 (1 op), 2 % 3 = 2 (1 op), 4 % 3 = 1 (1 op), 5 % 3 = 2 (1 op). Total: 4 operations.

Constraints

1 ≤ nums.length ≤ 10⁴
0 ≤ nums[i] ≤ 10⁴
Each operation changes an element by exactly ±1

Visualization

Tap to expand

Understanding the Visualization

Identify Problem

Each clock shows a wrong time, we need to fix them with minimum adjustments

Find Closest Target

For each clock, find the nearest 'good' position (divisible by 3)

Calculate Moves

Count minimum moves needed - never more than 1 move per clock

Sum Total

Add up all the individual moves to get the total operations

Key Takeaway

🎯 Key Insight: The minimum operations for any number is simply whether its remainder when divided by 3 is zero (0 ops) or non-zero (1 op).

Asked in

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

The optimal solution uses modulo arithmetic to solve this in O(n) time and O(1) space. For each element, calculate remainder = num % 3. If the remainder is not 0, we need exactly 1 operation to make it divisible by 3. Sum up all required operations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Possibilities)	O(n)	O(1)	Try all possible combinations of operations for each element
One-Pass Mathematical Solution (Optimal)	O(n)	O(1)	Use modulo operation to find minimum operations for each element in one pass

Brute Force (Check All Possibilities) — Algorithm Steps

For each element in the array
Calculate all possible ways to make it divisible by 3
Choose the minimum operations for each element
Sum up all minimum operations

Visualization

Tap to expand

Step-by-Step Walkthrough

Examine First Element

Calculate remainder when divided by 3

Determine Operations

If remainder is 1 or 2, need 1 operation

Repeat for All

Sum up operations for all elements

Code -

solution.c — C

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

int minimumOperations(int* nums, int numsSize) {
    int operations = 0;
    for (int i = 0; i < numsSize; i++) {
        // For each number, find minimum operations to make divisible by 3
        int remainder = nums[i] % 3;
        if (remainder == 0) {
            operations += 0; // Already divisible
        } else if (remainder == 1) {
            operations += 1; // Subtract 1
        } else { // remainder == 2
            operations += 1; // Add 1
        }
    }
    return operations;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Simple parsing for [1,2,3] format
    int nums[100];
    int count = 0;
    char *ptr = input + 1; // Skip '['
    while (*ptr && *ptr != ']') {
        nums[count++] = atoi(ptr);
        while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
        if (*ptr == ',') ptr++;
    }
    
    printf("%d\n", minimumOperations(nums, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We still only need to check each element once, but with unnecessary complexity

✓ Linear Growth

Space Complexity

O(1)

No extra space needed besides variables

✓ Linear Space

26.8K Views

Medium Frequency

~8 min Avg. Time

892 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 (Check All Possibilities) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler