Longest Nice Substring

Longest Nice Substring - Problem

A string s is nice if, for every letter of the alphabet that s contains, it appears both in uppercase and lowercase.

For example, "abABB" is nice because 'A' and 'a' appear, and 'B' and 'b' appear. However, "abA" is not nice because 'b' appears lowercase, but 'B' does not appear uppercase.

Given a string s, return the longest substring of s that is nice. If there are multiple longest nice substrings, return the substring of the earliest occurrence. If there are no nice substrings, return an empty string.

Input & Output

Example 1 — Complete Nice String

$ Input: s = "abABB"

› Output: "abABB"

💡 Note: The whole string is nice because 'a' and 'A' both appear, 'b' and 'B' both appear. This is the longest (and only) nice substring.

Example 2 — Partial Nice Substring

$ Input: s = "YazaAay"

› Output: "aAa"

💡 Note: The character 'Y' appears but 'y' does not, and 'z' appears but 'Z' does not. The substring "aAa" is nice because 'a' and 'A' both appear.

Example 3 — No Nice Substring

$ Input: s = "Bb"

› Output: "Bb"

💡 Note: Both 'B' and 'b' appear, making the entire string nice. Length is 2.

Constraints

1 ≤ s.length ≤ 100
s consists of uppercase and lowercase English letters.

Visualization

Tap to expand

Asked in

M Microsoft 15 a Amazon 8

The key insight is that if a character appears without its case partner, it cannot be part of any nice substring. The divide and conquer approach efficiently eliminates impossible characters by splitting the string recursively. Best time complexity: O(n²), Space: O(n).

Common Approaches

✓ Brute Force - Check All Substrings

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

Generate all possible substrings and for each one, verify if every character has both its uppercase and lowercase versions present. Keep track of the longest valid substring found.

Divide and Conquer

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

If a character appears without its case partner, it cannot be part of any nice substring. Split the string at such characters and recursively find the longest nice substring in each part.

Hash Map Character Tracking

⏱️ Time: O(n² × k) Space: O(k)

For each possible substring, use a hash map to store all characters present, then verify that every character has its case counterpart. This optimizes the character checking process.

Brute Force - Check All Substrings — Algorithm Steps

Step 1: Generate all possible substrings (O(n²) combinations)
Step 2: For each substring, check if it's nice by verifying character pairs
Step 3: Track the longest nice substring found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Create all possible substrings

Check Each One

Verify if each substring is nice

Find Longest

Keep track of the longest valid substring

Code -

solution.c — C

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

int isNice(char* s, int start, int end) {
    int chars[128] = {0};
    for (int i = start; i < end; i++) {
        chars[(int)s[i]] = 1;
    }
    
    for (int i = start; i < end; i++) {
        char c = s[i];
        if (islower(c) && !chars[toupper(c)]) {
            return 0;
        }
        if (isupper(c) && !chars[tolower(c)]) {
            return 0;
        }
    }
    return 1;
}

char* solution(char* s) {
    int n = strlen(s);
    int maxLen = 0;
    int bestStart = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j <= n; j++) {
            if (isNice(s, i, j) && (j - i) > maxLen) {
                maxLen = j - i;
                bestStart = i;
            }
        }
    }
    
    char* result = malloc((maxLen + 1) * sizeof(char));
    strncpy(result, s + bestStart, maxLen);
    result[maxLen] = '\0';
    return result;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    char* result = solution(s);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) substrings × O(n) to check each substring for niceness

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for tracking variables

✓ 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 - Check All Substrings — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler