La sfida consiste semplicemente nel far passare una stringa all'interno di un'altra stringa.

Spiegazione

Se la stringa di attivazione / disattivazione è una sottostringa della stringa principale , rimuovere tutte le istanze della stringa di attivazione / disattivazione dalla stringa principale ; in caso contrario, aggiungere la stringa di attivazione / disattivazione alla fine della stringa principale .

Regole

• Tutte le stringhe sono composte da caratteri ASCII stampabili
• La funzione dovrebbe assumere due parametri: la stringa principale e la stringa di attivazione / disattivazione .
• La stringa principale può essere vuota.
• La stringa di attivazione / disattivazione non può essere vuota.
• Il risultato dovrebbe essere una stringa, che può essere vuota.
• Vince la risposta più breve.

Esempi

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'

Casi di test

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

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

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

Gelatina , 7 byte

œṣȮ⁸e⁹ẋ

Provalo online!

Come funziona

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

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

Probabilmente il mio 'codegolf' Java più corto finora .. xD
con un po 'di aiuto dai commenti ..;)

Spiegazione:

Provalo online.

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 byte

yyXf?''YX}h

Provalo online!

Tutti i casi di test

Spiegazione

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

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

JavaScript (ES6), 39 37 byte

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

Pyke, 14 byte

DX{iIXRk:)i!IJ

Provalo qui!

Dato che Pyke non ha else struttura, penso che questo sia un punteggio abbastanza ragionevole

Spiegazione:

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]

Provalo online. Grazie jimmy23013 per tagliare 1 byte :)

Spiegazione:

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 byte

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

Retina , 38 31 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

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

T`·¶

L'avanzamento finale è significativo. Il formato di input è costituito da entrambe le stringhe separate da un avanzamento di riga.

Provalo online!La prima riga consente di eseguire diversi casi di test contemporaneamente (per la suite di test, utilizzare; per separare stringhe e avanzamenti di riga per separare i casi di test; la prima riga si occupa della conversione).

Spiegazione

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

In questo primo passaggio sostituiamo tutte le occorrenze della stringa di commutazione nella stringa principale con ·. Dobbiamo inserire questi marcatori in modo da poter determinare in seguito se si è verificata una sostituzione.

1>`·|¶.+

Questa è un'altra sostituzione che rimuove un ·marcatore o la seconda riga (incluso l'alimentatore di separazione). Tuttavia, 1>è un limite che significa che vengono prese in considerazione solo le corrispondenze dopo la prima. Quindi, se la stringa di attivazione / disattivazione non si fosse verificata nella stringa principale, non ne avremmo inserito alcuno ·, quindi la seconda riga sarà la prima corrispondenza e non verrà rimossa. Altrimenti, rimuoviamo la seconda riga insieme a tutti tranne il primo marcatore.

