Einmal habe ich ein JavaScript-Programm geschrieben, das eine Zeichenfolge und ein Zeichen als Eingabe verwendet und alle Zeichen mit Ausnahme des ersten und des als Eingabe angegebenen Zeichens nacheinander entfernt.

Berechnen Sie dies beispielsweise mit Eingaben codegolf.stackexchange.comund efür die Zeichenerträge:

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 behält das erste Zeichen und alle es. Alle anderen Zeichen werden einzeln entfernt.

Ihre Aufgabe ist es, ein Programm (oder eine Funktion) zu schreiben, das zwei Ein- und Ausgaben (oder Rückgaben) eines Strings verwendet, der diesen Effekt erzielt.

Spezifikationen

• Sie können davon ausgehen, dass die Zeichenfolge keine Zeilenumbrüche enthält.
• Die zweite Eingabe ist immer ein Zeichen.
• Wenn die Antwort in Form einer Funktion vorliegt, können Sie ein Array von Zeichenfolgen zurückgeben, die jede Zeile in der Ausgabe enthalten.
• Die Ausgabe kann einen nachgestellten Zeilenumbruch enthalten.

Testfälle

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

Das ist Code-Golf , also gewinnt der kürzeste Code (in Bytes).

V , 12 Bytes

òYpó.“„a]òd

Probieren Sie es online!

Hexdump:

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

Ich habe dies mit der neuesten Version von V getestet, die vor der Herausforderung verfügbar war , und alles läuft ordnungsgemäß, sodass diese Antwort konkurriert.

Erläuterung:

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

Der komprimierte reguläre Ausdruck wird in übersetzt

.\zs[^e]

Was bedeutet

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

Nicht konkurrierende Version (11 Bytes)

Diese Version verwendet eine Verknüpfung, die zum YpZeitpunkt der Veröffentlichung dieser Herausforderung nicht verfügbar war.

Vim, 27, 26 , 25 Bytes

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

Probieren Sie es online!

Die Eingabe erfolgt in folgendem Format:

e
codegolf.stackexchange.com

Mein naiver erster Ansatz ist drei Bytes länger:

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

Ich bin auch glücklich mit dieser Antwort, weil sie mit meinem Namen beginnt.

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

Sehen Sie die Ähnlichkeit? Wie?

Weniger erfolgreiche Ansätze:

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

Erläuterung:

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 Bytes

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

Probieren Sie es online! Oder überprüfen Sie die Testfälle: 1 , 2 , 3 , 4 , 5 .

Bonus

Geänderter Code, um zu sehen, dass die Zeichenfolge allmählich verkleinert wird (Offline-Compiler):

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

Oder probieren Sie es bei MATL Online!

Erläuterung

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 Bytes

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

Definiert eine Funktion, (%)die eine Liste von Zeichenfolgen zurückgibt.

Erläuterung

(%)heißt as w%c, wobei wes sich um die Eingabezeichenfolge und cdas zu behaltende Zeichen handelt. Kurz gesagt, diese Definition teilt sich win das erste Zeichen ( a) und den Rest ( x) auf, teilt sich xbeim ersten Auftreten eines anderen Zeichens auf cund ruft sich rekursiv auf, wobei dieses eine Zeichen fallengelassen wird.

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]

Retina , 28 27 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

Probieren Sie es online!

Erläuterung

;{G*1`

Hier gibt es viel Konfiguration. Die Bühne selbst ist wirklich gerecht G1`und behält nur die erste Zeile bei und verwirft das eingegebene Zeichen. *verwandelt es in einen Trockenlauf, was bedeutet, dass das Ergebnis (dh die erste Zeile der Zeichenfolge) gedruckt wird, ohne die Zeichenfolge tatsächlich zu ändern. {weist Retina an, beide Phasen in einer Schleife auszuführen, bis sich der String nicht mehr ändert und ;die Ausgabe am Ende des Programms verhindert.

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

Dies verwirft das erste Zeichen, das a) nicht am Anfang der Eingabe steht, b) nicht dem separaten Eingabezeichen entspricht.

Pip , 22 26 24 22 Bytes

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

Nimmt Zeichenfolge als erstes Befehlszeilenargument, Zeichen als zweites. Probieren Sie es online!

Erläuterung

Schleifen über Zeichen der Eingabe; Wenn das Zeichen dem Sonderzeichen entspricht, fahren Sie mit dem nächsten fort. Wenn nicht, löschen Sie es und drucken Sie die Zeichenfolge.

Eine ungolfed-Version ( a, bget cmdline args; obeginnt mit einem Wert von 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
 }

Golftricks:

• Der Schleifenkopf für Lwird nur einmal ausgewertet, damit wir den ersten Ausdruck dort hineinschleichen können. #Pa-1wird nicht funktionieren, weil Pes eine niedrige Priorität hat (es würde als geparst werden #P(a-1)), aber wir können es neu anordnen v+#Pa, indem wir die vvorinitialisierte Variable verwenden -1.
• Der RA:Operator gibt den neuen Wert von zurück a, sodass wir diesen Ausdruck drucken können, anstatt eine separate PaAnweisung zu haben.
• Jetzt sind beide Zweige der if-Anweisung einzelne Ausdrücke, sodass wir ?stattdessen den ternären Operator verwenden können.

Perl 5, 29 Bytes

Ich habe 35 Bytes mit Strawberry Perl: 31 Bytes plus 1 für -nE anstelle von -eplus 3 für Leerzeichen + -i(für die Eingabe mit einem Buchstaben verwendet; die längere Zeichenfolge stammt von STDIN).

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

Ich habe jedoch keinen Zweifel daran, dass dies ohne die chomp;Verwendung von <<<29 Byte möglich ist, obwohl ich es nicht selbst mit Strawberry testen kann.

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

Somit:

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

Perl 6 ,  47 40  38 Bytes

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

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

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

Erweitert:

{       # 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

}

...^Stattdessen wurde der Grund verwendet, ...dass der Wert &[eq]erst dann zurückgegeben wird, Truewenn der letzte Wert wiederholt wurde.

05AB1E ,26 25 Bytes

¬ˆ[¦Ð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

Probieren Sie es online!

Bitte beachten Sie, dass ¬²k0Qdies möglicherweise umgeschrieben wird ¬²Q, aber aus irgendeinem Grund nicht funktioniert, wenn das aktuelle Zeichen ein Anführungszeichen ist: Q gibt die tatsächliche Zeichenfolge anstelle eines Booleschen zurück und verursacht eine Endlosschleife.

Dieser Code kann weiter verwendet werden, da er ¯J?dupliziert wird. Das Verschieben dieses Teils in der Schleife würde die Duplizierung entfernen und es auch ermöglichen, die schließende eckige Klammer fallen zu lassen.

Python 2, 71 66 Bytes:

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

Ein volles Programm. Nimmt 2 Eingaben über STDIN im Format auf '<String>','<Char>'.

Außerdem gibt es hier eine rekursive Lösung mit derzeit 140 Byte :

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)

Dieser sollte im Format aufgerufen werden print(Q('<String>','<Char>')).

Python 3 , 72 Bytes

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

Probieren Sie es online!

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

Diät machen:

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

JavaScript (ES6), 74 Byte

