Java 如何编写函数（字符a、字符b、字符串s）？使用s.equals（"；），s.charAt（0），s.substring（1）

我正在尝试编写一个函数，该函数接受字符串s，如果字符b的每次出现总是由字符a继承，则返回true，否则返回false。 我试过：

boolean succeeds(char a, char b, String s) {
    boolean to_return = true;
    boolean seen_a = false;
    while(true) {
        if (s.equals("")) return to_return;
            char c2 = s.charAt(0);
            if (c2 == a) seen_a = true;
            if (c2 == b) {
                if (!seen_a) return false;
            }
            s = s.substring(1);
        }
    }
}

---

我想我的想法是对的。但我不知道如何把它组合起来

像这样的事情应该行得通。我还没有编译这个。希望它能让您走上正确的方向，即使可能有语法错误

public boolean succeeds(char a, char b, String s){
    boolean sawFirst= false;
    for(int i=0;i<s.length();i++){
        if(!sawA){
            if(s.charAt(i)==b)
                sawFirst = true;
        }
        else{
            if(s.charAt(i)!=a)
                return false;
            else sawFirst= false;
        }
    }
    return true;
}

public boolean成功（字符a、字符b、字符串s）{
布尔值sawFirst=false；
对于（int i=0；i这听起来像是家庭作业，所以可能是你的责任来解决细节问题，但无论如何，我脑子里总有一些建议

例如，您可以尝试：

删除临时字符串中出现的所有“ba”
如果临时字符串中没有其他字母“b”，则返回
true
否则返回
false
提示：您可以在步骤1和步骤2中使用。（单击教程/说明的链接，您应该能够在两行或三行代码中完成此操作，具体取决于您是否使用三元运算符作为返回值。）
它不必如此复杂。例如：

for (i = 0; i < s.length - 1; i++) {
  if (s.charAt(i - 1) == b && s.charAt(i) != a) {
    return false;
  }
}
return !s.endsWith(String.valueOf(b));

for（i=0；i
根据指导原则，您可以按照

while (!s.equals("")) {
    char c = s.charAt(0);  // record first char
    s = s.substring(1);    // cut off first char


    // if "first char is 'b' and next is
    // not 'a'", we can return false
    if (c == b && (s.equals("") || s.charAt(0) != a))
        return false;                
}

return true;


顺便说一句，这样做更容易：

return s.replace(""+b+a, "").indexOf(b) < 0;

返回s.replace（“+b+a）”）.indexOf（b）<0；

（我刚刚注意到这个方法最初是在中概述的）
使用s.equals（“”），s.charAt（0），s.substring（1）

这个怎么样：

public static boolean succeeds(final char a, final char b, String s)
{
if(s==null||s.equals(""))
  return true;
char previousFirstChar,newFirstChar;
previousFirstChar=s.charAt(0);
while(true)
  {
  s=s.substring(1);
  if(s.equals(""))
     {
     if(previousFirstChar==b)
       return false;
     break;
     }
  newFirstChar=s.charAt(0);
  if(previousFirstChar==b && newFirstChar!=a))
    return false;
  previousFirstChar=newFirstChar;
  }
return true;
}

假设您仅限于标题中的函数，并且希望检查每个b后面是否都跟有a（而不是相反）：您已经完成了一半，但您的逻辑有点倒退。当您遍历字符串时：

（1） 当你看到“b”时，你需要记住这个事实，所以你可能想要一个变量seen_b而不是seen_a

（2） 在下一个字符中，如果你记得你刚才看到了“b”，那么你需要确保下一个字符是“a”。因此

if (c2 == b) {
    if (!seen_a) return false;
}

你可能应该吃点类似的东西

if (seen_b) {
    if (c2 != a) return false;
}

或者更简洁地说

if (seen_b && c2 != a) return false;

（3） 因为seed_b==true意味着您看到的最后一个字符是b，所以每次看到非b的字符时，请确保将其设置回false

（4） 当字符串的最后一个字符是b时，请确保操作正确。必须返回false，因为后面没有“a”。
查看标题，我不清楚您的意思是必须使用s.equals、.charAt和.substring。但是，如果不是，您可以使用正则表达式
*b[^a].*b$
（感谢ajb）如果函数匹配
b
后接
a
以外的任何字符（或字符串末尾的特殊情况
b
），则函数将失败，例如：

请注意，如果字符串根本不包含
a
，则返回true。如果希望在这种情况下返回false，则必须先检查：

public boolean succeeds (char a, char b, String s) {

    if (s.indexOf(b) == -1)
        return false;

    String quoteda = Pattern.quote(Character.toString(a));
    String quotedb = Pattern.quote(Character.toString(b));
    return !(s.matches(".*" + quotedb + "[^" + quoteda + "].*|.*" + quotedb + "$"));

}

我们使用Pattern.quote的原因是允许它处理正则表达式中具有特殊含义的字符，例如']'

如果您不能使用正则表达式，状态机样式的方法将为您提供良好的结果：

public boolean succeeds (char a, char b, String s) {

    int state = 0;

    for (int n = 0; n < s.length(); ++ n) {
        if (state == 0) {
            if (s.charAt(n) == b)
                state = 1;
        } else if (state == 1) {
            if (s.charAt(n) == a)
                state = 0;
            else
                return false;
        }
    }

    return (state == 0);

}

public boolean成功（字符a、字符b、字符串s）{
int state=0；
对于（int n=0；n

因为只有两种状态，你可以只使用一个布尔值。
他只能使用
charAt（0）
。这不是问题所在，是吗？标题中说“使用s.equals（“”，s.charAt（0），s.substring（1）”天啊，我想你昨晚也看到了我的一个明显的超链接，不是吗？我的生活中需要你哈哈。开枪。你的意思是每次
b
之后都应该是
a
？你可以用正则表达式。请看我下面的答案。我们可以假设这个问题是家庭作业吗？前提是我们也可以假设这个问题是其中之一很少有有趣的家庭作业。来吧，发布一个答案！加入我们的7+家庭作业俱乐部，做下面的傻事。他只能使用
charAt（0）
：“使用s.equals（“”），s.charAt（0），s.substring（1）”
caba
会在您的算法中返回false，但是在
caba
中，字符b的每次出现都会被字符a所取代。OP没有说每次出现“a”都需要在“b”之前，但这是您的答案所检查的。没有修复。OP只能使用
charAt（0）
（不是
charAt（i）
）无法使用
endsWith
或
String.valueOf
.Lol。我正要评论-您没有使用
s.equals（“”）
，但刚才您做了更改，完全满足了所有要求。+1请注意，对于一个很长的字符串，这将创建大量新的字符串对象。如果最后一个字符有
b
，这将爆炸。确实如此。保存得很好！仅使用允许的方法的金星。@JosephMyers没问题，我添加了它。如果最后一个字符是b。注意那些边界条件！！聪明、缓慢、出界。
replace
和
indexOf
不在该赋值允许的方法列表中。我认为a和b可能会被颠倒。无论如何，如果顺序正确，模式应该是
s.matches（quotedb+“[^”+quoteda+“]）+quotedb+“$”
。注意那些边界条件！！对两个帐户都正确。编辑文章。谢谢。我可能真的会删除这篇文章。我不知道
public boolean succeeds (char a, char b, String s) {

    int state = 0;

    for (int n = 0; n < s.length(); ++ n) {
        if (state == 0) {
            if (s.charAt(n) == b)
                state = 1;
        } else if (state == 1) {
            if (s.charAt(n) == a)
                state = 0;
            else
                return false;
        }
    }

    return (state == 0);

}