Java Google Foobar，字符串清理，未通过测试5

我正在接受谷歌挑战，目前处于3级。这个问题叫做字符串清理

你的间谍，贝塔兔，已经设法潜入了一个疯狂科学家的实验室，他们正在把兔子变成僵尸。他给你发了一条短信，但被一个海盗截获了 通过多次在文本中重复插入同一个单词来混淆消息。在每一步中，他可能会在任何地方插入单词，包括开头或结尾，或者 甚至是他在上一步插入的单词的副本。通过给海盗一个dubloon，你可以让他告诉你这个词是什么。几瓶朗姆酒之后，他还告诉你 原始文本是通过反复删除该单词而形成的尽可能短的字符串，并且该文本实际上是所有可能的文本中最早的词典字符串 最短的候选人。利用这些信息，你能计算出你的间谍最初发送了什么信息吗

例如，如果文本的最后一块是“lolol”，插入的单词是“lol”，则最短的字符串是“ol”（从文本中删除“lol”） 开头）和“lo”（从末尾删除“lol”）。因此，原始文本必须是“lo”，这是词典编纂最早的字符串

编写一个名为answer（chunk，word）的函数，该函数返回最短的、词典编纂最早的字符串，该字符串可以通过从chunk中删除出现的单词而形成。请记住 引用可能是嵌套的，删除一个引用可能会导致另一个引用。例如，从“aabb”中删除“ab”会导致另一个不可用的“ab” 原来是现在的。还要记住，间谍的原始消息可能是一个空字符串

区块和单词将仅由小写字母[a-z]组成。 区块将不超过20个字符。 word将至少有一个字符，且不超过区块中的字符数

测试用例 投入： （string）chunk=“lolo” （字符串）word=“lol” 输出： （字符串）“looo”

投入： （字符串）chunk=“GoodGooogood” （字符串）word=“goo” 输出： （字符串）“狗粮”

这是我的密码：

public class Answer {   
public static String answer(String chunk, String word)
{
    if (compareString(chunk, word)) return "";
    String s1 = checkBack(chunk, word);
    String s2 = checkFront(chunk, word);
    if (s2.length() < s1.length()) return s2;
    else return s1;
}

private static String checkBack(String chunk, String word)
{
    if (compareString(chunk, word)) return "";
    if (chunk.length() <= word.length()) return chunk;
    for (int i = chunk.length(); i >= word.length(); i--)
    {
        if (compareString(chunk.substring(i-word.length(), i), word))
        {
            return checkBack(removeAt(i-word.length(), i-1, chunk), word);
        }
    }
    return chunk;
}

private static String checkFront(String chunk, String word)
{
    if (compareString(chunk, word)) return "";
    if (chunk.length() <= word.length()) return chunk;
    for (int i = 0; i < chunk.length()-word.length(); i++)
    {
        if (compareString(chunk.substring(i, word.length()+i), word))
        {
            return checkFront(removeAt(i, word.length()+i-1, chunk), word);
        }
    }
    return chunk;
}

private static String removeAt(int startIndex, int endIndex, String input)
{
   if (endIndex+1 == input.length())
   {
       return input.substring(0, startIndex);
   }
   else 
   {
      return input.substring(0, startIndex) + input.substring(endIndex+1);
   }
 }

 private static boolean compareString(String s1, String s2)
 {
   char[] c1 = s1.toCharArray();
   char[] c2 = s2.toCharArray();
   if (c1.length != c2.length) return false;
   for (int i = 0; i < c1.length; i++)
   {
       if (c1[i] != c2[i]) return false;      
   }
   return true;
 }

公共类答案{
公共静态字符串应答（字符串块、字符串字）
{
if（compareString（chunk，word））返回“”；
字符串s1=签回（块、字）；
字符串s2=检查前（块、字）；
if（s2.length（）在函数
CheckFront
中，您只在
CheckFront
上执行递归，而不是
CheckFront
和
CheckBack

在
核对中相同

有太多的递归，因此有太多的函数调用，这在GoogleFoobar中会非常慢。我认为迭代要好得多（这就是我使用的）

若两个字符串的长度相同，但s2是'lo'，s1是'ol'，我想你们把lexi顺序和长度弄混了

(s2.length() < s1.length()) return s2;
else return s1;

（s2.length（）

如果你有一个特殊的情况，你必须先删除中间的单词才能得到正确的结果

我没有比lance所说的更多的东西要补充，但是，我遇到了与测试5相同的问题。下面是我使用的python代码：

def string_cleaner(chunk, word):
     rev_chunk = chunk[::-1]
     rev_word = word[::-1]
     while word in chunk or rev_word in rev_chunk:
        chunk = chunk.replace(word,'')
        rev_chunk = rev_chunk.replace(rev_word,'')
     rev_chunk = rev_chunk[::-1]
     if len(rev_chunk) != len(chunk):
        solved_words = min([chunk, rev_chunk], key = len)
     else:
        solved_words_list = sorted([chunk, rev_chunk])
        solved_words = solved_words_list[0]
     return solved_words

代码也成功地运行了Ken Y-N测试用例。Lance提出了一个有趣的问题，每次数据块减少时是否有必要向前和向后检查数据块，或者您最终会得到相同的答案

例如：如果区块是'llolol'，单词是'lol'


通过在每次迭代中向前和向后检查，可以得到与只向前和向后检查相同的答案：一个空白字符串（“”）和3个字母的块（'llo'）
什么是测试5？或者你没有被告知吗？哦，还有一个你应该使用而不是你自己的。我认为，从代码检查来看，这是一个失败的测试用例：
答案（“llolol”，“lol”）；
你的代码是反向工作的，所以你得到了
“llo”
作为答案，但答案应该是
“llolol”
->
“lol”
->
”
。谢谢你，肯！你说得对，我不知道测试5是什么。测试的效果很好！谢谢你，我会更新我的代码来处理这个问题，然后再次运行它！我已经根据测试用例更新了代码。它通过了新的测试用例，但仍然没有通过测试5。