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


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "3180" 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 <= 2000 1 <= rewardValues[i] <= 2000  

	# Explanation
	Here's the breakdown of the solution:

*   **Greedy Approach:** Sort the reward values in ascending order. This allows us to prioritize smaller rewards first, increasing the chances of being able to collect larger rewards later.
*   **Iterative Selection:** Iterate through the sorted reward values. If a reward is greater than the current total reward, add it to the total and mark the index (conceptually; we don't need to physically mark indices).
*   **Maximization:**  By prioritizing smaller rewards initially, we ensure that we maximize the chances of collecting larger rewards, leading to the overall maximum total reward.

*   **Runtime Complexity:** O(n log n) due to sorting. **Storage Complexity:** O(n) for storing the sorted indices.

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

    Args:
        rewardValues: A list of integers representing the values of rewards.

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

    n = len(rewardValues)
    indices = list(range(n))
    indices.sort(key=lambda i: rewardValues[i])  # Sort indices based on reward values

    total_reward = 0
    for i in indices:
        if rewardValues[i] > total_reward:
            total_reward += rewardValues[i]

    return total_reward
	```