Find Mirror Score of a String - Practice Coding Problems

Find Mirror Score of a String - Problem

You are given a string s containing lowercase English letters. Your task is to calculate the mirror score of this string through a fascinating character-matching process.

What is a mirror character?
Each letter in the English alphabet has a corresponding mirror letter when the alphabet is reversed:
• 'a' ↔ 'z'
• 'b' ↔ 'y'
• 'c' ↔ 'x'
• ... and so on

The Process:

Start with a score of 0 and all characters unmarked
Iterate through the string from left to right
For each character at index i, find the closest unmarked index j where:
• j < i (must be to the left)
• s[j] is the mirror of s[i]
• Neither i nor j is already marked
If such a j exists, mark both indices and add i - j to your score
If no such j exists, continue to the next character

Goal: Return the total score after processing all characters.

Input & Output

example_1.py — Basic Mirror Matching

$ Input: s = "abcdef"

› Output: 0

💡 Note: No character has its mirror appearing before it in the string, so no matches are possible and the score remains 0.

example_2.py — Perfect Mirror Pairs

$ Input: s = "za"

› Output: 1

💡 Note: When processing 'a' at index 1, we find its mirror 'z' at index 0. Score = 1 - 0 = 1.

example_3.py — Multiple Matches

$ Input: s = "zaby"

› Output: 2

💡 Note: Processing 'a' at index 1: finds 'z' at index 0, score += 1. Processing 'y' at index 3: finds 'b' at index 2, score += 1. Total score = 2.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
Each character can only be used in at most one pair

Visualization

Tap to expand

Understanding the Visualization

Dancers Enter One by One

Each dancer represents a character in the string, entering in sequence

Look for Compatible Partner

New dancer looks for most recent unpaired dancer with complementary style (mirror character)

Calculate Chemistry Score

If match found, pair them up and earn points equal to their entrance time difference

Optimal Stack Organization

Use separate waiting areas (stacks) for each dance style - newest person is always at the front of their line

Key Takeaway

🎯 Key Insight: Using stacks for each character type allows us to instantly find the closest unmatched mirror character in O(1) time, making the overall solution O(n) instead of O(n²).

Asked in

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

The optimal solution uses a stack-based approach with O(n) time complexity. We maintain 26 stacks (one for each letter) to store indices of unmatched characters. For each character, we check if its mirror character's stack has any elements - if yes, we pop the most recent one (closest match) and add the distance to our score. The key insight is that stack's LIFO property automatically gives us the closest unmatched mirror character.

Common Approaches

Approach	Time	Space	Notes
✓ Stack-based Approach (Optimal)	O(n)	O(n)	Use stacks to track unmatched characters for instant closest match lookup
Brute Force (Nested Loops)	O(n²)	O(n)	For each character, scan backwards to find the closest unmarked mirror

Stack-based Approach (Optimal) — Algorithm Steps

Create 26 stacks, one for each letter a-z
For each character at index i:
Calculate its mirror character
Check if the stack for mirror character is non-empty
If yes, pop the top element (closest unmarked mirror) and add distance to score
If no, push current index to the stack for current character

Visualization

Tap to expand

Step-by-Step Walkthrough

Process 'z' at index 0

No mirror 'a' in stack, push 0 to stack[25] (z's stack)

Process 'a' at index 1

Found 'z' in stack[25], pop and calculate score: 1-0=1

Process 'b' at index 2

No mirror 'y' in stack, push 2 to stack[1] (b's stack)

Process 'y' at index 3

Found 'b' in stack[1], pop and calculate score: 3-2=1

Code -

solution.c — C

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

typedef struct {
    int* data;
    int top;
    int capacity;
} Stack;

Stack* createStack(int capacity) {
    Stack* stack = (Stack*)malloc(sizeof(Stack));
    stack->data = (int*)malloc(capacity * sizeof(int));
    stack->top = -1;
    stack->capacity = capacity;
    return stack;
}

void push(Stack* stack, int value) {
    stack->data[++stack->top] = value;
}

int pop(Stack* stack) {
    return stack->data[stack->top--];
}

int isEmpty(Stack* stack) {
    return stack->top == -1;
}

int findMirrorScore(char* s) {
    int n = strlen(s);
    Stack* stacks[26];
    
    // Initialize 26 stacks
    for (int i = 0; i < 26; i++) {
        stacks[i] = createStack(n);
    }
    
    int score = 0;
    
    for (int i = 0; i < n; i++) {
        int charIdx = s[i] - 'a';
        int mirrorIdx = 25 - charIdx;
        
        // Check if there's an unmatched mirror character
        if (!isEmpty(stacks[mirrorIdx])) {
            // Pop the closest (most recent) unmatched mirror
            int j = pop(stacks[mirrorIdx]);
            score += i - j;
        } else {
            // No mirror found, add current index to its stack
            push(stacks[charIdx], i);
        }
    }
    
    // Free memory
    for (int i = 0; i < 26; i++) {
        free(stacks[i]->data);
        free(stacks[i]);
    }
    
    return score;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each character is pushed and popped at most once from stacks

✓ Linear Growth

Space Complexity

O(n)

26 stacks can collectively hold at most n elements

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

847 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

Stack-based Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler