Plates Between Candles - Practice Coding Problems

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.

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

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!

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
✓ 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)	O(N + Q)	O(N)	Precompute candle positions and plate prefix sums for O(log n) query answering

Brute Force (Nested Loops) — Algorithm Steps

For each query [left, right], extract the substring
Find the first candle position from the left
Find the last candle position from the right
Count all plates between these two candle positions
Store the result for this query

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Query

Extract substring for current query range

Find Boundaries

Scan left-to-right for first candle, right-to-left for last candle

Count Plates

Count all plates between the boundary candles

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* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int q = 0; q < queriesSize; q++) {
        int left = queries[q][0];
        int right = queries[q][1];
        
        // Find first candle from left
        int firstCandle = -1;
        for (int i = left; i <= right; i++) {
            if (s[i] == '|') {
                firstCandle = i;
                break;
            }
        }
        
        // Find last candle from right
        int lastCandle = -1;
        for (int i = right; i >= left; i--) {
            if (s[i] == '|') {
                lastCandle = i;
                break;
            }
        }
        
        // Count plates between candles
        int count = 0;
        if (firstCandle != -1 && lastCandle != -1 && firstCandle < lastCandle) {
            for (int i = firstCandle; i <= lastCandle; i++) {
                if (s[i] == '*') {
                    count++;
                }
            }
        }
        
        result[q] = count;
    }
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(Q × N)

For Q queries, each query processes up to N characters in the worst case

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track positions and counts

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler