Codestin Search App

Array Transformation - Problem

Array Simulation Easy

Imagine you have an array that evolves day by day following specific transformation rules. Given an initial array, each day produces a new array based on the previous day's configuration.

Transformation Rules:

If an element is smaller than both its left and right neighbors, increment it by 1
If an element is larger than both its left and right neighbors, decrement it by 1
The first and last elements never change (they act as fixed boundaries)

The array will eventually reach a stable state where no more changes occur. Your task is to simulate this process and return the final stabilized array.

Example: [6,2,3,4] → [6,3,3,4] → [6,3,3,4] (stable)

Input & Output

example_1.py — Basic Transformation

$ Input: [6,2,3,4]

› Output: [6,3,3,4]

💡 Note: Element 2 is smaller than both neighbors (6 and 3), so it gets incremented to 3. After this change, no element satisfies the transformation conditions, so the array stabilizes.

example_2.py — Multiple Iterations

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

› Output: [1,4,4,4,1]

💡 Note: Day 1: 6>3 and 6>4, so 6→5, 3<6 and 3<4, so 3→4. Array: [1,5,4,4,1]. Day 2: 5>1 and 5>4, so 5→4. Final: [1,4,4,4,1]

example_3.py — Already Stable

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

› Output: [2,1,2,1,2]

💡 Note: No element is strictly smaller or larger than both neighbors. Element 1 has neighbors (2,2) but 1<2 and 1<2, so it would increment to 2, making [2,2,2,2,2], then [2,2,2,2,2] is stable.

Constraints

1 ≤ arr.length ≤ 100
1 ≤ arr[i] ≤ 100
The array will always converge to a stable state
First and last elements never change

Visualization

Tap to expand

Understanding the Visualization

Initial Landscape

Start with mountain range having peaks and valleys

Day 1 Changes

Deep valleys collect sediment, tall peaks lose material to erosion

Gradual Smoothing

Landscape gradually smooths out as extreme elevations balance

Equilibrium Reached

Final stable terrain where no more erosion or filling occurs

Key Takeaway

🎯 Key Insight: Like natural erosion, array transformation always converges because local extremes naturally balance toward their neighbors until equilibrium is reached.

Asked in

G Google 12 a Amazon 8 ⊞ Microsoft 6 Apple 4

The optimal approach is iterative simulation with O(k×n) time complexity where k is convergence days. Simply simulate each day's transformation until the array stabilizes - guaranteed convergence due to the bounded nature of local extrema.

Common Approaches

Approach	Time	Space	Notes
✓ Daily Simulation (Iterative)	O(k×n)	O(n)	Simulate each day's transformation until array becomes stable

Daily Simulation (Iterative) — Algorithm Steps

Start with the initial array
For each day, create a copy of the current array
Apply transformation rules to each interior element
Compare new array with previous day's array
If identical, return the stable array; otherwise continue

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with the original array [6,2,3,4]

Day 1 Analysis

Element 2 is smaller than both neighbors (6,3), so increment it

Day 1 Result

Array becomes [6,3,3,4] - first and last elements unchanged

Day 2 Analysis

No elements satisfy transformation conditions

Stable State

Array [6,3,3,4] remains unchanged - return final result

Code -

solution.c — C

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

int* transformArray(int* arr, int size) {
    if (size <= 2) {
        int* result = malloc(size * sizeof(int));
        memcpy(result, arr, size * sizeof(int));
        return result;
    }
    
    int* current = malloc(size * sizeof(int));
    memcpy(current, arr, size * sizeof(int));
    
    while (true) {
        int* newArr = malloc(size * sizeof(int));
        memcpy(newArr, current, size * sizeof(int));
        bool changed = false;
        
        for (int i = 1; i < size - 1; i++) {
            int left = current[i - 1];
            int curr = current[i];
            int right = current[i + 1];
            
            if (curr < left && curr < right) {
                newArr[i]++;
                changed = true;
            } else if (curr > left && curr > right) {
                newArr[i]--;
                changed = true;
            }
        }
        
        if (!changed) {
            free(newArr);
            return current;
        }
        
        free(current);
        current = newArr;
    }
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int arr[100], size = 0;
    char* token = strtok(input, "[,]\n ");
    while (token != NULL) {
        arr[size++] = atoi(token);
        token = strtok(NULL, "[,]\n ");
    }
    
    int* result = transformArray(arr, size);
    printf("[");
    for (int i = 0; i < size; i++) {
        printf("%d", result[i]);
        if (i < size - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k×n)

Where k is the number of days until convergence and n is array length. In worst case, k could be O(max_value), making it O(max_value×n)

✓ Linear Growth

Space Complexity

O(n)

Need extra space to store the new array for each iteration

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 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

Daily Simulation (Iterative) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler