एक स्ट्रिंग टॉगल करें

Question

चुनौती में दूसरे स्ट्रिंग के भीतर एक स्ट्रिंग को टॉगल करना शामिल है।

व्याख्या

तो टॉगल स्ट्रिंग की सबस्ट्रिंग है मुख्य स्ट्रिंग , की सभी आवृत्तियां निकाल टॉगल स्ट्रिंग से मुख्य स्ट्रिंग ; अन्यथा, मुख्य स्ट्रिंग के अंत में टॉगल स्ट्रिंग संलग्न करें ।

नियम

• सभी स्ट्रिंग मुद्रण योग्य 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'

Comments

@ केनीलाऊ यह सभी 3 घंटे के लिए सैंडबॉक्स में था। सिफारिश 2 दिन है।

— मॉर्गन थ्रैप

सिफारिश वास्तव में 72 घंटे है । मुख्य पृष्ठ पर सैंडबॉक्स की तुलना में अधिक दृश्यता है, इसलिए अधिक टिप्पणियों की यहां गारंटी है। उस ने कहा, यह एक बुरी चुनौती नहीं है , बस कुछ खुरदुरे किनारे हैं।

— AdmBorkBork

तो आप सभी गैर-अतिव्यापी उदाहरणों को प्रतिस्थापित करते हैं ?

— मुकदमा

@ जक्यूब हां, मुझे इसे अक्षरों और संख्या तक सीमित करना चाहिए जो मुझे लगता है।

— nobe4

नहीं, मुझे लगता है कि nonalphanumerics की अनुमति दें: यह उस तरह से अधिक चुनौतीपूर्ण है।

— msh210

Answer 1

जेली , 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.

Answer 2

जावा 8, 80 70 65 34 बाइट्स

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

संभवतः मेरा अब तक का सबसे छोटा जावा 'कोडगोल्फ' ..
टिप्पणियों से कुछ मदद के साथ 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`

Comments

ifएक टर्नरी को बदलकर आपको काफी कुछ बचाने में सक्षम होना चाहिए । अगर और कुछ नहीं, यह "अतिरिक्त" से छुटकारा मिलेगा return।

— जियोबिट्स

@Geobits आह, निश्चित रूप से .. मैं इतना उत्साही था कि एक एकल विधि में एक 'कम' बाइट काउंट था (जावा के संदर्भ में 'कोडगॉल्फिंग') कि मैं इफ्स और रिटर्न के लिए सबसे स्पष्ट कोडगॉर्फ़िंग में से एक भूल गया ..>> धन्यवाद, संपादित

— केविन क्रूज़सेन

आप एक नियमित कार्य के बजाय एक लंबोदा का उपयोग करके कुछ और बाइट्स बचा सकते हैं।

— डेन्कर

return m=m.replace(t,"")?m+t:m;

— लीक नून

m==(m=m.replace...

— लीक नून

Answer 3

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

Answer 4

पायथन 3, 38 बाइट्स

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

Answer 5

जावास्क्रिप्ट (ईएस 6), 39 37 बाइट्स

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

Answer 6

पाइके, 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

Answer 7

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)

Comments

9 बाइट्स: q~:B/2Be]।

— jimmy23013

Answer 8

जावास्क्रिप्ट (ECMAScript 6): 47 बाइट्स

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

Comments

यह विफल हो सकता है अगर टॉगल स्ट्रिंग में विशेष वर्ण हैं। उदाहरण के लिए, इसके बजाय ("a", ".")रिटर्न । """a."

— डेनिस

Answer 9

रेटिना , 38 31 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

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

T`·¶

अनुगामी लाइनफीड महत्वपूर्ण है। इनपुट प्रारूप दोनों स्ट्रिंग्स को एक लाइनफीड के साथ अलग किया गया है।

इसे ऑनलाइन आज़माएं! पहली पंक्ति एक बार में कई परीक्षण मामलों को चलाने की अनुमति देती है (परीक्षण सूट के लिए, ;स्ट्रिंग्स को अलग करने के लिए उपयोग करें और परीक्षण मामलों को अलग करने के लिए लाइनफीड करें; पहली पंक्ति रूपांतरण का ख्याल रखती है)।

व्याख्या

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

इस पहले चरण में हम मुख्य स्ट्रिंग में टॉगल स्ट्रिंग की सभी घटनाओं को प्रतिस्थापित करते हैं · । हमें इन मार्करों को सम्मिलित करने की आवश्यकता है ताकि हम बाद में यह निर्धारित कर सकें कि कोई प्रतिस्थापन हुआ है या नहीं।

1>`·|¶.+

यह एक और प्रतिस्थापन है जो एक ·मार्कर, या दूसरी लाइन (अलग लाइनफीड सहित) को हटाता है । हालाँकि, 1>यह एक सीमा है जिसका अर्थ है कि केवल मैच के बाद जाता है। इसलिए, यदि मुख्य स्ट्रिंग में टॉगल स्ट्रिंग नहीं हुई, तो हमने कोई भी सम्मिलित नहीं किया होगा ·, इसलिए दूसरी पंक्ति पहला मैच होगी और उसे हटाया नहीं जाएगा। अन्यथा, हम दूसरी पंक्ति को हटाते हैं, लेकिन पहले मार्कर के साथ।

T`·¶

हालांकि यह एक लिप्यंतरण चरण का उपयोग करता है, इसका उपयोग केवल वर्णों को हटाने के लिए भी किया जाता है। विशेष रूप से, हम दोनों को स्थानांतरित करते हैं ·और स्तनपान कराते हैं। हमें पहले एक की जरूरत है, अगर मैच था (क्योंकि तब पहले ·को पिछले चरण से पीछे छोड़ दिया जाएगा) और हमें दूसरे एक की जरूरत है अगर मैच नहीं था (दो लाइनों को एक साथ जोड़ने के लिए और इस तरह से टॉगल स्ट्रिंग को मुख्य स्ट्रिंग में जोड़ें)।

Answer 10

पायथन (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

एक डीट का उपयोग करना अधिक लंबा होगा क्योंकि आपको रिटर्न स्टेटमेंट का उपयोग करना होगा, यदि यह बिना रिटर्न के संभव था तो यह 2 बाइट्स को बचाएगा क्योंकि फ़ंक्शन की स्पष्ट घोषणा की आवश्यकता नहीं है (माफ करना मुझे पता नहीं था) 7 बाइट्स बचाए गए थे।

Comments

अच्छा उत्तर! हमारे नियमों के लिए, आपको फ़ंक्शन के लिए नाम की आवश्यकता नहीं है। तो आप निकाल सकते हैं toggle=।

— R

मुझे बस एहसास हुआ, अगर मैं इस समारोह का नाम नहीं लूंगा, लेकिन toggle=टेस्ट के साथ काम नहीं

— करूंगा

हां, toggleइसे परखने की जरूरत है। लेकिन आप केवल करने की जरूरत है गिनती से lambda m,t:पर।

— R

अगर मैं गलत नहीं हूँ तो आप 3 बाइट्स बचाने के m+''+tलिए बदल सकते हैं m+t।

— शर्लक

आप सही हैं, मैं के साथ शुरू कर रहे हैं m+' '+tउन दोनों के बीच एक अंतरिक्ष में प्रवेश करने की है, लेकिन वर्णन फिर से पढ़ने के बाद मैं श्वेतस्थान नहीं लेकिन '' और + नष्ट कर दिया

— levanth

Answer 11

सी #, 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

Answer 12

पायथ, 13 11 10 बाइट्स

?/Qz:Qzk+z

परीक्षण सूट।

इनपुट प्रारूप: उद्धरण में पहला स्ट्रिंग, उद्धरण के बिना दूसरा स्ट्रिंग।

यह भी 10 बाइट्स है:

?tJcQzsJ+z

परीक्षण सूट।

यह 11 बाइट्स है:

pscQz*!}zQz

परीक्षण सूट।

पिछला 13-बाइट समाधान:

?:IQzk+Qz:Qzk

परीक्षण सूट।

Comments

11 बाइट्स भी:?}zQ:Qzk+Qz

— ब्लू

Answer 13

जोल्फ, 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(γ);

Answer 14

जावास्क्रिप्ट (ईएस 6), 37 बाइट्स

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

बंटवारे और शामिल होने का फायदा उठाकर @ nobe4 के जवाब से थोड़ा कम

Answer 15

रैकेट, 70 बाइट्स

बहुत सीधा।

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

Answer 16

स्काला, 72 70 बाइट्स

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

ऑनलाइन दुभाषिया: www.tryscala.com

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! मुझे स्काला का पता नहीं है, लेकिन मुझे लगता है कि आप रिक्त स्थान निकाल सकते हैं if(r==m)।

— डेनिस

हाँ आप सही हैं

— एविस

Answer 17

ओरेकल SQL 11.2, 66 बाइट्स

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

Answer 18

पर्ल, 37 30 बाइट्स

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

टॉगल स्ट्रिंग के अंदर नियमित अभिव्यक्तियों का मूल्यांकन उद्धरण के कारण नहीं किया जाता है \Q...\E ।

sub Fऔर टिप्पणी के\E अनुसार हटा दिए जाते हैं msh210 द्वारा ।

यह सेटिंग के कारण साइड इफेक्ट्स से पूरी तरह मुक्त नहीं है $_। स्थानीय चर का उपयोग करने पर छह अतिरिक्त बाइट खर्च होंगे:

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

दूसरी ओर, स्विच किए गए इनपुट मापदंडों के साथ दो बाइट्स (28 बाइट्स) के popबजाय का उपयोग करके बचाया जा सकता है shift:

{$_=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.'

Comments

पर्ल्सब कहते हैं, "हस्ताक्षर एक सबरूटीन के शरीर का हिस्सा है। आम तौर पर एक सबरूटीन का शरीर कोड का एक लटके हुए ब्लॉक होता है।" इस प्रकार, आप sub Fअपनी बाइट की गिनती से चूक सकते हैं । इसके अलावा, आपको दो बाइट्स की बचत के popबजाय shift(इनपुट के क्रम को उलट कर), उपयोग करने में सक्षम होना चाहिए । (अनटाइटेड।) अंत में, आपको \Eदो और बाइट को बचाते हुए , छोड़ना चाहिए । (बिना

— पढ़े

@ msh210 धन्यवाद, आपके सुझावों ने सात बाइट्स बचाए। मैं देख रहा हूँ नहीं है, कैसे popके बजाय shiftकर सकते हैं मदद, क्योंकि $_बचने के लिए पहला तर्क होना चाहिए $_[1]=~s/.../। इनपुट तर्कों का क्रम AFAIK प्रश्न द्वारा तय किया गया है।

— हाइको ओबेरडीक

प्रश्न के उत्तर से इनपुट तर्कों का क्रम तय नहीं होता है।

— msh210

Answer 19

C # (58 बाइट्स)

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

यह कुछ बाइट्स को बंद करने के लिए इनलाइन असाइनमेंट का उपयोग करता है

Comments

नमस्कार, और PPCG में आपका स्वागत है! महान पहली पोस्ट! मैं C # का उपयोग नहीं करता, लेकिन क्या आप कर सकते हैं var s,tया var s,var tइसके बजाय string?

— NoOneIsHere

धन्यवाद! दुख की बात varयह है कि केवल उन स्थानों पर उपयोग किया जा सकता है जहां प्रकार संकलित समय पर जाना जाता है, इसलिए इसका उपयोग विधि हस्ताक्षर में नहीं किया जा सकता है। आप उपयोग कर सकते हैं dynamic, लेकिन यह 1 वर्ण अधिक लंबा हैstring

— Blue0500

किस बारे में var F(string s, string t? इसका अनुमान लगाया जा सकता है ...

— NoOneIsHere

Answer 20

बैश + सेड, 28 बाइट्स

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

स्क्रिप्ट एक टॉगल- string.bash फ़ाइल में रहती है, जिसे हम कहते हैं bash toggle-string.bash mainstring togglestring।

s/$2//g मुख्य स्ट्रिंग से टॉगल स्ट्रिंग निकालता है

t पिछले प्रतिस्थापन सफल होने पर अंत में कूदता है (यानी मुख्य स्ट्रिंग टॉगल स्ट्रिंग समाहित करता है)

/$/$2/ अंत में टॉगल स्ट्रिंग जोड़ता है ($ ), अगर हम अंत तक नहीं कूदते

हेस्टिंग के लिए बैश आवश्यक है

Comments

यदि टॉगल स्ट्रिंग में विशेष वर्ण हैं तो यह काम नहीं करेगा।

— डेनिस

Answer 21

जूलिया, 33 31 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 22

PowerShell v2 +, 47 बाइट्स

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

$a,$bएक इनपुट लेता है और फिर एक छद्म- ternary (... , ...)[...]स्टेटमेंट का उपयोग करता है , अगर / नहीं तो। आंतरिक भागों का मूल्यांकन पहले दो तत्वों की एक सरणी बनाने के लिए किया जाता है। 0th कुछ भी नहीं है, जो में संग्रहीत है के साथ घ $aकी सभी घटनाओं के $b -replaceसाथ है$c । 1 में से केवल एक स्ट्रिंग संयोजन है $aऔर $b।

अगर $cहै -eqकरने के लिए UAL $a, जिसका अर्थ है कि $bनहीं मिला था, है कि बूलियन $trueया 1, और इसलिए सरणी (संयोजन) के 1 तत्व चुना जाता है। और, यह बूलियन है $false, इसलिए हम आउटपुट $c, 0 तत्व।

ध्यान दें कि -replaceलालची है, इसलिए यह पहले बाईं ओर से बदल जाएगा, जिसका अर्थ है कि ababa / abaपरीक्षण का मामला ठीक से वापस आ जाएगा ba।

Answer 23

जावा 8, 65 बाइट्स

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

जावा 7 समाधान के समान तर्क, एक लैम्ब्डा के साथ लिखा गया।

इसे यहाँ आज़माएँ

Answer 24

रूबी, 33 बाइट्स 27 बाइट्स (28 अगर वैश्विक घटाव का उपयोग करके) निश्चित रूप से 28 बाइट्स

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

Answer 25

गणितज्ञ, 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.

Answer 26

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

Comments

नमस्कार, और PPCG में आपका स्वागत है! बहुत बढ़िया जवाब!

— NoOneIsHere

Answer 27

TSQL (Sqlserver 2012), 49 बाइट्स

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

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

इसे ऑनलाइन आज़माएं!

Answer 28

रूबी, 35 37 28 बाइट्स

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

स्ट्रिंग प्रक्षेप के लिए हुर्रे! यह regexes में भी काम करता है। बाकी सरल है: अगर में स्ट्रिंग tमैच के लिए m, की जगह tके साथ '', और वापसी m+t।

संपादित करें: एक बग फिक्स्ड।

संपादित करें: मैंने केविन लाउ के सुझाव को लागू किया, लेकिन ऐसा प्रतीत होता है कि मैं उसी एल्गोरिथ्म तक पहुंच गया हूं, जो लुइस मूसली के उत्तर में इस्तेमाल किया गया था ।

Comments

यह विफल हो सकता है अगर टॉगल स्ट्रिंग में विशेष वर्ण हैं। उदाहरण के लिए, इसके बजाय ("a", ".")रिटर्न । "a""a."

— डेनिस

m[t]से बहुत छोटा है m.include?(t)और अभी भी तार के भीतर शामिल करने के लिए जाँच करता है।

— वैल्यू इंक

Answer 29

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"

Answer 30

कोटलिन, 61 बाइट्स

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

यह छोटा होगा यदि असाइनमेंट कोटलिन में एक अभिव्यक्ति थी, और पैरामीटर परस्पर थे, और एक टर्नरी सशर्त ऑपरेटर था, दुख की बात यह नहीं है :(

इसे ऑनलाइन आज़माएं!

UnGolfed

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