Zorluk sadece bir dizgiyi başka bir dizgiye çevirmektir.

açıklama

Eğer geçiş dize de bir alt ana dize , tüm örneklerini kaldırmak geçiş dize gelen ana dize ; aksi takdirde, ana dizenin sonuna açma / kapatma dizesini ekleyin .

kurallar

• Tüm dize yazdırılabilir ASCII karakterlerinden oluşur
• İşlev iki parametre almalıdır: ana dize ve geçiş dizesi .
• Ana dize boş olabilir.
• Geçiş dize boş olamaz.
• Sonuç boş olabilen bir dize olmalıdır.
• En kısa cevap kazanır.

Örnekler

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'

Test örnekleri

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

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

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

Jöle , 7 bayt

œṣȮ⁸e⁹ẋ

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Muhtemelen benim en kısa Java 'codegolf' şimdiye kadar .. xD
yorumlardan biraz yardım ..;)

Açıklama:

Çevrimiçi deneyin.

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 bayt

yyXf?''YX}h

Çevrimiçi deneyin!

Tüm test örnekleri

açıklama

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

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

JavaScript (ES6), 39 37 bayt

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

Pyke, 14 bayt

DX{iIXRk:)i!IJ

Burada deneyin!

Pyke'nin bir elseyapısı olmadığı göz önüne alındığında, bunun oldukça makul bir puan olduğunu düşünüyorum

Açıklama:

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]

Çevrimiçi deneyin. 1 baytlık parçalama için teşekkürler jimmy23013 :)

Açıklama:

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 bayt

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

Retina , 38 31 bayt

Bayt sayımı ISO 8859-1 kodlamasını varsayar.

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

T`·¶

Sondaki satır besleme önemlidir. Girdi biçimi, satır beslemeyle ayrılmış iki dizgidir.

Çevrimiçi deneyin! İlk satır, aynı anda birkaç test senaryosu çalıştırmaya izin verir (test takımı için,; senaryolarını ayırmak için dizeleri ve hat beslemelerini ayırmak için ; ilk satır dönüşümle ilgilenir).

açıklama

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

Bu ilk adımda, ana dizgideki geçiş dizesinin tüm örneklerini değiştiririz ·. Herhangi bir ikame olup olmadığını daha sonra belirleyebilmemiz için bu işaretleri eklememiz gerekir.

1>`·|¶.+

Bu, bir ·işaretleyiciyi veya ikinci çizgiyi (ayırma çizgisi beslemesi dahil) kaldıran başka bir ikame işlemidir. Ancak, 1>bir sınırdır, yani sadece ilkinden sonra eşleşmeler dikkate alınır. Bu nedenle, ana dizgide geçiş dizesi oluşmadıysa, herhangi bir ekleme yapmayız ·, bu nedenle ikinci satır ilk eşleşme olur ve kaldırılmaz. Aksi takdirde, ikinci çizgiyi ilk işaretleyici hariç tümü ile birlikte kaldırırız.

