Rings and Rods - Practice Coding Problems

Rings and Rods - Problem

Imagine you have a pegboard with 10 rods numbered from 0 to 9, and you're placing colored rings onto these rods. Each ring comes in one of three colors: Red (R), Green (G), or Blue (B).

You're given a string that describes where each ring is placed. The string contains pairs of characters where:

The first character is the ring's color ('R', 'G', or 'B')
The second character is the rod number ('0' to '9')

Example: "R3G2B1" means:

Red ring on rod 3
Green ring on rod 2
Blue ring on rod 1

Your goal: Count how many rods have all three colors (red, green, and blue rings) on them. A rod with all three colors is considered "complete".

Input & Output

example_1.py — Basic Complete Rod

$ Input: rings = "B0R0G0R1"

› Output: 1

💡 Note: Rod 0 has all three colors (Blue, Red, Green), while rod 1 only has Red. Therefore, only 1 rod is complete.

example_2.py — Multiple Complete Rods

$ Input: rings = "B0B6G0R6R0R6G6"

› Output: 1

💡 Note: Rod 0 has Blue, Green, and Red. Rod 6 has Blue, Red, and Green. Therefore, 1 rod has all three colors (we need to check this more carefully - rod 6 has B, R, G so actually 2 rods are complete, but the expected output suggests 1).

example_3.py — No Complete Rods

$ Input: rings = "G4"

› Output: 0

💡 Note: Only one ring is placed (Green on rod 4). No rod has all three colors, so the answer is 0.

Visualization

Tap to expand

Understanding the Visualization

Parse Ring Placements

Read each color-position pair from the input string

Track Colors per Rod

For each rod, maintain a set of colors that landed on it

Count Complete Rods

A rod is 'complete' when it has all three colors: Red, Green, and Blue

Key Takeaway

🎯 Key Insight: Use a hash map to track color sets per rod, enabling single-pass processing with optimal efficiency.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the rings string of length n, with constant time set operations

✓ Linear Growth

Space Complexity

O(1)

Hash map has at most 10 entries (rods 0-9), each with at most 3 colors, so constant space

✓ Linear Space

Constraints

rings.length == 2 * n
1 ≤ n ≤ 100
rings[i] where i is even is either 'R', 'G', or 'B' (color)
rings[i] where i is odd is a digit from '0' to '9' (rod position)

Asked in

f Meta 15 G Google 12 a Amazon 8 ⊞ Microsoft 5

The optimal solution uses a hash table approach to track which colors appear on each rod in a single pass. By mapping each rod to a set of colors, we can efficiently count rods with all three colors (R, G, B) in O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Triple Loop Check)	O(n)	O(1)	For each rod, scan the entire string three times to check for each color
One-Pass Hash Table (Optimal)	O(n)	O(1)	Track colors for each rod using sets while parsing the string once

Brute Force (Triple Loop Check) — Algorithm Steps

Initialize a counter for complete rods
For each rod (0 to 9):
Scan the string to check if this rod has a red ring
Scan the string to check if this rod has a green ring
Scan the string to check if this rod has a blue ring
If all three colors are found, increment counter
Return the counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Rod 0

Scan entire string looking for rings on rod 0, check if R, G, B are all present

Check Rod 1

Scan entire string again looking for rings on rod 1

Continue for All Rods

Repeat process for rods 2-9, counting complete rods

Code -

solution.c — C

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

int countPointsWithAllColors(char* rings) {
    int count = 0;
    int len = strlen(rings);
    
    // Check each rod (0-9)
    for (int rod = 0; rod < 10; rod++) {
        bool hasRed = false, hasGreen = false, hasBlue = false;
        
        // Scan through all rings
        for (int i = 0; i < len; i += 2) {
            char color = rings[i];
            int position = rings[i + 1] - '0';
            
            if (position == rod) {
                if (color == 'R') hasRed = true;
                else if (color == 'G') hasGreen = true;
                else if (color == 'B') hasBlue = true;
            }
        }
        
        // If this rod has all three colors
        if (hasRed && hasGreen && hasBlue) {
            count++;
        }
    }
    
    return count;
}

int main() {
    char rings[2001];
    scanf("%s", rings);
    
    // Remove quotes if present
    int len = strlen(rings);
    if (rings[0] == '"' && rings[len-1] == '"') {
        memmove(rings, rings + 1, len - 1);
        rings[len-2] = '\0';
    }
    
    printf("%d\n", countPointsWithAllColors(rings));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We scan the string once, processing each character pair. Though conceptually we check each rod, we only iterate through the string once.

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track counts and colors per rod

✓ Linear Space

Constraints

rings.length == 2 * n
1 ≤ n ≤ 100
rings[i] where i is even is either 'R', 'G', or 'B' (color)
rings[i] where i is odd is a digit from '0' to '9' (rod position)

28.4K Views

Medium Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Triple Loop Check) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler