# 1243. Array Transformation

## Description

Given an initial array arr, every day you produce a new array using the array of the previous day.

On the i-th day, you do the following operations on the array of day i-1 to produce the array of day i:

1. If an element is smaller than both its left neighbor and its right neighbor, then this element is incremented.
2. If an element is bigger than both its left neighbor and its right neighbor, then this element is decremented.
3. The first and last elements never change.

After some days, the array does not change. Return that final array.

Example 1:

Input: arr = [6,2,3,4]
Output: [6,3,3,4]
Explanation:
On the first day, the array is changed from [6,2,3,4] to [6,3,3,4].
No more operations can be done to this array.


Example 2:

Input: arr = [1,6,3,4,3,5]
Output: [1,4,4,4,4,5]
Explanation:
On the first day, the array is changed from [1,6,3,4,3,5] to [1,5,4,3,4,5].
On the second day, the array is changed from [1,5,4,3,4,5] to [1,4,4,4,4,5].
No more operations can be done to this array.


Constraints:

• 3 <= arr.length <= 100
• 1 <= arr[i] <= 100

## Solutions

Solution 1: Simulation

Simulate each day. For each element, if it is greater than its left and right neighbors, it decreases by 1, otherwise, it increases by 1. If the array no longer changes on a certain day, return that array.

The time complexity is $O(n \times m)$, and the space complexity is $O(n)$. Where $n$ is the length of the array, and $m$ is the maximum value in the array.

• class Solution {
public List<Integer> transformArray(int[] arr) {
boolean f = true;
while (f) {
f = false;
int[] t = arr.clone();
for (int i = 1; i < t.length - 1; ++i) {
if (t[i] > t[i - 1] && t[i] > t[i + 1]) {
--arr[i];
f = true;
}
if (t[i] < t[i - 1] && t[i] < t[i + 1]) {
++arr[i];
f = true;
}
}
}
List<Integer> ans = new ArrayList<>();
for (int x : arr) {
}
return ans;
}
}

• class Solution {
public:
vector<int> transformArray(vector<int>& arr) {
bool f = true;
while (f) {
f = false;
vector<int> t = arr;
for (int i = 1; i < arr.size() - 1; ++i) {
if (t[i] > t[i - 1] && t[i] > t[i + 1]) {
--arr[i];
f = true;
}
if (t[i] < t[i - 1] && t[i] < t[i + 1]) {
++arr[i];
f = true;
}
}
}
return arr;
}
};

• class Solution:
def transformArray(self, arr: List[int]) -> List[int]:
f = True
while f:
f = False
t = arr[:]
for i in range(1, len(t) - 1):
if t[i] > t[i - 1] and t[i] > t[i + 1]:
arr[i] -= 1
f = True
if t[i] < t[i - 1] and t[i] < t[i + 1]:
arr[i] += 1
f = True
return arr


• func transformArray(arr []int) []int {
f := true
for f {
f = false
t := make([]int, len(arr))
copy(t, arr)
for i := 1; i < len(arr)-1; i++ {
if t[i] > t[i-1] && t[i] > t[i+1] {
arr[i]--
f = true
}
if t[i] < t[i-1] && t[i] < t[i+1] {
arr[i]++
f = true
}
}
}
return arr
}