문제는 단순히 다른 문자열 내에서 문자열을 전환하는 것입니다.

설명

는 IF 토글 문자열 의 하위 문자열입니다 주요 문자열 의 모든 인스턴스 제거 토글 문자열 로부터 주요 문자열을 ; 그렇지 않으면 기본 문자열 끝에 토글 문자열 을 추가하십시오 .

규칙

• 모든 문자열은 인쇄 가능한 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

파이썬 3, 38 바이트

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

자바 스크립트 (ES6), 39 37 바이트

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

파이크, 14 바이트

DX{iIXRk:)i!IJ

여기 사용해보십시오!

파이크에는 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]

온라인으로 사용해보십시오. 1 바이트를 잘라 낸 것에 대해 감사합니다 jimmy23013 :)

설명:

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)

자바 스크립트 (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>제한 은 첫 번째 이후 의 일치 항목 만 고려 됨을 의미합니다 . 따라서 기본 문자열에서 토글 문자열이 발생하지 않으면 아무 것도 삽입하지 ·않으므로 두 번째 줄이 첫 번째 일치하고 제거되지 않습니다. 그렇지 않으면 첫 번째 마커를 제외하고 두 번째 줄을 모두 제거합니다.

T`·¶

음역 단계를 사용하지만 단순히 문자를 제거하는 데에도 사용됩니다. 특히, 우리는 ·줄 바꿈과 줄 바꿈을 모두 이동합니다 . 일치하는 경우 (첫 번째 ·단계는 이전 단계에서 남았 기 때문에) 첫 번째 일치하는 것이 필요하고 일치하지 않은 경우 (두 행을 결합하여 토글 문자열을 기본 문자열에 추가하십시오).

파이썬 (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;

자바보다 낫다 :)

테스트 코드 :

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

자바 스크립트 (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""))

스칼라, 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);

펄, 37 30 바이트

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

토글 문자열 내부의 정규 표현식은 따옴표로 인해 평가되지 않습니다 \Q...\E .

sub F그리고 의견 에 \E따라 msh210에 의해 제거됩니다 .

설정 때문에 부작용이 전혀 없습니다 $_. 로컬 변수를 사용하면 6 바이트가 추가로 소비됩니다.

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

반면, 전환 된 입력 매개 변수를 pop사용하면 shift(28 바이트) 대신 2 바이트를 저장할 수 있습니다 .

{$_=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/ 끝에 토글 문자열을 추가합니다 ($ 하지 않은 경우 )에

herestring에는 bash가 필요합니다.

줄리아, 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를 수행합니다. 내부 부분을 먼저 평가하여 두 요소의 배열을 형성합니다. 0은 d에 $a모든 항목이 $b -replace있으며 아무것도없는 상태로 저장됩니다 $c. 첫 번째는 $aand 의 문자열 연결입니다 $b.

경우 $c입니다 -eq에 연간 $a의미 $b부울입니다 찾을 수 없습니다, $true또는 1배열 (병합)의 첫 번째 요소가 선택되고, 그래서. 그렇지 않으면 Boolean $false이므로 $c0 번째 요소를 출력 합니다.

참고 -replace는 의미 먼저 왼쪽에서 대체 할 수 있도록, 욕심이 ababa / aba제대로 돌아갑니다 테스트 케이스를 ba.

자바 8, 65 바이트

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

람다로 작성된 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

1 문자를 엄격히 입력 한 114 바이트

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)

온라인으로 사용해보십시오!

루비, 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"

코 틀린, 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
}