T`·¶

Mentre questo utilizza una fase di traslitterazione, viene anche utilizzato semplicemente per rimuovere i caratteri. In particolare, spostiamo entrambi ·e gli avanzamenti di riga. Abbiamo bisogno del primo, nel caso in cui ci fosse una partita (perché il primo ·sarà stato lasciato indietro dalla fase precedente) e abbiamo bisogno del secondo nel caso in cui non ci fosse una partita (per unire le due linee insieme e quindi aggiungere la stringa di attivazione / disattivazione alla stringa principale).

Python (3.4): 55 54 47 44 byte

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

test:

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

L'output del test

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

L'uso di un def sarebbe più lungo perché è necessario utilizzare un'istruzione return, se fosse possibile senza restituzione si risparmierebbero 2 byte Poiché non è necessaria la dichiarazione esplicita della funzione (mi dispiace non sapevo che) 7 byte sono stati salvati.

C #, 63

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

Meglio di Java :)

Codice di prova:

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

Produzione:

a

ba
b
b
ba

Pyth, 13 11 10 byte

?/Qz:Qzk+z

Suite di test.

Formato di input: prima stringa tra virgolette, seconda stringa senza virgolette.

Questo è anche 10 byte:

?tJcQzsJ+z

Suite di test.

Questo è 11 byte:

pscQz*!}zQz

Suite di test.

Precedente soluzione a 13 byte:

?:IQzk+Qz:Qzk

Suite di test.

Jolf, 12 byte

?=iγρiIE+iIγ

Oppure, se dobbiamo includere caratteri sensibili alla regex:

?=iγρiLeIE+iIγ

Provalo qui!

Spiegazione

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

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

Leggermente più breve della risposta di @ nobe4 sfruttando la divisione e l'unione

Racchetta, 70 byte

Abbastanza diretto.

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

Scala, 72 70 byte

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

Interprete online: 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 byte

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

Le espressioni regolari all'interno della stringa di attivazione / disattivazione non vengono valutate a causa della citazione con \Q...\E .

sub Fe \Evengono rimossi in base al commento di msh210.

Non è del tutto privo di effetti collaterali a causa dell'impostazione $_. L'uso di una variabile locale avrà un costo di sei byte aggiuntivi:

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

D'altra parte, con i parametri di input commutati è possibile salvare due byte utilizzando popinvece di shift(28 byte):

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

File di prova:

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

Risultato della prova:

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

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

Utilizza un'assegnazione in linea per eliminare alcuni byte

bash + sed, 28 byte

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

Lo script vive in un file toggle-string.bash, che chiamiamo bash toggle-string.bash mainstring togglestring.

s/$2//g rimuove la stringa di attivazione / disattivazione dalla stringa principale

t passa alla fine se la sostituzione precedente ha avuto esito positivo (ad es. la stringa principale conteneva la stringa di attivazione / disattivazione)

/$/$2/ aggiunge la stringa di commutazione alla fine ($ ), se non siamo passati alla fine

bash è richiesto per il herestring

Julia, 33 31 byte

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

Provalo online!

PowerShell v2 +, 47 byte

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

Accetta input $a,$be quindi utilizza (... , ...)[...]un'istruzione pseudo-ternaria per eseguire un if / else. Le parti interne vengono valutate per prime per formare una matrice di due elementi. Il 0 è $acon tutte le occorrenze di $b -replaced con nulla, in cui è memorizzato $c. Il primo è solo una concatenazione di stringhe di $ae$b .

Se $cè -equguale a $a, il che significa che $bnon è stato trovato, è Booleano $trueo 1, quindi viene scelto il primo elemento dell'array (la concatenazione). Altrimenti, è booleano $false, quindi produciamo$c il 0 ° elemento.

Nota che -replaceè avido, quindi sostituirà prima da sinistra, il che significa che il ababa / abatest case tornerà correttamente ba.

Java 8, 65 byte

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

La stessa logica della soluzione Java 7, scritta con una lambda.

Provalo qui

Ruby, 33 byte 27 byte (28 se si utilizza la sottotitolazione globale) sicuramente 28 byte

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

Mathematica, 45 byte

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

Funzione anonima che accetta la stringa principale e la stringa di commutazione (in quell'ordine) e restituisce il risultato. Spiegazione:

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

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

Leggibile:

   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 byte con input strettamente 1 carattere

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 byte

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

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

Provalo online!

Rubino, 35 37 28 byte

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

Evviva per l'interpolazione delle stringhe! Funziona anche in regex. Il resto è semplice: se la stringa tcorrisponde m, sostituisce tcon '', altrimenti restituisce m+t.

Modifica: risolto un bug.

Modifica: ho applicato il suggerimento di Kevin Lau, ma sembra che abbia raggiunto lo stesso algoritmo di quello usato nella risposta di Luis Masuelli .

k (23 byte)

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

Esempi:

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 byte

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

Ciò sarebbe più breve se l'assegnazione fosse un'espressione in Kotlin e i parametri fossero mutabili e esistesse un operatore condizionale ternario, purtroppo non è così :(

Provalo online!

UnGolfed

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