लक्ष्य

स्ट्रिंग समवर्ती को रिवर्स करने के लिए एक फ़ंक्शन बनाएं

इनपुट

दो तार (अल्फ़ान्यूमेरिक + स्थान), जहां एक को दूसरे के लिए घटाया जाना चाहिए।

आप मान सकते हैं कि घटाए जाने वाले तार कभी भी दूसरे से बड़े नहीं होंगे।

उत्पादन

घटाव से परिणाम

घटाव

आपको एक स्ट्रिंग को दूसरे स्ट्रिंग के शुरू या अंत से हटा देना चाहिए। यदि स्ट्रिंग प्रारंभ में और अंत में मौजूद है, तो आप केवल एक को हटा सकते हैं, जिसे हटा दिया जाएगा वह आपके ऊपर है।
यदि स्ट्रिंग प्रारंभ में या अंत में नहीं है, या एक सटीक मिलान नहीं है, तो यह एक अमान्य घटाव है और आपको मूल स्ट्रिंग का उत्पादन करना चाहिए।

परीक्षण के मामलों

मान्य घटाव

'abcde','ab' -> 'cde'
'abcde','cde' -> 'ab'
'abab','ab' -> 'ab'
'abcab','ab' -> 'abc' or 'cab'
'ababcde','ab' -> 'abcde'
'acdbcd','cd' -> 'acdb'
'abcde','abcde' -> ''
'abcde','' -> 'abcde'
'','' -> ''

अमान्य घटाव (मूल स्ट्रिंग लौटाता है)

'abcde','ae' -> 'abcde'
'abcde','aa' -> 'abcde'
'abcde','bcd' -> 'abcde'
'abcde','xab' -> 'abcde'
'abcde','yde' -> 'abcde'

अमान्य इनपुट (नियंत्रित करने की आवश्यकता नहीं है)

'','a' -> ''

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीतता है!

code-golf string

— छड़ी
स्रोत

4

पहले मामले का परिणाम क्यों नहीं है cde? आपको मान्य से क्या मतलब है? क्या हमें इनपुट की वैधता को आंकने की आवश्यकता है, या क्या आपका मतलब है कि हम अमान्य इनपुट प्राप्त नहीं करेंगे?

— लीक

7

धिक्कार है, 'abcde','bcd' -> 'abcde'मेरे समाधान को तोड़ने के लिए

— जॉन ड्वोरक

5

क्या हम मान सकते हैं कि स्ट्रिंग्स रेगेक्स-सेफ (अल्फ़ान्यूमेरिक + स्पेस) होंगे?

— जॉन ड्वोरक

2

मैं सुझाव देता हूं 'ababcde', 'ab'→ 'abcde'एक परीक्षण मामले के रूप में। कुछ भोले एल्गोरिदम उस पर विफल होते हैं।

2

@ क्या आप चुनौती को पीछे हटाने पर विचार कर सकते हैं "रिवर्स स्ट्रिंग कॉन्सेप्टन"?

— एमडी एक्सएफ

19

जावा 8, 46 45 44 40 बाइट्स

TheLethalCoder के लिए -1 बाइट धन्यवाद

-1 बाइट क्योंकि मैं गूंगा हूं (धन्यवाद रॉड!)

-4 बाइट्स केविन क्रूज़सेन की बदौलत

a->b->a.replaceFirst("^"+b+"|"+b+"$","")

इसे ऑनलाइन आज़माएं! (सभी परीक्षण मामले शामिल हैं)

एक जावा उत्तर वास्तव में कुछ अन्य व्यावहारिक भाषाओं को धड़कता है। मुस्कान। (और अब यह जेएस धड़कता है!)

— Okx
स्रोत

एक बाइट को बचाने के लिए करी का उपयोग करेंa->b->

— TheLethalCoder

@TheLethalCoder साभार

— ओकेक्स

आपने अपने ऑनलाइन उदाहरण में अप्रयुक्त हैशमाप में क्यों छोड़ दिया?

— माइकल

