Java中的字符串操作问题

我昨天在面试中问了以下两个问题

1> 给定一个字符串，计算一个新字符串，其中原始字符串中相邻的相同字符之间用“*”分隔

示例如下所示：：
函数名为

publicstringpairstar（stringstr）

2> 给定一个字符串，计算一个新字符串，其中所有小写“x”字符都已移动到该字符串的末尾

示例如下所示：：
函数名为

publicstringendx（stringstr）

---

我不知道如何完成给定的一组问题，并且正在努力解决这个问题。在第一种情况下，您可以遍历字符串，跟踪上一个字符并将其与当前字符进行比较。使用StringBuilder生成新字符串

在第二种情况下，使用两个字符串生成器（一个用于x以外的字符，另一个用于x）遍历，最后将它们组合起来

public String endX(String str) {
  int i = 0;
  if (str.length() == 0)
    return str;
  else if (str.charAt(i) == 'x')
    return endX(str.substring(i+1)) + 'x' ;
  return str.charAt(i) + endX(str.substring(i+1));
}

这在30秒内就从我的脑海中消失了，这是最简单的方法。第二个想法是，我可能会使用正则表达式，现在我再考虑10秒钟：）

对于1），这里有一个非常简单的正则表达式方法：

  String in = "helllo goodbye";
  String out = in.replaceAll("(.)(?=\\1)", "$1*");
  System.out.println(out);

印刷品：

hel*l*lo go*odbye

说明：

(.)     //match any one character into group 1
(?=\\1) //positive lookahead for that same character by backreferencing group 1

$1*     //replace that one character with the character followed by *

我可能会在晚些时候试一下，但我不喜欢把多个问题放在一个问题里

编辑 好吧，因为我现在心情很好，这里有2个：

---

这会将

x（某物）

替换为

（某物）x

，直到所有

x

都位于字符串的末尾。我确信有一种比正则表达式更好的方法来完成这项工作。

对于1，您需要一个具有两种状态的状态机：（a）不同于先前的状态机；（b）与先前的状态机相同。起始状态为（a）。对于每个字母，您必须检查处于哪个状态，输出一个字符并相应地更改状态。对于在状态（b）中读取的每个字母，还输出一个“*”

对于2，您需要一个数组，在该数组中可以向左移动元素，并在末尾推动。 1.在结束时推送监控器令牌（用于停止条件） 2.迭代所有字母：当找到一个“x”时，将所有元素向左移动，在末尾按x，然后计算你看到的x的数量。

---

3.看到监视器令牌时停止

我通常会用psuedo代码引发类似的问题，然后转到实际实现

对于问题1，以下是我脑海中的psuedo代码是如何工作的

for each character in the input string{
 if the previous character is the same{
  append a star to output string
 }
 append the character to the output string
}

问题2

for each character in the input string{
  if character is an x{
   increment x counter
  } else {
   append the character to the output string
  }
}
x counter times{
  append x to the output string
}

---

关于第一个问题：

public class StreamGobbler {

    public static void main(String[] a) {

        String s = "xxyy";

        StringBuffer sb = new StringBuffer(s);

        for(int i=0; i < sb.length()-1; i++) {
            if(sb.charAt(i) == sb.charAt(i+1)) {
                sb.insert(i+1, "*");
                i++;
            }
        }

        System.out.println(sb.toString());
    }
}

