Teemo Attacking - Practice Coding Problems

Teemo Attacking - Problem

Array Simulation Easy

Teemo's Poison Attack Challenge

In the world of League of Legends, our swift scout Teemo is unleashing poison attacks on the enemy champion Ashe! Each poison attack has a devastating effect that lasts for a specific duration.

How Poison Works:
• When Teemo attacks at second t, Ashe becomes poisoned for the time interval [t, t + duration - 1]
• If Teemo attacks again before the poison wears off, the poison timer resets to the new attack time
• Only one poison effect can be active at a time

Your Mission:
Given an array timeSeries representing when Teemo attacks (in chronological order) and the duration of each poison effect, calculate the total seconds that Ashe remains poisoned.

Example: If attacks happen at [1, 4] with duration 2:
• Attack 1: Poison active from second 1-2
• Attack 4: Poison active from second 4-5
• Total poisoned time: 4 seconds

Input & Output

example_1.py — Basic Case

$ Input: timeSeries = [1,4], duration = 2

› Output: 4

💡 Note: Attack at time 1: poison active from 1-2 (2 seconds). Attack at time 4: poison active from 4-5 (2 seconds). Total: 4 seconds. The poison effects don't overlap since there's a gap between times 2 and 4.

example_2.py — Overlapping Attacks

$ Input: timeSeries = [1,2], duration = 2

› Output: 3

💡 Note: Attack at time 1: poison would last 1-2, but attack at time 2 resets the timer. So poison is active from 1-3 continuously (3 seconds total). The second attack extends the poison duration rather than adding separate durations.

example_3.py — Single Attack

$ Input: timeSeries = [5], duration = 3

› Output: 3

💡 Note: Only one attack at time 5, so poison lasts for the full duration from time 5-7, which is exactly 3 seconds.

Constraints

1 ≤ timeSeries.length ≤ 10⁴
0 ≤ timeSeries[i], duration ≤ 10⁷
timeSeries is sorted in non-decreasing order

Visualization

Tap to expand

Understanding the Visualization

First Attack

Start poison timer counting down from full duration

Next Attack Check

If next attack comes before timer reaches 0, reset timer; otherwise count full duration

Sum Total Time

Add up all the time poison was actually active

Key Takeaway

🎯 Key Insight: Instead of simulating every second, we calculate poison duration by comparing the time gap between consecutive attacks with the poison duration. This reduces complexity from O(n×m) to O(n).

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 Apple 5

The optimal approach uses a single pass through the attacks array, comparing consecutive attacks to calculate poison duration. For each pair of attacks, we add min(gap, duration) to our total, plus the full duration for the final attack. This gives us O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Second)	O(n * m)	O(1)	Check every second from first to last attack to see if poison is active
One-Pass Optimal Solution	O(n)	O(1)	Compare consecutive attacks to calculate poison duration efficiently

Brute Force (Check Every Second) — Algorithm Steps

Find the time range from first attack to last attack + duration
For each second in this range, check if it's covered by any attack's poison
Count all seconds where poison is active
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup Range

Determine time range from first attack to last poison end

Check Each Second

For each second, scan all attacks to see if poison is active

Count Poisoned Time

Increment counter for each poisoned second found

Code -

solution.c — C

#include <stdio.h>

int findPoisonedDuration(int* timeSeries, int timeSeriesSize, int duration) {
    if (timeSeriesSize == 0) return 0;
    
    int startTime = timeSeries[0];
    int endTime = timeSeries[timeSeriesSize - 1] + duration - 1;
    
    int poisonedSeconds = 0;
    
    // Check every second in the range
    for (int currentTime = startTime; currentTime <= endTime; currentTime++) {
        // Check if currentTime is covered by any attack
        for (int i = 0; i < timeSeriesSize; i++) {
            if (timeSeries[i] <= currentTime && currentTime <= timeSeries[i] + duration - 1) {
                poisonedSeconds++;
                break;
            }
        }
    }
    
    return poisonedSeconds;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

Where n is number of attacks and m is the time range from first to last attack

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track time and count

✓ Linear Space

23.8K Views

Medium Frequency

~15 min Avg. Time

892 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 (Check Every Second) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler