Shortest Completing Word solution and explanation

from collections import Counter

def shortestCompletingWord(licensePlate, words):
    # Extract only the letters from the licensePlate and convert to lowercase
    filtered_letters = ''.join([char.lower() for char in licensePlate if char.isalpha()])
    # Count the frequency of the required letters
    plate_count = Counter(filtered_letters)
    result = None

    for word in words:
        word_count = Counter(word)
        # Check if word_count has all required letters in necessary frequency
        if all(word_count[char] >= plate_count[char] for char in plate_count):
            if result is None or len(word) < len(result):
                result = word

    return result

function shortestCompletingWord(licensePlate, words) {
    const getCharCount = (str) => {
        const count = {};
        for (let char of str.toLowerCase()) {
            if (char >= 'a' && char <= 'z') {
                count[char] = (count[char] || 0) + 1;
            }
        }
        return count;
    };
    const plateCount = getCharCount(licensePlate);
    let result = null;

    for (let word of words) {
        const wordCount = getCharCount(word);
        let isCompleting = true;
        for (const char in plateCount) {
            if ((wordCount[char] || 0) < plateCount[char]) {
                isCompleting = false;
                break;
            }
        }
        if (isCompleting && (!result || word.length < result.length)) {
            result = word;
        }
    }
    return result;
}

import java.util.*;

public class Solution {
    public String shortestCompletingWord(String licensePlate, String[] words) {
        // Extract only letters and convert to lowercase
        String filtered = licensePlate.toLowerCase().replaceAll("[^a-z]", "");
        int[] plateCount = new int[26];
        // Count occurrences of each character in the licensePlate
        for (char c : filtered.toCharArray()) {
            plateCount[c - 'a']++;
        }

        String result = null;
        for (String word : words) {
            int[] wordCount = new int[26];
            for (char c : word.toCharArray()) {
                wordCount[c - 'a']++;
            }

            boolean isCompleting = true;
            for (int i = 0; i < 26; i++) {
                if (plateCount[i] > 0 && wordCount[i] < plateCount[i]) {
                    isCompleting = false;
                    break;
                }
            }

            if (isCompleting && (result == null || word.length() < result.length())) {
                result = word;
            }
        }

        return result;
    }
}

using System;
using System.Linq;

public class Solution {
    public string ShortestCompletingWord(string licensePlate, string[] words) {
        var required = licensePlate.ToLower().Where(char.IsLetter).GroupBy(x => x)
            .ToDictionary(g => g.Key, g => g.Count());

        string shortestWord = null;

        foreach (var word in words) {
            var wordCount = word.GroupBy(x => x).ToDictionary(g => g.Key, g => g.Count());
            bool isCompleting = required.All(kvp => wordCount.ContainsKey(kvp.Key) && wordCount[kvp.Key] >= kvp.Value);

            if (isCompleting && (shortestWord == null || word.Length < shortestWord.Length)) {
                shortestWord = word;
            }
        }

        return shortestWord;
    }
}

class Solution {
public:
    string shortestCompletingWord(string licensePlate, vector<string>& words) {
        int cnt[26]{};
        for (char& c : licensePlate) {
            if (isalpha(c)) {
                ++cnt[tolower(c) - 'a'];
            }
        }
        string ans;
        for (auto& w : words) {
            if (ans.size() && ans.size() <= w.size()) {
                continue;
            }
            int t[26]{};
            for (char& c : w) {
                ++t[c - 'a'];
            }
            bool ok = true;
            for (int i = 0; i < 26; ++i) {
                if (cnt[i] > t[i]) {
                    ok = false;
                    break;
                }
            }
            if (ok) {
                ans = w;
            }
        }
        return ans;
    }
};

function shortestCompletingWord(licensePlate: string, words: string[]): string {
    const cnt: number[] = Array(26).fill(0);
    for (const c of licensePlate) {
        const i = c.toLowerCase().charCodeAt(0) - 97;
        if (0 <= i && i < 26) {
            ++cnt[i];
        }
    }
    let ans = '';
    for (const w of words) {
        if (ans.length && ans.length <= w.length) {
            continue;
        }
        const t = Array(26).fill(0);
        for (const c of w) {
            ++t[c.charCodeAt(0) - 97];
        }
        let ok = true;
        for (let i = 0; i < 26; ++i) {
            if (t[i] < cnt[i]) {
                ok = false;
                break;
            }
        }
        if (ok) {
            ans = w;
        }
    }
    return ans;
}

func shortestCompletingWord(licensePlate string, words []string) (ans string) {
	cnt := [26]int{}
	for _, c := range licensePlate {
		if unicode.IsLetter(c) {
			cnt[unicode.ToLower(c)-'a']++
		}
	}
	for _, w := range words {
		if len(ans) > 0 && len(ans) <= len(w) {
			continue
		}
		t := [26]int{}
		for _, c := range w {
			t[c-'a']++
		}
		ok := true
		for i, v := range cnt {
			if t[i] < v {
				ok = false
				break
			}
		}
		if ok {
			ans = w
		}
	}
	return
}

impl Solution {
    pub fn shortest_completing_word(license_plate: String, words: Vec<String>) -> String {
        let mut cnt = vec![0; 26];
        for c in license_plate.chars() {
            if c.is_ascii_alphabetic() {
                cnt[((c.to_ascii_lowercase() as u8) - b'a') as usize] += 1;
            }
        }
        let mut ans = String::new();
        for w in words {
            if !ans.is_empty() && w.len() >= ans.len() {
                continue;
            }
            let mut t = vec![0; 26];
            for c in w.chars() {
                t[((c as u8) - b'a') as usize] += 1;
            }
            let mut ok = true;
            for i in 0..26 {
                if t[i] < cnt[i] {
                    ok = false;
                    break;
                }
            }
            if ok {
                ans = w;
            }
        }
        ans
    }
}