# Solving Leetcode Interviews in Seconds with AI: Steps to Make Array Non-decreasing


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2289" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> You are given a 0-indexed integer array nums. In one step, remove all elements nums[i] where nums[i - 1] > nums[i] for all 0 < i < nums.length. Return the number of steps performed until nums becomes a non-decreasing array.   Example 1:  Input: nums = [5,3,4,4,7,3,6,11,8,5,11] Output: 3 Explanation: The following are the steps performed: - Step 1: [5,3,4,4,7,3,6,11,8,5,11] becomes [5,4,4,7,6,11,11] - Step 2: [5,4,4,7,6,11,11] becomes [5,4,7,11,11] - Step 3: [5,4,7,11,11] becomes [5,7,11,11] [5,7,11,11] is a non-decreasing array. Therefore, we return 3.  Example 2:  Input: nums = [4,5,7,7,13] Output: 0 Explanation: nums is already a non-decreasing array. Therefore, we return 0.    Constraints:  1 <= nums.length <= 105 1 <= nums[i] <= 109  

	# Explanation
	Here's the solution:

*   **Monotonic Stack with Steps:** Maintain a stack where each element stores the value and the number of steps it survived. When a new element `nums[i]` is encountered, compare it with the top of the stack. If `nums[i]` is greater than or equal to the top, push it onto the stack with a step count of 0. If `nums[i]` is smaller, pop elements from the stack until the top is smaller than or equal to `nums[i]`. The step count for the new element is the maximum of 1 plus the step count of the popped elements. The maximum step count encountered during this process is the final answer.

*   **Iterative Simulation Avoidance:** Instead of repeatedly simulating removal rounds, this approach determines the number of steps each element survives in a single pass using the stack. This dramatically improves efficiency.

*   **Complexity:** Time: O(n), Space: O(n)

	
	# Code
	```python
	def totalSteps(nums):
    """
    Calculates the number of steps until the array becomes non-decreasing.

    Args:
        nums: A list of integers.

    Returns:
        The number of steps.
    """

    stack = []  # (value, steps)
    ans = 0

    for num in nums:
        steps = 0
        while stack and num >= stack[-1][0]:
            steps = max(steps + 1, stack[-1][1])
            stack.pop()

        if stack:
            stack.append((num, steps))
            ans = max(ans, steps)
        else:
            stack.append((num, 0))

    return ans
	```