Question

2108. 找出数组中的第一个回文字符串

English Version

题目描述

给你一个字符串数组 words ，找出并返回数组中的 第一个回文字符串 。如果不存在满足要求的字符串，返回一个 空字符串_ _"" 。

回文字符串 的定义为：如果一个字符串正着读和反着读一样，那么该字符串就是一个 回文字符串 。

 

示例 1：

输入：words = ["abc","car","ada","racecar","cool"]
输出："ada"
解释：第一个回文字符串是 "ada" 。
注意，"racecar" 也是回文字符串，但它不是第一个。

示例 2：

输入：words = ["notapalindrome","racecar"]
输出："racecar"
解释：第一个也是唯一一个回文字符串是 "racecar" 。

示例 3：

输入：words = ["def","ghi"]
输出：""
解释：不存在回文字符串，所以返回一个空字符串。

 

提示：

• 1 <= words.length <= 100
• 1 <= words[i].length <= 100
• words[i] 仅由小写英文字母组成

解法

方法一：模拟

遍历数组 words，对于每个字符串 w，判断其是否为回文字符串，如果是，则返回 w，否则继续遍历。

判断一个字符串是否为回文字符串，可以使用双指针，分别指向字符串的首尾，向中间移动，判断对应的字符是否相等。如果遍历完整个字符串，都没有发现不相等的字符，则该字符串为回文字符串。

时间复杂度 $O(L)$，空间复杂度 $O(1)$，其中 $L$ 为数组 words 中所有字符串的长度之和。

class Solution:
  def firstPalindrome(self, words: List[str]) -> str:
    return next((w for w in words if w == w[::-1]), "")

class Solution {
  public String firstPalindrome(String[] words) {
    for (var w : words) {
      boolean ok = true;
      for (int i = 0, j = w.length() - 1; i < j && ok; ++i, --j) {
        if (w.charAt(i) != w.charAt(j)) {
          ok = false;
        }
      }
      if (ok) {
        return w;
      }
    }
    return "";
  }
}

class Solution {
public:
  string firstPalindrome(vector<string>& words) {
    for (auto& w : words) {
      bool ok = true;
      for (int i = 0, j = w.size() - 1; i < j; ++i, --j) {
        if (w[i] != w[j]) {
          ok = false;
        }
      }
      if (ok) {
        return w;
      }
    }
    return "";
  }
};

func firstPalindrome(words []string) string {
  for _, w := range words {
    ok := true
    for i, j := 0, len(w)-1; i < j && ok; i, j = i+1, j-1 {
      if w[i] != w[j] {
        ok = false
      }
    }
    if ok {
      return w
    }
  }
  return ""
}

function firstPalindrome(words: string[]): string {
  for (const word of words) {
    let left = 0;
    let right = word.length - 1;
    while (left < right) {
      if (word[left] !== word[right]) {
        break;
      }
      left++;
      right--;
    }
    if (left >= right) {
      return word;
    }
  }
  return '';
}

impl Solution {
  pub fn first_palindrome(words: Vec<String>) -> String {
    for word in words.iter() {
      let s = word.as_bytes();
      let mut left = 0;
      let mut right = s.len() - 1;
      while left < right {
        if s[left] != s[right] {
          break;
        }
        left += 1;
        right -= 1;
      }
      if left >= right {
        return word.clone();
      }
    }
    String::new()
  }
}

char* firstPalindrome(char** words, int wordsSize) {
  for (int i = 0; i < wordsSize; i++) {
    int left = 0;
    int right = strlen(words[i]) - 1;
    while (left < right) {
      if (words[i][left] != words[i][right]) {
        break;
      }
      left++;
      right--;
    }
    if (left >= right) {
      return words[i];
    }
  }
  return "";
}