विशिष्ट कीवर्ड के साथ उप-स्ट्रिंग चिमटा

Question

चुनौती

इस चुनौती का लक्ष्य एक फ़ंक्शन बनाना है जो एक इनपुट स्ट्रिंग, एक स्टार्ट कीवर्ड और एक अंतिम कीवर्ड लेता है। निकाले गए परिणाम का परिणाम (लेकिन बहिष्कृत) दिए गए प्रारंभ कीवर्ड से (लेकिन बहिष्कृत) अंत कीवर्ड है। आउटपुट उप-स्ट्रिंग नीचे दिए गए नियमों का पालन करती है।

• सभी मामलों में, आउटपुट उप-स्ट्रिंग में अग्रणी / अनुगामी रिक्त स्थान को हटा दिया जाना चाहिए।

• यदि दिया गया स्टार्ट कीवर्ड एक खाली स्ट्रिंग है, तो इसका मतलब है कि एंकर इनपुट स्ट्रिंग की शुरुआत में है। अन्यथा, दिए गए स्टार्ट कीवर्ड की पहली घटना एक स्टार्ट एंकर है। यदि दिए गए प्रारंभ कीवर्ड की कोई घटना नहीं है, तो आउटपुट एक रिक्त स्ट्रिंग है।

• यदि दिया गया अंत कीवर्ड एक रिक्त स्ट्रिंग है, तो इसका मतलब है कि एंकर इनपुट स्ट्रिंग के अंत में है। अन्यथा, दिए गए अंतिम कीवर्ड की पहली घटना अंत एंकर है। यदि दिए गए अंतिम कीवर्ड की कोई घटना नहीं है, तो आउटपुट एक रिक्त स्ट्रिंग है।

• यदि प्रारंभ एंकर का स्थान अंतिम एंकर के स्थान से अधिक है, या दिए गए प्रारंभ कीवर्ड की पहली घटना का एक हिस्सा है और दिए गए अंतिम कीवर्ड की पहली घटना का एक हिस्सा अतिव्यापी है, तो आउटपुट एक रिक्त स्ट्रिंग है।

इसी तरह लेकिन किसी दिए गए स्ट्रिंग से एक स्ट्रिंग निकालने से अलग , दिए गए प्रारंभ और अंत एंकर कई वर्ण हैं।

यहाँ C # में एक अपंग संदर्भ कार्यान्वयन है

private static string GetTargetString(string stringInput, string startKeywordInput, string endKeywordInput)
{
    int startIndex;
    if (String.IsNullOrEmpty(startKeywordInput))
    {
        startIndex = 0;
    }
    else 
    {
        if (stringInput.IndexOf(startKeywordInput) >= 0)
        {
            startIndex = stringInput.IndexOf(startKeywordInput) + startKeywordInput.Length;
        }
        else
        {
            return "";
        }
        
    }

    int endIndex;
    if (String.IsNullOrEmpty(endKeywordInput))
    {
        endIndex = stringInput.Length;
    }
    else
    {
        if (stringInput.IndexOf(endKeywordInput) > startIndex)
        {
            endIndex = stringInput.IndexOf(endKeywordInput);
        }
        else
        {
            return "";
        }
    }
    
    
    //    Check startIndex and endIndex
    if (startIndex < 0 || endIndex < 0 || startIndex >= endIndex)
    {
        return "";
    }

    if (endIndex.Equals(0).Equals(true))
    {
        endIndex = stringInput.Length;
    }
    int TargetStringLength = endIndex - startIndex;
    return stringInput.Substring(startIndex, TargetStringLength).Trim();
}

उदाहरण इनपुट और आउटपुट

उदाहरण इनपुट और आउटपुट को नीचे सूचीबद्ध किया गया है।

इनपुट स्ट्रिंग	कीवर्ड शुरू करें	अंत कीवर्ड	आउटपुट
"C # को Microsoft द्वारा इसके .NET पहल के भाग के रूप में 2000 के आसपास विकसित किया गया था"	""(खाली स्ट्रिंग)	""(खाली स्ट्रिंग)	"C # को Microsoft द्वारा इसके .NET पहल के भाग के रूप में 2000 के आसपास विकसित किया गया था"
"C # को Microsoft द्वारा इसके .NET पहल के भाग के रूप में 2000 के आसपास विकसित किया गया था"	""(खाली स्ट्रिंग)	".NET"	"C # को Microsoft द्वारा 2000 के आसपास विकसित किया गया था"
"C # को Microsoft द्वारा इसके .NET पहल के भाग के रूप में 2000 के आसपास विकसित किया गया था"	"सी#"	""(खाली स्ट्रिंग)	"Microsoft द्वारा इसकी .NET पहल के भाग के रूप में 2000 के आसपास विकसित किया गया था"
"C # को Microsoft द्वारा इसके .NET पहल के भाग के रूप में 2000 के आसपास विकसित किया गया था"	"सी#"	".NET"	"Microsoft द्वारा 2000 के आसपास विकसित किया गया था"
"C # को Microsoft द्वारा इसके .NET पहल के भाग के रूप में 2000 के आसपास विकसित किया गया था"	".NET"	""(खाली स्ट्रिंग)	"पहल"
"C # को Microsoft द्वारा इसके .NET पहल के भाग के रूप में 2000 के आसपास विकसित किया गया था"	""(खाली स्ट्रिंग)	"सी#"	""(खाली स्ट्रिंग)
"C # को Microsoft द्वारा इसके .NET पहल के भाग के रूप में 2000 के आसपास विकसित किया गया था"	".NET"	"सी#"	""(खाली स्ट्रिंग)
"C # को Microsoft द्वारा इसके .NET पहल के भाग के रूप में 2000 के आसपास विकसित किया गया था"	"एबीसी"	"सी#"	""(खाली स्ट्रिंग)
"C # को Microsoft द्वारा इसके .NET पहल के भाग के रूप में 2000 के आसपास विकसित किया गया था"	".NET"	"XYZ"	""(खाली स्ट्रिंग)
"C # को Microsoft द्वारा इसके .NET पहल के भाग के रूप में 2000 के आसपास विकसित किया गया था"	"एबीसी"	"XYZ"	""(खाली स्ट्रिंग)

नियम

यह कोड-गोल्फ है । सबसे कम बाइट्स के साथ उत्तर जीतता है।

Answer 1

APL (Dyalog विस्तारित) , 24 बाइट्स ( SBCS )

पूरा कार्यक्रम जो सरणी के लिए संकेत देता है [EndKeyword,StartKeyword,InputString]। 0-आधारित अनुक्रमण की आवश्यकता है।

⌂deb⊃(⌽⊢↓⍨1⍳⍨⊣,⍷)/⌽¨@0⊢⎕

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

⎕ इनपुट के लिए संकेत

⊢ उस पर…

⌽¨@0 ऑफसेट 0 पर होने वाले सभी तत्वों को उल्टा कर दें

(… )/ निम्नलिखित टैसिट फ़ंक्शन का उपयोग करके दाईं ओर से कम करें:

 ⍷ बूलियन सूची के साथ उन सभी स्थानों को इंगित करें जहां बाएं तर्क सही तर्क में शुरू होता है

 ⊣, उस पर छोड़ दिया तर्क प्रस्तुत करना

 1⍳⍨ पहले 1 की भरपाई करें

 ⊢↓⍨ सही तर्क से कई प्रमुख तत्वों को छोड़ दें

 ⌽ रिवर्स (अगली बार चारों ओर, अंत से ऐसा करें, और उसके बाद, ऑर्डर वापस करें)

⊃ 1-आयामी सरणी से 0-आयामी सरणी में कमी के कारण हुए बाड़े का खुलासा करें

⌂deb डी इलेट ई निडिंग (लीडिंग एंड ट्रेलिंग) बी लैंक्स

Answer 2

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

इसमें कुछ अनपेक्षित वर्ण हैं जो नीचे दिए गए हैं।

(s,a,b)=>s.replace(b||/$/,"").replace(a,"").match(/ *(.*?) *|$/)[1]||""

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

टिप्पणी की

(s, a, b) =>          // s = input string, a = start keyword, b = end keyword
  s.replace(          // replace in s:
    b || /$/, // look for the end keyword, or the regex /$/ if it's empty
    "\3"              //   and replace it with ETX (end of text)
  )                   //
  .replace(           // replace in the resulting string:
    a,                //   look for the start keyword
    "\2"              //   and replace it with STX (start of text)
  )                   //
  .match(             // attempt to match:
    /\2 *(.*?) *\3|$/ // "\2" STX ) // " *" followed by optional whitespace // "(.*?)" followed by a non-greedy string (the payload) // " *" followed by optional whitespace // "\3" followed by ETX // "|$"    OR match an empty string to make sure that
                      //           match() doesn't return null
  [1] || ""           // return the payload string, or an empty string if undefined

Answer 3

पायथन 3 , ^{86 77} 75 बाइट्स

Movatica के लिए 9 बाइट्स सहेजे गए !!!
सहेजे गए 2 बाइट्स ओव्स के लिए धन्यवाद !!!

lambda s,a,b:s[s.find(a):(b in s)*s.find(b)if b else None][len(a):].strip()

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

Answer 4

जावास्क्रिप्ट (Node.js) , 74 बाइट्स

(s,a,b)=>s.substr(p=(s+a).indexOf(a)+a.length,b?s.indexOf(b)-p:1/0).trim()

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

काफी निष्कपट...

Answer 5

रूबी , 66 बाइट्स

->w,s,e,r=Regexp{"#{w[/#{r.quote s}\K.+(?=#{r.quote e})/]}".strip}

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

रेगेक्स के उपयोग के बिना एक अन्य विधि,

रूबी , 72 बाइट्स

->w,s,e{"#{w[((w+s).index(s)+s.size rescue 0)...w.rindex(e)||0]}".strip}

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

Answer 6

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

रेगेक्स संस्करण, अभी भी स्लाइसिंग एल्गोरिथ्म को हरा नहीं सकता है ।

from re import*
r=escape
f=lambda s,b,e:(search(r(b)+'(.+)'+r(e),s)or'  ')[1].strip()

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

Answer 7

रेटिना 0.8.2 , 60 बाइट्स

(.*)¶(.+)?¶.*?\1 *(.*?) *(?<!(?=\2).*)(?(2)\2.*|$)|(.|¶)+ $3

इसे ऑनलाइन आज़माएं! स्टार्ट, एंड, स्ट्रिंग को अलग-अलग लाइनों पर इनपुट के रूप में लेता है, लेकिन लिंक हैडर के साथ सूट का परीक्षण करने के लिए है, जो अल्पविराम से अलग स्ट्रिंग, अंत में, सुविधा के लिए शुरू होता है। स्पष्टीकरण:

(.*)¶

स्टार्ट कीवर्ड से मिलान करें।

(.+)?¶

वैकल्पिक रूप से एक गैर-रिक्त अंत कीवर्ड से मेल खाता है।

.*?\1

स्ट्रिंग, प्लस वैकल्पिक स्थानों में जितना जल्दी हो सके स्टार्ट कीवर्ड खोजें।

 *(.*?) *

एक परिणाम के रूप में संभव के रूप में मिलान करें (ताकि अंत कीवर्ड स्ट्रिंग में जितनी जल्दी हो सके पाया जाता है) लेकिन इसके चारों ओर रिक्त स्थान भी ट्रिम करें।

(?<!(?=\2).*)

सुनिश्चित करें कि अंतिम कीवर्ड पहले से ही इस बिंदु पर पारित नहीं किया गया है।

(?(2)\2.*|$)

यदि अंतिम कीवर्ड खाली था, तो केवल स्ट्रिंग के अंत में मिलान करें अन्यथा अंत कीवर्ड और शेष स्ट्रिंग से मेल खाएं।

|(.|¶)+

यदि कुछ भी मिलान करना संभव नहीं था, तो सब कुछ हटा दें।

$3

वांछित परिणाम रखें।

Answer 8

वोल्फ्राम भाषा (गणितज्ञ) , 93 बाइट्स

sStringTrim@StringTake[s,i=1;If[i*=-1;#=="",0,StringPosition[s,#][[1,i]]]-i&/@#]/._@_:>""&

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

Answer 9

लाल , 90 बाइट्स

func[t s e][p:""if""<> s[append s" "]if e =""[e:[end]]parse t[thru s copy p to[opt" "e]]p]

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

Answer 10

C (gcc) , 168 152 143 132 112 बाइट्स

@Ceilingcat को भारी -38 धन्यवाद

#define r strstr(c
*f(c,s,e)int*c,*s,*e;{return*e&&r,s)>r,e)|!r,s)|!r,e)||*e&&(*r,e)=0)?"":r,s)+strlen(s)+!!*s;}

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

Answer 11

जावास्क्रिप्ट (ईएस 6) 95 92 बाइट्स, कोई रेगेक्स!

(i,s,e,t=i.indexOf(s),r=i.lastIndexOf(e))=>t!=-1&r!=-1?(i.substring(t+s.length,r)).trim():''

इसे कैसे आज़माएं:

अपने ब्राउज़र का जावास्क्रिप्ट कंसोल खोलें और निम्नलिखित पेस्ट करें।

((i,s,e,t=i.indexOf(s),r=i.lastIndexOf(e))=>t!=-1&r!=-1?(i.substring(t+s.length,r)).trim():'')('C# was developed around 2000 by Microsoft as part of its .NET initiative', 'C#', '.NET')

Answer 12

चारकोल , 41 बाइट्स

≔⎇ζ…θ⌕θζθθ≔⎇η⪫Φ⪪θηκηθθ≔⌕ＡＥθ›ι ¹ε¿ε✂θ⌊ε⊕⌈ε

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। कीवर्ड में से कोई एक खाली होने पर भी इनपुट में पर्याप्त नई कथानक शामिल करने का ध्यान रखें। स्पष्टीकरण:

≔⎇ζ…θ⌕θζθθ

यदि अंतिम कीवर्ड खाली नहीं है, तो स्ट्रिंग को उसकी पहली उपस्थिति में छोटा करें। ( CycleChopयदि इसका इनपुट ऋणात्मक है तो सौभाग्य से स्ट्रिंग को खाली कर देता है।)

≔⎇η⪫Φ⪪θηκηθθ

यदि स्टार्ट कीवर्ड खाली नहीं है, तो कीवर्ड पर स्ट्रिंग को विभाजित करें, पहले तत्व को छोड़ें, और फिर से स्ट्रिंग में शामिल हों। इसका परिणाम एक रिक्त स्ट्रिंग में है यदि स्टार्ट कीवर्ड स्ट्रिंग में दिखाई नहीं देता है।

≔⌕ＡＥθ›ι ¹ε

जांचें कि क्या स्ट्रिंग में कोई गैर-रिक्त स्थान है।

¿ε✂θ⌊ε⊕⌈ε

यदि ऐसा है तो पहले से अंतिम गैर-स्थान तक प्रिंट करें।

Answer 13

आर , 111 बाइट्स

function(s,a,b,c=?s,`?`=nchar,r=regexpr)trimws(substr(s,`if`((d=r(a,s,f=T))>0,d+?a,c),`if`(?b,r(b,s,f=T)-1,c)))

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

स्पष्ट दृष्टिकोण: का उपयोग कर शब्द बाउंडिंग पाता regexpr(तर्क के साथ fixed = Tयह सुनिश्चित करें कि पाठ स्ट्रिंग एक regex के रूप में व्याख्या नहीं है rue), हो जाता है substrउन दोनों के बीच आईएनजी, और फिर trimएस white sदोनों सिरों से गति।

चूंकि फ़ंक्शंस ncharऔर regexprप्रत्येक दो बार उपयोग किए जाते हैं, यह एकल-वर्ण उपनामों को परिभाषित करने के लिए छोटा है। के मामले में nchar, हम ?अपने संचालक के रूप में एकरी संचालक को फिर से परिभाषित कर सकते हैं , ताकि हम कोष्ठक की आवश्यकता से बच सकें। दुर्भाग्य से, यह ट्रिक संभव नहीं है regexprक्योंकि इसे अतिरिक्त तर्क के लिए फीड करने की आवश्यकता के कारण fixed = True।

Answer 14

C # 114 बाइट्स

(i,s,e)=>{int p=(i+(s??="")).IndexOf(s)+s.Length,q=$"{e}"==""?i.Length:i.IndexOf(e);return p<q?i[p..q].Trim():"";}