公共类StreamGobbler{
公共静态void main（字符串[]a）{
字符串s=“xxyy”；
StringBuffer sb=新的StringBuffer；
对于（int i=0；i

---

打印：x*xy*y

也许我误解了这个问题，但如果不是的话，似乎很简单。您的方法可能类似于数字1：

public String pairStar(String s) {
    StringBuilder answer = new StringBuilder();
    char lastChar = s.charAt(0);
    answer.append(lastChar);

    for (int i = 1; i < s.length(); i++) {
        char currentChar = s.charAt(i);

        if (currentChar == lastChar) {
             answer.append("*");
        }
        answer.append(currentChar);
        lastChar = currentChar;
    }
    return answer.toString();
}

公共字符串pairStar（字符串s）{
StringBuilder answer=新建StringBuilder（）；
char lastChar=s.charAt（0）；
回答：追加（lastChar）；
对于（int i=1；i

对于第二个：

循环遍历字符串，将所有非小写的x复制到一个新字符串中，同时保持x的计数。最后，只需添加相关数量的x，即可生成最终字符串

public String endX(String str)
{
    StringBuilder s = new StringBuilder();
    int x = 0;

    for (int i = 0; i < str.length(); ++i)
    {
        if (str.charAt(i) == 'x')
        {
            ++x;
        }
        else
        {
            s.append(str.charAt(i));
        }
    }

    for (int i = 0; i < x; ++i)
    {
        s.append('x');
    }

    return s.toString();
}

publicsstringendx（stringstr）
{
StringBuilder s=新的StringBuilder（）；
int x=0；
对于（int i=0；i

了解您的第一个问题

public String pairStar(String str){
        StringBuilder sb = new StringBuilder(str);
        for (int i = 0; i < sb.length()-1; i++) {
            if(sb.charAt(i)==sb.charAt(i+1)){
                sb.insert(++i, '*');
            }
        }
        return sb.toString();
    }

publicstringpairstar（stringstr）{
StringBuilder sb=新的StringBuilder（str）；
对于（int i=0；i

第二个问题呢

public String endX(String str){
        StringBuilder sb = new StringBuilder(str);
        int length = sb.length()-1;
        for (int i = 0; i < length; i++) {
            if(sb.charAt(i)=='x'){
                sb.deleteCharAt(i--);
                sb.append('x');
                length--;
            }
        }
        return sb.toString();
    }

publicsstringendx（stringstr）{
StringBuilder sb=新的StringBuilder（str）；
int length=sb.length（）-1；
for（int i=0；i

公共类识别卡{
/**
*分隔任意字符串的任意两个相同的n个相邻字符
*由一名*
*/
公共静态void main（字符串[]args）{
StringBuilder sb=新的StringBuilder（）；
字符串s=“aaabcgghelllloii”；
对于（int i=0；i+10）））{
（s.charAt（i+1））；
}
否则如果（（s.charAt（i）==s.charAt（i+1））&（i>0））{
sb.追加（“*”+s.charAt（i+1））；
}
如果（（s.charAt（i）==s.charAt（i+1））&&（i==0））{
sb.追加（s.charAt（i）+“*”+s.charAt（i+1））；
}
}
System.out.println（sb.toString（））；
}
}

---

输出：a*a*abcg*ghel*l*l*loi*i

步骤1。告诉他们把它推下去，然后改用python

第2步：

>>> strin = 'thixs ixs xan XArbitrarxy Stxrxing'
>>> xcnt = strin.count('x')
>>> result = ''.join(i for i in strin if i != 'x')
>>> result = result + ('x' * xcnt)
>>> print result
this is an XArbitrary Stringxxxxxx

---

下面是一个使用递归的简单答案：）

---

这些可以通过递归来完成

当str长度达到0时，第一个将中断。否则，它会检查当前字符和下一个字符是否相同，如果是，则返回当前字符和“*”字符串。否则它只会抓取当前字符串并循环返回。 (一)

这也是b

public String endX(String str){
        StringBuilder sb = new StringBuilder(str);
        int length = sb.length()-1;
        for (int i = 0; i < length; i++) {
            if(sb.charAt(i)=='x'){
                sb.deleteCharAt(i--);
                sb.append('x');
                length--;
            }
        }
        return sb.toString();
    }

public class IdenticalChars {

    /**
     * separates any two same n adjacent characters of any string
     * by a * 
     */
    public static void main(String[] args) {
        StringBuilder sb=new StringBuilder();
        String s="aaabcgghelllloii";
        for(int i=0;i+1<s.length();i++){
            if((s.charAt(i)!=s.charAt(i+1)&&(i==0))){
                sb.append(s.charAt(i)+" "+s.charAt(i+1));
                //System.out.println(sb.toString());
            }
            else if((s.charAt(i)!=s.charAt(i+1)&&(i>0))){
                sb.append(s.charAt(i+1));
            }
            else if((s.charAt(i)==s.charAt(i+1))&&(i>0)){
                sb.append("*"+s.charAt(i+1));

            }
            else if((s.charAt(i)==s.charAt(i+1))&&(i==0)){
                sb.append(s.charAt(i)+"*"+s.charAt(i+1));
                }
        }

        System.out.println(sb.toString());
    }

}

>>> strin = 'thixs ixs xan XArbitrarxy Stxrxing'
>>> xcnt = strin.count('x')
>>> result = ''.join(i for i in strin if i != 'x')
>>> result = result + ('x' * xcnt)
>>> print result
this is an XArbitrary Stringxxxxxx

public String pairStar(String str) {
     if(str.isEmpty())return ""; // our exit condition for recursion
     String sub1 = str.substring(0,1); // take the first char
     String sub2 = ""; 
     if(str.length()>1)sub2 = str.substring(1,2); // take second char if it it contains at least 2 chars
     if(sub1.equals(sub2)) return sub1+"*"+pairStar(str.substring(1)); //if two chars are equal putting star between
     return sub1 + pairStar(str.substring(1));//else continue as usual 
}

public String pairStar(String str) {
  int i = 0;
  if (str.length() == 0)
    return str;
  else if (str.length()-1 > i && str.charAt(i) == str.charAt(i+1))
    return str.charAt(i) + "*" + pairStar(str.substring(i+1));
  return str.charAt(i) + pairStar(str.substring(i+1));
} 

public String endX(String str) {
  int i = 0;
  if (str.length() == 0)
    return str;
  else if (str.charAt(i) == 'x')
    return endX(str.substring(i+1)) + 'x' ;
  return str.charAt(i) + endX(str.substring(i+1));
}