Open in App
Not now

# Smallest window in a String containing all characters of other String

• Difficulty Level : Hard
• Last Updated : 13 Oct, 2022

Given two strings, string and pattern, the task is to find the smallest substring in string containing all characters of pattern

Examples:

Input: string = “this is a test string”, pattern = “tist”
Output: “t stri”
Explanation: “t stri” contains all the characters of pattern.

Input: string = “geeksforgeeks”, pattern = “ork”
Output: “ksfor”

Naive Approach:

• Generate all substrings of string.
• For each substring, check whether the substring contains all characters of pattern (“tist”)
• Finally, print the smallest substring containing all characters of pattern.

Time Complexity: O(N3)
Auxiliary Space: O(N) to create substrings.

## Smallest window in a String containing all characters of other String using Hashing:

The idea is to use the two pointer approach on the hash array of pattern string and then find the minimum window by eliminating characters from the start of the window.

Follow the steps below to solve the problem:

• First check if the length of the string is less than the length of the given pattern, if yes then “no such window can exist “.
• Store the occurrence of characters of the given pattern in a hash array (say, hash_pat[]).
• We will be using two pointer technique basically
• Start matching the characters of the pattern with the characters of the string i.e. increment count if a character matches.
• Check if (count == length of pattern ) this means a window is found.
• If such a window is found, try to minimize it by removing extra characters from the beginning of the current window.
• Delete one character from the first and again find this deleted key at right.
• If found, then again check if count and pattern length are same and repeat the process.
• Update min_length.
• Print the minimum length window.

See the image below for a better understanding:

Illustration:

after the second image(array) our left pointer should be at s and then find I at right and then apply step5 (basically one step has not been shown)

Below is the implementation of the above aapproach.

## C++

 `// C++ program to find ` `// smallest window containing` `// all characters of a pattern.` `#include ` `using` `namespace` `std;`   `const` `int` `no_of_chars = 256;`   `// Function to find smallest ` `// window containing` `// all characters of 'pat'` `string findSubString(string str, string pat)` `{` `    ``int` `len1 = str.length();` `    ``int` `len2 = pat.length();`   `    ``// Check if string's length ` `    ``// is less than pattern's` `    ``// length. If yes then no such ` `    ``// window can exist` `    ``if` `(len1 < len2) {` `        ``cout << ``"No such window exists"``;` `        ``return` `""``;` `    ``}`   `    ``int` `hash_pat[no_of_chars] = { 0 };` `    ``int` `hash_str[no_of_chars] = { 0 };`   `    ``// Store occurrence ofs characters ` `    ``// of pattern` `    ``for` `(``int` `i = 0; i < len2; i++)` `        ``hash_pat[pat[i]]++;`   `    ``int` `start = 0, start_index = -1, min_len = INT_MAX;`   `    ``// Start traversing the string` `    ``// Count of characters` `    ``int` `count = 0; ` `    ``for` `(``int` `j = 0; j < len1; j++) {` `      `  `        ``// Count occurrence of characters ` `        ``// of string` `        ``hash_str[str[j]]++;`   `        ``// If string's char matches with ` `        ``// pattern's char` `        ``// then increment count` `        ``if` `(hash_str[str[j]] <= hash_pat[str[j]])` `            ``count++;`   `        ``// if all the characters are matched` `        ``if` `(count == len2) {` `          `  `            ``// Try to minimize the window ` `            ``while` `(hash_str[str[start]]` `                       ``> hash_pat[str[start]]` `                   ``|| hash_pat[str[start]] == 0) {`   `                ``if` `(hash_str[str[start]]` `                    ``> hash_pat[str[start]])` `                    ``hash_str[str[start]]--;` `                ``start++;` `            ``}`   `            ``// update window size` `            ``int` `len_window = j - start + 1;` `            ``if` `(min_len > len_window) {` `                ``min_len = len_window;` `                ``start_index = start;` `            ``}` `        ``}` `    ``}`   `    ``// If no window found` `    ``if` `(start_index == -1) {` `        ``cout << ``"No such window exists"``;` `        ``return` `""``;` `    ``}`   `    ``// Return substring starting from start_index` `    ``// and length min_len` `    ``return` `str.substr(start_index, min_len);` `}`   `// Driver code` `int` `main()` `{` `    ``string str = ``"this is a test string"``;` `    ``string pat = ``"tist"``;`   `    ``cout << findSubString(str, pat);` `    ``return` `0;` `}`

