It’s an easy problem with description being:

You are given a 0-indexed array of strings words and a character x.

Return an array of indices representing the words that contain the character x.

Note that the returned array may be in any order.

Example 1:

Input: words = ["leet","code"], x = "e"
Output: [0,1]
Explanation: "e" occurs in both words: "leet", and "code". Hence, we return indices 0 and 1.

Example 2:

Input: words = ["abc","bcd","aaaa","cbc"], x = "a"
Output: [0,2]
Explanation: "a" occurs in "abc", and "aaaa". Hence, we return indices 0 and 2.

Example 3:

Input: words = ["abc","bcd","aaaa","cbc"], x = "z"
Output: []
Explanation: "z" does not occur in any of the words. Hence, we return an empty array.

Constraints:

1 <= words.length <= 50

1 <= words[i].length <= 50

x is a lowercase English letter.

words[i] consists only of lowercase English letters.

To solve this problem you will need to iterate the words list, on each word check if contains the char, if so you store it’s index into a response list:

class Solution {
    public List<Integer> findWordsContaining(String[] words, char x) {
        // create response
        final List<Integer> indexes = new ArrayList<>();

        // iterate words string array
        for(int i=0;i<words.length;i++){
            // check if char exists into the word
            if(words[i].indexOf(x) != -1){
                indexes.add(i); // if yes add index into the response
            }
        }

        // return searched indexes
        return indexes;
    }
}

Runtime: 1ms, faster than 100.00% of Java online submissions.

Memory Usage: 44.95 MB, less than 49.76% of Java online submissions.

—

If you want to go into a lambda/function approach, which usually is cleaner but takes more toll on performance, it would look like this:

class Solution {
    public List<Integer> findWordsContaining(String[] words, char x) {
        return IntStream.range(0, words.length)
                .boxed() // convert primitive into Class related (int -> Integer)
                .map(i -> getIndexIfCharExistsInWord(words[i], i, x))
                .filter(Objects::nonNull) // to remove null ones from mapping
                .collect(Collectors.toList());
    }

    public Integer getIndexIfCharExistsInWord(final String word, final int i, final char x) {
        return word.indexOf(x) != -1 ? i : null;
    }
}

Runtime: 9ms, faster than 2.72% of Java online submissions.

Memory Usage: 44.90 MB, less than 66.32% of Java online submissions.

—

That’s it! If there is anything thing else to discuss feel free to drop a comment, if I missed anything let me know so I can update accordingly.

Until next post! :)