# Solving Leetcode Interviews in Seconds with AI: Maximum Total Reward Using Operations II


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "3181" 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 rewardValues of length n, representing the values of rewards. Initially, your total reward x is 0, and all indices are unmarked. You are allowed to perform the following operation any number of times:  Choose an unmarked index i from the range [0, n - 1]. If rewardValues[i] is greater than your current total reward x, then add rewardValues[i] to x (i.e., x = x + rewardValues[i]), and mark the index i.  Return an integer denoting the maximum total reward you can collect by performing the operations optimally.   Example 1:  Input: rewardValues = [1,1,3,3] Output: 4 Explanation: During the operations, we can choose to mark the indices 0 and 2 in order, and the total reward will be 4, which is the maximum.  Example 2:  Input: rewardValues = [1,6,4,3,2] Output: 11 Explanation: Mark the indices 0, 2, and 1 in order. The total reward will then be 11, which is the maximum.    Constraints:  1 <= rewardValues.length <= 5 * 104 1 <= rewardValues[i] <= 5 * 104  

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

*   **Greedy Approach:** The optimal strategy is to always choose the largest reward available that is also greater than the current total reward. This maximizes the reward accumulation at each step.
*   **Sorting:** Sort the `rewardValues` array in descending order. This makes it easy to pick the largest available reward.
*   **Iteration and Accumulation:** Iterate through the sorted rewards. If a reward is greater than the current total reward, add it to the total and mark it (conceptually - we don't need to explicitly track marked indices).

*   **Runtime Complexity:** O(n log n) due to sorting. **Storage Complexity:** O(n) in the worst case, due to sorted().

	
	# Code
	```python
	def max_reward(rewardValues):
    """
    Calculates the maximum total reward achievable by strategically selecting rewards.

    Args:
        rewardValues: A list of integers representing reward values.

    Returns:
        An integer representing the maximum total reward.
    """

    sorted_rewards = sorted(rewardValues, reverse=True)
    total_reward = 0

    for reward in sorted_rewards:
        if reward > total_reward:
            total_reward += reward

    return total_reward
	```