771. Jewels and Stones

You’re given strings J representing the types of stones that are jewels, and S representing the stones you have. Each character in S is a type of stone you have. You want to know how many of the stones you have are also jewels.

The letters in J are guaranteed distinct, and all characters in J and S are letters. Letters are case sensitive, so “a” is considered a different type of stone from “A”.

Example 1:

Input: J = “aA”, S = “aAAbbbb”
Output: 3
Example 2:

Input: J = “z”, S = “ZZ”
Output: 0
Note:

S and J will consist of letters and have length at most 50.
The characters in J are distinct.

C++:

class Solution771 {
public:
       int numJewelsInStones(string J, string S) {
           vector<int> j_table(128, 0);
           for_each(J.begin(), J.end(), [&j_table](char ch){j_table[ch]=1;});
           int ret = 0;
           for_each(S.begin(), S.end(), [&ret, &j_table](char ch){if (j_table[ch]){++ret;}});
           return ret;
       }      
} 

Python:

class Solution(object):
    def numJewelsInStones(self, J, S):
        """
        :type J: str
        :type S: str
        :rtype: int
        """
        return len(filter(lambda x: x in set(J), S))


 class Solution1(object):
    def numJewelsInStones(self, J, S):
        return sum([ch in set(J) for ch in S])

Java:

package com.pku.leetcode.study;

import java.util.HashMap;
import java.util.Map;

public class Solution771 {
    public int numJewelsInStones(String J, String S) {
        int cnt = 0;
        Map<Character, Integer> map = new HashMap<>();
        for (char ch : S.toCharArray()) {
            map.put(ch, map.getOrDefault(ch, 0) + 1);
        }

        for (char ch : J.toCharArray()) {
            if (map.containsKey(ch)) {
                cnt += map.get(ch);
            }
        }

        return cnt;
    }
}

class Solution771_1 {
    public int newJewelsInStones(String J, String S) {
        HashMap<Character, Integer> map = new HashMap<Character, Integer>();
        J.chars().mapToObj(x->(char)x).forEach(x->map.put(x, 0));
        S.chars().mapToObj(x->(char)x)
        .filter(x->map.containsKey(x))
        .forEach(x->map.put(x, map.get(x) + 1));
        return map.values().stream().mapToInt(x->x).sum();
    }
}