## Java

 `// Java program to find smallest ` `// window containing` `// all characters of a pattern.`   `public` `class` `GFG {` `    ``static` `final` `int` `no_of_chars = ``256``;`   `    ``// Function to find smallest ` `    ``// window containing` `    ``// all characters of 'pat'` `    ``static` `String findSubString(String str, String pat)` `    ``{` `        ``int` `len1 = str.length();` `        ``int` `len2 = pat.length();`   `        ``// Check if string's length is ` `        ``// less than pattern's` `        ``// length. If yes then no such ` `        ``// window can exist` `        ``if` `(len1 < len2) {` `            ``System.out.println(``"No such window exists"``);` `            ``return` `""``;` `        ``}`   `        ``int` `hash_pat[] = ``new` `int``[no_of_chars];` `        ``int` `hash_str[] = ``new` `int``[no_of_chars];`   `        ``// Store occurrence ofs ` `        ``// characters of pattern` `        ``for` `(``int` `i = ``0``; i < len2; i++)` `            ``hash_pat[pat.charAt(i)]++;`   `        ``int` `start = ``0``, start_index = -``1``,` `            ``min_len = Integer.MAX_VALUE;`   `        ``// Start traversing the string` `        ``// Count of characters` `        ``int` `count = ``0``; ` `        ``for` `(``int` `j = ``0``; j < len1; j++) {` `          `  `            ``// Count occurrence of characters ` `            ``// of string` `            ``hash_str[str.charAt(j)]++;`   `            ``// If string's char matches ` `            ``// with pattern's char` `            ``// then increment count` `            ``if` `(hash_str[str.charAt(j)]` `                ``<= hash_pat[str.charAt(j)])` `                ``count++;`   `            ``// If all the characters are matched` `            ``if` `(count == len2) {` `              `  `                ``// Try to minimize the window` `                ``while` `(hash_str[str.charAt(start)]` `                           ``> hash_pat[str.charAt(start)]` `                       ``|| hash_pat[str.charAt(start)]` `                              ``== ``0``) {`   `                    ``if` `(hash_str[str.charAt(start)]` `                        ``> hash_pat[str.charAt(start)])` `                        ``hash_str[str.charAt(start)]--;` `                    ``start++;` `                ``}`   `                ``// update window size` `                ``int` `len_window = j - start + ``1``;` `                ``if` `(min_len > len_window) {` `                    ``min_len = len_window;` `                    ``start_index = start;` `                ``}` `            ``}` `        ``}`   `        ``// If no window found` `        ``if` `(start_index == -``1``) {` `            ``System.out.println(``"No such window exists"``);` `            ``return` `""``;` `        ``}`   `        ``// Return substring starting ` `        ``// from start_index` `        ``// and length min_len` `        ``return` `str.substring(start_index,` `                             ``start_index + min_len);` `    ``}`   `    ``// Driver Method` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``String str = ``"this is a test string"``;` `        ``String pat = ``"tist"``;`   `        ``System.out.print(findSubString(str, pat));` `    ``}` `}`

## Python3

 `# Python3 program to find the smallest window` `# containing all characters of a pattern.` `no_of_chars ``=` `256`   `# Function to find smallest window` `# containing all characters of 'pat'` `def` `findSubString(string, pat):`   `    ``len1 ``=` `len``(string)` `    ``len2 ``=` `len``(pat)`   `    ``# Check if string's length is` `    ``# less than pattern's` `    ``# length. If yes then no such` `    ``# window can exist` `    ``if` `len1 < len2:`   `        ``print``(``"No such window exists"``)` `        ``return` `""`   `    ``hash_pat ``=` `[``0``] ``*` `no_of_chars` `    ``hash_str ``=` `[``0``] ``*` `no_of_chars`   `    ``# Store occurrence ofs characters of pattern` `    ``for` `i ``in` `range``(``0``, len2):` `        ``hash_pat[``ord``(pat[i])] ``+``=` `1`   `    ``start, start_index, min_len ``=` `0``, ``-``1``, ``float``(``'inf'``)`   `    ``# Start traversing the string` `    ``count ``=` `0`  `# count of characters` `    ``for` `j ``in` `range``(``0``, len1):`   `        ``# count occurrence of characters of string` `        ``hash_str[``ord``(string[j])] ``+``=` `1`   `        ``# If string's char matches with` `        ``# pattern's char then increment count` `        ``if` `(hash_str[``ord``(string[j])] <``=` `                ``hash_pat[``ord``(string[j])]):` `            ``count ``+``=` `1`   `        ``# if all the characters are matched` `        ``if` `count ``=``=` `len2:`   `            ``# Try to minimize the window` `            ``while` `(hash_str[``ord``(string[start])] >` `                   ``hash_pat[``ord``(string[start])] ``or` `                   ``hash_pat[``ord``(string[start])] ``=``=` `0``):`   `                ``if` `(hash_str[``ord``(string[start])] >` `                        ``hash_pat[``ord``(string[start])]):` `                    ``hash_str[``ord``(string[start])] ``-``=` `1` `                ``start ``+``=` `1`   `            ``# update window size` `            ``len_window ``=` `j ``-` `start ``+` `1` `            ``if` `min_len > len_window:`   `                ``min_len ``=` `len_window` `                ``start_index ``=` `start`   `    ``# If no window found` `    ``if` `start_index ``=``=` `-``1``:` `        ``print``(``"No such window exists"``)` `        ``return` `""`   `    ``# Return substring starting from` `    ``# start_index and length min_len` `    ``return` `string[start_index: start_index ``+` `min_len]`     `# Driver code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``string ``=` `"this is a test string"` `    ``pat ``=` `"tist"`   `    ``print``(findSubString(string, pat))`   `# This code is contributed by Rituraj Jain`

## C#

 `// C# program to find smallest ` `// window containing` `// all characters of a pattern.` `using` `System;`   `class` `GFG {` `    ``static` `int` `no_of_chars = 256;`   `    ``// Function to find smallest ` `    ``// window containing` `    ``// all characters of 'pat'` `    ``static` `String findSubString(String str, ` `                                ``String pat)` `    ``{` `        ``int` `len1 = str.Length;` `        ``int` `len2 = pat.Length;`   `        ``// Check if string's length is ` `        ``// less than pattern's` `        ``// length. If yes then no such ` `        ``// window can exist` `        ``if` `(len1 < len2) {` `            ``Console.WriteLine(``"No such window exists"``);` `            ``return` `""``;` `        ``}`   `        ``int``[] hash_pat = ``new` `int``[no_of_chars];` `        ``int``[] hash_str = ``new` `int``[no_of_chars];`   `        ``// Store occurrence ofs characters ` `        ``// of pattern` `        ``for` `(``int` `i = 0; i < len2; i++)` `            ``hash_pat[pat[i]]++;`   `        ``int` `start = 0, start_index = -1,` `            ``min_len = ``int``.MaxValue;`   `        ``// Start traversing the string` `        ``// Count of characters` `        ``int` `count = 0; ` `        ``for` `(``int` `j = 0; j < len1; j++) {` `          `  `            ``// Count occurrence of characters ` `            ``// of string` `            ``hash_str[str[j]]++;`   `            ``// If string's char matches ` `            ``// with pattern's char` `            ``// then increment count` `            ``if` `(hash_str[str[j]] <= hash_pat[str[j]])` `                ``count++;`   `            ``// if all the characters are matched` `            ``if` `(count == len2) {` `              `  `                ``// Try to minimize the window ` `                ``while` `(hash_str[str[start]]` `                           ``> hash_pat[str[start]]` `                       ``|| hash_pat[str[start]] == 0) {`   `                    ``if` `(hash_str[str[start]]` `                        ``> hash_pat[str[start]])` `                        ``hash_str[str[start]]--;` `                    ``start++;` `                ``}`   `                ``// update window size` `                ``int` `len_window = j - start + 1;` `                ``if` `(min_len > len_window) {` `                    ``min_len = len_window;` `                    ``start_index = start;` `                ``}` `            ``}` `        ``}`   `        ``// If no window found` `        ``if` `(start_index == -1) {` `            ``Console.WriteLine(``"No such window exists"``);` `            ``return` `""``;` `        ``}`   `        ``// Return substring starting from start_index` `        ``// and length min_len` `        ``return` `str.Substring(start_index, min_len);` `    ``}`   `    ``// Driver Method` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``String str = ``"this is a test string"``;` `        ``String pat = ``"tist"``;`   `        ``Console.WriteLine(findSubString(str, pat));` `    ``}` `}`   `/* This code contributed by PrinciRaj1992 */`

## PHP

 ` ` `                   ``\$hash_pat``[ord(``\$str``[``\$start``])] || ` `                   ``\$hash_pat``[ord(``\$str``[``\$start``])] == 0) ` `            ``{ `   `                ``if` `(``\$hash_str``[ord(``\$str``[``\$start``])] >` `                    ``\$hash_pat``[ord(``\$str``[``\$start``])]) ` `                    ``\$hash_str``[ord(``\$str``[``\$start``])]--; ` `                ``\$start``++; ` `            ``} `   `            ``// update window size ` `            ``\$len_window` `= ``\$j` `- ``\$start` `+ 1; ` `            ``if` `(``\$min_len` `> ``\$len_window``) ` `            ``{ ` `                ``\$min_len` `= ``\$len_window``; ` `                ``\$start_index` `= ``\$start``; ` `            ``} ` `        ``} ` `    ``} `   `    ``// If no window found ` `    ``if` `(``\$start_index` `== -1) ` `    ``{ ` `        ``echo` `"No such window exists"``; ` `        ``return` `""``; ` `    ``} `   `    ``// Return substring starting from ` `    ``// start_index and length min_len ` `    ``return` `substr``(``\$str``, ``\$start_index``, ``\$min_len``); ` `} `   `// Driver code ` `\$str` `= ``"this is a test string"``; ` `\$pat` `= ``"tist"``; `   `echo` `findSubString(``\$str``, ``\$pat``); ` `      `  `// This code is contributed by` `// rathbhupendra` `?>`

