The Number of Weak Characters in the Game

The Number of Weak Characters in the Game - Problem

🎮 The Number of Weak Characters in the Game

Welcome to an epic RPG battle arena! You're analyzing character statistics to determine which heroes need power-ups.

You have a collection of game characters, each with two crucial combat stats: attack and defense. Your mission is to identify how many characters are considered weak in the current meta.

A character is weak if there exists at least one other character who completely dominates them - meaning that other character has both higher attack and higher defense values.

Input: A 2D array properties where properties[i] = [attack_i, defense_i] represents the combat stats of the i-th character.

Output: Return the total count of weak characters who are completely outclassed by at least one other character.

Example: If Character A has [5, 5] and Character B has [6, 6], then Character A is weak because Character B dominates in both stats.

Input & Output

example_1.py — Basic Characters

$ Input: properties = [[2,2],[3,3]]

› Output: 1

💡 Note: The first character [2,2] is weak because the second character [3,3] has both higher attack (3 > 2) and higher defense (3 > 2). The second character [3,3] is not weak since no other character dominates it in both stats.

example_2.py — Multiple Characters

$ Input: properties = [[5,5],[6,3],[3,6]]

› Output: 0

💡 Note: No character is weak. Character [5,5] vs [6,3]: 6>5 but 3<5. Character [5,5] vs [3,6]: 3<5 but 6>5. Each character has at least one stat that's not strictly dominated by others.

example_3.py — Complex Scenario

$ Input: properties = [[1,5],[10,4],[4,3]]

› Output: 1

💡 Note: Character [4,3] is weak because character [10,4] has both higher attack (10 > 4) and higher defense (4 > 3). Characters [1,5] and [10,4] don't dominate each other completely.

Constraints

2 ≤ properties.length ≤ 10⁵
properties[i].length == 2
1 ≤ attack_i, defense_i ≤ 10⁵
All characters have positive integer stats

Visualization

Tap to expand

Understanding the Visualization

Arrange by Attack Power

Sort all characters by attack strength (highest first)

Track Defense Champions

Use a stack to remember the strongest defenders seen so far

Identify the Weak

Any character facing a stronger defender with higher attack is weak

Key Takeaway

🎯 Key Insight: By sorting characters by attack power and using a monotonic stack to track defense values, we can efficiently identify weak characters without comparing everyone to everyone!

Asked in

G Google 45 a Amazon 38 f Meta 28 ⊞ Microsoft 22

The optimal approach uses sorting + monotonic stack in O(n log n) time. Key insight: sort by attack descending and defense ascending, then use a monotonic decreasing stack to efficiently track the maximum defense values among characters with higher attacks.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Monotonic Stack (Optimal)	O(n log n)	O(n)	Sort by attack, then use stack to track maximum defense efficiently
Brute Force (Nested Loops)	O(n²)	O(1)	Compare every character against every other character

Sorting + Monotonic Stack (Optimal) — Algorithm Steps

Sort characters by attack descending, then by defense ascending (to handle ties properly)
Use a monotonic decreasing stack to track maximum defense values seen so far
For each character, check if stack top has higher defense (meaning this character is weak)
Maintain the stack by removing elements with defense ≤ current character's defense
Count weak characters during the traversal

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Characters

Sort by attack descending, defense ascending for ties

Process with Stack

Use monotonic stack to track maximum defense values

Check Weakness

If stack top > current defense, character is weak

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    int* charA = *(int**)a;
    int* charB = *(int**)b;
    if (charA[0] != charB[0]) {
        return charB[0] - charA[0]; // attack descending
    }
    return charA[1] - charB[1]; // defense ascending
}

int numberOfWeakCharacters(int** properties, int propertiesSize, int* propertiesColSize) {
    qsort(properties, propertiesSize, sizeof(int*), compare);
    
    int* stack = (int*)malloc(propertiesSize * sizeof(int));
    int stackSize = 0;
    int weakCount = 0;
    
    for (int i = 0; i < propertiesSize; i++) {
        int attack = properties[i][0];
        int defense = properties[i][1];
        
        // Check if current character is weak
        if (stackSize > 0 && stack[stackSize-1] > defense) {
            weakCount++;
        }
        
        // Maintain monotonic decreasing stack
        while (stackSize > 0 && stack[stackSize-1] <= defense) {
            stackSize--;
        }
        stack[stackSize++] = defense;
    }
    
    free(stack);
    return weakCount;
}

int main() {
    int row1[] = {2, 2};
    int row2[] = {3, 3};
    int* properties[] = {row1, row2};
    int colSizes[] = {2, 2};
    
    printf("%d\n", numberOfWeakCharacters(properties, 2, colSizes));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting step, stack operations are O(n) total

⚡ Linearithmic

Space Complexity

O(n)

Stack can hold up to n elements in worst case, plus sorting space

⚡ Linearithmic Space

41.2K Views

High 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

🎮 The Number of Weak Characters in the Game

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Sorting + Monotonic Stack (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler