# Find the smallest window in a string containing all characters of another string

• Difficulty Level : Hard
• Last Updated : 12 Oct, 2021

Given two strings, string1 and string2, the task is to find the smallest substring in string1 containing all characters of string2 efficiently.

Examples:

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

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

Method 1 ( Brute force solution )
1- Generate all substrings of string1 (“this is a test string”)
2- For each substring, check whether the substring contains all characters of string2 (“tist”)
3- Finally, print the smallest substring containing all characters of string2.

Method 2 ( Efficient Solution )

1. 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 “.
2. Store the occurrence of characters of the given pattern in a hash_pat[].
3. we will be using two pointer technique basically
4. Start matching the characters of pattern with the characters of string i.e. increment count if a character matches.
5. Check if (count == length of pattern ) this means a window is found.
6. If such a window found, try to minimize it by removing extra characters from the beginning of the current window.
7. delete one character from first and again find this deleted key at right, once found apply step 5 .
8. Update min_length.
9. Print the minimum length window.

A diagram to explain the stated algorithm:

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 program to implement the above algorithm:

## 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 << ``"Smallest window is : \n"``         ``<< 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(``"Smallest window is :\n "``                         ``+ 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``(``"Smallest window is : "``)``    ``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(``"Smallest window is :\n "``                          ``+ 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` `"Smallest window is : \n"` `.``      ``findSubString(``\$str``, ``\$pat``);``      ` `// This code is contributed by``// rathbhupendra``?>`

## Javascript

 ``
Output
```Smallest window is :
t stri```

Method 3 (Efficient Solution)

(Using sliding window  Technique )

## 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"``;``}` `main()``{``    ``string s = ``"ADOBECODEBANC"``;``    ``string t = ``"ABC"``;``    ` `      ``cout<<``"-->Smallest window that contain all character : "``<

## 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 = ``"ADOBECODEBANC"``;``    ``String t = ``"ABC"``;``    ` `      ``System.out.print(``"-->Smallest window that contain all character : "``);``    ``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 ``=` `"ADOBECODEBANC"``    ``p ``=` `"ABC"``    ``result ``=` `smallestWindow(s, p)``    ``print``(``"-->Smallest window that contain all character :"``, 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 = ``"ADOBECODEBANC"``;``    ``String t = ``"ABC"``;``    ` `    ``Console.Write(``        ``"-->Smallest window that contain all character : "``);``    ``Console.Write(Minimum_Window(s.ToCharArray(),``                                 ``t.ToCharArray()));``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

```-->Smallest window that contain all character :
BANC```

Time Complexity  :  O(|s|) , where |s| is the length of string s.

Space Complexity : O(1)

Explanation –   Array m  of length 256 is used ,which is constant space, so the Space Complexity is 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.