## Javascript

 ``

Output

`t stri`

Time Complexity:  O(N), where N is the length of string.
Auxiliary Space: O(1)

## Smallest window in a string containing all characters of other string using Sliding Window:

The idea is to use the sliding window technique whenever any window contains all the characters of the pattern string then start minimizing it from the start of the window.

Follow the steps below to solve the problem:

• Make a hash array of size 256.
• First store the frequency of every character of pattern string.
• Then loop over the string and decrement the frequency from the hash array.
• When count variable equals to zero then start minimizing the window.

Below is the implementation of the above approach:

## C++14

 `#include ` `using` `namespace` `std;`   `// Function` `string Minimum_Window(string s, string t)` `{`   `    ``int` `m[256] = { 0 };`   `    ``// Answer` `    ``int` `ans = INT_MAX; ``// length of ans` `    ``int` `start = 0; ``// starting index of ans` `    ``int` `count = 0;`   `    ``// creating map` `    ``for` `(``int` `i = 0; i < t.length(); i++) {` `        ``if` `(m[t[i]] == 0)` `            ``count++;` `        ``m[t[i]]++;` `    ``}`   `    ``// References of Window` `    ``int` `i = 0;` `    ``int` `j = 0;`   `    ``// Traversing the window` `    ``while` `(j < s.length()) {` `        ``// Calculations` `        ``m[s[j]]--;` `        ``if` `(m[s[j]] == 0)` `            ``count--;`   `        ``// Condition matching` `        ``if` `(count == 0) {` `            ``while` `(count == 0) {` `                ``// Sorting ans` `                ``if` `(ans > j - i + 1) {` `                    ``ans = min(ans, j - i + 1);` `                    ``start = i;` `                ``}` `                ``// Sliding I` `                ``// Calculation for removing I`   `                ``m[s[i]]++;` `                ``if` `(m[s[i]] > 0)` `                    ``count++;`   `                ``i++;` `            ``}` `        ``}` `        ``j++;` `    ``}`   `    ``if` `(ans != INT_MAX)` `        ``return` `s.substr(start, ans);` `    ``else` `        ``return` `"-1"``;` `}`   `int` `main()` `{` `    ``string s = ``"this is a test string"``;` `    ``string t = ``"tist"``;`   `    ``cout << Minimum_Window(s, t);` `    ``return` `0;` `}`

