Welcome to Subscribe On Youtube

2681. Power of Heroes

Description

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

Solutions

• Java
• C++
• Python
• Go
• TypeScript

• class Solution {
      public int sumOfPower(int[] nums) {
          final int mod = (int) 1e9 + 7;
          Arrays.sort(nums);
          long ans = 0, p = 0;
          for (int i = nums.length - 1; i >= 0; --i) {
              long x = nums[i];
              ans = (ans + (x * x % mod) * x) % mod;
              ans = (ans + x * p % mod) % mod;
              p = (p * 2 + x * x % mod) % mod;
          }
          return (int) ans;
      }
  }
  

• class Solution {
  public:
      int sumOfPower(vector<int>& nums) {
          const int mod = 1e9 + 7;
          sort(nums.rbegin(), nums.rend());
          long long ans = 0, p = 0;
          for (long long x : nums) {
              ans = (ans + (x * x % mod) * x) % mod;
              ans = (ans + x * p % mod) % mod;
              p = (p * 2 + x * x % mod) % mod;
          }
          return ans;
      }
  };
  

• class Solution:
      def sumOfPower(self, nums: List[int]) -> int:
          mod = 10**9 + 7
          nums.sort()
          ans = 0
          p = 0
          for x in nums[::-1]:
              ans = (ans + (x * x % mod) * x) % mod
              ans = (ans + x * p) % mod
              p = (p * 2 + x * x) % mod
          return ans
  
  

• func sumOfPower(nums []int) (ans int) {
  	const mod = 1e9 + 7
  	sort.Ints(nums)
  	p := 0
  	for i := len(nums) - 1; i >= 0; i-- {
  		x := nums[i]
  		ans = (ans + (x*x%mod)*x) % mod
  		ans = (ans + x*p%mod) % mod
  		p = (p*2 + x*x%mod) % mod
  	}
  	return
  }
  

• function sumOfPower(nums: number[]): number {
      const mod = 10 ** 9 + 7;
      nums.sort((a, b) => a - b);
      let ans = 0;
      let p = 0;
      for (let i = nums.length - 1; i >= 0; --i) {
          const x = BigInt(nums[i]);
          ans = (ans + Number((x * x * x) % BigInt(mod))) % mod;
          ans = (ans + Number((x * BigInt(p)) % BigInt(mod))) % mod;
          p = Number((BigInt(p) * 2n + x * x) % BigInt(mod));
      }
      return ans;
  }
  
  

All Problems

All Solutions