挑战涉及简单地在另一个字符串中切换一个字符串。

说明

如果切换字符串是主字符串的子字符串，则从主字符串中删除切换字符串的所有实例; 否则，将切换字符串附加在main string的末尾。

规则

• 所有字符串均由可打印的ASCII字符组成
• 该函数应带有两个参数：主字符串和切换字符串。
• 在主串可以是空的。
• 该拨动弦不能为空。
• 结果应该是一个字符串，可以为空。
• 最短的答案将获胜。

例子

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'

测试案例

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

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

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

果冻，7 个字节

œṣȮ⁸e⁹ẋ

在线尝试！

怎么运行的

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

爪哇8，80 70 65 34字节

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

可能是我到目前为止最短的Java'codegolf'。.xD
在注释中提供了一些帮助。

说明：

在线尝试。

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个字节

yyXf?''YX}h

在线尝试！

所有测试用例

说明

            % 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个字节

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

JavaScript（ES6），39 37字节

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

Pyke，14个字节

DX{iIXRk:)i!IJ

在这里尝试！

鉴于派克（Pyke）没有 else结构，我认为这是相当合理的分数

说明：

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]

在线尝试。感谢jimmy23013砍掉1个字节:)

说明：

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个位元组

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

视网膜，38 31字节

字节数假定为ISO 8859-1编码。

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

T`·¶

尾随换行很重要。输入格式是两个用换行符分隔的字符串。

在线尝试！第一行允许一次运行多个测试用例（对于测试套件，用于;分隔字符串和换行符以分隔测试用例；第一行负责转换）。

说明

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

在第一步中，我们用替换主字符串中所有出现的切换字符串·。我们需要插入这些标记，以便以后可以确定是否发生任何替换。

1>`·|¶.+

这是另一个替代，它删除了·标记或第二行（包括分隔的换行符）。但是，这1>是一个限制，这意味着仅考虑第一个之后的匹配项。因此，如果切换字符串未出现在主字符串中，则不会插入any ·，因此第二行将是第一个匹配项，不会被删除。否则，我们将删除第二行以及第一个标记以外的所有标记。

T`·¶

尽管这使用了音译阶段，但它也仅用于删除字符。特别是，我们同时移动了·换行符。我们需要第一个，如果有匹配项（因为第·一个阶段将被上一阶段遗忘），而我们需要第二个，如果没有匹配项（将两行连接在一起，从而将切换字符串附加到主字符串）。

Python（3.4）：55 54 47 44字节

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

测试：

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

测试输出

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

使用def会更长，因为您必须使用return语句，如果可以不返回就可以节省2个字节。 由于不需要显式声明函数（对不起，我不知道），因此节省了7个字节。

C＃，63

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

比Java更好:)

测试代码：

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

输出：

a

ba
b
b
ba

Pyth，13 11 10字节

?/Qz:Qzk+z

测试套件。

输入格式：第一个字符串用引号引起来，第二个字符串不带引号。

这也是10个字节：

?tJcQzsJ+z

测试套件。

这是11个字节：

pscQz*!}zQz

测试套件。

以前的13字节解决方案：

?:IQzk+Qz:Qzk

测试套件。

Jolf，12个字节

?=iγρiIE+iIγ

或者，如果必须包含对正则表达式敏感的字符：

?=iγρiLeIE+iIγ

在这里尝试！

说明

?=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个字节

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

利用split和join的优势，比@ nobe4的答案略短

球拍，70个字节

非常简单。

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

Scala，72 70字节

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

在线口译：www.tryscala.com

Oracle SQL 11.2，66字节

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

Perl，37个 30字节

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

由于使用\Q... 引号，因此无法评估切换字符串内的正则表达式\E。

sub F并\E根据msh210 的注释将其删除。

由于凝结，它并非完全没有副作用$_。使用局部变量将花费另外六个字节：

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

另一方面，对于切换的输入参数，可以使用pop而不是shift（28个字节）来保存两个字节：

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

测试文件：

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

测试结果：

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字节）

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

它使用内联分配来剃除一些字节

bash + sed，28个字节

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

该脚本位于一个toggle-string.bash文件中，我们称之为 bash toggle-string.bash mainstring togglestring。

s/$2//g 从主字符串中删除切换字符串

t 如果先前的替换成功，则跳转到结尾（即，主字符串包含切换字符串）

/$/$2/ 在结尾添加切换字符串（$如果我们没有跳到结尾，则）

bash是herestring必需的

朱莉娅，33 31字节

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

在线尝试！

PowerShell v2 +，47个字节

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

接受输入$a,$b，然后使用伪三元(... , ...)[...]语句执行if / else。首先评估内部零件，以形成两个元素的数组。d的$a所有出现都为0 $b -replace，而没有任何结果，将其存储到中$c。第1只是一个字符串连接$a和$b。

如果$c是-eqUAL到$a，这个含义$b没有被发现，这是布尔$true或1，因此被选择的阵列（级联）的第一元件。否则，它是Boolean $false，所以我们输出$c第0个元素。

请注意，这-replace是贪婪的，因此它将首先从左开始替换，这意味着ababa / aba测试用例将正确返回ba。

Java 8，65字节

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

用lambda编写的与Java 7解决方案相同的逻辑。

在这里尝试

Ruby，33个字节 27个字节（如果使用全局替换，则为 28个字节）绝对为28个字节

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

Mathematica，45个字节

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

匿名函数，接受主字符串和切换字符串（按此顺序）并返回结果。说明：

                                            &  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字节

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

可读性：

   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个字节，仅输入1个字符

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字节

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

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

在线尝试！

Ruby，35 37 28字节

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

万岁字符串插值！它甚至可以在正则表达式中使用。其余的很简单：如果中的字符串t与匹配m，则替换t为''，否则返回m+t。

编辑：修复了一个错误。

编辑：我采用了Kevin Lau的建议，但看来我已经达到了与Luis Masuelli的答案中使用的算法相同的算法。

k（23个字节）

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

例子：

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字节

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

如果赋值是Kotlin中的一个表达式，并且参数是可变的，并且有一个三元条件运算符，那么会更短一些，可惜不是这样的：(

在线尝试！

松散

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