# Solving Leetcode Interviews in Seconds with AI: Find the Maximum Number of Marked Indices


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2576" 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. Initially, all of the indices are unmarked. You are allowed to make this operation any number of times:  Pick two different unmarked indices i and j such that 2 * nums[i] <= nums[j], then mark i and j.  Return the maximum possible number of marked indices in nums using the above operation any number of times.   Example 1:  Input: nums = [3,5,2,4] Output: 2 Explanation: In the first operation: pick i = 2 and j = 1, the operation is allowed because 2 * nums[2] <= nums[1]. Then mark index 2 and 1. It can be shown that there's no other valid operation so the answer is 2.  Example 2:  Input: nums = [9,2,5,4] Output: 4 Explanation: In the first operation: pick i = 3 and j = 0, the operation is allowed because 2 * nums[3] <= nums[0]. Then mark index 3 and 0. In the second operation: pick i = 1 and j = 2, the operation is allowed because 2 * nums[1] <= nums[2]. Then mark index 1 and 2. Since there is no other operation, the answer is 4.  Example 3:  Input: nums = [7,6,8] Output: 0 Explanation: There is no valid operation to do, so the answer is 0.     Constraints:  1 <= nums.length <= 105 1 <= nums[i] <= 109     

	# Explanation
	Here's the solution to the problem:

*   **Sort the array:** Sorting allows us to efficiently find pairs that satisfy the `2 * nums[i] <= nums[j]` condition.
*   **Two Pointers/Greedy Matching:**  Iterate through the first half of the sorted array, attempting to find a match in the second half for each element. This maximizes the number of marked indices.

*   **Time Complexity:** O(n log n) due to sorting. **Space Complexity:** O(1) (in-place sort or using constant extra space).

	
	# Code
	```python
	def max_marked_indices(nums):
    """
    Finds the maximum possible number of marked indices in nums.

    Args:
        nums: A 0-indexed integer array.

    Returns:
        The maximum possible number of marked indices.
    """

    nums.sort()
    n = len(nums)
    left = 0
    right = (n + 1) // 2  # Start from the middle or slightly beyond
    marked_count = 0

    while left < n // 2 and right < n:
        if 2 * nums[left] <= nums[right]:
            marked_count += 2
            left += 1
            right += 1
        else:
            right += 1

    return marked_count
	```