Le défi consiste simplement à basculer une chaîne dans une autre chaîne.

Explication

Si la chaîne à bascule est une sous-chaîne de la chaîne principale , supprimez toutes les instances de la chaîne à bascule de la chaîne principale ; sinon, ajoutez la chaîne de bascule à la fin de la chaîne principale .

Règles

• Toutes les chaînes sont composées de caractères ASCII imprimables
• La fonction doit prendre deux paramètres: la chaîne principale et la chaîne à bascule .
• La chaîne principale peut être vide.
• La chaîne de bascule ne peut pas être vide.
• Le résultat doit être une chaîne, qui peut être vide.
• La réponse la plus courte l'emporte.

Exemples

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'

Cas de tests

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

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

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

Gelée , 7 octets

œṣȮ⁸e⁹ẋ

Essayez-le en ligne!

Comment ça fonctionne

œṣȮ⁸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 octets

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

Probablement mon plus court 'codegolf' Java jusqu'à présent .. xD
avec l'aide des commentaires ..;)

Explication:

Essayez-le en ligne.

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 octets

yyXf?''YX}h

Essayez-le en ligne!

Tous les cas de test

Explication

            % 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 octets

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

JavaScript (ES6), 39 37 octets

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

Pyke, 14 octets

DX{iIXRk:)i!IJ

Essayez-le ici!

Étant donné que Pyke n'a pas de elsestructure, je pense que c'est un score assez raisonnable

Explication:

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]

Essayez-le en ligne. Merci jimmy23013 pour avoir coupé 1 octet :)

Explication:

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 octets

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

Rétine , 38 31 octets

Le nombre d'octets suppose un codage ISO 8859-1.

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

T`·¶

Le saut de ligne arrière est important. Le format d'entrée est les deux chaînes séparées par un saut de ligne.

Essayez-le en ligne!La première ligne permet d'exécuter plusieurs cas de test à la fois (pour la suite de tests, utilisez ;pour séparer les chaînes et les sauts de ligne pour séparer les cas de test; la première ligne s'occupe de la conversion).

Explication

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

Dans cette première étape, nous remplaçons toutes les occurrences de la chaîne à bascule dans la chaîne principale par ·. Nous devons insérer ces marqueurs afin de pouvoir déterminer ultérieurement si une substitution s'est produite.

1>`·|¶.+

Il s'agit d'une autre substitution qui supprime un ·marqueur ou la deuxième ligne (y compris le saut de ligne de séparation). Cependant, le 1>est une limite, ce qui signifie que seules les correspondances après la première sont prises en compte. Par conséquent, si la chaîne de bascule ne s'est pas produite dans la chaîne principale, nous n'en aurons pas inséré ·, donc la deuxième ligne sera la première correspondance et ne sera pas supprimée. Sinon, nous supprimons la deuxième ligne avec tout sauf le premier marqueur.

