Find All Anagrams in a String solution and explanation

def findAnagrams(s, p):
    from collections import Counter
    p_count = Counter(p)
    s_count = Counter(s[:len(p) - 1])
    result = []

    for i in range(len(p) - 1, len(s)):
        s_count[s[i]] += 1  # Include the new character in the window
        if s_count == p_count:  # Compare window with p
            result.append(i - len(p) + 1)  # Append the start index
        s_count[s[i - len(p) + 1]] -= 1  # Remove the character sliding out of the window
        if s_count[s[i - len(p) + 1]] == 0:
            del s_count[s[i - len(p) + 1]]  # Clean up the count dictionary

    return result

function findAnagrams(s, p) {
    const pCount = new Array(26).fill(0);
    const sCount = new Array(26).fill(0);
    const result = [];
    const aCharCode = 'a'.charCodeAt(0);

    for (const char of p) {
        pCount[char.charCodeAt(0) - aCharCode]++;
    }
    
    for (let i = 0; i < s.length; i++) {
        sCount[s[i].charCodeAt(0) - aCharCode]++;

        if (i >= p.length) {
            sCount[s[i - p.length].charCodeAt(0) - aCharCode]--;
        }

        if (arraysEqual(pCount, sCount)) {
            result.push(i - p.length + 1);
        }
    }
    return result;
}

function arraysEqual(arr1, arr2) {
    for (let i = 0; i < 26; i++) {
        if (arr1[i] !== arr2[i]) return false;
    }
    return true;
}

import java.util.*;

public class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        List<Integer> result = new ArrayList<>();
        if (p.length() > s.length()) return result;

        int[] pCount = new int[26];
        int[] sCount = new int[26];

        for (char c : p.toCharArray()) {
            pCount[c - 'a']++;
        }

        for (int i = 0; i < s.length(); i++) {
            sCount[s.charAt(i) - 'a']++;

            if (i >= p.length()) {
                sCount[s.charAt(i - p.length()) - 'a']--;
            }

            if (Arrays.equals(pCount, sCount)) {
                result.add(i - p.length + 1);
            }
        }
        return result;
    }
}

#include <vector>
#include <string>
#include <unordered_map>
using namespace std;

vector<int> findAnagrams(string s, string p) {
    unordered_map<char, int> p_count, s_count;
    vector<int> result;
    int pl = p.size(), sl = s.size();

    if (pl > sl) return result;

    for (int i = 0; i < pl; i++) {
        p_count[p[i]]++;
        s_count[s[i]]++;
    }

    for (int i = pl; i < sl; i++) {
        if (p_count == s_count) {
            result.push_back(i - pl);
        }
        s_count[s[i]]++;
        s_count[s[i - pl]]--;
        if (s_count[s[i - pl]] == 0) {
            s_count.erase(s[i - pl]);
        }
    }

    if (p_count == s_count) {
        result.push_back(sl - pl);
    }
    return result;
}

function findAnagrams(s: string, p: string): number[] {
    const m = s.length;
    const n = p.length;
    const ans: number[] = [];
    if (m < n) {
        return ans;
    }
    const cnt1: number[] = new Array(26).fill(0);
    const cnt2: number[] = new Array(26).fill(0);
    const idx = (c: string) => c.charCodeAt(0) - 'a'.charCodeAt(0);
    for (const c of p) {
        ++cnt1[idx(c)];
    }
    for (const c of s.slice(0, n - 1)) {
        ++cnt2[idx(c)];
    }
    for (let i = n - 1; i < m; ++i) {
        ++cnt2[idx(s[i])];
        if (cnt1.toString() === cnt2.toString()) {
            ans.push(i - n + 1);
        }
        --cnt2[idx(s[i - n + 1])];
    }
    return ans;
}

public class Solution {
    public IList<int> FindAnagrams(string s, string p) {
        int m = s.Length, n = p.Length;
        IList<int> ans = new List<int>();
        if (m < n) {
            return ans;
        }
        int[] cnt1 = new int[26];
        int[] cnt2 = new int[26];
        for (int i = 0; i < n; ++i) {
            ++cnt1[p[i] - 'a'];
        }
        for (int i = 0, j = 0; i < m; ++i) {
            int k = s[i] - 'a';
            ++cnt2[k];
            while (cnt2[k] > cnt1[k]) {
                --cnt2[s[j++] - 'a'];
            }
            if (i - j + 1 == n) {
                ans.Add(j);
            }
        }
        return ans;
    }
}

func findAnagrams(s string, p string) (ans []int) {
	m, n := len(s), len(p)
	if m < n {
		return
	}
	cnt1 := [26]int{}
	cnt2 := [26]int{}
	for _, c := range p {
		cnt1[c-'a']++
	}
	for _, c := range s[:n-1] {
		cnt2[c-'a']++
	}
	for i := n - 1; i < m; i++ {
		cnt2[s[i]-'a']++
		if cnt1 == cnt2 {
			ans = append(ans, i-n+1)
		}
		cnt2[s[i-n+1]-'a']--
	}
	return
}

impl Solution {
    pub fn find_anagrams(s: String, p: String) -> Vec<i32> {
        let (s, p) = (s.as_bytes(), p.as_bytes());
        let (m, n) = (s.len(), p.len());
        let mut ans = vec![];
        if m < n {
            return ans;
        }

        let mut cnt = [0; 26];
        for i in 0..n {
            cnt[(p[i] - b'a') as usize] += 1;
            cnt[(s[i] - b'a') as usize] -= 1;
        }
        for i in n..m {
            if cnt.iter().all(|&v| v == 0) {
                ans.push((i - n) as i32);
            }
            cnt[(s[i] - b'a') as usize] -= 1;
            cnt[(s[i - n] - b'a') as usize] += 1;
        }
        if cnt.iter().all(|&v| v == 0) {
            ans.push((m - n) as i32);
        }
        ans
    }
}