Die Herausforderung besteht darin, einfach eine Zeichenfolge innerhalb einer anderen Zeichenfolge zu wechseln.

Erläuterung

Wenn die Umschaltzeichenfolge eine Teilzeichenfolge der Hauptzeichenfolge ist , entfernen Sie alle Instanzen der Umschaltzeichenfolge aus der Hauptzeichenfolge . Ansonsten hängen Sie die Umschaltzeichenfolge an das Ende der Hauptzeichenfolge an .

Regeln

• Alle Zeichenfolgen bestehen aus druckbaren ASCII-Zeichen
• Die Funktion sollte zwei Parameter annehmen: die Hauptzeichenfolge und die Umschaltzeichenfolge .
• Die Hauptzeichenfolge kann leer sein.
• Die Umschaltzeichenfolge darf nicht leer sein.
• Das Ergebnis sollte eine Zeichenfolge sein, die leer sein kann.
• Die kürzeste Antwort gewinnt.

Beispiele

function toggle(main_string, toggle_string){ ... }

toggle('this string has 6 words ', 'now') 
=> 'this string has 6 words now'

toggle('this string has 5 words now', ' now') 
=> 'this string has 5 words'

Testet Fälle

'','a'          => 'a'
'a','a'         => ''

'b','a'         => 'ba'
'ab','a'        => 'b'

'aba','a'       => 'b'
'ababa', 'aba'  => 'ba'

Gelee , 7 Bytes

œṣȮ⁸e⁹ẋ

Probieren Sie es online!

Wie es funktioniert

œṣȮ⁸e⁹ẋ  Main link. Arguments: s (string), t (toggle string)

œṣ       Split s at occurrences of t.
  Ȯ      Print the result.
   ⁸e    Check if s occurs in the split s. Yields 1 (true) or 0 (false).
     ⁹ẋ  Repeat t that many times.

Java 8, 80 70 65 34 Bytes

t->m->m==(m=m.replace(t,""))?m+t:m

Wahrscheinlich mein bisher kürzester Java 'Codegolf' .. xD
mit etwas Hilfe aus den Kommentaren ..;)

Erläuterung:

Probieren Sie es online aus.

t->m->                     // Method with two String parameters and String return-type
                           // (NOTE: Takes the toggle `t` and main `m` in reversed order)
  m==(m=m.replace(t,""))?  //  If `m` equals `m` with all `t`-substrings removed:
                           //  (And set `m` to `m` with all `t`-substrings removed)
   m+t                     //   Output this new `m` concatted with `t`
  :                        //  Else:
   m                       //   Output just this new `m`

MATL, 11 Bytes

yyXf?''YX}h

Probieren Sie es online!

Alle Testfälle

Erläuterung

            % Implicitly grab the main string
            % Implicitly grab the toggle string
y           % Copy the main string
y           % Copy the toggle string
Xf          % Check to see if the toggle string is present in the main string
?           % If so
    ''YX    % Replace with an empty string
}           % else
    h       % Horizontally concatenate the two strings
            % Implicit end of if...else
            % Implicitly display the result

Python 3, 38 Bytes

lambda s,t:(s+t,s.replace(t,""))[t in s]

JavaScript (ES6), 39 37 Bytes

(s,t,u=s.split(t).join``)=>u==s?s+t:u

Pyke, 14 Bytes

DX{iIXRk:)i!IJ

Probieren Sie es hier aus!

Vorausgesetzt, Pyke hat keine else Struktur hat, halte ich dies für eine ziemlich vernünftige Punktzahl

Erläuterung:

D              -    Duplicate input
 X             -   a,b = ^
  {            -  a in b
   i           - i = ^
    I          - if i:
     XRk:      -  a = b.replace(a,"")
         i!I   - if not i:
            J  -  a = "".join(input)
               - print a

CJam, 9

q~:B/2Be]

Probieren Sie es online aus. Danke jimmy23013 für das Abhacken von 1 Byte :)

Erläuterung:

q~     read and evaluate the input (given as 2 quoted strings)
:B     store the toggle string in B
/      split the main string by the toggle string
2Be]   pad the array of pieces to the right with B, up to length 2 (if shorter)

Javascript (ECMAScript 6): 47 Bytes

(a,b)=>(c=a.replace(RegExp(b,'g'),''))!=a?c:a+b

Retina , 38 31 Bytes

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

(.+)(?=.*¶\1$)
·
1>`·|¶.+

T`·¶

Der Zeilenvorschub am Ende ist signifikant. Das Eingabeformat besteht aus beiden durch einen Zeilenvorschub getrennten Zeichenfolgen.

Probieren Sie es online!In der ersten Zeile können mehrere Testfälle gleichzeitig ausgeführt werden (für die Testsuite ;trennen Sie die Zeichenfolgen und Zeilenvorschübe nach Testfällen; in der ersten Zeile wird die Konvertierung vorgenommen).

Erläuterung

(.+)(?=.*¶\1$)
·

In diesem ersten Schritt ersetzen wir alle Vorkommen der Umschaltzeichenfolge in der Hauptzeichenfolge durch ·. Wir müssen diese Marker einfügen, damit wir später feststellen können, ob eine Substitution stattgefunden hat.

1>`·|¶.+

Dies ist eine weitere Ersetzung, durch die ein ·Marker oder die zweite Zeile (einschließlich des Trennzeilenvorschubs) entfernt wird. Dies 1>ist jedoch eine Grenze, was bedeutet, dass nur Übereinstimmungen nach der ersten berücksichtigt werden. Wenn die Umschaltzeichenfolge nicht in der Hauptzeichenfolge vorkommt, haben wir keine eingefügt ·, sodass die zweite Zeile die erste Übereinstimmung darstellt und nicht entfernt wird. Ansonsten entfernen wir die zweite Zeile zusammen mit allen bis auf den ersten Marker.

T`·¶

Während dies eine Transliterationsstufe verwendet, wird sie auch einfach zum Entfernen von Zeichen verwendet. Insbesondere verschieben wir sowohl ·Zeilen- als auch Zeilenvorschübe. Wir brauchen die erste, falls es ein Match gab (weil dann die erste ·von der vorherigen Phase zurückgelassen wurde) und wir brauchen die zweite, falls es kein Match gab (um die beiden Linien miteinander zu verbinden und damit die Toggle-Zeichenfolge an die Hauptzeichenfolge anhängen).

Python (3.4): 55 54 47 44 Bytes

lambda m,t:m.replace(t,'')if t in m else m+t

Testen:

toggle=lambda m,t:m.replace(t,'')if t in m else m+t
print('', 'a', toggle('','a'))
print('a', 'a', toggle('a','a'))
print('b', 'a', toggle('b','a'))
print('ab', 'a', toggle('ab','a'))
print('aba', 'a', toggle('aba','a'))
print('ababa', 'aba', toggle('ababa','aba'))

Die Testausgabe

 a a
a a
b a ba
ab a b
aba a b
ababa aba ba

Die Verwendung eines def würde länger dauern, da Sie eine return-Anweisung verwenden müssen, wenn dies ohne return möglich wäre, würde dies 2 Bytes sparen. Da keine explizite Deklaration der Funktion erforderlich ist (sorry, das wusste ich nicht), wurden 7 Bytes gespeichert.

C #, 63

string F(string s,string t)=>s.Contains(t)?s.Replace(t,""):s+t;

Besser als Java :)

Testcode:

public static void Main()
{
    Console.WriteLine(F("", "a"));
    Console.WriteLine(F("a", "a"));
    Console.WriteLine(F("b", "a"));
    Console.WriteLine(F("ab", "a"));
    Console.WriteLine(F("aba", "a"));
    Console.WriteLine(F("ababa", "aba"));
    Console.ReadLine();
}

Ausgabe:

a

ba
b
b
ba

Pyth, 13 11 10 Bytes

?/Qz:Qzk+z

Testsuite.

Eingabeformat: erste Zeichenfolge in Anführungszeichen, zweite Zeichenfolge ohne Anführungszeichen.

Dies sind ebenfalls 10 Bytes:

?tJcQzsJ+z

Testsuite.

Das sind 11 Bytes:

pscQz*!}zQz

Testsuite.

Bisherige 13-Byte-Lösung:

?:IQzk+Qz:Qzk

Testsuite.

Jolf, 12 Bytes

?=iγρiIE+iIγ

Oder, wenn wir regex-sensitive Zeichen einfügen müssen:

?=iγρiLeIE+iIγ

Probieren Sie es hier aus!

Erläuterung

?=iγρiIE+iIγ    if(i === (γ = i.replace(I, E))) alert(i + I); else alert(γ);
  i                i
 =                   ===
    ρ                          .replace( ,  )
     iI                       i         I 
       E                                   E
   γ                     (γ =                )
