Transform Array to All Equal Elements

Transform Array to All Equal Elements - Problem

Array Greedy Medium

You are given an integer array nums of size n containing only 1 and -1, and an integer k.

You can perform the following operation at most k times:

Choose an index i (0 <= i < n - 1), and multiply both nums[i] and nums[i + 1] by -1.

Note: You can choose the same index i more than once in different operations.

Return true if it is possible to make all elements of the array equal after at most k operations, and false otherwise.

Input & Output

Example 1 — Basic Transformation

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

› Output: true

💡 Note: Apply operation at index 0: multiply nums[0] and nums[1] by -1, getting [-1,1,1]. Then apply operation at index 1: multiply nums[1] and nums[2] by -1, getting [-1,-1,-1]. All elements are now equal.

Example 2 — Insufficient Operations

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

› Output: false

💡 Note: We have 2 positive and 2 negative elements. To make all equal, we need at least 1 operation to group negatives or positives, but the arrangement makes it impossible with just k=1 operations.

Example 3 — Already Equal

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

› Output: true

💡 Note: All elements are already equal to -1, so no operations needed.

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 1 or -1
0 ≤ k ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that each operation flips exactly 2 adjacent elements, so we can analyze mathematically instead of simulating. Count positive and negative elements, calculate minimum operations needed to make all equal, and check if it's ≤ k. Best approach is Mathematical Analysis with Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(n^k) Space: O(k)

Generate all possible sequences of operations and check if any leads to all elements being equal. This involves recursively trying each possible index for each operation.

Mathematical Analysis

⏱️ Time: O(n) Space: O(1)

Each operation flips two adjacent elements. The key insight is that operations have predictable effects on array parity and can be analyzed mathematically rather than simulated.

Brute Force Simulation — Algorithm Steps

Try every possible operation sequence
For each sequence, simulate the operations
Check if result has all elements equal

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original array

Try Operations

Recursively try each possible operation

Check Result

Verify if all elements are equal

Code -

solution.c — C

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

static int nums[1000];

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

bool canAchieveTarget(int* nums, int size, int k, int target) {
    // Create a copy to work with
    int current[1000];
    for (int i = 0; i < size; i++) {
        current[i] = nums[i];
    }
    
    int operations = 0;
    
    // Simple greedy: try to fix from left to right
    for (int i = 0; i < size - 1; i++) {
        if (current[i] != target) {
            // Flip current[i] and current[i+1]
            current[i] *= -1;
            current[i + 1] *= -1;
            operations++;
            
            if (operations > k) {
                return false;
            }
        }
    }
    
    // Check if last element is correct
    if (current[size - 1] != target) {
        return false;
    }
    
    // Check if we used at most k operations
    return operations <= k;
}

bool solution(int* nums, int size, int k) {
    // If only one element, already equal
    if (size == 1) {
        return true;
    }
    
    // If all elements are already equal
    bool allSame = true;
    for (int i = 1; i < size; i++) {
        if (nums[i] != nums[0]) {
            allSame = false;
            break;
        }
    }
    if (allSame) {
        return true;
    }
    
    // Try to make all elements 1
    if (canAchieveTarget(nums, size, k, 1)) {
        return true;
    }
    
    // Try to make all elements -1
    if (canAchieveTarget(nums, size, k, -1)) {
        return true;
    }
    
    return false;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int size;
    parseArray(line, nums, &size);
    
    int k;
    scanf("%d", &k);
    
    printf(solution(nums, size, k) ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^k)

For each of k operations, we have n-1 choices of indices

✓ Linear Growth

Space Complexity

O(k)

Recursion stack depth up to k operations

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

867 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