# Solving Leetcode Interviews in Seconds with AI: Power of Heroes


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2681" 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 representing the strength of some heroes. The power of a group of heroes is defined as follows:  Let i0, i1, ... ,ik be the indices of the heroes in a group. Then, the power of this group is max(nums[i0], nums[i1], ... ,nums[ik])2 * min(nums[i0], nums[i1], ... ,nums[ik]).  Return the sum of the power of all non-empty groups of heroes possible. Since the sum could be very large, return it modulo 109 + 7.   Example 1:  Input: nums = [2,1,4] Output: 141 Explanation:  1st group: [2] has power = 22 * 2 = 8. 2nd group: [1] has power = 12 * 1 = 1.  3rd group: [4] has power = 42 * 4 = 64.  4th group: [2,1] has power = 22 * 1 = 4.  5th group: [2,4] has power = 42 * 2 = 32.  6th group: [1,4] has power = 42 * 1 = 16.  ​​​​​​​7th group: [2,1,4] has power = 42​​​​​​​ * 1 = 16.  The sum of powers of all groups is 8 + 1 + 64 + 4 + 32 + 16 + 16 = 141.   Example 2:  Input: nums = [1,1,1] Output: 7 Explanation: A total of 7 groups are possible, and the power of each group will be 1. Therefore, the sum of the powers of all groups is 7.    Constraints:  1 <= nums.length <= 105 1 <= nums[i] <= 109  

	# Explanation
	Here's the solution to the problem, focusing on efficiency and clarity.

*   **Sort the Input:** Sorting `nums` allows us to efficiently determine the minimum value for any sub-group ending at a specific index. This is because for any sub-group ending at index `i`, the minimum value will always be `nums[0]` to `nums[i]`.

*   **Iterative Calculation:** Iterate through the sorted array. At each index `i`, the current number `nums[i]` will be the maximum of all the sub-groups ending at `i`. This lets us calculate the power of all these sub-groups in one go.

*   **Power of 2 Optimization:** Maintain a running sum of powers of 2 (modulo 10^9 + 7). For a sorted array, when we get to an element `nums[i]`, this element is the maximum in every group ending with `nums[i]`. The minimum element in all these groups can range from `nums[0]` to `nums[i]`. The running sum calculates the number of such groups ending with `nums[i]`.

*   **Runtime Complexity:** O(n log n) due to the sorting step.
*   **Storage Complexity:** O(1) excluding the space used by the input array, as the algorithm uses a fixed number of variables.

	
	# Code
	```python
	def sum_of_power(nums):
    nums.sort()
    n = len(nums)
    MOD = 10**9 + 7
    ans = 0
    power_sum = 0

    for i in range(n):
        ans = (ans + (nums[i] * nums[i]) % MOD * (nums[i] + power_sum)) % MOD
        power_sum = (power_sum * 2 + nums[i]) % MOD

    return ans
	```