일단 문자열과 문자를 입력으로 받아 첫 번째 문자와 입력으로 주어진 문자를 하나씩 제외한 모든 문자를 제거하는 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

첫 문자와 모든 문자를 유지합니다 e. 다른 모든 문자는 하나씩 제거됩니다.

당신의 임무는이 효과를 달성하는 문자열을 두 입력 및 출력 (또는 반환)하는 프로그램 (또는 함수)을 작성하는 것입니다.

사양

• 문자열에 줄 바꿈이 포함되지 않는다고 가정 할 수 있습니다.
• 두 번째 입력은 항상 한 문자입니다.
• 답이 함수 형태 인 경우 출력에 각 줄을 포함하는 문자열 배열을 반환 할 수 있습니다.
• 출력에는 후행 줄 바꿈이 포함될 수 있습니다.

테스트 사례

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

이것은 code-golf 이므로 가장 짧은 코드 (바이트)가 이깁니다.

V , 12 바이트

òYpó.“„a]òd

온라인으로 사용해보십시오!

16 진 덤프 :

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

내 순진한 첫 번째 접근 방식은 3 바이트 더 깁니다.

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

하스켈, 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

문자열을 첫 번째 명령 줄 인수로 사용하고 문자를 두 번째로 사용합니다. 온라인으로 사용해보십시오!

설명

입력 문자를 반복합니다. 캐릭터가 특수 캐릭터와 같으면 다음 캐릭터로 넘어갑니다. 그렇지 않은 경우 삭제하고 문자열을 인쇄하십시오.

ungolfed 버전 ( a, bget cmdline args; o값으로 시작 1, xis "") :

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 문의 두 가지 분기 모두 단일 표현식이므로 삼항 연산자를 ?대신 사용할 수 있습니다 .

펄 5, 29 바이트

31 바이트, 플러스 1 : 나는 딸기 펄 사용하여 35 바이트를 가지고 -nE대신 -e, 플러스 공간 + 3 -i(; 긴 문자열이 STDIN에서 수있는 단일 문자 입력에 사용을).

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

그러나 딸기를 사용하여 직접 테스트 할 수는 없지만 29 바이트 인 을 chomp;사용 하지 않고 이것이 가능 <<<하다는 것은 의심의 여지가 없습니다 .

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

그러므로:

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

펄 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?는 복제 되었으므로 추가로 골프를 칠 수 있습니다 . 루프에서이 부품을 이동하면 복제가 제거되고 닫는 대괄호가 떨어질 수 있습니다.

파이썬 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>')).

파이썬 3 , 72 바이트

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

온라인으로 사용해보십시오!

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

다이어트를하십시오 :

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

자바 스크립트 (ES6), 74 바이트

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

루비, 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로 대체 된 풋

밀 마법사 덕분에 공백을 제거하고 바이트 수를 정확하게 계산했습니다.

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 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);
    }
}

문자열의 시작 부분에 대한 포인터를 가져 와서 문자열 끝에 도달 할 때 까지이 포인터를 반복하여 반복합니다. 루프 내에서 첫 번째 문자를 인쇄 한 다음 문자열의 시작과 포인터 사이에서 찾은 두 번째 인수의 인스턴스를 인쇄합니다. 그런 다음 포인터를 놓고 나머지 문자열을 인쇄합니다.

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 바이트

2 바이트에 대한 @Kade 감사합니다!
1 바이트 주셔서 @Emigna 감사합니다!

¬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 덕분에 1 바이트가 절약되었습니다.

파이썬 2-65 73 바이트

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

그리고 76 바이트의 재귀 솔루션은 firt보다 길지만, 나는 그것을 더 좋아하기 때문에 :

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
""

자바 스크립트 (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 바이트

스위프트는 특히 문자열 인덱싱과 관련하여 골프에 이상적인 언어는 아닙니다. 이것이 내가 할 수있는 최선입니다.

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))
        }
    }
}

파이크, 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루프와 몇 가지 임시 변수를 .

자바 스크립트 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>

그루비, 34 바이트

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