Transform Array to All Equal Elements - Practice Coding Problems

Transform Array to All Equal Elements - Problem

Array Greedy Medium

You're given an array of n integers where each element is either 1 or -1, and you have up to k operations to transform it.

The Operation: Choose any index i (where 0 ≤ i < n-1) and multiply both nums[i] and nums[i+1] by -1. This flips the signs of two adjacent elements simultaneously.

Goal: Determine if it's possible to make all elements equal (either all 1s or all -1s) using at most k operations.

Key Insights:

You can apply the same operation multiple times on the same index
Each operation affects exactly two adjacent elements
The strategy depends on the current distribution of 1s and -1s

Input & Output

example_1.py — Basic Case

$ Input: nums = [1, -1, 1, -1], k = 1

› Output: false

💡 Note: We have 4 segments: [1], [-1], [1], [-1]. To make all equal, we need to eliminate 3 boundaries, requiring at least 2 operations. Since k=1 < 2, it's impossible.

example_2.py — Sufficient Operations

$ Input: nums = [1, -1, 1, -1], k = 2

› Output: true

💡 Note: With k=2 operations, we can make all elements equal. For example: apply operation at index 1 to get [1, 1, -1, -1], then at index 1 again to get [1, 1, 1, 1].

example_3.py — Already Equal

$ Input: nums = [1, 1, 1], k = 0

› Output: true

💡 Note: All elements are already equal, so no operations are needed. Return true regardless of k value.

Constraints

1 ≤ n ≤ 10⁵
nums[i] is either 1 or -1
0 ≤ k ≤ 10⁹
Each operation affects exactly two adjacent elements

Visualization

Tap to expand

Understanding the Visualization

Initial State

Count how many 'segments' of consecutive same-state switches exist

Identify Boundaries

Each transition between segments represents a boundary to eliminate

Calculate Minimum Operations

Each tool use can eliminate at most 2 boundaries

Check Feasibility

Compare required operations with available tool uses (k)

Key Takeaway

🎯 Key Insight: The minimum operations needed equals ⌈(number of segments - 1) / 2⌉, since each operation can eliminate at most 2 boundaries between segments.

Asked in

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

The optimal solution uses a greedy segment analysis approach that counts consecutive segments of equal elements. The key insight is that we need to eliminate boundaries between different segments, and each operation can affect at most 2 boundaries. This gives us a simple formula: operations needed = ⌈(segments - 1) / 2⌉.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(n^k)	O(k)	Try all possible sequences of operations up to k steps
Greedy Segment Analysis (Optimal)	O(n)	O(1)	Count segments and calculate minimum operations needed to make all elements equal

Brute Force Simulation — Algorithm Steps

Start with the original array
For each possible operation (index 0 to n-2), create a new state
Recursively try all operations up to depth k
Check if any resulting state has all elements equal
Return true if found, false otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original array [1, -1, 1, -1]

Branch on Operations

Try operation at each valid index (0, 1, 2)

Recursive Exploration

For each new state, recursively try more operations

Check Terminal States

At each leaf, check if all elements are equal

Code -

solution.c — C

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

bool allEqual(int* arr, int n) {
    for (int i = 1; i < n; i++) {
        if (arr[i] != arr[0]) return false;
    }
    return true;
}

bool backtrack(int* arr, int n, int operationsLeft) {
    if (allEqual(arr, n)) return true;
    if (operationsLeft == 0) return false;
    
    for (int i = 0; i < n - 1; i++) {
        arr[i] *= -1;
        arr[i + 1] *= -1;
        
        if (backtrack(arr, n, operationsLeft - 1)) {
            return true;
        }
        
        arr[i] *= -1;
        arr[i + 1] *= -1;
    }
    
    return false;
}

bool canMakeEqual(int* nums, int n, int k) {
    int* copy = malloc(n * sizeof(int));
    memcpy(copy, nums, n * sizeof(int));
    bool result = backtrack(copy, n, k);
    free(copy);
    return result;
}

int main() {
    int nums[] = {1, -1, 1, -1};
    int n = 4, k = 3;
    printf("%s\n", canMakeEqual(nums, n, k) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^k)

For each of k operations, we have n-1 choices of indices, leading to exponential growth

✓ Linear Growth

Space Complexity

O(k)

Recursion depth is at most k levels deep

✓ Linear Space

24.6K Views

Medium Frequency

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

Visualization

Code -

Time & Space Complexity

Select Compiler