Maximum Points in an Archery Competition

Maximum Points in an Archery Competition - Problem

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 calculated as follows:
- The target has integer scoring sections ranging from 0 to 11 inclusive.
- For each section of the target with score k (between 0 to 11), say Alice and Bob have shot a_k and b_k arrows on that section respectively. If a_k >= b_k, then Alice takes k points. If a_k < b_k, then Bob takes k points.
- However, if a_k == b_k == 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 & Output

Example 1 — Strategic Competition

$ 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]

💡 Note: Bob competes for sections 4,5,8,9,10,11. He needs 1+1+1+2+3+1=9 arrows total. This gives him 4+5+8+9+10+11=47 points, while Alice gets 1+1+3+7+1=13 points from sections 0,1,3,6,7.

Example 2 — Focus on High Value

$ Input: numArrows = 3, aliceArrows = [0,0,1,0,0,0,0,0,0,0,0,2]

› Output: [0,0,0,0,0,0,0,0,1,1,1,0]

💡 Note: Bob has only 3 arrows. He competes for sections 8,9,10 (needing 1 arrow each) to get 8+9+10=27 points. Alice gets 2+11=13 points from sections 2,11.

Example 3 — All Arrows to One Section

$ Input: numArrows = 2, aliceArrows = [1,1,1,1,1,1,1,1,1,1,1,1]

› Output: [0,0,0,0,0,0,0,0,0,0,0,2]

💡 Note: Best strategy is to compete only for section 11 (highest value) with 2 arrows, beating Alice's 1 arrow. Bob gets 11 points, Alice gets 0+1+2+3+4+5+6+7+8+9+10=55 points.

Constraints

1 ≤ numArrows ≤ 10⁵
aliceArrows.length == 12
0 ≤ aliceArrows[i] ≤ numArrows
sum(aliceArrows[i]) == numArrows

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 f Meta 8

The key insight is that Bob only needs aliceArrows[i] + 1 arrows to win section i. Best approach is bit manipulation to enumerate all 2^12 possible subsets of sections to compete for. Time: O(2^12), Space: O(1)

Common Approaches

✓ Bit Manipulation - Subset Enumeration

⏱️ Time: O(2^12) Space: O(1)

Use a bitmask to enumerate all possible subsets of sections (0-11) that Bob could compete for. For each subset, calculate the required arrows and score, then find the optimal allocation.

Brute Force - Try All Combinations

⏱️ Time: O(numArrows^12) Space: O(12)

Try every possible way to distribute numArrows arrows across 12 sections. For each distribution, calculate Bob's score and keep track of the maximum.

Bit Manipulation - Subset Enumeration — Algorithm Steps

Step 1: Iterate through all possible bitmasks (2^12 combinations)
Step 2: For each mask, calculate arrows needed and points gained
Step 3: If feasible, allocate remaining arrows to section 0 and update best result

Visualization

Tap to expand

Step-by-Step Walkthrough

Enumerate

Use bitmask to represent which sections Bob competes for

Calculate

For each valid subset, compute required arrows and score

Optimize

Find the subset that maximizes Bob's score

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void solution(int numArrows, int* aliceArrows, int* result) {
    int maxScore = 0;
    memset(result, 0, 12 * sizeof(int));
    
    // Try all possible subsets of sections to compete for
    for (int mask = 0; mask < (1 << 12); mask++) {
        int arrowsNeeded = 0;
        int score = 0;
        
        // Calculate arrows needed and score for this subset
        for (int i = 0; i < 12; i++) {
            if (mask & (1 << i)) {
                arrowsNeeded += aliceArrows[i] + 1;
                score += i;
            }
        }
        
        // If we can afford this combination
        if (arrowsNeeded <= numArrows) {
            // Allocate arrows
            int bobArrows[12] = {0};
            for (int i = 0; i < 12; i++) {
                if (mask & (1 << i)) {
                    bobArrows[i] = aliceArrows[i] + 1;
                }
            }
            
            // Put remaining arrows in section 0 if we're not competing for it
            // Otherwise, put them in the lowest competing section
            int remaining = numArrows - arrowsNeeded;
            if (remaining > 0) {
                if (!(mask & 1)) {  // Not competing for section 0
                    bobArrows[0] = remaining;
                } else {
                    // Find the lowest section we're competing for
                    for (int i = 0; i < 12; i++) {
                        if (mask & (1 << i)) {
                            bobArrows[i] += remaining;
                            break;
                        }
                    }
                }
            }
            
            if (score > maxScore) {
                maxScore = score;
                memcpy(result, bobArrows, 12 * sizeof(int));
            }
        }
    }
}

int main() {
    int numArrows;
    scanf("%d", &numArrows);
    
    int aliceArrows[12];
    char c;
    scanf(" %c", &c); // consume '['
    for (int i = 0; i < 12; i++) {
        scanf("%d", &aliceArrows[i]);
        if (i < 11) scanf("%c", &c); // consume ','
    }
    scanf("%c", &c); // consume ']'
    
    int result[12];
    solution(numArrows, aliceArrows, result);
    
    printf("[");
    for (int i = 0; i < 12; i++) {
        printf("%d", result[i]);
        if (i < 11) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^12)

Iterate through all 2^12 = 4096 possible subsets of sections to compete for

✓ Linear Growth

Space Complexity

O(1)

Only use constant extra space for variables and result array

✓ Linear Space

28.5K Views

Medium Frequency

~35 min Avg. Time

924 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bit Manipulation - Subset Enumeration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler