Smallest window in a String containing all characters of other String

using System;

class GFG {

    static bool ContainsAllCharacters(string s, string p)
    {
        int[] count = new int[256];

        // Count the frequency of each character in the
        // pattern
        foreach(char ch in p) count[ch]++;

        // For each character in the substring, decrement
        // its count
        foreach(char ch in s)
        {
            if (count[ch] > 0)
                count[ch]--;
        }

        // If all counts in the count array are zero,
        // the substring contains all characters of the
        // pattern
        foreach(int c in count)
        {
            if (c > 0)
                return false;
        }

        return true;
    }

    static string FindSmallestSubstring(string s, string p)
    {
        int m = s.Length;
        int n = p.Length;
        string smallestSubstring = "";
        int minLen = int.MaxValue;

        // Generate all substrings of the given string
        for (int i = 0; i < m; i++) {
            for (int j = i; j < m; j++) {
                string substr = s.Substring(i, j - i + 1);

                // Check if the substring contains all
                // characters of the pattern
                if (ContainsAllCharacters(substr, p)) {
                    int currLen = substr.Length;

                    // Update the smallestSubstring if the
                    // current substring is smaller
                    if (currLen < minLen) {
                        minLen = currLen;
                        smallestSubstring = substr;
                    }
                }
            }
        }

        return smallestSubstring;
    }

    static void Main(string[] args)
    {
        string s = "timetopractice";
        string p = "toc";

        string result = FindSmallestSubstring(s, p);

        if (!string.IsNullOrEmpty(result)) {
            Console.WriteLine(result);
        }
        else {
            Console.WriteLine("-1");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

class GfG {
    static bool IsValid(string s, string p, int mid,
                        out int start)
    {
        int[] count = new int[256];
        Array.Fill(count, 0);

        int distinct = 0;

        // Count the frequency of each character in p
        foreach(char x in p)
        {
            if (count[x] == 0)
                distinct++;
            count[x]++;
        }

        // Stores the number of characters in a substring of
        // size mid in s whose frequency is the same as the
        // frequency in p
        int currCount = 0;
        start = -1;
        for (int i = 0; i < s.Length; i++) {
            count[s[i]]--;
            if (count[s[i]] == 0) {
                currCount++;
            }

            if (i >= mid) {
                count[s[i - mid]]++;
                if (count[s[i - mid]] == 1) {
                    currCount--;
                }
            }

            if (i >= mid - 1) {
                // Substring of length mid found which
                // contains all the characters of p
                if (currCount == distinct) {
                    start = (i - mid) + 1;
                    return true;
                }
            }
        }

        return false;
    }

    static string SmallestWindow(string s, string p)
    {
        int m = s.Length;
        int n = p.Length;

        // If s is smaller than p, it's impossible
        if (m < n)
            return "-1";

        int minLength = int.MaxValue;

        // Lower bound and Upper Bound for Binary Search
        // The smallest valid window size is n (size of p)
        int low = n, high = m;

        int idx = -1;

        while (low <= high) {
            int mid = (low + high) / 2;
            int start;

            if (IsValid(s, p, mid, out start)) {
                if (mid < minLength) {
                    minLength = mid;
                    idx = start;
                }
                high = mid - 1;
            }
            else {
                low = mid + 1;
            }
        }

        if (idx == -1)
            return "-1";

        return s.Substring(idx, minLength);
    }

    static void Main()
    {
        string s = "timetopractice";
        string p = "toc";

        Console.WriteLine(SmallestWindow(s, p));
    }
}

using System;
using System.Collections.Generic;

public class SmallestWindow {
    public static string SmallestWindowFunc(string s, string p) {
        int len1 = s.Length;
        int len2 = p.Length;

        if (len1 < len2)
            return "-1";

        int[] countP = new int[256];
        int[] countS = new int[256];

        // Store occurrence of characters of P
        for (int i = 0; i < len2; i++)
            countP[p[i]]++;

        int start = 0, start_idx = -1, min_len = int.MaxValue;
        int count = 0;

        for (int j = 0; j < len1; j++) {
            char currChar = s[j];
            
            // Count occurrence of characters of string S
            countS[currChar]++;

            // If S's char matches with P's char, increment count
            if (countP[currChar] > 0 && countS[currChar] <= countP[currChar]) {
                count++;
            }

            // If all characters are matched
            if (count == len2) {
                
                // Try to minimize the window
                char startChar;
                while (countS[startChar = s[start]] > countP[startChar] || countP[startChar] == 0) {
                    if (countS[startChar] > countP[startChar]) {
                        countS[startChar]--;
                    }
                    start++;
                }

                // Update window size
                int len = j - start + 1;
                if (min_len > len) {
                    min_len = len;
                    start_idx = start;
                }
            }
        }

        if (start_idx == -1)
            return "-1";

        return s.Substring(start_idx, min_len);
    }

    public static void Main(string[] args) {
        string s = "timetopractice";
        string p = "toc";

        string result = SmallestWindowFunc(s, p);
        Console.WriteLine(result);
    }
}