T`·¶

Bu bir harf çevirisi aşaması kullanırken, yalnızca karakterleri kaldırmak için de kullanılır. Özellikle, hem ·satırları hem de satır beslemelerini hareket ettiriyoruz . Bir maç olması durumunda birincisine ihtiyacımız var (çünkü o zaman ilk ·aşama bir önceki aşamada geride kalacak) ve bir maç olmaması durumunda ikincisine ihtiyacımız var (iki çizgiyi birleştirmek ve böylece açma / kapatma dizesini ana dizeye ekleyin).

Python (3.4): 55 54 47 44 Bayt

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

Test yapmak:

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

Test çıktısı

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

Bir iade ifadesi kullanmak zorunda olduğunuz için bir def kullanmak daha uzun olacaktır, çünkü geri dönüş olmadan mümkün olsaydı 2 Bayt kaydederdi Fonksiyonun açık beyanı gerekli olmadığından (üzgünüm bunu bilmiyordum) 7 Bayt kaydedildi.

C #, 63

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

Java'dan daha iyi :)

Test kodu:

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

Çıktı:

a

ba
b
b
ba

Pyth, 13 11 10 bayt

?/Qz:Qzk+z

Test odası.

Girdi biçimi: tırnak içinde ilk dize, tırnaksız ikinci dize.

Bu ayrıca 10 bayttır:

?tJcQzsJ+z

Test odası.

Bu 11 bayt:

pscQz*!}zQz

Test odası.

Önceki 13 baytlık çözüm:

?:IQzk+Qz:Qzk

Test odası.

Jolf, 12 bayt

?=iγρiIE+iIγ

Veya regex'e duyarlı karakterleri eklememiz gerekirse:

?=iγρiLeIE+iIγ

Burada deneyin!

açıklama

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

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

Böl ve katıl özelliğinden yararlanarak @ nobe4'ün cevabından biraz daha kısa

Raket, 70 bayt

Oldukça düz ileri.

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

Scala, 72 70 bayt

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

Çevrimiçi tercüman: www.tryscala.com

Oracle SQL 11.2, 66 bayt

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

Perl, 37 30 bayt

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

Geçiş dizesi içindeki düzenli ifadeler, \Q... ile tırnak işareti nedeniyle değerlendirilmez \E.

sub F ve \E uygun olarak çıkarılır yoruma msh210 tarafından göre kaldırılmıştır.

Ayar nedeniyle tamamen yan etkisi yoktur $_. Yerel bir değişken kullanmak altı ek bayta mal olur:

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

Öte yandan, anahtarlamalı giriş parametreleriyle iki bayt kullanarak kaydedilebilir popyerine shift(28 bayt):

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

Test dosyası:

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

Test sonucu:

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

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

Birkaç bayt tıraş etmek için satır içi atama kullanır

bash + sed, 28 bayt

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

Komut dosyası, çağırdığımız bir toggle-string.bash dosyasında yaşar bash toggle-string.bash mainstring togglestring.

s/$2//g açma / kapatma dizesini ana dizeden kaldırır

t önceki ikame başarılı olursa sonuna kadar atlar (örn. ana dize geçiş dizesini içeriyordu)

/$/$2/ sonuna değiştirme dize ekler ($ ),

Herhring için bash gerekli

Julia, 33 31 bayt

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

Çevrimiçi deneyin!

PowerShell v2 +, 47 bayt

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

Girdiyi alır $a,$bve sonra (... , ...)[...]bir if / else gerçekleştirmek için sözde üçlü bir deyim kullanır . İç kısımlar önce iki elemandan oluşan bir dizi oluşturmak için değerlendirilir. O $a, $b -replaced'de saklanan hiçbir şey olmadan tüm d oluşumları içindedir $c. 1 sadece bir dize birleşimidir $ave $b.

Eğer $colduğu -eqiçin ual $a, anlam $bBoole var bulunmadı, $trueya 1dizinin (birleştirme) 1. eleman seçilir ve böylece. Else, bu Boolean $false, bu yüzden $c0'ıncı elementin çıktısını alıyoruz .

-replaceAçgözlü olduğuna dikkat edin , bu yüzden önce soldan değiştirilecek, yani ababa / abatest durumu düzgün bir şekilde dönecektir ba.

Java 8, 65 bayt

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

Bir lambda ile yazılmış Java 7 çözümü ile aynı mantık.

Burada deneyin

Ruby, 33 bayt 27 bayt (küresel altyazı kullanılıyorsa 28 ) kesinlikle 28 bayt

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

Mathematica, 45 bayt

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

Ana dizeyi ve geçiş dizesini (bu sırayla) alan ve sonucu döndüren anonim işlev. Açıklama:

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

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

Okunabilir:

   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

Kesinlikle 1 karakter girişli 114 Bayt

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 bayt

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

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

Çevrimiçi deneyin!

Yakut, 35 37 28 bayt

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

Dize enterpolasyonu için Yaşasın! Normal ifadelerde bile çalışır. Gerisi basit: dize ise tmaçlara myerine tbirlikte '', başka dönüş m+t.

Düzenleme: Bir hata düzeltildi.

Düzenleme: Kevin Lau önerisini uyguladım, ancak Luis Masuelli'nin cevabında kullanılan algoritma ile aynı algoritmaya ulaştığım anlaşılıyor .

k (23 bayt)

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

Örnekler:

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 Bayt

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

Atama Kotlin'de bir ifade olsaydı ve parametreler değişebiliyorsa ve üçlü bir koşullu operatör varsa bu daha kısa olurdu, ne yazık ki durum böyle değil :(

Çevrimiçi deneyin!

UnGolfed

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