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

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 ) 
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_pat[].we will be using two pointer technique basicallyStart matching the characters of pattern with the characters of 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 found, try to minimize it by removing extra characters from the beginning of the current window.delete one character from first and again find this deleted key at right, once found apply step 5 .Update min_length.Print the minimum length window.
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_pat[].
we will be using two pointer technique basically
Start matching the characters of pattern with the characters of 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 found, try to minimize it by removing extra characters from the beginning of the current window.
delete one character from first and again find this deleted key at right, once found apply step 5 .
Update min_length.
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++
Java
Python3
C#
PHP
Javascript
// C++ program to find// smallest window containing// all characters of a pattern.#include <bits/stdc++.h>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 codeint main(){    string str = "this is a test string";    string pat = "tist";     cout << "Smallest window is : \n"         << findSubString(str, pat);    return 0;}
// 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 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 codeif __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# 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// PHP program to find smallest window// containing all characters of a pattern. define("no_of_chars", 256); // Function to find smallest window// containing all characters of 'pat'function findSubString(&$str, &$pat){    $len1 = strlen($str);    $len2 = strlen($pat);     // check if string's length is less    // than pattern's length. If yes    // then no such window can exist    if ($len1 < $len2)    {        echo "No such window exists";        return "";    }     $hash_pat = array_fill(0, no_of_chars, 0);    $hash_str = array_fill(0, no_of_chars, 0);     // store occurrence ofs characters    // of pattern    for ($i = 0; $i < $len2; $i++)        $hash_pat[ord($pat[$i])]++;     $start = 0;    $start_index = -1;    $min_len = PHP_INT_MAX;     // start traversing the string    $count = 0; // count of characters    for ($j = 0; $j < $len1 ; $j++)    {        // count occurrence of characters        // of string        $hash_str[ord($str[$j])]++;         // If string's char matches with        // pattern's char then increment count        if ($hash_str[ord($str[$j])] <=            $hash_pat[ord($str[$j])])            $count++;         // if all the characters are matched        if ($count == $len2)        {            // Try to minimize the window i.e.,            // check if any character is occurring            // more no. of times than its occurrence            // in pattern, if yes then remove it from            // starting and also remove the useless            // characters.            while ($hash_str[ord($str[$start])] >                   $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?>
<script>// javascript program to find smallest// window containing// all characters of a pattern. var no_of_chars = 256; // Function to find smallest// window containing// all characters of 'pat'function findSubString(str, pat){    var len1 = str.length;    var 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) {        document.write("No such window exists");        return "";    }     var hash_pat = Array.from({length: no_of_chars}, (_, i) => 0);    var hash_str = Array.from({length: no_of_chars}, (_, i) => 0);     // Store occurrence ofs    // characters of pattern    for (var i = 0; i < len2; i++)        hash_pat[pat.charAt(i).charCodeAt(0)]++;     var start = 0, start_index = -1,        min_len = Number.MAX_VALUE;     // Start traversing the string    // Count of characters    var count = 0;    for (var j = 0; j < len1; j++) {               // Count occurrence of characters        // of string        hash_str[str.charAt(j).charCodeAt(0)]++;         // If string's char matches        // with pattern's char        // then increment count        if (hash_str[str.charAt(j).charCodeAt(0)]            <= hash_pat[str.charAt(j).charCodeAt(0)])            count++;         // If all the characters are matched        if (count == len2) {                       // Try to minimize the window            while (hash_str[str.charAt(start).charCodeAt(0)]                       > hash_pat[str.charAt(start).charCodeAt(0)]                   || hash_pat[str.charAt(start).charCodeAt(0)]                          == 0) {                 if (hash_str[str.charAt(start).charCodeAt(0)]                    > hash_pat[str.charAt(start).charCodeAt(0)])                    hash_str[str.charAt(start).charCodeAt(0)]--;                start++;            }             // update window size            var 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) {        document.write("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 Methodvar str = "this is a test string";var pat = "tist"; document.write("Smallest window is :\n "                 + findSubString(str, pat));// This code is contributed by 29AjayKumar</script>
Smallest window is : 
t stri
Method 3 (Efficient Solution)
(Using sliding window  Technique )
C++14
Java
Python3
C#
Javascript
#include <bits/stdc++.h>using namespace std; // Functionstring 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 : "<<endl;    cout << Minimum_Window(s, t);}
import java.util.*; class GFG{ // Functionstatic 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
''' 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 codeif __name__ == "__main__":    s = "ADOBECODEBANC"    p = "ABC"    result = smallestWindow(s, p)    print("-->Smallest window that contain all character :", result)         # This code is contributed by cyclades.
using System; class GFG{ // Functionstatic 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 codepublic 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
<script> // Functionfunction Minimum_Window(s,t){    let m = new Array(256);     for(let i = 0; i < 256; i++)    {        m[i] = 0;    }         // Length of ans    let ans = Number.MAX_VALUE;         // Starting index of ans    let start = 0;    let count = 0;         // Creating map    for(let i = 0; i < t.length; i++)    {        if (m[t[i].charCodeAt(0)] == 0)            count++;                     m[t[i].charCodeAt(0)]++;    }      // References of Window    let i = 0;    let j = 0;      // Traversing the window    while (j < s.length)    {                // Calculations        m[s[j].charCodeAt(0)]--;                 if (m[s[j].charCodeAt(0)] == 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].charCodeAt(0)]++;                                 if (m[s[i].charCodeAt(0)] > 0)                    count++;                  i++;            }        }        j++;    }    if (ans != Number.MAX_VALUE)        return (s).join("").substring(            start, (start + ans));    else        return "-1";} // Driver codelet s = "ADOBECODEBANC";let t = "ABC";document.write("-->Smallest window that " +               "contain all character : <br>");document.write(Minimum_Window(    s.split(""), t.split(""))); // This code is contributed by rag2127 </script>
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.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
kamikaze101
Satyendra Kumar
rathbhupendra
princiraj1992
rituraj_jain
mazharalibaig
roshankumar9
divyeshvyas562
simmytarika5
29AjayKumar
rag2127
kapoorsagar226
cyclades
iramkhalid24
abhishekkumarsingh31
Amazon
Codenation
FactSet
MakeMyTrip
sliding-window
Streamoid Technologies
Hash
Strings
Amazon
FactSet
MakeMyTrip
Codenation
Streamoid Technologies
sliding-window
Hash
Strings
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Hashing | Set 2 (Separate Chaining)
Sort string of characters
Most frequent element in an array
Counting frequencies of array elements
Sorting a Map by value in C++ STL
Reverse a string in Java
Write a program to reverse an array or string
Longest Common Subsequence | DP-4
Write a program to print all permutations of a given string
C++ Data Types