Teemo Attacking

Teemo Attacking - Problem

Array Simulation Easy

Our hero Teemo is attacking an enemy Ashe with poison attacks! When Teemo attacks Ashe, Ashe gets poisoned for exactly duration seconds.

More formally, an attack at second t will mean Ashe is poisoned during the inclusive time interval [t, t + duration - 1]. If Teemo attacks again before the poison effect ends, the timer for it is reset, and the poison effect will end duration seconds after the new attack.

You are given a non-decreasing integer array timeSeries, where timeSeries[i] denotes that Teemo attacks Ashe at second timeSeries[i], and an integer duration. Return the total number of seconds that Ashe is poisoned.

Input & Output

Example 1 — Basic Case

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

› Output: 4

💡 Note: Attack at t=1: poison from [1,2]. Attack at t=4: poison from [4,5]. Total: 2 + 2 = 4 seconds

Example 2 — Overlapping Attacks

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

› Output: 3

💡 Note: Attack at t=1: poison [1,2]. Attack at t=2 resets timer: poison [2,3]. Total unique seconds: 1,2,3 = 3 seconds

Example 3 — Single Attack

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

› Output: 3

💡 Note: Only one attack at t=1, poison lasts for 3 seconds: [1,2,3]

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that consecutive attacks either overlap or don't - we only need to add the minimum of the gap between attacks and the poison duration. The optimal approach uses gap analysis to calculate poison time in O(n) time and O(1) space.

Common Approaches

✓ Brute Force - Track Every Second

⏱️ Time: O(n × duration) Space: O(max_time)

Create a boolean array to track which seconds are poisoned. For each attack, mark the next duration seconds as poisoned. Count total poisoned seconds.

Optimized - Gap Analysis

⏱️ Time: O(n) Space: O(1)

For each consecutive pair of attacks, determine if they overlap. If the gap between attacks is smaller than duration, add the gap. Otherwise, add full duration.

Brute Force - Track Every Second — Algorithm Steps

Create boolean array for all time ranges
For each attack, mark duration seconds as poisoned
Count total true values

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create boolean array for all time slots

Mark Poison

For each attack, mark duration seconds as true

Count

Sum up all true values

Code -

solution.c — C

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

int solution(int* timeSeries, int timeSeriesSize, int duration) {
    if (timeSeriesSize == 0 || duration == 0) {
        return 0;
    }
    
    int maxTime = timeSeries[timeSeriesSize - 1] + duration;
    bool* poisoned = (bool*)calloc(maxTime + 1, sizeof(bool));
    
    for (int i = 0; i < timeSeriesSize; i++) {
        int attackTime = timeSeries[i];
        for (int t = attackTime; t < attackTime + duration && t <= maxTime; t++) {
            poisoned[t] = true;
        }
    }
    
    int count = 0;
    for (int i = 0; i <= maxTime; i++) {
        if (poisoned[i]) count++;
    }
    
    free(poisoned);
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int timeSeries[10000];
    int size = 0;
    
    // Remove brackets and parse
    char* start = strchr(line, '[');
    char* end = strchr(line, ']');
    if (start && end && start < end) {
        start++;
        *end = '\0';
        
        if (start < end) {  // Not empty array
            char* token = strtok(start, ",");
            while (token != NULL) {
                // Skip whitespace
                while (isspace(*token)) token++;
                if (*token) {
                    timeSeries[size++] = atoi(token);
                }
                token = strtok(NULL, ",");
            }
        }
    }
    
    int duration;
    scanf("%d", &duration);
    
    printf("%d\n", solution(timeSeries, size, duration));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × duration)

For each of n attacks, we mark duration seconds as poisoned

✓ Linear Growth

Space Complexity

O(max_time)

Boolean array to track poison status for each second up to maximum time

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

890 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 - Track Every Second — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler