Longest Nice Substring - Practice Coding Problems

Longest Nice Substring - Problem

A string is considered "nice" if for every letter of the alphabet that appears in the string, both its uppercase and lowercase versions are present.

For example:

"abABB" is nice because 'A' and 'a' both appear, and 'B' and 'b' both appear
"abA" is not nice because 'b' appears but 'B' does not
"YazaAay" is nice because 'Y','y', 'a','A', and 'z','Z' all have their pairs

Goal: Find the longest substring that is nice. If multiple substrings have the same maximum length, return the one that appears earliest in the string. If no nice substring exists, return an empty string.

Input & Output

example_1.py — Basic Nice String

$ Input: s = "abABB"

› Output: "abABB"

💡 Note: The whole string is nice because 'a' and 'A' are both present, and 'b' and 'B' are both present. This is the longest possible nice substring.

example_2.py — Partial Nice String

$ Input: s = "abA"

› Output: ""

💡 Note: The string contains 'b' but not 'B', so no substring can be nice. The longest nice substring has length 0.

example_3.py — Multiple Nice Substrings

$ Input: s = "YazaAay"

› Output: "aAay"

💡 Note: There are nice substrings like "aA" (length 2) and "aAay" (length 4). We return "aAay" as it's the longest nice substring.

Visualization

Tap to expand

Understanding the Visualization

Identify Solo Dancers

Find characters that don't have their case partner in the string - these are 'solo dancers' who can't participate in any nice dance group

Split the Ballroom

Divide the ballroom (string) at solo dancer positions since they can't be part of any valid dance group

Check Each Section

Recursively check each section of the ballroom to find the largest valid dance group

Return Best Group

Compare all valid dance groups found and return the largest one

Key Takeaway

🎯 Key Insight: Characters without case partners act as natural "barriers" that split the problem, making divide-and-conquer the optimal approach with O(n) time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) to generate all substrings, O(n) to check each substring

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a constant amount of extra space for tracking characters

✓ Linear Space

Constraints

1 ≤ s.length ≤ 100
s consists of uppercase and lowercase English letters only
Nice substring must have at least 2 characters

Asked in

f Facebook 25 a Amazon 18 G Google 15 ⊞ Microsoft 12

The optimal solution uses divide and conquer with a key insight: any character without its case partner acts as a "barrier" - no nice substring can contain it. We split the string at such characters and recursively solve subproblems, achieving O(n) time complexity instead of the brute force O(n³) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n³)	O(1)	Check every possible substring to see if it's nice, keeping track of the longest one
Divide and Conquer (Optimal)	O(n)	O(n)	Split the string at characters that don't have their case partner, recursively solve subproblems

Brute Force (Check All Substrings) — Algorithm Steps

Generate all possible substrings using nested loops
For each substring, create a set of all characters present
Check if every character has both uppercase and lowercase versions
Keep track of the longest nice substring found
Return the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Start with the first character and generate all substrings beginning from that position

Check Nice Property

For each substring, verify if every character has both upper and lower case versions

Track Maximum

Keep track of the longest nice substring found so far

Continue Process

Move to the next starting position and repeat the process

Code -

solution.c — C

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

char* longestNiceSubstring(char* s) {
    int len = strlen(s);
    if (len < 2) {
        char* result = malloc(1);
        result[0] = '\0';
        return result;
    }
    
    char* longest = malloc(len + 1);
    longest[0] = '\0';
    int maxLen = 0;
    
    for (int i = 0; i < len; i++) {
        for (int j = i + 2; j <= len; j++) {
            bool charPresent[128] = {false};
            
            // Mark characters as present
            for (int k = i; k < j; k++) {
                charPresent[(int)s[k]] = true;
            }
            
            // Check if nice
            bool isNice = true;
            for (int k = i; k < j && isNice; k++) {
                char c = s[k];
                char swapped = isupper(c) ? tolower(c) : toupper(c);
                if (!charPresent[(int)swapped]) {
                    isNice = false;
                }
            }
            
            if (isNice && (j - i) > maxLen) {
                maxLen = j - i;
                strncpy(longest, s + i, j - i);
                longest[j - i] = '\0';
            }
        }
    }
    
    return longest;
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = '\0';  // Remove newline
    
    char* result = longestNiceSubstring(s);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) to generate all substrings, O(n) to check each substring

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a constant amount of extra space for tracking characters

✓ Linear Space

Constraints

1 ≤ s.length ≤ 100
s consists of uppercase and lowercase English letters only
Nice substring must have at least 2 characters

28.5K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler