Find Mirror Score of a String

Find Mirror Score of a String - Problem

You are given a string s. We define the mirror of a letter in the English alphabet as its corresponding letter when the alphabet is reversed. For example, the mirror of 'a' is 'z', and the mirror of 'y' is 'b'.

Initially, all characters in the string s are unmarked. You start with a score of 0, and you perform the following process on the string s:

Iterate through the string from left to right.
At each index i, find the closest unmarked index j such that j < i and s[j] is the mirror of s[i].
Then, mark both indices i and j, and add the value i - j to the total score.
If no such index j exists for the index i, move on to the next index without making any changes.

Return the total score at the end of the process.

Input & Output

Example 1 — Basic Mirror Matching

$ Input: s = "abccba"

› Output: 0

💡 Note: Process each character: 'a' at 0 (no mirror 'z' before), 'b' at 1 (no mirror 'y' before), 'c' at 2 (no mirror 'x' before), 'c' at 3 (no mirror 'x' before), 'b' at 4 (no mirror 'y' before), 'a' at 5 (no mirror 'z' before). No matches found, so score = 0.

Example 2 — No Mirrors Available

$ Input: s = "abc"

› Output: 0

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

Example 3 — Multiple Mirror Matches

$ Input: s = "azba"

› Output: 1

💡 Note: 'a' at 0 (no mirror 'z' before), 'z' at 1 finds mirror 'a' at 0, score += 1-0 = 1, 'b' at 2 (no mirror 'y' before), 'a' at 3 (mirror 'z' at 1 is already marked). Total score = 1.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only

Visualization

Tap to expand

Asked in

M Microsoft 15 a Amazon 12

The key insight is using stacks to efficiently find the closest unmarked mirror character. Each letter maintains a stack of its unmarked positions, and when we need a mirror, we pop from the corresponding stack. Best approach is stack-based solution with Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force

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

Iterate through each character and for each one, search backwards through all previous characters to find the closest unmarked character that is its mirror. Mark both and add distance to score.

Stack Approach

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

Maintain 26 stacks (one for each letter) to store indices of unmarked characters. For each character, check if its mirror has any unmarked indices in the corresponding stack, pop the most recent one for O(1) lookup.

Brute Force — Algorithm Steps

For each character i from left to right
Search backwards from i-1 to 0 for closest unmarked mirror
If found, mark both characters and add distance to score

Visualization

Tap to expand

Step-by-Step Walkthrough

Current Character

Process character at index i

Search Backwards

Scan from i-1 to 0 for unmarked mirror

Match Found

Mark both and add distance to score

Code -

solution.c — C

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

int solution(char* s) {
    int n = strlen(s);
    bool* marked = (bool*)calloc(n, sizeof(bool));
    int score = 0;
    
    for (int i = 0; i < n; i++) {
        // Find mirror character
        char mirror = 'z' - (s[i] - 'a');
        
        // Search backwards for closest unmarked mirror
        for (int j = i - 1; j >= 0; j--) {
            if (!marked[j] && s[j] == mirror) {
                marked[i] = true;
                marked[j] = true;
                score += i - j;
                break;
            }
        }
    }
    
    free(marked);
    return score;
}

int main() {
    char s[100001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0; // Remove newline
    int result = solution(s);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n characters, we potentially scan through all previous characters

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a boolean array to track marked characters

✓ Linear Space

23.0K 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler