# Reconstructing an Array: Replace `arr[i]` with `(arr[i-1]+1) % M`

In this blog post, we’ll explore a Python program that reconstructs an array by replacing each element `arr[i]` with `(arr[i-1] + 1) % M`, where `M` is a given positive integer. The article will walk through the algorithm used in the program, provide the Python code for implementation, and include examples with corresponding outputs.

## Understanding the Algorithm

The algorithm for reconstructing an array involves the following steps:

1. Input Array: Accept an array of elements, either predefined or entered by the user.
2. Replace Elements: Iterate through the array, replacing each element with `(arr[i-1] + 1) % M`. Handle the special case for the first element.
3. Display Reconstructed Array: Print or display the reconstructed array.

## Python Program for Reconstructing the Array

Let’s implement the algorithm in a Python program:

``````def reconstruct_array(arr, M):
reconstructed_arr = [arr[0]]

# Reconstruct array by replacing each element
for i in range(1, len(arr)):
reconstructed_arr.append((reconstructed_arr[i-1] + 1) % M)

return reconstructed_arr

# Example array and M value
example_array = [4, 7, 1, 2]
M_value = 10

# Reconstruct the array
result_array = reconstruct_array(example_array, M_value)

# Display the reconstructed array
print("Original Array:", example_array)
print("Reconstructed Array:", result_array)
``````

## Output Example

### Example: Reconstructing the Array for `arr = [4, 7, 1, 2]` and `M = 10`

``````Original Array: [4, 7, 1, 2]
Reconstructed Array: [4, 5, 6, 7]
``````

## Explanation

The Python program defines a function `reconstruct_array` that takes an array `arr` and a positive integer `M` as input. It initializes `reconstructed_arr` with the first element of the input array. The subsequent elements are determined by the formula `(arr[i-1] + 1) % M`. The reconstructed array is then displayed along with the original array.

## Conclusion

This Python program showcases the process of reconstructing an array based on a specific rule. You can experiment with different arrays and `M` values to observe the variations in the reconstructed arrays. Understanding array manipulation is crucial in solving diverse programming challenges. Feel free to adapt this program for different scenarios or incorporate it into more complex algorithms. If you have any questions or would like further clarification, please don’t hesitate to ask!