
### Problem Statement

###### Alice and Bob are opponents in an archery competition. The competition has set the following rules:

- ###### Alice first shoots numArrows arrows and then Bob shoots numArrows arrows.
- ###### The points are then calculated as follows :
  - ###### The target has integer scoring sections ranging from 0 to 11 inclusive.
  - ###### For each section of the target with score k (in between 0 to 11), say Alice and Bob have shot a&#8342; and b&#8342; arrows on that section respectively. If a&#8342; >= b&#8342;, then Alice takes k points. If a&#8342; < b&#8342;, then Bob takes k points.
  - ###### However, if a&#8342; == b&#8342; == 0, then nobody takes k points.

###### For example, if Alice and Bob both shot 2 arrows on the section with score 11, then Alice takes 11 points. On the other hand, if Alice shot 0 arrows on the section with score 11 and Bob shot 2 arrows on that same section, then Bob takes 11 points.

###### You are given the integer numArrows and an integer array aliceArrows of size 12, which represents the number of arrows Alice shot on each scoring section from 0 to 11. Now, Bob wants to maximize the total number of points he can obtain.

###### Return the array bobArrows which represents the number of arrows Bob shot on each scoring section from 0 to 11. The sum of the values in bobArrows should equal numArrows.

###### If there are multiple ways for Bob to earn the maximum total points, return any one of them.

**INPUT**

- **numArrows = 9, aliceArrows = [1,1,0,1,0,0,2,1,0,1,2,0]**

**OUTPUT**

- **[0,0,0,0,1,1,0,0,1,2,3,1]**

**EXPLANATION**

![Archery](https://assets.leetcode.com/uploads/2022/02/24/ex1.jpg)

**The table above shows how the competition is scored.
Bob earns a total point of 4 + 5 + 8 + 9 + 10 + 11 = 47.
It can be shown that Bob cannot obtain a score higher than 47 points.**

**Steps To Solve**

- Lets first understand the question . The question says Alice and Bob are two players with equal number of arrows say numArrows.
- Now it is also given that Alice has shot all her arrows to collect some points . Example Lets say we have array called aliceArrows and its 10th index has a value of 2 ,that implies Alice have used her 2 arrows to collect point 10.
- Now we want to maximize total number of points that Bob can obtain and to gain points Bob has to shoot more arrows than Alice. Example if Alice took 2 arrows to collect 10 points , then Bob has to hit 3 arrows at 10th index to collect 10 points.
- Our first intuition here would be to think greedy and start shooting the index with maximum points.
- That greedy approach won't work. Lets say Alice has shot in this formation : **[0,0,0,0,3,8]** and gained **4+5 = 9** points.
- So if bob goes for index 5 and shoots 9 arrows there to gain 5 points it would not be usefull to him.He can get higher score than **9** by shooting other indexes say out of 11 arrows that he got,he shot 4 at index 4 and 1 each at index 0,1,2,3.In this way he collected 10 points shooting 8 arrows.

- Now our next approach will be to check every subset and look for maximum score.The total number of subset possible is 2^12 , as there are 12 indexes and for each index we can either include it in our set or exclude it.

- So every number from 1 till 2^12 will represent a possible subset.Example : Say that array = [0,1,2], so subset [1,2] is represented by number 011 i.e 3 which will always lie in betweeen 1 to 2^3 = 8.

- Now we will send the generated subsets to a function and that function will return total score that can be gained by Bob and also the array values of Bob's arrow distribution.

- Inside the function we will check for set bits and if that bit is on , we know that Alice has shot that index , so we add 1 to the value at that index and store it in Bob's arrow distribution.

- If the remaining arrows becomes less than the arrows needed , we return 0 and empty array , as we know that subset is not valid for Bob's arrow distribution.

- In case of having remain arrows then it means in all sections Bob always win and we can distribute the remain to any section

- Lets look at the solution

```js
/**
 * @param {number} numArrows
 * @param {number[]} aliceArrows
 * @return {number[]}
 */
var maximumBobPoints = function (numArrows, aliceArrows) {
  let bestScore = 0;
  let bestBobArrows = [];

  for (let mask = 0; mask < 1 << 12; mask++) {
    const [score, bobArrows] = getBobPoints(mask, numArrows, aliceArrows);

    if (score > bestScore) {
      bestScore = score;
      bestBobArrows = bobArrows;
    }
  }

  return bestBobArrows;
};

function getBobPoints(mask, remainArrows, aliceArrows) {
  let score = 0;
  const bobArrows = new Array(12).fill(0);

  for (let k = 0; k < 12; k++) {
    if (mask & (1 << k)) {
      const arrowsNeeded = aliceArrows[k] + 1;
      if (remainArrows < arrowsNeeded) {
        return [0, []];
      }
      score += k;
      bobArrows[k] = arrowsNeeded;
      remainArrows -= arrowsNeeded;
    }
  }

  bobArrows[0] += remainArrows;
  return [score, bobArrows];
}
```

###### Time and Space Complexity

Time Complexity is **O(12 \* 2 ^ 12)**.

Space complexity in this case is **O(1)**.
