如何使用以下命令获取此输出？删除连续字符的Javascript是否与给定字符串相同？（Bomber算法）

如何使用以下命令获取此输出？删除连续字符的Javascript是否与给定字符串相同？（Bomber算法） 例子： 输入1:aabcccdee aabcccdee->bcccdee->bdee->bd 输出1:bd

输入2:abcdeedcbfgf ABCDEEDCFGF->eeabcddcbfgf->abcddcbfgf->abccbfgf->ABFGF->afgf

---

输出2:afgf

您可以使用索引前后的字符检查字符，并返回一个新字符串。换衣服时重复

功能b（s）{
变量t；
做{
t=s；
s=t.split（''）.filter（函数（a，i，aa）{
返回a！==aa[i-1]&&a！==aa[i+1]；
}).加入（“”）；
}而（s！==t）；
返回s；
}
console.log（b（'aabcccdee'））；
console.log（b（'abcdeedcbfgf'）您可以使用索引前后的字符检查该字符，并返回一个新字符串。换衣服时重复


功能b（s）{
变量t；
做{
t=s；
s=t.split（''）.filter（函数（a，i，aa）{
返回a！==aa[i-1]&&a！==aa[i+1]；
}).加入（“”）；
}而（s！==t）；
返回s；
}
console.log（b（'aabcccdee'））；
console.log（b（'abcdeedcbfgf'）这只是另一个取自
a
头部并连接到
b
尾部的问题，非常适合尾部代码优化递归调用或while循环方法

我的解决办法是


函数缩减限制（a，b=”“，c=0）{
如果（！a.length）返回c？b.slice（0，-c-1）：b；
b[b.length-1]==a[0]？（c++，b++=a[0]，a=a.slice（1））
：c？（b=b.slice（0，-c-1），c=0）
：（b+=a[0]，a=a.slice（1））；
返回还原限制（a、b、c）；
}
var myArr=“aabcccdee”，
结果=减少开支（myArr）；
控制台日志（结果）；
日志（reduceString（“abcdeedcbfgf”）这只是另一个取自
a
头部并连接到
b
尾部的问题，非常适合尾部代码优化递归调用或while循环方法

我的解决办法是


函数缩减限制（a，b=”“，c=0）{
如果（！a.length）返回c？b.slice（0，-c-1）：b；
b[b.length-1]==a[0]？（c++，b++=a[0]，a=a.slice（1））
：c？（b=b.slice（0，-c-1），c=0）
：（b+=a[0]，a=a.slice（1））；
返回还原限制（a、b、c）；
}
var myArr=“aabcccdee”，
结果=减少开支（myArr）；
控制台日志（结果）；
日志（reduceString（“abcdeedcbfgf”）看看这里的解决方案，他们已经解释了两种方法

一种使用堆栈的简单方法，我提供了一个伪代码复杂性O（n）

str=abccbfgf
堆栈s；
计数器=0
bombFlag=false
while（计数器=2）{
bombFlag=true；
}
否则{
如果（爆炸旗）{
loopCtr=顶部计数器；
bombFlag=false
（loopCtr>0）
s、 流行音乐（）
loopCtr--；
}
推送（{char，1}）
}
} 
看看这里的解决方案，他们已经解释了两种方法

一种使用堆栈的简单方法，我提供了一个伪代码复杂性O（n）

