Let's say there are 2 bottles and one trial. How many pigs do we need then? One, because we can feed the first bottle to pig 1. If it dies, then the poison is in bottle 1, otherwise, the poison is in bottle 2.

We can generalize the idea above using binary numbers. How?

Let's number the bottles from $$$1$$$ to $$$n$$$. Consider the poison bottle. I want to know whether the first digit in its binary representation is 1 or 0. To do that, I will feed pig 1 all bottles whose first digit is 1 (that is, 1, 3, 5, ...). If pig 1 dies, then the first digit is 1, otherwise it is 0. The same process can be repeated for other digits.

If we have more than 1 trial (let's say 2) we can use ternary numbers instead of binary numbers. [How?]

This way we see that the answer is $$$\lceil \log_{t + 1} (n) \rceil$$$. [This is not really a full solution, since there is no proof that we can't do it with less pigs]

We can use a set or a boolean array to count the characters.

int count(string & s) {
	set<char>st;
	for (char i : s) {
		st.insert(i);
	}
	return st.size();
}

int count(string & s) {
	int mask = 0;
	for (char i : s) {
		mask |= (1 << (i - 'a'));
	}
	return __builtin_popcount(mask);
}

class Solution {
public:
    int maxProduct(vector<string>& words) {
        vector<int> a(words.size() , 0);
        for(int i = 0;i < words.size();i++){
            for(int j = 0;j < words[i].size();j++){
                a[i] |= 1 << (words[i][j] - 'a');
            }
        }
        int res = 0;
        for(int i = 0;i < words.size();i++){
            for(int j = i + 1;j < words.size();j++){
                if((a[i] & a[j]) == 0){
                    if(words[i].size() * words[j].size() > res){
                        res = words[i].size() * words[j].size();
                    }
                }
            }
        }
        return res;
    }
};

$2^{\text{number of set bits}}

class Solution {
public:
    vector<int> findNumOfValidWords(vector<string>& words, vector<string>& puzzles) {
        vector<unordered_map<int,int>>mp(26);
        for(string & i: words){
            int p=0;
            for(char j:i){
                p |= (1<< (j-'a'));
            }
            int vis=0;
            for(char j:i){
                if(!(vis & (1 << (j-'a'))))mp[j-'a'][p]++;
                vis |= (1 << (j-'a'));
            }
        }
        vector<int>ans;
        for(string &i:puzzles){
            int p=0;
            for(char j:i){
                p |= (1<<(j-'a'));
            }
            int k=p;
            int res=0;
            int r=0;
            while(k){
                r++;
                if(mp[i[0]-'a'].count(k))res+=mp[i[0]-'a'][k];
                k=(k-1)&p;
            }
            assert(r==127);
            ans.push_back(res);
        }
        return ans;
    }
};

int g (int n) {
    return n ^ (n >> 1);
}

int rev_g (int g) { int n = 0; for (; g; g >>= 1) n ^= g; return n; }