9

所以我整天都在尝试解决这个任务，就是无法完成。

以下函数接受 2 个字符串，第二个（不是第一个）可能包含*'s（星号）。
an*是字符串的替换（空，1 个字符或更多），它可以出现（仅在 s2 中）一次、两次、更多或根本不出现，它不能与另一个相邻*（ab**c），无需检查。

public static boolean samePattern(String s1, String s2)

如果字符串具有相同的模式，则返回 true。
它必须是递归的，不能使用任何循环、静态和全局变量。可以使用局部变量和方法重载。

只能使用以下方法：charAt(i), substring(i), substring(i, j), length().

例子：

1 TheExamIsEasy：；2: The*xamIs*y→ 真
1: TheExamIsEasy; 2: Th*mIsEasy*→ 真
1: TheExamIsEasy; 2: *→ 真
1: TheExamIsEasy; 2: TheExamIsEasy→ 真
1: TheExamIsEasy; 2：The*IsHard→假

我尝试使用逐个比较字符，charAt直到遇到星号，然后通过比较连续字符 ( i+1) 与s1at 位置的字符来检查星号是否为空i，如果为真 - 继续递归i+1作为s2&的计数器i作为计数器s1；
如果为假 - 继续递归i+1作为两者的计数器。
继续此操作，直到找到另一个星号或字符串结尾。

我不知道，我的大脑失去了对事物的追踪，无法集中注意力，任何指针/提示？我在正确的方向吗？

此外，据说要使用回溯技术来解决这个问题。

到目前为止我的代码（即使在理论上也不能完成这项工作）：

public static boolean samePattern(String s1, String s2) {
    if (s1.equals(s2) || s2 == "*") {
        return true;
    }
    return samePattern(s1, s2, 1);
}
public static boolean samePattern(String s1, String s2, int i)
{
    if (s1.equals(s2))
        return true;
    if (i == s2.length() - 1) // No *'s found -- not same pattern.
        return false;

    if (s1.substring(0, i).equals(s2.substring(0, i)))
        samePattern(s1, s2, i+1);
    else if (s2.charAt(i-1) == '*')
        samePattern(s1.substring(0, i-1), s2.substring(0, i), 1); // new smaller strings.
    else
        samePattern(s1.substring(1), s2, i);
}
4

5 回答 5

6

这是一些可能有帮助的 Python“伪代码”

def samePattern(s1,s2):
    if s2 == "*" or s1 == s2: return True
    if s1 == "": return False
    if s1[0] == s2[0]: return samePattern(s1[1:], s2[1:])
    if s2[0] == "*": return samePattern(s1, s2[1:]) or samePattern(s1[1:], s2)
    return False

这是转换代码的粗略指南

s[0] = the first character
s[1:] = the string minus the first character
于 2010-06-07T00:07:13.740 回答
5

您当前方法的问题在于它没有考虑 * 可以匹配的所有可能子字符串。例如，samePattern("ababababab", "a*b") 应该返回 true；* 可以匹配除字符串的第一个和最后一个字母之外的所有字母，但您的代码假定由于后面的字母是 b，因此 * 匹配空字符串。

我建议在寻找匹配项时将 samePattern 视为“消耗”它的两个输入字符串。在每一步，samePattern 应该只需要查看每个字符串的第一个字符来确定第一个字符是否可能匹配，如果是，则进行递归调用以检查字符串的其余部分。诀窍是知道当您在模式字符串中到达 * 时该怎么做，因为它可能用于匹配 s1 中的第一个字符，也可能不用于匹配。您不需要查看字符串的其余部分来决定要做什么。

由于这是家庭作业，我将不去弄清楚发生在你身上的细节，但希望这能让你思考正确的道路。

于 2010-06-06T21:37:30.743 回答
2

这是用 c# 编写的示例解决方案。抱歉没有评论，但我没有时间给他们：/如果你明天仍然需要它们，那么我可以写一些，但我希望你能抓住这个想法。

 public static bool CompareString(string s1, string s2, bool wildCard)
 {
        // Both strings are empty
        if ((s1.Length == 0) && (s2.Length == 0)) return true;

        // Second string is empty and there is wildCard character
        if (s2.Length == 0 && wildCard) return true;

        //First string is empty. Answer will be true only if all characters in second string are *.
        if (s1.Length == 0 && s2.Length > 0 && s2[0] == '*')
        {
            string newS2 = s2.Remove(0, 1);
            return CompareString(s1, newS2, true);
        }

        // One of the strings is empty, and second one is not.
        if (s1.Length * s2.Length == 0) return false;

        if (wildCard)
        {
            string newS1 = s1.Remove(0, 1);
            if (CompareString(newS1,s2,true) || CompareString(newS1,s2,false))
            {
                return true;
            }
        }
        else
        {
            if (s2[0] == '*')
            {
                string newS2 = s2.Remove(0,1);
                if (CompareString(s1,newS2,true) || CompareString(s1,newS2,false))
                {
                    return true;
                }
            }
            else
            {
                if (s1[0] == s2[0])
                {
                    string newS1 = s1.Remove(0,1);
                    string newS2 = s2.Remove(0,1);
                    return CompareString(newS1,newS2,false);
                }
                else
                {
                    return false;
                }
            }
        }
        return false;
    }
于 2010-06-06T21:28:39.047 回答
2

在处理这样的算法时，将问题分解成小块通常是值得的。

由于您正在解析字符串，因此请逐个字符地考虑解决方案。此外，由于您无法控制这些字符串的实际大小，因此请限制自己在任何给定时间只考虑字符串的第一个字符。（嗯 - 除了一个例外）

一旦你确定你正在处理的字符需要进一步调查字符串的其余部分，就把它们扔掉；保留它们只会增加复杂性，那何必呢？（相反，如果字符完全不匹配，你就完成了 - 对吗？）

当然，这是对字符串的递归，因此您必须有几个条件来控制失败/成功，以处理字符串的整体状态——但这些不是问题的核心——检查状态函数顶部的字符串，然后继续。

我有一个算法（11 行代码，加上大括号），如果你想要一个完整的解决方案，我可以发布它 - 但我不确定你的消息是想得到算法，还是只是指针。

于 2010-06-06T22:13:58.443 回答
1

这是我解决它的方法...

public static void main(String[] args)
{
    System.out.println(samePattern("TheExamIsEasy", "The*xamIs*y")); // True
    System.out.println(samePattern("TheExamIsEasy", "Th*mIsEasy*")); // True
    System.out.println(samePattern("TheExamIsEasy", "*")); // True
    System.out.println(samePattern("TheExamIsEasy", "TheExamIsEasy")); // True
    System.out.println(samePattern("TheExamIsEasy", "The*IsHard")); // false
}

public static boolean samePattern(String s1, String s2)
{
    if (s1.length() == 0 && s2.length() == 0 || 
            s1.length() == 0 && s2.length() == 1 && s2.charAt(0) == '*')
        return true;
    
    if (s1.length() == 0 || s2.length() == 0)
        return false;           
    
    if (s1.charAt(0) == s2.charAt(0))
        return samePattern(s1.substring(1), s2.substring(1));
    
    boolean r1 = samePattern(s1, s2.substring(1));
    boolean r2 = samePattern(s1.substring(1), s2);
    
    return r1 || r2;
}
于 2021-05-01T21:24:20.777 回答