?               if(                           )
        +iI                                     alert(i + I);
                                                              else
           γ                                                       alert(γ);

JavaScript (ES6), 37 Bytes

(m,t)=>(w=m.split(t).join``)==m?m+t:w

Etwas kürzer als die Antwort von @nobe4, da Split und Join genutzt werden

Schläger, 70 Bytes

Ziemlich einfach.

(λ(s t)((if(string-contains? s t)string-replace string-append)s t""))

Scala, 72-70 Bytes

def x(m:String,s:String)={val r=m.replaceAll(s,"");if(r==m)m+s else r}

Online-Dolmetscher: www.tryscala.com

Oracle SQL 11.2, 66 Byte

SELECT DECODE(:1,s,s||:2,s)FROM(SELECT REPLACE(:1,:2)s FROM DUAL);

Perl, 37-30 Bytes

{$_=shift;s/\Q@_//g?$_:"$_@_"}

Reguläre Ausdrücke in der Umschaltzeichenfolge werden aufgrund der Anführungszeichen mit \Q... nicht ausgewertet \E.

sub Fund \Ewerden laut Kommentar von msh210 entfernt.

Es ist nicht ganz frei von Nebenwirkungen aufgrund der Einstellung $_. Die Verwendung einer lokalen Variablen kostet sechs zusätzliche Bytes:

{my$a=shift;$a=~s/\Q@_//g?$a:"$a@_"}

Andererseits können bei umgeschalteten Eingangsparametern zwei Bytes mit popanstelle von shift(28 Bytes) gespeichert werden :

{$_=pop;s/\Q@_//g?$_:"$_@_"}

Testdatei:

#!/usr/bin/env perl

sub F{$_=shift;s/\Q@_//g?$_:"$_@_"}

sub test ($$$) {
  my ($m, $t, $r) = @_;
  my $result = F($m, $t);
  print "F('$m', '$t') -> '$result' ",
    ($result eq $r ? '=OK=' : '<ERROR>'), " '$r'\n";
}
test '', 'a', 'a';
test 'a', 'a', '';
test 'b', 'a', 'ba';
test 'ab', 'a', 'b';
test 'aba', 'a', 'b';
test 'ababa', 'aba', 'ba';
test 'ababa', 'a*', 'ababaa*';
test 'foobar', '.', 'foobar.';
__END__

Testergebnis:

F('', 'a') -> 'a' =OK= 'a'
F('a', 'a') -> '' =OK= ''
F('b', 'a') -> 'ba' =OK= 'ba'
F('ab', 'a') -> 'b' =OK= 'b'
F('aba', 'a') -> 'b' =OK= 'b'
F('ababa', 'aba') -> 'ba' =OK= 'ba'
F('ababa', 'a*') -> 'ababaa*' =OK= 'ababaa*'
F('foobar', '.') -> 'foobar.' =OK= 'foobar.'

C # (58 Bytes)

string F(string s,string t)=>s==(s=s.Replace(t,""))?s+t:s;

Es verwendet eine Inline-Zuweisung, um ein paar Bytes zu sparen

Bash + Sed, 28 Bytes

sed "s/$2//g;t;s/$/$2/"<<<$1

Das Skript befindet sich in einer toggle-string.bash-Datei, die wir aufrufen bash toggle-string.bash mainstring togglestring .

s/$2//g Entfernt die Umschaltzeichenfolge aus der Hauptzeichenfolge

t springt zum Ende, wenn die vorherige Ersetzung erfolgreich war (dh die Hauptzeichenfolge enthielt die Umschaltzeichenfolge)

/$/$2/ Fügt die Umschaltzeichenfolge am Ende hinzu ($ ) hinzu, wenn wir nicht zum Ende gesprungen sind

bash wird für den herestring benötigt

Julia, 33 31 Bytes

s|t=(r=replace(s,t,""))t^(s==r)

Probieren Sie es online!

PowerShell v2 +, 47 Byte

param($a,$b)(($c=$a-replace$b),"$a$b")[$c-eq$a]

Übernimmt Eingaben $a,$bund verwendet dann eine pseudoternäre (... , ...)[...]Anweisung, um ein if / else auszuführen. Die inneren Teile werden zuerst ausgewertet, um ein Array aus zwei Elementen zu bilden. Die 0. ist $abei allen Vorkommen von $b -replaced mit nichts, was in gespeichert ist $c. Die 1. ist nur eine String-Verkettung von $aund $b.

If $cis -equal to $a, was bedeutet, dass $bdas nicht gefunden wurde, ist Boolean $trueor 1, und daher wird das erste Element des Arrays (die Verkettung) ausgewählt. Sonst ist es Boolean $false, also geben wir $cdas 0. Element aus.

Beachten Sie, dass dies -replacegierig ist und daher zuerst von links ersetzt wird, was bedeutet, dass der ababa / abaTestfall ordnungsgemäß zurückgegeben wird ba.

Java 8, 65 Bytes

BinaryOperator<String>l=(m,t)->m.contains(t)?m.replace(t,""):m+t;

Dieselbe Logik wie die Java 7-Lösung, die mit einem Lambda geschrieben wurde.

Probieren Sie es hier aus

Ruby, 33 Bytes 27 Bytes (28 bei Verwendung der globalen Substitution) definitiv 28 Bytes

->u,v{u[v]?u.gsub(v,''):u+v}

Mathematica, 45 Bytes

If[StringContainsQ@##,StringDelete@##,#<>#2]&

Anonyme Funktion, die die Hauptzeichenfolge und die Umschaltzeichenfolge (in dieser Reihenfolge) verwendet und das Ergebnis zurückgibt. Erläuterung:

                                            &  Anonymous function returning...

If[StringContainsQ@##,               ,     ]    if its first argument contains
                                                its second argument, then...
                      StringDelete@##            its first argument with its
                                                 second argument removed, else...
                                      #<>#2      its second argument appended to
                                                 its first argument.

TSQL, 143 129 121 Bytes

DECLARE @1 VARCHAR(10)='',@2 VARCHAR(10)='a'SELECT CASE WHEN @1 LIKE'%'+@2+'%'THEN REPLACE(@1,@2,'')ELSE CONCAT(@1,@2)END

Lesbar:

   DECLARE @1 VARCHAR(10) = ''
    , @2 VARCHAR(10) = 'a'

SELECT CASE WHEN @1 LIKE '%' + @2 + '%'
            THEN REPLACE(@1, @2, '')
            ELSE CONCAT (@1, @2)
            END

Live Demo

114 Bytes mit einer Zeicheneingabe

DECLARE @1 CHAR(1) = 'a'
    , @2 CHAR(1) = '.'

SELECT CASE WHEN @1 LIKE '%' + @2 + '%'
            THEN REPLACE(@1, @2, '')
            ELSE CONCAT (@1, @2) END

TSQL (SQL Server 2012), 49 Byte

DECLARE @ VARCHAR(10) = 'hello',@x VARCHAR(10) = 'o'

PRINT IIF(@ LIKE'%'+@x+'%',REPLACE(@,@x,''),@+@x)

Probieren Sie es online!

Ruby, 35 37 28 Bytes

->m,t{m[t]?m.gsub(t,''):m+t}

Hurra für die String-Interpolation! Es funktioniert sogar in regulären Ausdrücken. Der Rest ist einfach: Wenn der String in tübereinstimmt m, ersetzen Sie ihn tdurch '', sonst kehren Sie zurück m+t.

Bearbeiten: Ein Fehler wurde behoben.

Bearbeiten: Ich habe den Vorschlag von Kevin Lau angewendet, aber es scheint, dass ich den gleichen Algorithmus wie in Luis Masuellis Antwort erreicht habe .

k (23 Bytes)

{$[#x ss y;,/y\:x;x,y]}

Beispiele:

k){$[#x ss y;,/y\:x;x,y]}["aba";"a"]
,"b"
k){$[#x ss y;,/y\:x;x,y]}["this string has 6 words ";"now"]
"this string has 6 words now"
k){$[#x ss y;,/y\:x;x,y]}["this string has 5 words now";"now"]
"this string has 5 words "
k){$[#x ss y;,/y\:x;x,y]}["ababa";"ba"]
,"a"
k){$[#x ss y;,/y\:x;x,y]}["";"a"]
,"a"

Kotlin, 61 Bytes

{m:String,t:String->var n=m.replace(t,"");if(m==n)m+t else n}

Dies wäre kürzer, wenn die Zuweisung ein Ausdruck in Kotlin wäre und Parameter veränderlich wären und es einen ternären bedingten Operator gäbe. Leider ist dies nicht der Fall :(

Probieren Sie es online!

Ungolfed

fun t(m:String, t:String):String{
    var n=m.replace(t, "")
    return if(m==n)m+t else n
}