str=abccbfgf
堆栈s；
计数器=0
bombFlag=false
while（计数器=2）{
bombFlag=true；
}
否则{
如果（爆炸旗）{
loopCtr=顶部计数器；
bombFlag=false
（loopCtr>0）
s、 流行音乐（）
loopCtr--；
}
推送（{char，1}）
}
} 
var finalString=“”；
var bombIt=函数（currentString）{
var currentArray=currentString.split（“”）；
var计数器=1；
var recurAgain=假；
var currentString=''；
对于（var i=0；i2）{
recurAgain=真；
电流阵列拼接（i+1计数器，计数器）；
计数器=1；
打破
}否则{
计数器=1；
}
}
如果（重复）{
bombIt（currentArray.join（“”））；
}否则{
finalString=currentArray.join（“”）；
}
}; 
bombIt（“aabbbcceeecfffa”）；
var finalString=“”；
var bombIt=函数（currentString）{
var currentArray=currentString.split（“”）；
var计数器=1；
var recurAgain=假；
var currentString=''；
对于（var i=0；i2）{
recurAgain=真；
电流阵列拼接（i+1计数器，计数器）；
计数器=1；
打破
}否则{
计数器=1；
}
}
如果（重复）{
bombIt（currentArray.join（“”））；
}否则{
finalString=currentArray.join（“”）；
}
}; 
bombIt（“aabbbcceeecfffa”）；
公共类BoomberAlogrithm{
公共静态void main（字符串[]args）{
字符串s=“abcccbda”；
int size=s.length（）；
BoomberAlogrithm boom=新的BoomberAlogrithm（）；
char[]a=s.toCharArray（）；
int i=0；
int c=0；
对于（i=0；i0）{
而（c+1>0）{
对于（int k=i；kstr = abccbfgf
Stack s;
counter = 0
bombFlag = false
while(counter < str.length){
char = str.index(counter);
 if(s.isEmpty){
    push( {char,1 })
 }else{
    top = s.peek;
    if(top.val == char )
        ctr = top.counter+1;
        push( {char,ctr })
        if(ctr >= 2){
            bombFlag = true;
        }
    else{
        if(bombFlag){
        loopCtr = top.counter;
        bombFlag = false
        (loopCtr > 0)
         s.pop()
         loopCtr--; 
        }
        push( {char,1 })
 }
} 

var finalString = "";
var bombIt = function(currentString){
     var currentArray = currentString.split('');
     var counter = 1;
     var recurAgain = false;
     var currentString = '';
    for(var i = 0; i < currentArray.length; i++){
        recurAgain = false;
        if(currentArray[i] == currentArray[i+1]){
            counter++
            continue;
        }
        if(counter > 2){
            recurAgain = true;
            currentArray.splice(i+1-counter,counter);
            counter = 1;
            break;
        }else{
            counter = 1;
        }
     }
     if(recurAgain){
        bombIt(currentArray.join(''));
     }else{
        finalString = currentArray.join('');
     }
}; 
bombIt("aabbbcceeecfffa");

public class BoomberAlogrithm {

public static void main(String[] args) {
    String s = "abcccbda";
    int size = s.length();
    BoomberAlogrithm boom = new BoomberAlogrithm();
    char[] a = s.toCharArray();

    int i = 0;
    int c = 0;
    for (i = 0; i < size; i++) {
        for (int j = i + 1; j < size; j++) {

            if (a[i] != a[j]) {
                if (c > 0) {
                    while (c + 1 > 0) {
                        for (int k = i; k < size - 1; k++) {
                            a[k] = a[k + 1];

                        }
                        size--;
                        c--;
                    }
                    i = 0;
                    c = 0;
                }
                break;
            }
            if (a[i] == a[j]) {
                c++;
            }

        }

    }
    for (i = 0; i < size; i++) {
        System.out.println(a[i]);
    }

}

}

function b(s) 
{
var t;
do {t = s;s = t.split('').filter(function (a, i, aa) {
     if(i==0) return a;
     else
     return a !== aa[i - 1] && a !== aa[i + 1];}).join('');} while (s !== t); 
     return s;
}
console.log(b("abbabbac"));
console.log(b('aabcccdee'));
console.log(b('abcdeedcbfgf'));

import java.io.*;


    public class Arr {

        public static void main(String[] args) throws IOException {

            InputStreamReader r =new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(r);

            //char[] ab= {'a','b','b','c','c','d','e','e','d'};
            String a=br.readLine();
            int i=0,j=0,k;
            char[] ab= a.toCharArray();
            char[] c = new char[ab.length];
            char[] d= new char[ab.length];

            for(k=1;k<ab.length-1;k++)
            {
                if(ab[k]==ab[k-1] && ab[k]!='\0')
                {
                for (i=1;i<ab.length;i++)
                {
                    if(ab[i]!=ab[i-1])
                    {
                            c[j]=ab[i-1];
                            j++;
                            if(i==ab.length-1)
                            {

                                c[j]=ab[i];
                                j++;
                            }
                    }

                    else
                    {
                        i=i+1;
                            if(i==ab.length-1)    
                            {
                                c[j]=ab[i];
                                j++;
                            }
                    }
                }
                ab=c;
                c=d;
                k=0;
                j=0;
                }
            }

                for(j=0;j<ab.length;j++)
                {
                    System.out.print(ab[j]);
                }
        }
    }