आप बदल सकते हैं Firstकरने के लिए All-2 बाइट्स के लिए। की वजह से ^और $यह हमेशा या तो स्ट्रिंग के अंत में होता है या शुरू होता है, इसलिए यहां तक कि replaceAllइसे केवल एक बार बदल देता है। इसे यहाँ आज़माएँ। पुनश्च: मैंने आपके उत्तर के लिए पिछले बाइट-काउंट्स को स्ट्राइक-थ्रू जोड़ा है, जो आमतौर पर पीपीसीजी पर कोड-गोल्फ संपादन के बाद किया जाता है।

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

@ केविनक्रूजसेन मुझे स्ट्राइक थ्रू के बारे में पता था, लगता है मैं इस बार भूल गया। हालांकि, अगर मैं Allइसके बजाय का उपयोग करता हूं, तो Firstयह सच हो जाता है:"abab" + "ab" -> ""

— ओकेक्स

9

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

s=>t=>s.replace(eval(`/^${t}|${t}$/`),'')

करी सिंटैक्स के माध्यम से इनपुट लेता है, अर्थात f("abab")("ab")।

— ETHproductions
स्रोत

3

अब, मैंने पहले कभी eval()RegExes के निर्माण के लिए उपयोग करने के लिए क्यों नहीं सोचा है ?!

— झबरा

9

Brachylog (यह ऑनलाइन प्रयास करें!), 12 बाइट्स

~cpĊh.∧Ċtw|w

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

मानक इनपुट से घटने के लिए स्ट्रिंग लेता है, और कमांड लाइन तर्क के रूप में घटाना करने के लिए स्ट्रिंग।

व्याख्या

~cpĊh.∧Ċtw|w
~c            Split {the input} into pieces
  p           and (possibly) rearrange those pieces
   Ċ          such that there are two pieces
    h         and the first
     .        matches the command line argument
      ∧       then
         w    print
        t     the last
       Ċ      piece.
          |   If all else fails,
           w  print {the input}.

6

रेटिना , 21 बाइट्स

मार्टिन एंडर को 1 बाइट धन्यवाद।

(.*);(\1|(.*)\1$|)
$3

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

— लीक नन
स्रोत

6

जावास्क्रिप्ट (ईएस 6), 76 70 45 41 बाइट्स

s=>t=>s.replace(RegExp(`^${t}|${t}$`),"")

कोशिश करो

f=
s=>t=>s.replace(RegExp(`^${t}|${t}$`),"")
o.innerText=f(i.value="abcde")(j.value="ab")
i.oninput=j.oninput=_=>o.innerText=f(i.value)(j.value)

<input id=i><input id=j><pre id=o>

स्निपेट का विस्तार करें

— झबरा
स्रोत

2

आप की जरूरत नहीं है new ।

— प्रोग्रामर

@ programmer500, जब मैंने ETH का संस्करण देखा, तो मैंने इस पर काम करना छोड़ दिया! : D अभी अपडेट किया गया। धन्यवाद।

— झबरा

4

पर्ल 6 , 21 बाइट्स

