# Solving Leetcode Interviews in Seconds with AI: Sorting Three Groups


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2826" 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 an integer array nums. Each element in nums is 1, 2 or 3. In each operation, you can remove an element from nums. Return the minimum number of operations to make nums non-decreasing.   Example 1:  Input: nums = [2,1,3,2,1] Output: 3 Explanation: One of the optimal solutions is to remove nums[0], nums[2] and nums[3].  Example 2:  Input: nums = [1,3,2,1,3,3] Output: 2 Explanation: One of the optimal solutions is to remove nums[1] and nums[2].  Example 3:  Input: nums = [2,2,2,2,3,3] Output: 0 Explanation: nums is already non-decreasing.    Constraints:  1 <= nums.length <= 100 1 <= nums[i] <= 3    Follow-up: Can you come up with an algorithm that runs in O(n) time complexity?

	# Explanation
	Here's a breakdown of the approach and the Python code:

*   **Key Idea:** The problem asks for the minimum number of elements to *remove* to make the array non-decreasing. Equivalently, we want to find the *longest* non-decreasing subsequence. Because the numbers are restricted to 1, 2, and 3, we can consider all possible non-decreasing subsequences: `1`, `1, 2`, `1, 2, 3`, `1, 3`, `2`, `2, 3`, and `3`. We can then determine the length of the longest of these subsequences present in the given array and return the number of elements removed, which is the difference between the array's length and the longest non-decreasing subsequence's length.

*   **Dynamic Programming:** We can efficiently find the longest subsequence by iterating through the input array and keeping track of the maximum length ending with 1, 2, and 3 at each step.

*   **Optimization:** Since the numbers are limited to 1, 2, and 3, we can use a few variables to store counts instead of a full DP table.

*   **Complexity:** O(n) time, O(1) space.

	
	# Code
	```python
	def min_operations(nums):
    """
    Calculates the minimum number of operations to make nums non-decreasing.

    Args:
        nums: A list of integers where each element is 1, 2, or 3.

    Returns:
        The minimum number of operations to make nums non-decreasing.
    """
    count1 = 0
    count12 = 0
    count123 = 0

    for num in nums:
        if num == 1:
            count1 += 1
        elif num == 2:
            count12 = max(count1, count12) + (num==2) -1 if count12 > 0 else count1+ (num==2) -1 if count1 > 0 else count12 + 1
            count12 = max(count12, count1)
        else:  # num == 3
            count123 = max(count12, count123) + (num == 3) -1 if count123 > 0 else count12 + (num==3) -1 if count12 > 0 else count123 +1
            count123 = max(count123, count12)
    
    return len(nums) - max(count1, count12, count123)
	```