Codestin Search App

Plates Between Candles - Problem

Imagine you're at an elegant dinner party where a long dining table is decorated with alternating plates and candles. You're given a string s where '*' represents a plate and '|' represents a candle.

Your task is to answer multiple queries efficiently. For each query [left, right], you need to count how many plates are properly positioned between candles within that substring range.

What makes a plate "between candles"?
A plate is considered between candles if there's at least one candle to its left AND at least one candle to its right within the given substring.

Example: For s = "||**||**|*" and query [3, 8], the substring is "*||**|". The two plates marked with ** in the middle are between candles, so the answer is 2.

Goal: Return an array where each element is the answer to the corresponding query.

Input & Output

example_1.py — Basic Case

$ Input: s = "**|**|***|", queries = [[2,5],[5,9]]

› Output: [2, 3]

💡 Note: Query [2,5]: substring "**|***" has leftmost candle at index 2 and rightmost at index 5, with 2 plates between them. Query [5,9]: substring "|***|" has 3 plates between candles at indices 5 and 9.

example_2.py — Complex Case

$ Input: s = "||**||**|*", queries = [[3,8]]

› Output: [2]

💡 Note: Query [3,8]: substring "*||**|" has first candle at index 4, last candle at index 8. Between these candles are 2 plates (the ** part).

example_3.py — Edge Case

$ Input: s = "***", queries = [[0,2]]

› Output: [0]

💡 Note: No candles in the substring, so no plates can be between candles. Result is 0.

Visualization

Tap to expand

Understanding the Visualization

Setup Phase

Create a map of candle positions and plate counts for quick reference

Query Processing

When guests ask about their section, instantly find the boundary candles

Count Calculation

Use the precomputed data to calculate illuminated plates in constant time

Key Takeaway

🎯 Key Insight: By preprocessing candle positions and plate counts, we transform a potentially expensive O(n) query operation into an instant O(1) lookup, making our dinner party management incredibly efficient!

Time & Space Complexity

Time Complexity

⏱️

O(N + Q)

O(N) for preprocessing, then O(1) for each of Q queries

✓ Linear Growth

Space Complexity

O(N)

Three additional arrays of size N for precomputed data

✓ Linear Space

Constraints

3 ≤ s.length ≤ 10⁵
s consists of '*' and '|' characters only
1 ≤ queries.length ≤ 10⁵
queries[i].length == 2
0 ≤ left_i ≤ right_i < s.length

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 25

The optimal solution uses preprocessing with prefix sums to achieve O(1) query time. We precompute the nearest candle positions for each index and maintain a cumulative count of plates. This allows us to answer any range query instantly using the mathematical property of prefix sums: count(i,j) = prefix[j] - prefix[i].

Common Approaches

Approach	Time	Space	Notes
✓ Prefix Sum + Binary Search (Optimal)	O(N + Q)	O(N)	Precompute candle positions and plate prefix sums for O(log n) query answering
Brute Force (Nested Loops)	O(Q × N)	O(1)	For each query, scan the substring to find plates between candles

Prefix Sum + Binary Search (Optimal) — Algorithm Steps

Precompute leftmost candle position for each index
Precompute rightmost candle position for each index
Create prefix sum array for plate counts
For each query, find the effective candle boundaries
Use prefix sum to count plates between boundaries in O(1)

Visualization

Tap to expand

Step-by-Step Walkthrough

Preprocess Arrays

Build left candle, right candle, and prefix sum arrays

Find Boundaries

Use precomputed arrays to instantly find effective boundaries

Calculate Result

Use prefix sum difference to get plate count in O(1)

Code -

solution.c — C

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

int* platesBetweenCandles(char* s, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    int n = strlen(s);
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    // Precompute nearest candle to the left
    int* leftCandle = (int*)malloc(n * sizeof(int));
    int lastCandle = -1;
    for (int i = 0; i < n; i++) {
        if (s[i] == '|') {
            lastCandle = i;
        }
        leftCandle[i] = lastCandle;
    }
    
    // Precompute nearest candle to the right
    int* rightCandle = (int*)malloc(n * sizeof(int));
    int nextCandle = -1;
    for (int i = n - 1; i >= 0; i--) {
        if (s[i] == '|') {
            nextCandle = i;
        }
        rightCandle[i] = nextCandle;
    }
    
    // Precompute prefix sum of plates
    int* prefixPlates = (int*)malloc((n + 1) * sizeof(int));
    prefixPlates[0] = 0;
    for (int i = 0; i < n; i++) {
        prefixPlates[i + 1] = prefixPlates[i] + (s[i] == '*' ? 1 : 0);
    }
    
    for (int q = 0; q < queriesSize; q++) {
        int left = queries[q][0];
        int right = queries[q][1];
        
        int leftBoundary = rightCandle[left];
        int rightBoundary = leftCandle[right];
        
        if (leftBoundary != -1 && rightBoundary != -1 && leftBoundary < rightBoundary) {
            result[q] = prefixPlates[rightBoundary] - prefixPlates[leftBoundary];
        } else {
            result[q] = 0;
        }
    }
    
    free(leftCandle);
    free(rightCandle);
    free(prefixPlates);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(N + Q)

O(N) for preprocessing, then O(1) for each of Q queries

✓ Linear Growth

Space Complexity

O(N)

Three additional arrays of size N for precomputed data

✓ Linear Space

Constraints

3 ≤ s.length ≤ 10⁵
s consists of '*' and '|' characters only
1 ≤ queries.length ≤ 10⁵
queries[i].length == 2
0 ≤ left_i ≤ right_i < s.length

68.4K Views

Medium Frequency

~25 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Prefix Sum + Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler