每日一题-查找包含给定字符的单词🟢

2025年5月24日 00:00

给你一个下标从 0 开始的字符串数组 words 和一个字符 x 。

请你返回一个 下标数组 ，表示下标在数组中对应的单词包含字符 x 。

注意，返回的数组可以是任意顺序。

示例 1：

输入：words = ["leet","code"], x = "e"
输出：[0,1]
解释："e" 在两个单词中都出现了："leet" 和 "code" 。所以我们返回下标 0 和 1 。

示例 2：

输入：words = ["abc","bcd","aaaa","cbc"], x = "a"
输出：[0,2]
解释："a" 在 "abc" 和 "aaaa" 中出现了，所以我们返回下标 0 和 2 。

示例 3：

输入：words = ["abc","bcd","aaaa","cbc"], x = "z"
输出：[]
解释："z" 没有在任何单词中出现。所以我们返回空数组。

提示：

1 <= words.length <= 50
1 <= words[i].length <= 50
x 是一个小写英文字母。
words[i] 只包含小写英文字母。

正则表达式判断字符串中是否含有某个字符

LeetCode 每日一题题解

infallible-almeidazkc

2024年1月11日 13:50

Problem: 2942. 查找包含给定字符的单词

[TOC]

思路

单层for循环判断每个字符串中是否含有某个字符

解题方法

先定义一个正则表达式，然后利用Sting中的matches方法进行判断，存在则add到list中

复杂度

时间复杂度:

添加时间复杂度, 示例： $O(n)$

空间复杂度:

添加空间复杂度, 示例： $O(n)$

Code

###Java

class Solution {
    public List<Integer> findWordsContaining(String[] words, char x) {
        List list = new ArrayList();
        String pattern = ".*" + x + ".*";
        for(int i =0;i < words.length;i++){
            if(words[i].matches(pattern)){
                list.add(i);
            }
        }

        return list;
    }
}

简单易懂，通过头文件方法解决

LeetCode 每日一题题解

relaxed-7ehmannbgd

2023年11月28日 16:11

Problem: 2942. 查找包含给定字符的单词

[TOC]

思路

这题很简单，通过头文件自带的方法判断其返回值就可以了

解题方法

暴力

复杂度

时间复杂度:O(n)

空间复杂度:O(n)

Code

###C


/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* findWordsContaining(char** words, int wordsSize, char x, int* returnSize) {
    int *arr =(int*)malloc(sizeof(int)*wordsSize);
    int index=0;
    for(int i=0;i<wordsSize;i++){
        if(strchr(words[i],x)){
            arr[index++]=i;
        }
    }
    *returnSize = index;
    return arr;
}

库函数写法（Python/Java/C++/C/Go/JS/Rust）

LeetCode 每日一题题解

endlesscheng

2023年11月26日 19:05

遍历 $\textit{words}$，判断 $x$ 是否在 $\textit{words}[i]$ 中，如果是则把 $i$ 加入答案。

###py

class Solution:
    def findWordsContaining(self, words: List[str], x: str) -> List[int]:
        return [i for i, s in enumerate(words) if x in s]

###java

class Solution {
    public List<Integer> findWordsContaining(String[] words, char x) {
        List<Integer> ans = new ArrayList<>();
        for (int i = 0; i < words.length; i++) {
            if (words[i].indexOf(x) >= 0) {
                ans.add(i);
            }
        }
        return ans;
    }
}

###java

class Solution {
    public List<Integer> findWordsContaining(String[] words, char x) {
        return IntStream.range(0, words.length)
                        .filter(i -> words[i].indexOf(x) >= 0)
                        .boxed()
                        .collect(Collectors.toList());
    }
}

###cpp

class Solution {
public:
    vector<int> findWordsContaining(vector<string>& words, char x) {
        vector<int> ans;
        for (int i = 0; i < words.size(); i++) {
            if (words[i].contains(x)) {
                ans.push_back(i);
            }
        }
        return ans;
    }
};

###c

int* findWordsContaining(char** words, int wordsSize, char x, int* returnSize) {
    int* ans = malloc(sizeof(int) * wordsSize);
    int k = 0;
    for (int i = 0; i < wordsSize; i++) {
        if (strchr(words[i], x)) {
            ans[k++] = i;
        }
    }
    *returnSize = k;
    return ans;
}

###go

func findWordsContaining(words []string, x byte) (ans []int) {
for i, s := range words {
if strings.IndexByte(s, x) >= 0 {
ans = append(ans, i)
}
}
return
}

###js

var findWordsContaining = function(words, x) {
    const ans = [];
    for (let i = 0; i < words.length; i++) {
        if (words[i].includes(x)) {
            ans.push(i);
        }
    }
    return ans;
};

###rust

impl Solution {
    pub fn find_words_containing(words: Vec<String>, x: char) -> Vec<i32> {
        words.into_iter()
             .enumerate()
             .filter_map(|(i, s)| s.contains(x).then_some(i as i32))
             .collect()
    }
}

###rust

impl Solution {
    pub fn find_words_containing(words: Vec<String>, x: char) -> Vec<i32> {
        let mut ans = vec![];
        for (i, s) in words.into_iter().enumerate() {
            if s.contains(x) {
                ans.push(i as i32);
            }
        }
        ans
    }
}