->$_,$b {S/^$b|$b$//}

कोशिश करो

विस्तारित:

-> $_, $b {   # pointy block lambda

  S/          # Str replace and return (implicitly against ｢$_｣)

  |   ^ $b    # starting with the second argument
  |     $b $  # or ending with the second argument

  //          # replace with nothing.

}

— ब्रैड गिल्बर्ट b2gills
स्रोत

4

जाप , 11 9 बाइट्स

k"^|$"¬qV

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

— ल्यूक
स्रोत

3

टीआई-बेसिक (TI-84 Plus CE), 63 बाइट्स

Prompt Str0,Str2
inString(Str0,Str2
If Ans
sub(Str0,1,Ans-1)+sub(Str0,Ans+length(Str2),length(Str0)-Ans+1-length(Str2→Str0
Str0

— pizzapants184
स्रोत

मेरा एक प्रश्न है, आपने Str1 को एक चर के रूप में उपयोग क्यों नहीं किया?

— जकार्इ

@ Zacharý मुझे लगता है कि मेरे पास उस समय कुछ संग्रहीत था। मुझे सच में याद नहीं है।

— pizzapants184

Ansचौथी पंक्ति पर भी क्या उल्लेख है?

— Zacharý

@ Zacharý Ansअंतिम मूल्यांकन किए गए मान को संदर्भित करता है, इसलिए इस मामले में यह उस मान को लौटाता है inString(, जो स्ट्रिंग Str2में सबरिंग का सूचकांक है Str0या यदि सबस्ट्रिंग प्रकट नहीं होता है। यदि स्टेटमेंट में Ans के मान को संशोधित नहीं किया जाता है, तो चौथी लाइन पर इंडेक्स अभी भी बना हुआ है Ans।

— pizzapants184

ओह, मैं भूल गया कि कैसे inStringकाम किया। अच्छा गोल्फ!

— ज़ाचारि

3

गणितज्ञ, 162 बाइट्स

(c=Characters;a=c@#;b=c@#2;l=Length;t={};If[l@Intersection[a,b]==l@b,If[MemberQ[Partition[a,l@b,1],b],t=a;Table[t=DeleteCases[t,b[[i]],1,1],{i,l@b}]],t=a];""<>t)&

परीक्षण इनपुट शैली ["abcde", "ab"]

— J42161217
स्रोत

1

अच्छा समाधान! आप #इसके बजाय का उपयोग करके एक बाइट बचा सकते हैं #1- वे बिल्कुल एक ही मतलब है। इसके अलावा, उपयोग करने के बजाय StringJoin@t, आप इसके साथ एक खाली स्ट्रिंग को जोड़कर धोखा दे सकते हैं ""<>t, जो स्वचालित रूप से सब कुछ tएक साथ भी जुड़ता है। क्या आपने मैथेमेटिका गोल्फिंग टिप्स पेज देखा है ?

— पेड़ नहीं

कुछ और चीजें हैं जो आप बाइट्स को बचाने के लिए कर सकते हैं (मुझे नहीं लगता कि आपको t={};शुरुआत में परिभाषित करने की आवश्यकता नहीं है , उदाहरण के लिए), लेकिन पूरी तरह से एक अलग दृष्टिकोण का उपयोग करना आसान हो सकता है - क्या आपने उपयोग करने की कोशिश की है StringReplaceसमारोह?

— पेड़ नहीं

आपको इनपुट के रूप में स्ट्रिंग सरणी लेने की अनुमति है, इसलिए आपको वास्तव में ज़रूरत नहीं हैc=Characters;a=c@#;b=c@#2;

— जंगवान मिन

भी है, l@Intersection[a,b]है l[a∩b]।

— जुंगवान मिन

3

पायथन, 69 68 64 57 51 45 बाइट्स

यह रेगेक्स के साथ एक पूरी तरह से अलग समाधान होने के नाते समाप्त हो गया।

-2 बाइट्स के लिए वैल्यू इंक का धन्यवाद !
और विशाल -6 बाइट्स के लिए फेलिप नारदी बतिस्ता !

import re
lambda s,c:re.sub(c+'$|^'+c,'',s,1)

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

— Artyer
स्रोत

-2 बाइट्स के लिए:re.sub(c.join("^|$"),'',s,1)

— वैल्यू इंक

1

फॉर -6 बाइट्स:c+'$|^'+c

— फेलिप नारदी बतिस्ता

3

बैश ,66 61 49 बाइट्स

case $1 in *$2)echo ${1%$2};;*)echo ${1#$2};;esac

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

कम गोल्फ वाला:

a=$1;
case $1 in 
    *$2)  c=${a%$2};;       
    $2*)  c=${a#$2};;
      *)  c=$1;;
esac;
echo $c

भीख मांगने या समाप्त करने के लिए मामले का उपयोग करता है, और सरणी उपसर्ग / प्रत्यय (% / #) विकल्प

— marcosm
स्रोत

1

का अच्छा उपयोग case, लेकिन आवश्यकता से अधिक लंबा। 2 और 3 पैटर्न को एक ही में विलय किया जा सकता है *)c=${1#$2};;:। फिर साथ केवल 2 शाखाओं को कम किया जाएगा echoप्रत्येक के बजाय सीधे चर का उपयोग करने का $c: case $1 in *$2)echo ${1%$2};;*)echo ${1#$2};;esac। या फिर आप इसका उपयोग जारी रखना सकता है, लेकिन बिना case: c=${1%$2};[[ $c = $1 ]]&&c=${1#$2};echo $c।

— मैनेटवर्क

3

APL (Dyalog) , 31 30 बाइट्स

-1 Zacharý को धन्यवाद ।

यह वास्तव में रिवर्स (यानी उलटा) का उपयोग करता है! बाएं तर्क के रूप में मूल स्ट्रिंग लेता है, और सही तर्क के रूप में घटाना क्या है।

{0::⍺{0::⍺⋄,∘⍵⍣¯1⊢⍺}⍵⋄⍵,⍣¯1⊢⍺}

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

Ungolfed:

{
    0::⍺{         ⍝ if an error happens, apply the following function on the arguments
        0::⍺          ⍝ if an error happens, return the left argument unmodified
        ,∘⍵⍣¯1⊢⍺      ⍝ inverse-append right argument on left argument
        }⍵
    ⍵,⍣¯1⊢⍺      ⍝ inverse-prepend the right argument on the left argument
}

लीजेंड:

{… } अनाम फ़ंक्शन

⍺ वर्तमान फ़ंक्शन के बाएं तर्क

⍵ वर्तमान फ़ंक्शन का सही तर्क

0::... यदि कोई त्रुटि होती है, तो इसे निष्पादित करें, अन्यथा ...

⍣¯1⊢ श्लोक में

,∘⍵ CONCATENATE ⍵ सही पर

⍵, CONCATENATE ⍵ बाईं तरफ

— एडम
स्रोत

मुझे लगता है कि आप एक बाइट को बचा सकते हैं {0::⍺{0::⍺⋄,∘⍵⍣¯1⊢⍺}⍵⋄⍵,⍣¯1⊢⍺}।

— ज़ाचारि

@ Zacharý हाँ, धन्यवाद।

— अदम

2

PHP, 54 बाइट्स

[,$x,$y]=$argv;echo preg_replace("#^$y|$y$#","",$x,1);

परीक्षण के मामलों

— जार्ग हुल्सरमैन
स्रोत

2

पायथन 2 , 68 बाइट्स

def f(s,c):v=len(c);print[s[v:],s[:-v],s][[s[:v],s[-v:],c].index(c)]

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

— जोनाथन एलन
स्रोत

2

हास्केल , 49 बाइट्स

f s a b|s==b=a|a/=b,h:t<-a=f(s++[h])t b|1<3=s
f""

इसे ऑनलाइन आज़माएं! उपयोग: f"" "abcdef" "ab"। वैकल्पिक रूप से, परिभाषित करें (-)=f""और जैसे उपयोग करें "abcdef" - "ab"।

यह रेगेक्स-मुक्त समाधान अपने सभी पूर्व और उपसर्गों में स्ट्रिंग को पुनरावर्ती रूप से विभाजित करके काम करता है और जाँचता है कि क्या स्ट्रिंग को प्रतिस्थापित किया जा सकता है।

— Laikoni
स्रोत

2

पायथन 2 , 72 65 बाइट्स

a,b=input()
l=len(b)
print[[a,a[:-l]][b==a[-l:]],a[l:]][b==a[:l]]

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

-7 बाइट्स @FelipeNardiBatista को धन्यवाद

— OVS
स्रोत

गोल्फ

— फेलिप

@FelipeNardiBatista को बहुत-बहुत धन्यवाद!

— ओव्स

1

सी #, 88 बाइट्स

s=>r=>s.StartsWith(r)?s.Substring(r.Length):s.EndsWith(r)?s.Substring(0,s.IndexOf(r)):s;

के संकलन करता है Func<string, Func<string, string>>।

— TheLethalCoder
स्रोत

1

रूबी (लैम्ब्डा अभिव्यक्ति), 29 बाइट्स

->a,b{a.sub /^#{b}|#{b}$/,""}

रेगेक्स प्रक्षेप के लिए याय! Regex-safe सबट्रेन्ड की आवश्यकता है, लेकिन यह चुनौती के अनुसार ठीक है।

— जॉन ड्वोरक
स्रोत

1

Tcl , 37 बाइट्स

proc s {a b} {regsub "^$b|$b$" $a {}}

इसे ऑनलाइन आज़माएं! (अब सभी परीक्षण चल रहे हैं)

Tcl सीधा है। proc s {a b}एक फ़ंक्शन को परिभाषित करता है जिसका नाम sपैरामीटर है aऔर b। regsubविकल्प {}, जो एक रिक्त स्ट्रिंग है, के मूल्य के लिए bजब यह शुरू या अंत में है a। वापसी निहित है।

— माइकल प्लॉटके
स्रोत

1

सी, 96 बाइट्स

यह सामान्य ज्ञान है कि सी में स्ट्रिंग हेरफेर बोझिल है, क्योंकि एक विस्तार गोल्फिंग सीमावर्ती मसोचस्टिक होगा। मेरे लिए ठीक लगता है।

f(a,b,t,l)char**a,*b,*t;{t=*a;l=strlen(b);bcmp(t,b,l)?bcmp(t+=strlen(t)-l,b,l)||(*t=0):(*a+=l);}

मेरे द्वारा लिखे गए कम पठनीय कार्यक्रमों में से एक। दो इनपुट लेता है (फ़ंक्शन कैसे दिखता है) के बावजूद, char**स्ट्रिंग को डिकॉनेटनेट करने के लिए इंगित करता है और char*जो हटाने के लिए स्ट्रिंग है। इनपुट पॉइंटर को जगह-जगह संपादित किया जाता है और आउटपुट बन जाता है (जो मैमोरी के बारे में वैसे भी लीक होते हैं)।

उदाहरण का उपयोग:

char *a = malloc(6);
strcpy(a, "abcde");
char *b = malloc(4);
strcpy(b, "abc");
f(&a,b);
printf("%s\n", a); // "de"

— algmyr
स्रोत

1

AWK , 21 32 बाइट्स

{sub("^"$2"|"$2"$",z,$1);$0=$1}1

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

मूल रूप से मूल पाठ को पहले स्ट्रिंग में बदल दिया गया, न कि केवल शुरुआत या अंत में।

{sub($2,z,$1);$0=$1}1

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

मूल रूप से ब्रेसिज़ के बिना कोशिश की गई, लेकिन इसे खाली लाइनों और या नहीं-मैचों को प्रिंट करने के लिए ट्रिक्स की आवश्यकता थी, जो इस संस्करण की तुलना में अधिक बाइट्स जोड़कर समाप्त हो गई।

— रॉबर्ट बेन्सन
स्रोत

1

आर, 20 42 41 बाइट्स

pryr::f(sub(sprintf('^%s|%s$',b,b),'',a))

-1 बाइट मिक्की को धन्यवाद!

एक अनाम फ़ंक्शन देता है (जिसमें ऑर्डर में तर्क हैं b,a)। स्ट्रिंग अंतर की गणना करता है a-b। subएक साधारण प्रतिस्थापन है जो पैटर्न की पहली घटना को स्वैप करता है, इस मामले में, खाली स्ट्रिंग ''। sprintfस्ट्रिंग के आरंभ और अंत में मिलान के साथ रेगेक्स का निर्माण करता है । आवश्यक pryrपैकेज स्थापित होने के लिए।

TIO लिंक पर, function(a,b)चार और बाइट्स के लिए फ़ंक्शन के लिए अधिक वर्बोज़ परिभाषा का उपयोग करता है ।

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

— ग्यूसेप
स्रोत

1

'abcde','bcd' -> 'abcde'केस का क्या ?

— जोनाथन एलन

" subएक साधारण प्रतिस्थापन है जो बस में पहली घटना को स्वैप करता bहै a": क्या यह स्वैप होगा यदि दूसरा स्ट्रिंग पहले स्ट्रिंग के बीच में है?

— TheLethalCoder

मैंने सवाल को गलत बताया! उफ़। उस पकड़ने के लिए धन्यवाद!

— ग्यूसेप

आप 1 बाइट के साथ वापस आ सकते हैंsprintf('^%s|%s$',b,b)

— मिकी

@ मिक्की, धन्यवाद! तय की।

— ग्यूसेप

1

आम लिस्प, 121 बाइट्स

(lambda(x y)(cond((equal(#1=subseq x 0 #3=(length y))y)(#1#x #3#))((equal(#1#x #2=(-(length x)#3#))y)(#1#x 0 #2#))(t x)))

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

आम वर्दी आम लिस्प!

Ungolfed संस्करण:

(defun f(x y)
  (cond ((equal (subseq x 0 (length y)) y)               ; if x starts with y
         (subseq x (length y)))                          ; return rest of x
        ((equal (subseq x (- (length x) (length y))) y)  ; if x ends with x
         (subseq x 0 (- (length x) (length y))))         ; return first part of x
        (t x)))                                          ; else return x

— रेंज़ो
स्रोत

1

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

{a,b->val v=b.length
if(a.startsWith(b))a.drop(v)else if(a.endsWith(b))a.dropLast(v)else a}

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

— snail_
स्रोत

? {a,b->var c=a.removePrefix(b);if(a==c){c=a.removeSuffix(b)};c}

— माज़ी

@mazzy खुद को जवाब के रूप में प्रस्तुत करने के लिए स्वतंत्र महसूस करें।

— घोंघा_

1

पॉवर्सशेल, 34 40 बाइट्स

Invalid Subtractionपरीक्षण के मामले जोड़े जाने पर +6 बाइट्स

param($s,$t)$s-replace"^$t(?!.*$t$)|$t$"

टिप्पणी:

रेगेक्सप एक्सप्रेशन ^$t|$t$अपेक्षा के अनुरूप काम नहीं करता है: यह दोनों मैचों को एक के बजाय ( gहमेशा ध्वज पर) बदलता है । इसलिए, हम नकारात्मक रूपांतर समूह का उपयोग करने के लिए मजबूर हैं।

टेस्ट स्क्रिप्ट:

$f = {
    param($s,$t)$s-replace"^$t(?!.*$t$)|$t$"
}

@(
    ,('abcde','ab', 'cde')
    ,('abcde','cde', 'ab')
    ,('abab','ab', 'ab')
    ,('abcab','ab', 'abc', 'cab')
    ,('ababcde','ab', 'abcde')
    ,('acdbcd','cd', 'acdb')
    ,('abcde','abcde', '')
    ,('abcde','', 'abcde')
    ,('','', '')

    ,('abcde','ae', 'abcde')
    ,('abcde','aa', 'abcde')
    ,('abcde','bcd', 'abcde')
    ,('abcde','xab', 'abcde')
    ,('abcde','yde', 'abcde')

    ,('','a', '')
) | % {
    $s,$t,$e = $_
    $r = &$f $s $t
    "$($r-in$e): $r"
}

आउटपुट:

True: cde
True: ab
True: ab
True: abc
True: abcde
True: acdb
True:
True: abcde
True:

— Mazzy
स्रोत

0

QBIC , 57 बाइट्स

Whegh, यह QBIC / QBasic में एक गड़बड़ है ...

B=@ `+B┘x=instr(;,;)~x|?_t_sB,x-1|+_sB,x+_lC|,_lB|||\?B

B=@ `+B          Prepend a string to B$. Thisis a hack to avoid errors with 
                 removing substrings stating at index 1
┘                Line-break in QBasic output
       (;,;)     Read the string (B$) and the to-be-removed substring (C$)
x=instr          And make x to be the starting index of the first C$ in B$
~x|              IF X <> 0 (ie C$ is present in B$)
?                PRINT
 _t                trimmed version (drops the prepended space)
  _sB,x-1|+        of a substring from 1 to x (the start of C$) -1
  _sB,x+_lC|,_lB   and the rest of the string, starting after C$
                     _l takes the length of a string
  |||              End TRIM, end Substring, end Length
\?B              When missing C$, just print B$

— steenbergh
स्रोत

0

लूआ , 71 65 बाइट्स

सुझाव स्वीकार करना

a,b=...p='(.*)'print(a:match('^'..b..p)or a:match(p..b..'$')or a)

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

— फेलिप नारदी बतिस्ता
स्रोत

0

मैंने शुरू में निर्देशों को गलत बताया। धन्यवाद, मेरी गलती को इंगित करने के लिए अर्जन जोहान्सन !

पॉवरशेल , 46 51 बाइट्स

Function F($o,$a){([regex]"^$a").replace($o,'',1);}

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

— जेफ फ्रीमैन
स्रोत

यह 'abcde' 'bcd' मामले में विफल रहता है।

— अर्जन जोहान्सन

मैं उस परीक्षण मामले से अपेक्षित परिणाम देख रहा हूँ - TIO यहाँ

— जेफ फ्रीमैन

यह ओपी का एक सूचीबद्ध परीक्षण मामला है और परिणाम होना चाहिए abcde- bcdस्ट्रिंग के दोनों छोर पर नहीं होता है।

— अर्जन जोहान्सन

तुम सही हो। मैंने निर्देशों को गलत बताया। इस पर ध्यान दिलाने के लिए धन्यवाद!

— जेफ फ्रीमैन

0

एक्सेल, 129 बाइट्स

=IFERROR(IF(FIND(B1,A1)=1,SUBSTITUTE(A1,B1,"",1),IF(FIND(B1,A1,LEN(A1)-LEN(B1))>LEN(A1)-LEN(B1),LEFT(A1,LEN(A1)-LEN(B1)),A1)),A1)

— Wernisch
स्रोत

0

sed , 56 53 बाइट्स

s/^(.*),(.*)\1$/\2/
s/^(.*),\1(.*)$/\2/
s/.*,(.*)/\1/

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

— Logern
स्रोत

स्ट्रिंग घटाव

लक्ष्य

इनपुट

उत्पादन

घटाव

परीक्षण के मामलों

मान्य घटाव

अमान्य घटाव (मूल स्ट्रिंग लौटाता है)

अमान्य इनपुट (नियंत्रित करने की आवश्यकता नहीं है)

जावा 8, 46 45 44 40 बाइट्स

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

Brachylog (यह ऑनलाइन प्रयास करें!), 12 बाइट्स

व्याख्या

रेटिना , 21 बाइट्स

जावास्क्रिप्ट (ईएस 6), 76 70 45 41 बाइट्स

कोशिश करो

पर्ल 6 , 21 बाइट्स

विस्तारित:

जाप , 11 9 बाइट्स

टीआई-बेसिक (TI-84 Plus CE), 63 बाइट्स

गणितज्ञ, 162 बाइट्स

पायथन, 69 68 64 57 51 45 बाइट्स

बैश ,66 61 49 बाइट्स

APL (Dyalog) , 31 30 बाइट्स

PHP, 54 बाइट्स

पायथन 2 , 68 बाइट्स

हास्केल , 49 बाइट्स

पायथन 2 , 72 65 बाइट्स

सी #, 88 बाइट्स

रूबी (लैम्ब्डा अभिव्यक्ति), 29 बाइट्स

Tcl , 37 बाइट्स

सी, 96 बाइट्स

AWK , 21 32 बाइट्स

आर, 20 42 41 बाइट्स

आम लिस्प, 121 बाइट्स

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

पॉवर्सशेल, 34 40 बाइट्स

QBIC , 57 बाइट्स

लूआ , 71 65 बाइट्स

पॉवरशेल , 46 51 बाइट्स

एक्सेल, 129 बाइट्स

sed , 56 53 बाइट्स