T`·¶

Bien que cela utilise une étape de translittération, il est également utilisé simplement pour supprimer des caractères. En particulier, nous déplaçons les deux ·et les sauts de ligne. Nous avons besoin du premier, au cas où il y aurait un match (car alors le premier ·aura été laissé par l'étape précédente) et nous avons besoin du second au cas où il n'y aurait pas de match (pour joindre les deux lignes ensemble et ainsi ajoutez la chaîne de bascule à la chaîne principale).

Python (3.4): 55 54 47 44 octets

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

Essai:

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

La sortie de test

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

L'utilisation d'un def serait plus longue car vous devez utiliser une instruction return, si elle était possible sans return, cela économiserait 2 octets, car la déclaration explicite de la fonction n'est pas nécessaire (désolé, je ne le savais pas) 7 octets ont été enregistrés.

C #, 63

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

Mieux que Java :)

Code de test:

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

Production:

a

ba
b
b
ba

Pyth, 13 11 10 octets

?/Qz:Qzk+z

Suite de tests.

Format d'entrée: première chaîne entre guillemets, deuxième chaîne sans guillemets.

C'est aussi 10 octets:

?tJcQzsJ+z

Suite de tests.

C'est 11 octets:

pscQz*!}zQz

Suite de tests.

Solution précédente de 13 octets:

?:IQzk+Qz:Qzk

Suite de tests.

Jolf, 12 octets

?=iγρiIE+iIγ

Ou, si nous devons inclure des caractères sensibles aux regex:

?=iγρiLeIE+iIγ

Essayez-le ici!

Explication

?=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 octets

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

Légèrement plus courte que la réponse de @ nobe4 en profitant du split and join

Raquette, 70 octets

Assez simple.

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

Scala, 72 70 octets

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

Interprète en ligne: www.tryscala.com

Oracle SQL 11.2, 66 octets

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

Perl, 37 30 octets

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

Les expressions régulières à l'intérieur de la chaîne de bascule ne sont pas évaluées en raison de la citation avec \Q...\E .

sub Fet \Esont supprimés selon le commentaire de msh210.

Il n'est pas entièrement exempt d'effets secondaires en raison du réglage $_. L'utilisation d'une variable locale coûtera six octets supplémentaires:

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

En revanche, avec des paramètres d'entrée commutés, deux octets peuvent être enregistrés en utilisant popau lieu de shift(28 octets):

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

Fichier de test:

#!/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__

Résultat du test:

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

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

Il utilise une affectation en ligne pour raser quelques octets

bash + sed, 28 octets

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

Le script réside dans un fichier toggle-string.bash, que nous appelons avec bash toggle-string.bash mainstring togglestring .

s/$2//g supprime la chaîne de bascule de la chaîne principale

t saute à la fin si la substitution précédente a réussi (c'est-à-dire que la chaîne principale contenait la chaîne à bascule)

/$/$2/ajoute la chaîne de bascule à la fin ( $), si nous ne sautons pas à la fin

bash est requis pour l'héritage

Julia, 33 31 octets

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

Essayez-le en ligne!

PowerShell v2 +, 47 octets

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

Prend des données $a,$bpuis utilise une (... , ...)[...]instruction pseudo-ternaire pour effectuer un if / else. Les parties internes sont évaluées en premier pour former un tableau de deux éléments. Le 0 est $aavec toutes les occurrences de $b -replaced avec rien, qui est stocké dans $c. Le 1er est juste une concaténation de chaînes de $aet $b.

Si $cest -equal $a, c'est- à -dire qui $bn'a pas été trouvé, c'est booléen $trueou 1, et donc le 1er élément du tableau (la concaténation) est choisi. Sinon, c'est booléen $false, donc nous $csortons le 0ème élément.

Notez que -replacec'est gourmand, il remplacera donc d'abord par la gauche, ce qui signifie que le ababa / abacas de test reviendra correctement ba.

Java 8, 65 octets

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

La même logique que la solution Java 7, écrite avec un lambda.

Essayez-le ici

Ruby, 33 octets 27 octets (28 si vous utilisez la sous-substitution globale) certainement 28 octets

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

Mathematica, 45 octets

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

Fonction anonyme qui prend la chaîne principale et la chaîne à bascule (dans cet ordre) et renvoie le résultat. Explication:

                                            &  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 octets

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

Lisible:

   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 octets avec strictement 1 caractère d'entrée

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

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

TSQL (Sqlserver 2012), 49 octets

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

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

Essayez-le en ligne!

Rubis, 35 37 28 octets

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

Hourra pour l'interpolation de chaînes! Cela fonctionne même dans les expressions régulières. Le reste est simple: si la chaîne dans tcorrespond à m, remplacez tpar '', sinon retournez m+t.

Éditer: correction d'un bug.

Edit: J'ai appliqué la suggestion de Kevin Lau, mais il semble que j'aie atteint le même algorithme que celui utilisé dans la réponse de Luis Masuelli .

k (23 octets)

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

Exemples:

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 octets

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

Ce serait plus court si l'affectation était une expression dans Kotlin, et les paramètres étaient mutables, et il y avait un opérateur conditionnel ternaire, malheureusement ce n'est pas le cas :(

Essayez-le en ligne!

UnGolfed

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