Algorithm 在这个递归最长回文查找器中，我的逻辑错误在哪里？

我的目标是返回字节数组中最长的回文。我的算法是：

• 分支A
  • 从第一个字符到最后一个字符，字符串是回文吗？如果是，请退回
  • 如果不是，从第一个字符到最后第二个字符，字符串是回文吗
  • 如果不是，从第一个字符到最后第三个字符，字符串是回文吗
  • 剩下的字符是否少于2个？如果是这样，请转到分支A，但不要读取第一个字符，而是检查第二个字符
  • 剩下的字符是否少于2个？如果是这样，请转到分支A，但不要读取第一个字符，而是检查第三个字符
  • 剩下的字符是否少于2个？返回“无”

这个问题本质上是迭代的，但该算法在我的迭代或递归解决方案中似乎都不起作用。 到目前为止，我已经做到了：

//切片是上限独占的
//返回表达式可以是隐式的
fn是_回文（字节：&[u8]）->bool{
如果bytes.len（）==1{
真的
}如果bytes.len（）==2，则为else{
字节[0]==字节[1]
}如果字节[0]==字节[bytes.len（）-1]，则为else{
是回文（&bytes[1..bytes.len（）-1]）
}否则{
假的
}
}
fn recurse_回文选项（s:&'a[u8]）->Option此算法不起作用，因为它从左侧查找第一个回文，而不是最长的回文
 我将使用
slice:：windows
迭代长度等于或小于原始切片的所有子切片。然后我找到第一个子片段，它是回文。我还重写了
is_回文
以进行迭代：

fn is_palindrome(mut bytes: &[u8]) -> bool {
    loop {
        match bytes {
            [] | [_] => return true,
            other => {
                let (h, m) = other.split_first().unwrap();
                let (t, m) = m.split_last().unwrap();
                if h != t {
                    return false;
                }
                bytes = m;
            }
        }
    }
}

pub fn longest_palindrome(s: &[u8]) -> Option<&[u8]> {
    (0..s.len())
        .rev()
        .flat_map(|l| s.windows(l + 1))
        .filter(|ss| is_palindrome(ss))
        .next()
}

请注意，在这种情况下，我不是传递切片，而是传递第一个和最后一个索引。您尝试过调试吗？找到一个小的失败案例并调试它。我还不太了解递归回文的作用，但是
是回文的，因为
1..bytes.len（）-2
不包括端点，正如你的评论所说：
切片是上限排他性的
。看起来你的问题可能会由的答案来回答。如果没有，请回答您的问题以解释差异。否则，我们可以将此问题标记为已回答。您的论点可能不正确。你会很快发现问题所在。尤其是
#![feature(slice_patterns)]

fn is_palindrome(mut bytes: &[u8]) -> bool {
    loop {
        match bytes {
            [] | [_] => return true,
            [h, m @ .., t] => {
                if h != t {
                    return false;
                }
                bytes = m;
            }
        }
    }
}