You are given alphanumeric strings `s`

and `t`

. Find the minimum window (substring) in `s`

which contains all the characters of `t`

.

```
{
"s": "AYZABOBECODXBANC",
"t": "ABC"
}
```

Output:

```
"BANC"
```

The minimum window is `"BANC"`

, which contains all letters - `'A'`

`'B'`

and `'C'`

. We cannot find a window of smaller length than `"BANC"`

.

```
{
"s": "BACRDESDFBAER",
"t": "BAR"
}
```

Output:

```
"BACR"
```

Here, we can see that there are 2 smallest windows - `"BACR"`

and `"BAER"`

. However, the output is `"BACR"`

because it is the leftmost one.

- If no such window exists, return an empty string
`""`

. - If there are multiple minimum windows of the same length, return the leftmost window.

Constraints:

- 1 <= length of
`s`

<= 100000 - 1 <= length of
`t`

<= 100000

We provided two solutions. We will refer to the length of `s`

as `n`

and length of `t`

as `m`

.

This is a brute force approach. We check whether each substring of string `s`

is a valid window or not. If we find it to be a valid window, we update our result accordingly.

O(n^{3}).

As we are checking for all substrings and as there are O(n^{2}) substrings and we take O(n) time to check whether the particular substring can be a valid window, so total complexity is O(n^{3}).

O(1).

We create frequency arrays of size 128 to count the occurrence of each character present in strings `t`

and `s`

. So overall complexity is O(1).

O(n + m).

For storing input it will take O(n + m), as we are storing two strings of length `n`

and length `m`

and the auxiliary space used is O(1) hence total complexity will be O(n + m).

Note: We could use an array of length 62 (with some mapping) instead of 128, but this is a general solution which works for the input string containing any ASCII characters.

```
/*
* Asymptotic complexity in terms of length of \`s\` \`n\` and length of \`t\` \`m\`:
* Time: O(n^3).
* Auxiliary space: O(1).
* Total space: O(n + m).
*/
static String minimum_window(String s, String t){
String result = "";
if(t.length() > s.length()) {
return "";
}
int freq1[] = new int[128]; //creating a frequency array to store the frequencies of the characters in string t
int n = s.length();
for(int i = 0; i < t.length(); i++) {
freq1[(int)t.charAt(i)]++;
}
int len = n + 1;
//looping over every substring of string s
for(int i = 0; i < n; i++){
for(int j = i; j < n; j++){
int freq2[] = new int[128]; //creating a frequency array to store the frequencies of the characters in the substring
for(int k = i; k <= j; k++){
freq2[s.charAt(k)]++;
}
//checking if a substring contains all the letters in string t
for(int k = 0; k < 128; k++){
if(freq2[k] < freq1[k]) {
break;
}
if(k == 127){
// if the substring contains all the characters, we check if it can
// become the smallest one and update the result accordingly
if(len > (j - i)){
len = j - i;
result = s.substring(i, j + 1);
}
}
}
}
}
return (result.length() == 0 ? "" : result);
}
```

In this approach, we create an array named frequency to keep a count of occurrences of each character in string `t`

. Now we start traversing the string `s`

and keep a variable `cnt`

which increases whenever we encounter a character present in string `t`

. When the value of count reaches the length of `t`

, this substring contains all the characters present in string `t`

. We try removing extra characters as well as unwanted characters from the beginning of the obtained string. The resultant string is checked whether it can become the minimum window, and the answer is updated accordingly.

This algorithm uses the 2 pointer method, which is widely used in solving various problems.

O(n).

Since each character of string `s`

is traversed at most 2 times, the time complexity of the algorithm is O(n) + O(m).

O(1).

We are creating 2 frequency arrays of size 128, hence it is O(1).

O(n + m).

For storing input it will take O(n + m), as we are storing two strings of length `n`

and length `m`

and the auxiliary space used is O(1) hence total complexity will be O(n + m).

Note: We could use an array of length 62 (with some mapping) instead of 128, but this is a general solution which works for the input string containing any ASCII characters.

```
/*
* Asymptotic complexity in terms of length of \`s\` \`n\` and length of \`t\` \`m\`:
* Time: O(n).
* Auxiliary space: O(1).
* Total space: O(n + m).
*/
static String minimum_window(String s, String t){
String result = "";
if(t.length() > s.length()) {
return "";
}
int n = s.length(), m = t.length();
int freq1[] = new int[128]; /*creating a frequency array to store the
frequencies of the characters in string t*/
int freq2[] = new int[128]; /*creating a frequency array to store the
frequencies of the characters in string s*/
for (char c : t.toCharArray()) {
freq1[c]++;
}
int l = 0, len = n + 1;
int cnt = 0;
// This part uses "2 pointer method." You can find a link for the same in the editorial of this problem.
for (int i = 0; i < n ; i++){
char temp = s.charAt(i);
freq2[temp]++;
// If a character is present in string t we increment the count of cnt variable.
if (freq1[temp] != 0 && freq2[temp] <= freq1[temp]) {
cnt++;
}
// If we match all the characters present in string t, we try to find the minimum window possible
if (cnt == m) {
// if any character is occuring more than the required times, we try to remove it
// from the starting and also try to remove the unwanted characters that are
// not a part of string t from the starting. We check the remainder string if it
// can become the smallest window.
while (freq2[s.charAt(l)] > freq1[s.charAt(l)] || freq1[s.charAt(l)] == 0) {
if (freq2[s.charAt(l)] > freq1[s.charAt(l)]) {
freq2[s.charAt(l)]--;
}
l++;
}
//check if this can become the smallest window and update the result accordingly.
if (len > i - l + 1) {
len = i - l + 1;
result = s.substring(l, l + len);
}
}
}
return (result.length() == 0 ? "" : result);
}
```

We hope that these solutions to the 4 sum problem have helped you level up your coding skills. You can expect problems like these at top tech companies like Amazon and Google.

If you are preparing for a tech interview at FAANG or any other Tier-1 tech company, register for Interview Kickstart’s FREE webinar to understand the best way to prepare.

Interview Kickstart offers interview preparation courses taught by FAANG+ tech leads and seasoned hiring managers. Our programs include a comprehensive curriculum, unmatched teaching methods, and career coaching to help you nail your next tech interview.

We offer 18 interview preparation courses, each tailored to a specific engineering domain or role, including the most in-demand and highest-paying domains and roles, such as:

- Back-end Engineering Interview Course
- Front-end Engineering Interview Course
- Full Stack Developer Interview Course

To learn more, register for the FREE webinar.

Note: Input and Output will already be taken care of.