(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 Bytes

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

Sie sind sich nicht sicher, ob Amateur-Code für diesen Austausch akzeptiert wird, aber ich bin daran interessiert, das Codieren von Golf zu lernen, obwohl ich schrecklich darin bin. Gibt es eine Hilfe, wie ich dieses Programm so klein wie die anderen hier aussehen lassen könnte?

BEARBEITEN:

Ersetzte Puts durch p

Dank des Weizen-Assistenten wurden eine Tonne Leerzeichen entfernt und die Bytes korrekt gezählt

Dank Challenger5 ging von s=gets.chop;c=gets.chop;biss,c=gets.chop,gets.chop;

ersetzt then mit ;und gets.chopmit gets[0]Dank Mhutter!

Eingabe jetzt als Kommandozeilenvariable übernehmen, z. prog.rb helloworld l

Dank zahlreichen Verbesserungen durch jeroenvisser101 ersetzt a=s.dupmit s=""+aund die vorherige if - Anweisung if s[i]!=c;s[i]="";p s;else i+=1;endmit (d!=c)?(s[i]="";p s):i+=1;großem Fortschritt!

c90, 129 125 Bytes

mit Leerzeichen:

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

ohne Leerzeichen:

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

ungolfed:

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

Dadurch wird ein Zeiger auf den Anfang der Zeichenfolge gesetzt und eine Schleife ausgeführt, die diesen Zeiger durchläuft, bis das Ende der Zeichenfolge erreicht ist. Innerhalb der Schleife wird das erste Zeichen und dann alle Instanzen des zweiten Arguments ausgegeben, die zwischen dem Anfang der Zeichenfolge und dem Zeiger gefunden werden. Danach setzt es den Zeiger auf und druckt den Rest der Zeichenkette aus.

Dies muss auf einem System mit sizeof (int) == sizeof (char *) kompiliert werden. +3 Bytes sonst.

Dies ist das erste Mal, dass ich Code Golfing hier ausprobiert habe, daher bin ich sicher, dass einige Optimierungen vorgenommen werden müssen.

Dyalog APL , 27 Bytes

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

⍺der ausgeschlossene Charakter ist, ⍵ist die anfängliche Zeichenkette

Argument drucken; Index ides ersten nicht ⍺nach dem ersten Zeichen suchen ; Wenn gefunden, rekursiv mit ientfernt aufrufen

Mathematica, 64 Bytes

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

Anonyme Funktion. Nimmt zwei Zeichenfolgen als Eingabe und gibt eine Liste von Zeichenfolgen als Ausgabe zurück. Entfernt wiederholt die erste Nichtinstanz des Zeichens.

PHP, 88 84 86 85 82 81 78 Bytes

1 Byte gespeichert dank @IsmaelMiguel, 3 Byte dank @ user59178, 3 Byte inspiriert von @ user59178

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

Nimmt Eingaben von Befehlszeilenargumenten entgegen. renn mitphp -r <code> '<string>' <character>

• Hängt eine neue Zeile an die Eingabe an, um einen impliziten endgültigen Ausdruck zu erhalten.
  Das fügt 5 4 Bytes Code hinzu, spart aber bei der Ausgabe und zusätzlich echo$a;.

05AB1E, 26 24 23 Bytes

Danke @Kade für 2 Bytes!
Danke @Emigna für 1 Byte!

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

Verwendet die CP-1252- Codierung. Probieren Sie es online!

y²k0Ê könnte sein y²Ê aber die sein" vermasseln sein.

Dies könnte wahrscheinlich mehr Golf gespielt werden, da «es zweimal wiederholt wird. Bitte hinterlassen Sie einen Kommentar, wenn Sie Vorschläge oder Möglichkeiten zum Golfspielen haben.

Java 10, 155 140 139 124 Bytes

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

Probieren Sie es online aus.

Erläuterung:

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

Alte 139 Bytes rekursive Antwort:

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 Bytes dank @Eugene . (Machen Sie das nächste Mal einen Kommentar, anstatt den Beitrag eines anderen zu bearbeiten.)

Probieren Sie es online aus.

Erläuterung:

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 Bytes

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

Ungolfed:

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

Gibt eine Auflistung von Zeichenfolgen zurück.

TSQL, 127 Byte (ohne Variablendefinitionen)

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

Formatiert:

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 Bytes

Golf gespielt:

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

Ungolfed:

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

Die Funktion gibt eine Sammlung von Zeichenfolgen zurück.

EDIT1: @psycho hat festgestellt, dass der Algorithmus nicht richtig implementiert wurde.

EDIT2: Variable für erstellt s.Length. Ein Byte gespart dank @TheLethalCoder.

Python 2 - 65 73 Bytes

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

Und eine rekursive 76- Byte-Lösung, denn obwohl sie länger als die erste ist, gefällt sie mir irgendwie besser:

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]

Schläger 194 Bytes

(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)]))

Ungolfed:

(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)])))

Testen:

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

Ausgabe:

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

Zurückgeben einer einzelnen Zeichenfolge mit Zeilenumbrüchen

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>

Swift 3 - 151 147 Bytes

Swift ist nicht die ideale Sprache zum Golfen, besonders wenn es um das Indizieren von Saiten geht. Das ist das Beste, was ich tun kann:

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

Leider braucht Swift Leerzeichen !=(aber nicht für ==), und Swift 3 hat den ++Operator fallen gelassen . Der Trick für beide besteht darin, in ein Zeichenarray zu konvertieren, das die Indizierung von Ganzzahlen ermöglicht, und die Zeichenfolge-Interpolation zu verwenden, um zurück in a String( "\(c)") zu konvertieren .

Ungolfed:

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

Vorherige, nicht rekursive Lösung

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 Bytes

jljjhF3<Q/Q*jih>s

Probieren Sie es hier aus!

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

Verdammt, Martin Ender, ich war fast der Erste: p

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

Unbenannte Funktion; einfache Implementierung mit einer WhileSchleife und einigen temporären Variablen.

JavaScript ES6, 89 Bytes

Ich dachte, das wäre eine leichte Herausforderung, aber ich bin mir ziemlich sicher, dass mir hier etwas fehlt.

Verwendet die Rekursion und gibt ein Array von Zeichenfolgen zurück

(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 Bytes

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