一旦我编写了一个JavaScript程序，它将一个字符串和一个字符作为输入，并将一个一个一个地删除除第一个字符和输入字符之外的所有字符。

例如，使用输入codegolf.stackexchange.com和e字符计算得出：

codegolf.stackexchange.com
cdegolf.stackexchange.com
cegolf.stackexchange.com
ceolf.stackexchange.com
celf.stackexchange.com
cef.stackexchange.com
ce.stackexchange.com
cestackexchange.com
cetackexchange.com
ceackexchange.com
ceckexchange.com
cekexchange.com
ceexchange.com
ceechange.com
ceehange.com
ceeange.com
ceenge.com
ceege.com
ceee.com
ceeecom
ceeeom
ceeem
ceee

它保留第一个字符和所有es。所有其他字符将被一一删除。

您的任务是编写一个接受两个输入和输出（或返回）一个字符串的程序（或函数），以完成此操作。

技术指标

• 您可以假定该字符串将不包含任何换行符。
• 第二个输入将始终是一个字符。
• 如果答案是函数形式，则可以返回包含输出中每一行的字符串数组。
• 输出可以包含尾随换行符。

测试用例

Test Cases，s：

Test Cases
Tst Cases
Ts Cases
TsCases
Tsases
Tsses
Tsss

Make a "Ceeeeeeee" program，e：

Make a "Ceeeeeeee" program
Mke a "Ceeeeeeee" program
Me a "Ceeeeeeee" program
Mea "Ceeeeeeee" program
Me "Ceeeeeeee" program
Me"Ceeeeeeee" program
MeCeeeeeeee" program
Meeeeeeeee" program
Meeeeeeeee program
Meeeeeeeeeprogram
Meeeeeeeeerogram
Meeeeeeeeeogram
Meeeeeeeeegram
Meeeeeeeeeram
Meeeeeeeeeam
Meeeeeeeeem
Meeeeeeeee

Hello World!，!：

Hello World!
Hllo World!
Hlo World!
Ho World!
H World!
HWorld!
Horld!
Hrld!
Hld!
Hd!
H!

Hello World!，z：

Hello World!
Hllo World!
Hlo World!
Ho World!
H World!
HWorld!
Horld!
Hrld!
Hld!
Hd!
H!
H

alphabet，a：

alphabet
aphabet
ahabet
aabet
aaet
aat
aa

upperCASE，e：

upperCASE
uperCASE
uerCASE
ueCASE
ueASE
ueSE
ueE
ue

这是代码高尔夫球，因此最短的代码（以字节为单位）获胜。

V，12个字节

òYpó.“„a]òd

在线尝试！

十六进制转储：

00000000: f259 70f3 2e93 8412 615d f264            .Yp.....a].d

在挑战赛之前，我已经使用最新版本的V进行了测试，并且一切正常运行，使该答案具有竞争性。

说明：

ò         ò    " Recursively:
 Yp            "   Duplicate this line
   ó           "   Remove:
    .a]      "     A compressed regex
            d  " Delete our extra line

压缩的正则表达式转换为

.\zs[^e]

意思是

.           " Any character
 \zs        " Leave the previous character out of the selection
    [^e]    " Any character except for 'e' (Or whatever is given for input)

非竞争版本（11字节）

此版本使用了Yp发布此挑战时不可用的快捷方式。

Vim，27，26，25字节

DJqqYp:s/.\zs[^<C-r>-]<CR>@qq@qD

在线尝试！

输入格式如下：

e
codegolf.stackexchange.com

我幼稚的第一种方法是将三个字节长：

i:s/.\zs[^<Right>]<Esc>"addqqYp@a@qq@qdd

我对这个答案也很满意，因为它以我的名字开头。

