删除字符串（java）中相邻的重复字符，即输入：aaaabbbccdbbaae输出：abcdbae

我的代码并没有给出预期的输出，但干运行工作正常。请看一下问题出在哪里

public static StringBuffer singleOccurence(String s)
{
 StringBuffer sb = new StringBuffer(s);
 int length=s.length();


 for(int i=0; i< length ; i++)
 {
  for(int j=i; i<length&&j<length ; j++)
  {
    if(sb.charAt(i)!=sb.charAt(j+1)) 
         i=j+1;
    else
    sb.deleteCharAt(j+1);
   } 
 }

 return sb;
}

publicstaticstringbuffersingleoccurrence（字符串s）
{
StringBuffer sb=新的StringBuffer；
int length=s.length（）；
for（int i=0；i
String input = "aaaabbbccdbbaae";
String regex = "(.)(\\1)+"; // matches any character followed by the same one(s)
String output = input.replaceAll(regex, "$1");
System.out.println(output); // abcdbae

你的方法是：

public static String singleOccurence(String s) {
    return s.replaceAll("(.)(\\1)+", "$1");
}

对我来说，这听起来很像是一个消极的展望：

 String input = "aaaaabbbbccccddd";
    Pattern p = Pattern.compile("(.)(?!\\1)");
    Matcher m = p.matcher(input);

    while(m.find()){
        System.out.println(m.group(1));
    }

你的方法做了很多不必要的工作

可以通过在字符串上迭代一次并将每个字符与其前面的字符进行比较来解决此问题：

public static StringBuilder singleOccurence(String s)
{
    StringBuilder sb = new StringBuilder();
    if (s.length() > 0) {
        char prev = s.charAt(0);
        sb.append(prev);
        for (int i = 1; i < s.length(); ++i) {
            char cur = s.charAt(i);
            if (cur != prev) {
                sb.append(cur);
                prev = cur;
            }
        }
    }
    return sb;
}

公共静态StringBuilder SingleOccurrence（字符串s）
{
StringBuilder sb=新的StringBuilder（）；
如果（s.长度（）>0）{
char prev=s.charAt（0）；
某人附加（上）；
对于（int i=1；i

此方法具有线性时间复杂度。
最简单的方法是从头到尾遍历字符串：

public static StringBuffer singleOccurence(String s)
{
    StringBuffer sb = new StringBuffer(s);        
    for (int i = sb.length() - 2; i >= 0; i--)
        if (sb.charAt(i) == sb.charAt(i + 1))
             sb.deleteCharAt(i + 1);
    return sb;
}

试试这个：

    String reg;
    String input;
    String output;
    reg    = "(.)(\\1)+";
    input  = "aaaabbbccdbbaae";
    output = input.replaceAll(reg,"$1");
    System.out.println("Input :"+input);
    System.out.println("Output:"+output);

您可以将
replaceAll
方法与
regex

string result = myString.replaceAll(/([a-z])\1+/ig, "$1");

这个
regex
的作用是，它匹配由部件
\1+
触发的任何重复的字母字符
[a-z]

正则表达式中的标志（在最后一个
/
之后）表示它应该搜索整个字符串（
g
标志），并且应该忽略大小写（
i
标志）。您可能不需要
g
标志，因为这里我们使用的是
replaceAll

这里，我们将替换为
$1
，这意味着替换为第一个匹配的组。
由于在
[a-z]
周围有括号，
$1
将是匹配的字符

这一切都意味着，在忽略大小写的同时，在字符串中查找重复的字符，并用该字符替换它们。
public class removeadjacketters{

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.print("Enter any word: "); // Inputting the word
    String str = scanner.nextLine();
    for (int i = 1; i < str.length(); i++) { // from 2nd letter
        if (str.charAt(i) == str.charAt(i - 1)) { // comparing adjacent
                                                    // letters

            str = str.substring(0, i - 1) + str.substring(i + 1); // eliminating
                                                                    // 1st
                                                                    // duplicates
            System.out.println(str);
            i = 0;                // i=0 because I need to check for all possible adjacent letters.. 

        }
    }
    if (str.length() == 0) {
        System.out.println("Empty String");
    } 
    scanner.close();
}

publicstaticvoidmain（字符串[]args）{
扫描仪=新的扫描仪（System.in）；
System.out.print（“输入任何单词：”；//输入单词
String str=scanner.nextLine（）；
对于（int i=1；i

}导入java.util.array；
导入java.util.Scanner

公共类反向{

public static void main(String[] args) {
    String str;
    Scanner in = new Scanner(System.in);
    System.out.println("Enter the Word or Sentence");
    str =in.nextLine();
    String revStr ="null";

    char [] chars = str.toCharArray();
    char [] reversedChars = new char[chars.length];

    reversedChars[reversedChars.length - 1] = chars[0];


    int r = reversedChars.length - 2;
    for(int i = 1 ; i < chars.length ; i++ ){
        if(chars[i] != chars[i-1]){
            reversedChars[r] = chars[i];
            r--;
        }
    }

    revStr = new String(Arrays.copyOfRange(reversedChars, r+1, reversedChars.length));

    System.out.println(revStr);
}

publicstaticvoidmain（字符串[]args）{
字符串str；
扫描仪输入=新扫描仪（系统输入）；
System.out.println（“输入单词或句子”）；
str=in.nextLine（）；
字符串revStr=“null”；
char[]chars=str.toCharArray（）；
char[]reversedChars=新字符[chars.length]；
reversedChars[reversedChars.length-1]=字符[0]；
int r=反向字符长度-2；
for（int i=1；i

}这在Java中很容易解决。您只需使用StringBuffer。
这是完整的代码：

public class Test3 {
public static void main(String[] args) {
    String str = "aaaabbbccdbbaae";
    StringBuffer sbr = new StringBuffer();
    int i = 0 ;
    while(i < str.length()) {
        if(sbr.length() == 0 ) sbr.append(str.charAt(i));
        if(str.charAt(i) == sbr.charAt(sbr.length() -1)) {i++ ;}
        else {sbr.append(str.charAt(i)); i++;}
    }//while
System.out.println(sbr);
}

}//end1

您正在从StringBuffer中删除字符，这会使它变短。您的循环会一直运行，直到达到原始长度s，但只要您调用sb.deleteCharAt，它就会变短。我同意。对于学习Java的人，您的答案更好。对于实际使用Java，我更喜欢我的：）抱歉，但我没有Java IDE，我认为从这段代码中可以清楚地看出算法的概念。它有什么问题？请随意更正显而易见的问题。虽然这段代码片段是受欢迎的，并且可能提供一些帮助，但它将是关于如何以及为什么解决问题的。请记住，您是在为将来的读者回答这个问题，而不仅仅是作为一个人king now！请您的答案添加解释，并说明适用的限制和假设。我已经编写了一个程序，通过以下规则尽可能减少字符串，例如“aabccddd”…只要尽可能多地删除具有相同值的相邻字母…aabccddd->bccddd bccddd->bddd bddd bddd->bd假设在减少最少值的同时，您得到bb->打印空字符串用于该场景..逻辑很简单，我只是比较第2个字符和第1个字符，如果它们相同，我将删除它们..否则我必须比较第3个和第2个..和重复到最后…你能给出一些描述吗，回答？使用Scanner类给出输入，并对字符进行计数，并使用反向字符创建相同计数的新数组。然后将最后一个字符放在第一位。现在检查最后一个字符和旁边的字符，如果相同，则使用i-1等将其删除。现在打印输出
def lis(a):
    list1 = [] 
    # put the characters in the list
    [list1.append(ch)  for ch in a]
    print(list1)
    # moving backwards from last element i.e.len(a) -1 to first element 0 and step is -1
    for i in range(len(list1) - 1 , 0 , -1):
        # delete the repeated element
        if list1[i] == list1[i - 1]: del list1[i]

    return ''.join(list1)    


a = "Protiijaayii"
# output Protijayi
print(lis(a))