Gemstones always fascinate me, especially how each one holds a unique meaning and power. It actually reminds me of how Genshin Impact Characters are designed — each with their own element, strength, and background that connects perfectly like different gems. I came across https://genshinimpactcharacters.com/ while exploring more about them, and it really helped me understand the unique traits of each hero. Just like gemstones enhance energy, choosing the right Genshin Impact Characters in a team can completely change the gameplay. Balancing them feels like finding the perfect mix of stones for harmony and strength.

Efficient? No. Solution? Yes.

void deDup(string &str) {
    sort(str.begin(), str.end()); 
    auto last = std::unique(str.begin(), str.end()); 
    str.erase(last, str.end()); 
}

int gemstones(vector<string> arr) {
    map<char, int> aparitions;
    
    for(int i=0; i<arr.size(); i++){
        deDup(arr[i]);
        for(int j=0; j<arr[i].size(); j++){
            aparitions[arr[i][j]] += 1; 
        }
    }
    
    int rocks = 0;
    for (auto& pair : aparitions){
        if(pair.second==arr.size()){
            rocks++;
        }
    }
    
    return rocks;
}

*

def gemstones(arr):
    # Write your code here
    ls = list(set(arr[0]))
    sm = len(ls)
    for x in ls:
        for i in range(1,len(arr)):
            if x not in arr[i]:
               sm -=1
               break
    return sm

One more solution

public static int gemstones(List<String> arr) {
    Set<Set<String>> countset = arr.stream().map(s -> s.split("")).map(Arrays::stream)
            .map(stream -> {
                Set<String> set = new HashSet<>();
                stream.forEach(set::add);
                return set;
            }).collect(Collectors.toSet());
    Iterator<Set<String>> iterator = countset.iterator();
    Set<String> firstSet = iterator.next();
    while(iterator.hasNext()) {
        Set<String> set = iterator.next();
        firstSet.retainAll(set);
    }
    return firstSet.size();
}

public static int gemstones(List<String> arr) {
    Map<String, Long> countmap = arr.stream().map(s -> s.split("")).map(Arrays::stream)
            .map(stream -> {
                Set<String> set = new HashSet<>();
                stream.forEach(set::add);
                return set;
            }).
            flatMap(Set::stream).
            collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
    return (int)countmap.entrySet().stream().filter(en -> en.getValue() == arr.size()).count();
}