DJqq:t$|s/.\zs[^<C-r>"]<CR>@qq@qD
DJMcMayhem

看到相似之处吗？嗯

不太成功的方法：

i:s/.\zs[^<Right>]<Esc>"addqqYp@a@qq@qdd
i:s/.\zs[^<Right>]<CR>@q<Esc>"adkqqYp@aq@qdd
DJ:s/.\zs[^<C-r>"]<CR>uqqYp@:@qq@qdd
DJqq:t.|$s/.\zs[^<C-r>"]<CR>@qq@qdd

说明：

D                                   " Delete everything on this first line
 J                                  " Remove this empty line
  qq                                " Start recording into register 'q'
    Y                               " Yank this line
     p                              " And paste it
      :s/                           " Run a substitute command on the last line in the buffer. Remove:
         .                          "   Any character
          \zs                       "   Move the selection forward (so we don't delete the first one)
             [^<C-r>-]              "   Followed by anything *except* for the character we deleted
                      <CR>          " Run the command
                          @q        " Call register 'q'
                            q       " Stop recording
                             @q     " Run the recursive macro
                               D    " Delete our extra line

MATL，20 16字节

y-f1X-"t[]@X@q-(

在线尝试！或验证测试情况：1，2，3，4，5。

奖金

修改后的代码可以看到字符串逐渐缩小（离线编译器）：

y-f1X-"tt.3Y.XxD[]@X@q-(].3Y.XxDvx

或在MATL Online上尝试！

说明

y        % Implicitly input string and char. Duplicate string onto top
-        % Subtract. Gives nonzero for chars in the input string that are
         % different from the input char
f        % Array of indices of nonzero values
1X-      % Remove 1 from that array. This gives an array of the indices of 
         % chars to be removed from the string
"        % For each
  t      %   Duplicate previous string
  []     %   Push empty array
  @      %   Push index of char to be removed. But this index needs to be 
         %   corrected to account for the fact that previous chars have
         %   already been removed...
  X@q-   %   ... So we correct by subtracting the 0-based iteration index
  (      %   Assign empty array to that position, to remove that char
         % Implicitly end for each
         % Implicitly display

Haskell，50个字节

w@(a:x)%c|(d,_:y)<-span(==c)x=w:(a:d++y)%c|0<1=[w]

定义一个(%)返回字符串列表的函数。

说明

(%)被称为w%c，与w被输入字符串，并c保持字符。简而言之，此定义的工作方式是将w第一个字符（a）和其余部分（x）分开x，在第一次出现除以外的其他字符时进行拆分c，然后递归地调用该自身并删除该字符。

w@(a:x)%c              -- define (%) with w separated into a and x.
 |(d,_:y)<-span(==c)x  -- split x; bind the string of `c` to d, and the rest
                       -- to _:y, dropping first character and calling the rest y.
  =w:(a:d++y)%c        -- if there was a character to drop, cons w onto the
                       -- sequence gained by recursively calling (%) with that
                       -- character removed (i.e. call with a:d++y).
 |0<1=[w]              -- if nothing needed to be dropped, the result sequence is
                       -- simply the one-element list [w]

视网膜，28 27字节

字节数假定为ISO 8859-1编码。

;{G*1`
R1r`(?!^|.*¶?\1$)(.)

在线尝试！

说明

;{G*1`

这里有很多配置。阶段本身实际上是just G1`，它仅保留第一行，并丢弃输入字符。*将其转换为空运行，这意味着将在不实际更改字符串的情况下打印结果（即字符串的第一行）。{告诉Retina循环运行两个阶段，直到字符串停止更改并;阻止在程序结束时输出。

R1r`(?!^|.*¶?\1$)(.)

这将丢弃第一个字符，其中a）不在输入的开头，b）不等于单独的输入字符。

点，22 26 24 22字节

Lv+#Paa@oQb?++oPaRA:ox

将string作为第一个命令行参数，将character作为第二个命令行参数。在线尝试！

说明

循环输入的字符；如果该字符等于特殊字符，则转到下一个字符；如果不是，请将其删除并打印字符串。

一个ungolfed版本（a，b得到CMDLINE ARGS; o用的值开始1，x是""）：

P a         Print a
L #a-1      Loop len(a)-1 times:
 I a@o Q b   If a[o] string-eQuals b:
  ++o         Increment o
 E {         Else:
  a RA: o x   In-place in a, Replace char At index o with x (i.e. delete it)
  P a         Print a
 }

高尔夫技巧：

• 的循环标头L仅计算一次，因此我们可以在其中偷偷摸摸地打印初始图像。#Pa-1因为P低优先级（它将解析为#P(a-1)）而无法工作，但是我们可以v+#Pa使用v预初始化为的变量将其重新排列为-1。
• 该RA:运算符返回的新的价值a，所以我们可以打印出表达而不是一个单独的Pa声明。
• 现在，if语句的两个分支都是单个表达式，因此我们可以改用三元运算符?。

Perl 5，29个字节

我用Strawberry Perl得到了35个字节：31个字节，加上1 -nE代替-e，加上3表示空格+ -i（用于单字母输入；更长的字符串来自STDIN）。

chomp;say;s/(.)[^$^I]/$1/&&redo

但是，毫无疑问，不chomp;使用<<<29字节的，这是可行的，即使我自己无法使用Strawberry进行测试。

say;s/(.)[^$^I]/$1/&&redo

从而：

perl -im -nE'say;s/(.)[^$^I]/$1/&&redo' <<< "example"

Perl 6的， 47个40  38字节

->\a,\b{a,{S/^(."{b}"*:)./$0/}...^{$^a eq $^b}}

->\a,\b{a,{S/^(."{b}"*:)./$0/}...^&[eq]}

{$^b;$^a,{S/^(."$b"*:)./$0/}...^&[eq]}

展开：

{       # lambda with two placeholder parameters ｢$a｣ and ｢$b｣

  $^b;    # declare second parameter

  $^a,    # declare first parameter, and use it to seed the sequence

  {       # bare block lambda with implicit parameter ｢$_｣
    S/      # string replace and return
      ^       # beginning of string
      (       # capture into ｢$0｣
        .       # the first character
        "$b"*   # as many ｢$b｣ as possible
        :       # don't allow backtracking
      )
      .       # any character ( the one to be removed )

    /$0/      # put the captured values back into place
  }

  ...^      # repeat that until: ( and throw away the last value )

  &[eq]     # the infix string equivalence operator/subroutine

}

之所以...^使用它，...是因为直到重复最后一个值才&[eq]返回True。

05AB1E，26 25字节

¬ˆ[¦Ðg_#¬²k0Qi²ˆë¯J?,]¯J?

¬ˆ                         Put the first character into an array
  [                        While true
   ¦                       Remove the first character
    Ð                      Triplicate
     g_#                   if the string is empty, break
        ¬²k0Qi             if the first character is equal to the one specified in the input
              ²ˆ           Add it to the array
                ë          Else
                 ¯J?       Display the array
                    ,      Display the remaining string
                     ]     End while
                      ¯J?  Display the last string

在线尝试！

请注意，这¬²k0Q可能会被重写¬²Q，但是由于某些原因，当当前字符是一个引号时，它将不起作用：Q返回实际的字符串而不是布尔值，这会导致无限循环。

由于该代码¯J?重复，因此可以进一步进行打标。在循环中移动此部分将删除重复项，也将允许删除右方括号。

Python 2，71 66个字节：

f,m=input();k=f[0]
while f:a=f[0]==m;k+=f[0]*a;f=f[1+a:];print k+f

完整的程序。通过STDIN以格式输入2个输入'<String>','<Char>'。

另外，这是当前140字节的递归解决方案：

Q=lambda c,p,k='',j=1,l=[]:c and Q(c[1:],p,k+c[0]*(j<2)+c[0]*(c[0]==p),j+1,l+[k+c])or'\n'.join(sorted({*l},key=l.index))+('\n'+k)*(k not in l)

此格式应以格式调用print(Q('<String>','<Char>'))。

Python 3，72个字节

def e(i,k):
 for r in i:
  if r!=k:i=i[0]+i[1:].replace(r,'',1);print(i)

在线尝试！

e('😋🥕🍎🥓🥑🥓🥑🥒🍆🥔🍆🥓🍅🥜🥓🥔🍅🍄🍆','🥓')

节食：

😋🥕🍎🥓🥑🥓🥑🥒🍆🥔🍆🥓🍅🥜🥓🥔🍅🍄🍆
😋🍎🥓🥑🥓🥑🥒🍆🥔🍆🥓🍅🥜🥓🥔🍅🍄🍆
😋🥓🥑🥓🥑🥒🍆🥔🍆🥓🍅🥜🥓🥔🍅🍄🍆
😋🥓🥓🥑🥒🍆🥔🍆🥓🍅🥜🥓🥔🍅🍄🍆
😋🥓🥓🥒🍆🥔🍆🥓🍅🥜🥓🥔🍅🍄🍆
😋🥓🥓🍆🥔🍆🥓🍅🥜🥓🥔🍅🍄🍆
😋🥓🥓🥔🍆🥓🍅🥜🥓🥔🍅🍄🍆
😋🥓🥓🍆🥓🍅🥜🥓🥔🍅🍄🍆
😋🥓🥓🥓🍅🥜🥓🥔🍅🍄🍆
😋🥓🥓🥓🥜🥓🥔🍅🍄🍆
😋🥓🥓🥓🥓🥔🍅🍄🍆
😋🥓🥓🥓🥓🍅🍄🍆
😋🥓🥓🥓🥓🍄🍆
😋🥓🥓🥓🥓🍆
😋🥓🥓🥓🥓

JavaScript（ES6），74个字节

(s,c)=>[...t=s.slice(1)].map(d=>c!=d?s+=`
`+s[0]+(t=t.replace(d,``)):s)&&s

Ruby，148 139 97 90 83 77 62字节

a,c=$*;p s=""+a;i=1;while d=s[i];(d!=c)?(s[i]="";p s):i+=1;end

不知道这次交换是否接受了业余代码，但是尽管我对此感到很糟糕，但我对学习高尔夫代码感兴趣，这对我如何使该程序看起来像这里的其他程序一样有用吗？

编辑：

用p替换了看跌期权

借助Wheat Wizard，删除了一吨的空白并正确计数了字节

由于challenger5从去s=gets.chop;c=gets.chop;到s,c=gets.chop,gets.chop;

更换then用;和gets.chop与gets[0]感谢Mhutter！

现在将输入作为命令行变量，例如。 prog.rb helloworld l

多亏了jeroenvisser101的大量改进a=s.dup，s=""+a并用之前的if语句if s[i]!=c;s[i]="";p s;else i+=1;end进行了(d!=c)?(s[i]="";p s):i+=1;巨大的改进！

C90，129个 125字节

带空格：

main(q, x)
{
    for (char **v = x, *a = v[1], *b = a, *c;*b++;)
        for (c = a; c == a | *c == *v[2] && *b != *v[2] && putchar(*c),
            ++c != b || *b != *v[2] && !puts(b););
}

没有空格：

main(q,x){for(char**v=x,*a=v[1],*b=a,*c;*b++;)for(c=a;c==a|*c==*v[2]&&*b!=*v[2]&&putchar(*c),++c!=b||*b!=*v[2]&&!puts(b););}

松散

#include <stdio.h>
int main(int argc, char **argv)
{
    char *a = argv[1];
    for (char *b = a + 1; *b; b++) {
        if (*b == *argv[2]) {
            continue;
        }
        putchar(*a);
        for (char *c = a + 1; c != b; c++) {
            if (*c == *argv[2]) {
                putchar(*c);
            }
        }
        puts(b);
    }
}

这需要一个指向字符串开头的指针，并进行循环，迭代该指针直到它到达字符串的末尾。在循环中，它先打印第一个字符，然后在字符串的开头和指针之间找到第二个参数的所有实例。之后，它调用放置在指针上的puts，打印出字符串的其余部分。

这必须在sizeof（int）== sizeof（char *）的系统上编译。否则+3个字节。

这是我第一次尝试在此处进行代码打高尔夫球，因此我确定需要进行一些优化。

Dyalog APL，27 字节

{×i←⊃1+⍸⍺≠1↓⎕←⍵:⍺∇⍵/⍨i≠⍳≢⍵}

⍺是排除的字符，⍵是初始字符串

打印参数 查找i第⍺一个字符之后的第一个非索引。如果找到，则递归调用并i删除

Mathematica，64个字节

Most@FixedPointList[StringReplace[#,b_~~Except@a:>b,1]&,a=#2;#]&

匿名函数。将两个字符串作为输入，并返回一个字符串列表作为输出。通过重复删除字符的第一个非实例来工作。

PHP，88 84 86 85 82 81 78字节

@IsmaelMiguel节省了1个字节，@ user59178节省了3个字节，@ user59178启发了3个字节

while($b=substr("$argv[1]\n",$i++))$a>""&$b[0]!=$argv[2]?print$a.$b:$a.=$b[0];

从命令行参数获取输入；与php -r <code> '<string>' <character>

• 在输入中添加换行符以隐式最终打印。
  这会增加5 4个字节的代码，但会节省输出和一个额外的echo$a;。

05AB1E，26 24 23字节

感谢@Kade 2个字节！
感谢@Emigna 1个字节！

¬UDvy²k0Êiy¡¬s¦yý«Xs«=¦

使用CP-1252编码。在线尝试！

y²k0Ê可能是，y²Ê但"搞砸了。

这可能会打更多，因为«重复了两次。如果您有任何建议或更多建议，请发表评论。

爪哇10，155个 140 139 124字节

c->s->{var r=s+"\n";for(int i=0;++i<s.length();)if(s.charAt(i)!=c)r+=(s=s.substring(0,i)+s.substring(i--+1))+"\n";return r;}

在线尝试。

说明：

c->s->{          // Method with character and String parameters and String return-type
  var r=s+"\n";  //  Result-String, starting at the input-String with trailing new-line
  for(int i=0;++i<s.length();)
                 //  Loop over the characters of the String, skipping the first
    if(s.charAt(i)!=c)
                 //   If the current character and the input-character are equal
      r+=(s=s.substring(0,i)+s.substring(i--+1))
                 //     Remove this character from the String `s`
         +"\n";  //     And append the new `s` with trailing new-line to the result-String
  return r;}     //  Return the result-String

旧的139字节递归答案：

void c(String s,int c){System.out.println(s);for(int i=1;i<s.length();)if(s.charAt(i++)!=c){c(s.substring(0,i-1)+s.substring(i),c);break;}}

-1个字节，感谢@Eugene。（下一次请发表评论，而不要编辑别人的帖子。）

在线尝试。

说明：

void c(String s,int c){     // Method with String and integer parameters and no return-type
  System.out.println(s);    //  Print the input-String with trailing new-line
  for(int i=1;i<s.length();)//  Loop over the characters of the String, skipping the first
    if(s.charAt(i++)!=c){   //   If the current character and the input-character are equal
      c(s.substring(0,i-1)+s.substring(i),c); 
                            //    Remove this character, and do a recursive call
      break;}}              //    And stop the loop

C＃，122个 117 112字节

IEnumerable F(string s,char c){for(int i=0;i<s.Length;++i)if(i<1||s[i]!=c)yield return i>0?s=s.Remove(i--,1):s;}

松散

public IEnumerable F(string s, char c) {
    for (int i = 0; i < s.Length; ++i) {
        if (i < 1 || s[i] != c)
            yield return i > 0 ? s = s.Remove(i--, 1) : s;
    }
}

返回字符串的集合。

TSQL，127个字节（不包括变量定义）

DECLARE @1 VARCHAR(100)='codegolf.stackexchange.com'
DECLARE @2 CHAR(1) = 'o'

DECLARE @ char=LEFT(@1,1)WHILE patindex('%[^'+@2+']%',@1)>0BEGIN SET @1=STUFF(@1,patindex('%[^'+@2+']%',@1),1,'')PRINT @+@1 END

格式：

DECLARE @1 VARCHAR(100) = 'codegolf.stackexchange.com'
DECLARE @2 CHAR(1) = 'o'
DECLARE @ CHAR = LEFT(@1, 1)

WHILE patindex('%[^' + @2 + ']%', @1) > 0
BEGIN
    SET @1 = STUFF(@1, patindex('%[^' + @2 + ']%', @1), 1, '')

    PRINT @ + @1
END

C＃，135个 138 :( 137字节

打高尔夫球：

IEnumerable<string>F(string s,char c){int i=1,l;for(;;){yield return s;l=s.Length;while(i<l&&s[i]==c)i++;if(i==l)break;s=s.Remove(i,1);}}

取消高尔夫：

    IEnumerable<string> F(string s, char c)
    {
        int i = 1, l;

        for (;;)
        {
            yield return s;

            l = s.Length;

            while (i < l && s[i] == c)
                i++;

            if (i == l)
                break;

            s = s.Remove(i, 1);
        }
    }

函数返回字符串的集合。

EDIT1：@psycho注意到算法未正确实施。

EDIT2：为创建了变量s.Length。@TheLethalCoder节省了一个字节。

Python 2-65 73字节

lambda s,c:[s[0]+c*s[1:i].count(c)+s[i+1:]for i in range(len(s))]

还有一个76字节的递归解决方案，因为尽管比第一个更长，但我还是更喜欢它：

f=lambda s,c,i=1:s[i:]and[[s]+f(s[:i]+s[i+1:],c,i),f(s,c,i+1)][s[i]==c]or[s]

拍子194字节

(let p((s s)(n 1)(t substring)(a string-append))(displayln s)(cond[(>= n(string-length s))""]
[(equal? c(string-ref s n))(p(a(t s 0 n)(t s n))(+ 1 n)t a)][else(p(a(t s 0 n)(t s(+ 1 n)))n t a)]))

取消高尔夫：

(define (f s c)
  (let loop ((s s)
             (n 1))
    (displayln s)
    (cond
      [(>= n (string-length s))""]
      [(equal? c (string-ref s n))
       (loop (string-append (substring s 0 n) (substring s n))
             (add1 n))]
      [else
       (loop (string-append (substring s 0 n) (substring s (add1 n)))
             n)])))

测试：

(f "Test cases" #\s)
(f "codegolf.stackexchange.com" #\e)

输出：

Test cases
Tst cases
Tst cases
Ts cases
Tscases
Tsases
Tsses
Tsses
Tsss
Tsss
""
codegolf.stackexchange.com
cdegolf.stackexchange.com
cegolf.stackexchange.com
cegolf.stackexchange.com
ceolf.stackexchange.com
celf.stackexchange.com
cef.stackexchange.com
ce.stackexchange.com
cestackexchange.com
cetackexchange.com
ceackexchange.com
ceckexchange.com
cekexchange.com
ceexchange.com
ceexchange.com
ceechange.com
ceehange.com
ceeange.com
ceenge.com
ceege.com
ceee.com
ceee.com
ceeecom
ceeeom
ceeem
ceee
""

JavaScript（ES6），64 69

用换行符返回单个字符串

s=>c=>[...s].map((x,i,z)=>i&&x!=c&&(z[i]='',s+=`
`+z.join``))&&s

F=
s=>c=>[...s].map((x,i,z)=>i&&x!=c&&(z[i]='',s+=`
`+z.join``))&&s
  

function update() {
  var s=S.value,c=C.value[0]
  O.textContent=F(s)(c)
}

update()

<input id=S value='Hello world!' oninput='update()'>
<input id=C value='!' oninput='update()'>
<pre id=O></pre>

迅速3 - 151个 147字节

Swift不是打高尔夫球的理想语言，尤其是在与字符串索引相关的时候。这是我能做的最好的事情：

func c(a:String,b:String){print(a);var q=Array(a.characters),i=1;while i<q.count{if "\(q[i])" != b{q.remove(at:i);c(a:String(q),b:b);break};i=i+1}}

不幸的是，Swift需要周围有空格!=（但不是==），而Swift 3删除了++运算符。这两种技巧都在于将其转换为允许整数索引的字符数组，并使用字符的字符串内插将其转换回String（"\(c)"）。

取消高尔夫：

func c(a:String, b:String) {
    print(a)
    var q = Array(a.characters)
    var i = 1
    while i < q.count {
        if "\(q[i])" != b {
            q.remove(at:i)
            c(a: String(q), b: b)
            break
        }
        i=i+1
    }
}

以前的非递归解决方案

func c(a:String,b:String){var q=Array(a.characters),e={q.removeFirst()},z="\(e())";print(a);while !q.isEmpty{"\(e())"==b ? z=z+b : print(z+String(q))}}

func c(a:String, b:String) {
    var q = Array(a.characters)
    var z = "\(q.removeFirst())"
    print(a)
    while !q.isEmpty {
        if "\(q.removeFirst())" == b {
            z = z + b
        }else{
            print(z + String(q))
        }
    }
}

Pyke，26 19 17字节

jljjhF3<Q/Q*jih>s

在这里尝试！

                  - Q = input
j                 - j = input_2
 ljjhF3           - for (i, j, j[0]) for i in range(len(j))
       <          -     j[:i]
        Q/        -    ^.count(Q)
          Q*      -   ^*Q
                s -  sum(j[0], ^, V)
            jih>  -   j[i+1:]

Mathematica，78个字节

该死的马丁·恩德，我几乎是第一位：p

(i=2;a={c=#};While[i<=Length@c,If[c[[i]]==#2,i++,c=c~Drop~{i};a=a~Append~c]];a)&

未命名函数；具有While循环和一些临时变量的简单实现。

JavaScript ES6，89个字节

我以为这是一个容易的挑战，但是我敢肯定我在这里遗漏了一些东西。

使用递归并返回字符串数组

(c,i=1,r)=>f=a=>a[i]?a[i++]==c?f(a):f(g=a.slice(0,i-1)+a.slice(i--),(r=r||[a]).push(g)):r

F=
  (c,i=1,r)=>f=a=>a[i]?a[i++]==c?f(a):f(g=a.slice(0,i-1)+a.slice(i--),(r=r||[a]).push(g)):r

G=_=>A.value.length>1 && (O.innerHTML = F(E.value)(A.value).join`
`)

G()

<input id=A oninput='G()' value='alphabet'>
<input id=E oninput='G()' value='a'>
<pre id=O>

Groovy，34个字节

{a,b->a.inject{i,r->i+=r==b?b:""}}