## Java

 `import` `java.util.*;`   `class` `GFG {`   `    ``// Function` `    ``static` `String Minimum_Window(``char``[] s, ``char``[] t)` `    ``{`   `        ``int` `m[] = ``new` `int``[``256``];`   `        ``// Answer` `        ``int` `ans = Integer.MAX_VALUE; ``// length of ans` `        ``int` `start = ``0``; ``// starting index of ans` `        ``int` `count = ``0``;` `        ``// creating map` `        ``for` `(``int` `i = ``0``; i < t.length; i++) {` `            ``if` `(m[t[i]] == ``0``)` `                ``count++;` `            ``m[t[i]]++;` `        ``}`   `        ``// References of Window` `        ``int` `i = ``0``;` `        ``int` `j = ``0``;`   `        ``// Traversing the window` `        ``while` `(j < s.length) {`   `            ``// Calculations` `            ``m[s[j]]--;` `            ``if` `(m[s[j]] == ``0``)` `                ``count--;`   `            ``// Condition matching` `            ``if` `(count == ``0``) {` `                ``while` `(count == ``0``) {`   `                    ``// Sorting ans` `                    ``if` `(ans > j - i + ``1``) {` `                        ``ans = Math.min(ans, j - i + ``1``);` `                        ``start = i;` `                    ``}`   `                    ``// Sliding I` `                    ``// Calculation for removing I` `                    ``m[s[i]]++;` `                    ``if` `(m[s[i]] > ``0``)` `                        ``count++;`   `                    ``i++;` `                ``}` `            ``}` `            ``j++;` `        ``}`   `        ``if` `(ans != Integer.MAX_VALUE)` `            ``return` `String.valueOf(s).substring(start,` `                                               ``ans + start);` `        ``else` `            ``return` `"-1"``;` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``String s = ``"this is a test string"``;` `        ``String t = ``"tist"``;`   `        ``System.out.print(Minimum_Window(s.toCharArray(),` `                                        ``t.toCharArray()));` `    ``}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `''' Python solution '''`     `def` `smallestWindow(s, p):` `    ``n ``=` `len``(s)` `    ``if` `n < ``len``(p):` `        ``return` `-``1` `    ``mp ``=` `[``0``]``*``256`   `    ``# Starting index of ans` `    ``start ``=` `0`   `    ``# Answer` `    ``# Length of ans` `    ``ans ``=` `n ``+` `1` `    ``cnt ``=` `0`   `    ``# creating map` `    ``for` `i ``in` `p:` `        ``mp[``ord``(i)] ``+``=` `1` `        ``if` `mp[``ord``(i)] ``=``=` `1``:` `            ``cnt ``+``=` `1`   `     ``# References of Window` `    ``j ``=` `0` `    ``i ``=` `0`   `    ``# Traversing the window` `    ``while``(j < n):`   `      ``# Calculating` `        ``mp[``ord``(s[j])] ``-``=` `1` `        ``if` `mp[``ord``(s[j])] ``=``=` `0``:` `            ``cnt ``-``=` `1`   `            ``# Condition matching` `            ``while` `cnt ``=``=` `0``:` `                ``if` `ans > j ``-` `i ``+` `1``:`   `                  ``# calculating answer.` `                    ``ans ``=` `j ``-` `i ``+` `1` `                    ``start ``=` `i`   `                 ``# Sliding I` `                ``# Calculation for removing I` `                ``mp[``ord``(s[i])] ``+``=` `1` `                ``if` `mp[``ord``(s[i])] > ``0``:` `                    ``cnt ``+``=` `1` `                ``i ``+``=` `1` `        ``j ``+``=` `1` `    ``if` `ans > n:` `        ``return` `"-1"` `    ``return` `s[start:start``+``ans]`     `# Driver code` `if` `__name__ ``=``=` `"__main__"``:` `    ``s ``=` `"this is a test string"` `    ``p ``=` `"tist"` `    ``result ``=` `smallestWindow(s, p)` `    ``print``(result)`   `    ``# This code is contributed by cyclades.`

## C#

 `using` `System;`   `class` `GFG {`   `    ``// Function` `    ``static` `String Minimum_Window(``char``[] s, ``char``[] t)` `    ``{` `        ``int``[] m = ``new` `int``[256];`   `        ``// Answer` `        ``// Length of ans` `        ``int` `ans = ``int``.MaxValue;`   `        ``// Starting index of ans` `        ``int` `start = 0;` `        ``int` `count = 0, i = 0;`   `        ``// Creating map` `        ``for` `(i = 0; i < t.Length; i++) {` `            ``if` `(m[t[i]] == 0)` `                ``count++;`   `            ``m[t[i]]++;` `        ``}`   `        ``// References of Window` `        ``i = 0;` `        ``int` `j = 0;`   `        ``// Traversing the window` `        ``while` `(j < s.Length) {`   `            ``// Calculations` `            ``m[s[j]]--;`   `            ``if` `(m[s[j]] == 0)` `                ``count--;`   `            ``// Condition matching` `            ``if` `(count == 0) {` `                ``while` `(count == 0) {`   `                    ``// Sorting ans` `                    ``if` `(ans > j - i + 1) {` `                        ``ans = Math.Min(ans, j - i + 1);` `                        ``start = i;` `                    ``}`   `                    ``// Sliding I` `                    ``// Calculation for removing I` `                    ``m[s[i]]++;`   `                    ``if` `(m[s[i]] > 0)` `                        ``count++;`   `                    ``i++;` `                ``}` `            ``}` `            ``j++;` `        ``}`   `        ``if` `(ans != ``int``.MaxValue)` `            ``return` `String.Join(``""``, s).Substring(start, ans);` `        ``else` `            ``return` `"-1"``;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``String s = ``"this is a test string"``;` `        ``String t = ``"tist"``;`   `        ``Console.Write(Minimum_Window(s.ToCharArray(),` `                                     ``t.ToCharArray()));` `    ``}` `}`   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

`t stri`

Time Complexity:  O(N), where N is the length of string s.
Auxiliary Space: O(1)

This article is contributed by Sahil Chhabra. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.