# 1763. Longest Nice Substring | LeetCode

## 1763. Longest Nice Substring

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 because `'b'` appears, but `'B'` does not.

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

Example 1:

```Input: s = "YazaAay"
Output: "aAa"
Explanation: "aAa" is a nice string because 'A/a' is the only letter of the alphabet in s, and both 'A' and 'a' appear.
"aAa" is the longest nice substring.
```

Example 2:

```Input: s = "Bb"
Output: "Bb"
Explanation: "Bb" is a nice string because both 'B' and 'b' appear. The whole string is a substring.```

Example 3:

```Input: s = "c"
Output: ""
Explanation: There are no nice substrings.```

Example 4:

```Input: s = "dDzeE"
Output: "dD"
Explanation: Both "dD" and "eE" are the longest nice substrings.
As there are multiple longest nice substrings, return "dD" since it occurs earlier.```

Constraints:

• `1 <= s.length <= 100`
• `s` consists of uppercase and lowercase English letters.

### Solution

class Solution
{
public:
bool helper(string s)
{
unordered_map<int, pair<int, int>> mymap;
for (int i = 0; i < s.length(); i++)
{
int a = s[i];
if (a > 91)
{
int b = a - 32;

auto it = mymap.find(b);
if (it != mymap.end())
{
it->second.second++;
}
else
{
mymap.insert({b, make_pair(0, 1)});
}
}
else
{
auto itt = mymap.find(a);
if (itt != mymap.end())
{
itt->second.first++;
}
else
{
mymap.insert({a, make_pair(1, 0)});
}
}
}
for (auto it = mymap.begin(); it != mymap.end(); it++)
{
if (it->second.first == 0 || it->second.second == 0)
{
return false;
}
}
return true;
}

string longestNiceSubstring(string s)
{
string ans;
string temp = "";
int n = s.length();
for (int i = 0; i < n; i++)
{
temp = "";
for (int j = i; j < n; j++)
{
temp += s[j];
if (helper(temp) && temp.length() > ans.length())
{
ans = temp;
}
}
}
return ans;
}
};