Maximum Points in an Archery Competition - Practice Coding Problems

Maximum Points in an Archery Competition - Problem

🏹 Archery Competition Strategy

In this competitive archery challenge, you need to help Bob optimize his shooting strategy to maximize his points against Alice.

Competition Rules:
• The target has 12 scoring sections numbered from 0 to 11
• Alice shoots first with numArrows arrows
• Bob shoots second with the same numArrows arrows
• For each section k: whoever shoots more arrows wins k points
• If tied (both shoot same number), Alice wins (she shot first)
• If both shoot 0 arrows, nobody gets points

Your Task: Given Alice's arrow distribution in aliceArrows[12], determine Bob's optimal strategy to maximize his total points. Return Bob's arrow distribution as bobArrows[12].

Key Insight: Bob only needs to shoot one more arrow than Alice in any section to win those points completely!

Input & Output

example_1.py — Basic 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 by shooting 1,1,1,2,3,1 arrows respectively (just one more than Alice in each). This gives him 4+5+8+9+10+11=47 points total using exactly 9 arrows.

example_2.py — Focus High Value

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

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

💡 Note: With only 3 arrows, Bob should focus on sections 8,9,10 (need 1 arrow each since Alice shot 1). This gives 8+9+10=27 points, which is better than competing for section 11 (needs 3 arrows for only 11 points).

example_3.py — All Remaining Arrows

$ Input: numArrows = 89, aliceArrows = [3,2,28,1,7,1,16,24,0,3,2,2]

› Output: [81,0,29,0,8,0,17,25,1,0,0,3]

💡 Note: Bob competes for sections 2,4,6,7,8,11 and puts remaining 81 arrows in section 0. Even though section 0 gives 0 points, we need to use all arrows as required.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Analyze Alice's Strategy

Look at how Alice distributed her arrows across all 12 sections. This tells us the minimum cost to compete for each section.

Calculate Cost vs Benefit

For each section, the cost is (Alice's arrows + 1) and benefit is the section number. Section 11 gives most points but might be expensive.

Find Optimal Combination

Use bit manipulation to try all possible subsets of sections to compete for. Each bit represents whether to compete for that section.

Distribute Remaining Arrows

After competing for chosen sections, put any remaining arrows in section 0 to satisfy the constraint of using all arrows.

Key Takeaway

🎯 Key Insight: This is an optimization problem disguised as a game theory problem. The key insight is recognizing that Bob only needs to spend exactly (Alice's arrows + 1) to win any section completely, making it a subset selection problem that can be solved efficiently with bit manipulation.

Asked in

A Amazon 45 G Google 32 M Microsoft 28 f Meta 22

The optimal approach uses bit manipulation to enumerate all 2^12 possible competition strategies. For each bitmask representing which sections to compete for, calculate the arrows needed (Alice's arrows + 1 per section) and points gained. The key insight is that Bob only needs to shoot one more arrow than Alice in any section to win all points for that section. This gives us O(2^12) time complexity, which is very efficient for the small constraint of 12 sections.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Backtracking	O(C(n+11, 11))	O(12)	Try all possible ways to distribute Bob's arrows using recursive backtracking
Bit Manipulation Enumeration (Optimal)	O(2^12)	O(1)	Use bit manipulation to efficiently try all possible subsets of sections to compete for

Brute Force Backtracking — Algorithm Steps

Use recursive backtracking to generate all possible arrow distributions
For each complete distribution, calculate Bob's total score
Keep track of the maximum score and corresponding distribution
Return the distribution that gives maximum points

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at section 0

Begin with 0 arrows distributed and full arrow count available

For each section

Decide: compete (spend arrows) or skip (save arrows)

Explore both branches

Recursively try both competing and not competing

Backtrack and try alternatives

Undo choices and explore other possibilities

Code -

solution.c — C

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

int maxScore = 0;
int bestDistribution[12];

void backtrack(int section, int remainingArrows, int* currentDistribution, int currentScore, int* aliceArrows) {
    if (section == 12) {
        if (remainingArrows >= 0) {
            int finalDistribution[12];
            memcpy(finalDistribution, currentDistribution, 12 * sizeof(int));
            finalDistribution[0] += remainingArrows;
            if (currentScore > maxScore) {
                maxScore = currentScore;
                memcpy(bestDistribution, finalDistribution, 12 * sizeof(int));
            }
        }
        return;
    }
    
    // Don't compete
    backtrack(section + 1, remainingArrows, currentDistribution, currentScore, aliceArrows);
    
    // Compete
    int needed = aliceArrows[section] + 1;
    if (remainingArrows >= needed) {
        currentDistribution[section] = needed;
        backtrack(section + 1, remainingArrows - needed, currentDistribution, currentScore + section, aliceArrows);
        currentDistribution[section] = 0;
    }
}

int* maximumBobPoints(int numArrows, int* aliceArrows) {
    maxScore = 0;
    memset(bestDistribution, 0, 12 * sizeof(int));
    int currentDistribution[12] = {0};
    backtrack(0, numArrows, currentDistribution, 0, aliceArrows);
    return bestDistribution;
}

int main() {
    int numArrows;
    scanf("%d", &numArrows);
    int aliceArrows[12];
    for (int i = 0; i < 12; i++) {
        scanf("%d", &aliceArrows[i]);
    }
    int* result = maximumBobPoints(numArrows, aliceArrows);
    for (int i = 0; i < 12; i++) {
        printf("%d%c", result[i], i == 11 ? '\n' : ' ');
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(n+11, 11))

Number of ways to distribute n arrows among 12 sections using stars and bars

✓ Linear Growth

Space Complexity

O(12)

Recursion depth is at most 12 (number of sections)

✓ Linear Space

52.4K Views

Medium Frequency

~18 min Avg. Time

1.8K 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

Brute Force Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler