Count Words Obtained After Adding a Letter solution and explanation

def count_obtained_words(startWords, targetWords):
    def sorted_tuple(word):
        return tuple(sorted(word))

    # Create a set of sorted character tuples for startWords
    startSet = {sorted_tuple(word) for word in startWords}

    count = 0
    for target in targetWords:
        for i in range(len(target)):
            # Remove the character at i and sort the remaining
            signature = sorted_tuple(target[:i] + target[i+1:])
            if signature in startSet:
                count += 1
                break
    return count

#include <iostream>
#include <vector>
#include <unordered_set>
#include <string>
#include <algorithm>

std::string get_sorted_signature(const std::string& word) {
    std::string sortedWord = word;
    std::sort(sortedWord.begin(), sortedWord.end());
    return sortedWord;
}

int count_obtained_words(std::vector<std::string>& startWords, std::vector<std::string>& targetWords) {
    std::unordered_set<std::string> startSet;
    for (const auto& word : startWords) {
        startSet.insert(get_sorted_signature(word));
    }

    int count = 0;
    for (const auto& target : targetWords) {
        for (size_t i = 0; i < target.size(); ++i) {
            std::string modifiedTarget = target;
            modifiedTarget.erase(modifiedTarget.begin() + i);
            if (startSet.count(get_sorted_signature(modifiedTarget))) {
                ++count;
                break;
            }
        }
    }
    return count;
}

import java.util.HashSet;

class Solution {
    private int getBitmask(String word) {
        int bitmask = 0;
        for (char ch : word.toCharArray()) {
            bitmask |= 1 << (ch - 'a');
        }
        return bitmask;
    }
    public int countObtainedWords(String[] startWords, String[] targetWords) {
        HashSet<Integer> startSet = new HashSet<>();
        for (String word : startWords) {
            startSet.add(getBitmask(word));
        }

        int count = 0;
        for (String target : targetWords) {
            int targetBitmask = getBitmask(target);
            for (char ch : target.toCharArray()) {
                int newBitmask = targetBitmask ^ (1 << (ch - 'a'));
                if (startSet.contains(newBitmask)) {
                    count++;
                    break;
                }
            }
        }
        return count;
    }
}

function countObtainedWords(startWords, targetWords) {
    const getBitmask = (word) => {
        let bitmask = 0;
        for (let char of word) {
            bitmask |= 1 << (char.charCodeAt(0) - 'a'.charCodeAt(0));
        }
        return bitmask;
    };

    const startSet = new Set();
    for (let word of startWords) {
        startSet.add(getBitmask(word));
    }

    let count = 0;
    for (let target of targetWords) {
        const targetBitmask = getBitmask(target);
        for (let char of target) {
            const newBitmask = targetBitmask ^ (1 << (char.charCodeAt(0) - 'a'.charCodeAt(0)));
            if (startSet.has(newBitmask)) {
                count++;
                break;
            }
        }
    }
    return count;
}

function wordCount(startWords: string[], targetWords: string[]): number {
    const s = new Set<number>();
    for (const w of startWords) {
        let x = 0;
        for (const c of w) {
            x ^= 1 << (c.charCodeAt(0) - 97);
        }
        s.add(x);
    }
    let ans = 0;
    for (const w of targetWords) {
        let x = 0;
        for (const c of w) {
            x ^= 1 << (c.charCodeAt(0) - 97);
        }
        for (const c of w) {
            if (s.has(x ^ (1 << (c.charCodeAt(0) - 97)))) {
                ++ans;
                break;
            }
        }
    }
    return ans;
}

func wordCount(startWords []string, targetWords []string) (ans int) {
	s := map[int]bool{}
	for _, w := range startWords {
		x := 0
		for _, c := range w {
			x |= 1 << (c - 'a')
		}
		s[x] = true
	}
	for _, w := range targetWords {
		x := 0
		for _, c := range w {
			x |= 1 << (c - 'a')
		}
		for _, c := range w {
			if s[x^(1<<(c-'a'))] {
				ans++
				break
			}
		}
	}
	return
}