पुनरावर्ती स्ट्रिंग प्रतिस्थापन

Question

काम

एक प्रोग्राम या समारोह है कि दिए गए तीन तार लिखें A, B, Cएक आउटपुट स्ट्रिंग जहां के प्रत्येक उदाहरण का उत्पादन Bमें Aरिकर्सिवली के साथ प्रतिस्थापित किया गया है C। रिकर्सिवली एक प्रतिस्थापन जहां हर कदम पर के सभी गैर-अतिव्यापी उदाहरणों दोहरा साधन प्रतिस्थापन Bमें A(लालच से चुना बाएं से दाएं) के साथ बदल दिया जाता है Cजब तक Bकोई और अधिक में निहित है A।

इनपुट आउटपुट

• आप I / O के लिए किसी भी डिफ़ॉल्ट तरीके का उपयोग कर सकते हैं ।
• स्ट्रिंग्स में केवल मुद्रण योग्य ASCII वर्ण होंगे (और उनमें से कोई भी हो सकता है )।
• Bएक खाली स्ट्रिंग कभी नहीं होगा, जबकि Aऔर Cहो सकता है।
• स्ट्रिंग्स को प्लेटेक्स्ट माना जाता है, उदाहरण के लिए आप Bरेगेक्स पैटर्न के रूप में व्यवहार नहीं कर सकते ।
• इनपुट के कुछ संयोजन कभी समाप्त नहीं होंगे। आपका कार्यक्रम उन मामलों में कुछ भी कर सकता है।

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

ये प्रारूप में हैं: A/B/C\nOutput

Hello, world!/world!/PPCG
Hello, PPCG

Uppercase is up/up/down
Uppercase is down

ababababa/aba/ccc
cccbcccba

delete/e/{empty string}
dlt

{empty string}/no/effect
{empty string}

llllrrrr/lr/rl
rrrrllll

+-+-+-+/+-+/+
+

ababababa/aba/bada
badabbadbada

abaaba/aba/ab
abb

((())())())/()/{empty string}
)

वे उदाहरण जो समाप्त नहीं होते हैं:

grow/ow/oow

loop/lo/lo

Comments

एक और परीक्षण मामला:((())())())/()/

— कॉनर ओ'ब्रायन

@ ConorO'Brien ने जोड़ा

— Leo

पहले तो, मैं इसे केस-संवेदी बनाने में असफल रहा। downpercase is down

— इंजीनियर टोस्ट

Answer 1

05AB1E , 2 बाइट्स

`:

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

व्याख्या

`    # split input to stack
 :   # replace (until string doesn't change)

यह 1 बाइट के: लिए हो सकता है यदि हमें खाली तारों से निपटना नहीं है।

Comments

अगर मैं इसे सही ढंग से समझूं, तो आपका 4-बाइट समाधान मान्य है। "इनपुट के कुछ संयोजन कभी समाप्त नहीं होंगे। आपका कार्यक्रम उन मामलों में कुछ भी कर सकता है।"

— सिंह

@Leo। आप सही हैं। मैंने उस भाग पर स्किम कर दी :)

— एमिगा

तो मूल रूप :से एक बिल्डिन है जो पूरी चुनौती को हल करता है? मुझे बिल्डिंस पर प्रतिबंध लगा देना चाहिए;)

— लियो

@ लियो: यदि यह खाली स्ट्रिंग्स के लिए नहीं थे, जो किसी एकल में बनाया गया था, तो यह हां को हल करेगा। और खाली तारों के साथ एकमात्र अंतर यह है कि हमें यह निर्दिष्ट करने की आवश्यकता है कि 3 इनपुट हैं, जो अन्यथा ऑपरेशन से अनुमानित रूप से

— प्रभावित होंगे

की तरह कुछ है इस भी संभव?

— अदनान

Answer 2

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

lambda s,*l:eval('s'+'.replace(*l)'*len(s))

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

प्रपत्र की एक स्ट्रिंग का मूल्यांकन करता है

s.replace(*l).replace(*l).replace(*l) ...

यदि कोई मौजूद है, तो एक निश्चित बिंदु तक पहुंचने के लिए, यह मूल स्ट्रिंग की लंबाई के बराबर प्रतिस्थापन करने के लिए पर्याप्त है।

Answer 3

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

• सेविंग का उपयोग करके 4 बाइट्स सहेजे गए (धन्यवाद @Neil!)

golfed

c=>b=>R=a=>(x=a.split(b).join(c))==a?x:R(x)

कोशिश करो

Q=c=>b=>R=a=>(x=a.split(b).join(c))==a?x:R(x)

function doit() {
  console.log(Q(C.value)(B.value)(A.value));
}

A: <input type="text" value="abaaba" id="A"/> B: <input type="text" value="aba" id="B"/> C: <input type="text" value="ab" id="C"/> <input type="submit" onclick="doit();" value="REPLACE"/>

Comments

आप उल्टे क्रम में तर्कों पर करीने से 4 बाइट बचा सकते हैं:c=>b=>g=a=>a==(a=a.split(b).join(c))?a:g(a)

— नील

उफ़। i.imgur.com/vPCycwR.png

— मेटोनीम

@ मीटोनीमSome combinations of inputs will never terminate. Your program can do anything in those cases.

— ज़ेपेलिन

@zeppelin ओह, मैं देख रहा हूँ।

— Metoniem

Answer 4

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

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

+`(.+)(?=.*¶\1¶(.*))
$2
G1`

इनपुट को पंक्तिबद्ध-अलग किया जाना चाहिए।

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

Answer 5

सी #, 44 बाइट्स

लघु संस्करण:

r=(a,b,c)=>a==(a=a.Replace(b,c))?a:r(a,b,c);

उदाहरण कार्यक्रम:

using System;

namespace ConsoleApplication1
{
    class Program
    {
    static void Main(string[] args)
        {
            Func<string, string, string, string> r = null;
            r=(a,b,c)=>a==(a=a.Replace(b,c))?a:r(a,b,c);

            Action <string, string, string, string> test =
                (a, b, c, answer) =>
                {
                    var result = r(a, b, c);
                    Console.WriteLine("A: \"{0}\"\r\nB: \"{1}\"\r\nC: \"{2}\"\r\nResult: \"{3}\"\r\n{4}\r\n\r\n",
                        a, b, c, result, result == answer ? "CORRECT" : "INCORRECT"
                        );
                };

            test("Hello, world!", "world!", "PPCG", "Hello, PPCG");
            test("Uppercase is up", "up", "down", "Uppercase is down");
            test("ababababa", "aba", "ccc", "cccbcccba");
            test("delete", "e", "", "dlt");
            test("", "no", "effect", "");
            test("llllrrrr", "lr", "rl", "rrrrllll");
            test("+-+-+-+", "+-+", "+", "+");
            test("ababababa", "aba", "bada", "badabbadbada");
            test("abaaba", "aba", "ab", "abb");
            test("((())())())", "()", "", ")");


            Console.WriteLine("Press any key...");
            Console.ReadKey();
        }
    }
}

स्पष्टीकरण: फ़ंक्शन को एक पूंछ पुनरावर्ती अभिव्यक्ति के रूप में लिखा गया है, निम्नलिखित का शोषण करके वापसी कीवर्ड और घुंघराले कोष्ठक से बचें:

• कोष्ठक के भीतर एक असाइनमेंट निर्दिष्ट मान लौटाता है
• समानता चेक के बाईं ओर का मूल्यांकन दाईं ओर असाइनमेंट से पहले किया जाएगा, जिससे हमें इनलाइन से पहले / बाद में तुलना करने की अनुमति मिलती है, और परिणाम का उपयोग होता है

इससे हम इसे एक ही कथन पर रख सकते हैं।

संपादित करें: फ़ंक्शन आर के प्रकार को छोड़ने के लिए वापस चला गया, क्योंकि यह स्वीकार्य प्रतीत होता है। सरणियों का उपयोग करके प्रकार की घोषणा के साथ, यह 68 वर्ण है। इसके बिना, यह 44 अक्षर है।

Comments

यदि फ़ंक्शन केवल विशिष्ट नाम दिए जाने पर काम करेगा, तो आपको उस नाम को फ़ंक्शन देने के लिए बाइट्स खर्च करने की आवश्यकता होगी। यह मेरे लिए तुरंत स्पष्ट नहीं है कि r=घोषणा के लिए 2 बाइट्स हैं या बहुत अधिक (आंशिक रूप से क्योंकि मैं नियमों को पूरी तरह से नहीं जानता हूं, आंशिक रूप से क्योंकि मैं सी # अच्छी तरह से उन्हें लागू करने के लिए नहीं जानता हूं)।

हाँ, मैं ठीक कर रहा था कि किसी और की प्रविष्टि पर किसी और की टिप्पणी पढ़ने के बाद। और यह बहुत अधिक है, चूंकि सभी प्रकार निर्दिष्ट होने चाहिए। मैंने उस पर सहेजने के लिए एक सरणी का उपयोग करने के लिए स्विच किया, और पुनरावर्ती कॉल पर बाइट्स को बचाने के लिए।

— डैनियल

आपका क्या मतलब है जो सही आउटपुट नहीं देता है ? मुझे नहीं लगता कि आपको इनपुट का उत्पादन करने की आवश्यकता है, वास्तव में, कुछ अन्य उत्तर ऐसा नहीं करते हैं। क्या मुझे यह कहते हुए एक टिप्पणी याद आती है कि मुझे इनपुट आउटपुट करने की आवश्यकता है?

— अनुहामन

कोई बात नहीं, मैं समस्या पाया है, यह पुनरावर्ती नहीं है।

— अनुहं

Answer 6

जाप , 15 बाइट्स

@¥(U=UqV qW}a@U

इसे ऑनलाइन टेस्ट करें!

यह काम किस प्रकार करता है

@¥(U=UqV qW}a@U  // Implicit: U, V, W = input strings
            a@U  // Return the first non-negative integer mapped by the function X => U
@          }     // that returns truthily when mapped through this function:
     UqV qW      //   Split U at instances of V, and rejoin with W.
  (U=            //   Set U to this new value.
 ¥               //   Return (old U == new U). This stops the loop when U stops changing.
                 // Implicit: output result of last expression

जाप में एक पुनरावर्ती-निर्मित बिल्ट-इन है, लेकिन यह पहला इनपुट रेगेक्स के रूप में देखता है। यदि इनपुट की गारंटी केवल अल्फ़ान्यूमेरिक वर्णों में होती है तो यह तीन-बाइट समाधान काम करेगा:

eVW

इनपुट को छोड़कर किसी भी वर्ण को रोकने के लिए अनुमति दी गई हैं ^, \या ], इस 12-बाइट समाधान मान्य होगा बजाय:

eV®"[{Z}]"ÃW

Answer 7

सी #, 33 49 बाइट्स

संभवतः, सी # में लिखे गए सबसे छोटे स्निपेट्स में से Replaceएक है ... और चूंकि यह stringसंरचना का मूल है , इसलिए एस की कोई आवश्यकता नहीं है using( कम से कम वीएस निर्मित सुविधा, सी # इंटरएक्टिव पर नहीं ... ) पर नहीं

इसके अलावा, चूंकि Bहमेशा एक मूल्य होता है, कोड को किसी भी सत्यापन की आवश्यकता नहीं होती है।

---

golfed

(a,b,c)=>{while(a!=(a=a.Replace(b,c)));return a;}

---

Ungolfed

(a, b, c) => {
    while( a != ( a = a.Replace( b, c ) ) );

    return a;
}

---

पूर्ण कोड

using System;

namespace Namespace {
    class Program {
        static void Main( string[] args ) {
            Func<string, string, string, string> func = (a, b, c) => {
                // Recursively ( now truly recursive ) replaces every 'b' for 'c' on 'a',
                // while saving the value to 'a' and checking against it. Crazy, isn't it?
                while( a != ( a = a.Replace( b, c ) ) );

                return a;
            };

            int index = 1;

            // Cycle through the args, skipping the first ( it's the path to the .exe )

            while( index + 3 < args.Length ) {
                Console.WriteLine( func(
                    args[index++],
                    args[index++],
                    args[index++]) );
            }

            Console.ReadLine();
        }
    }
}

---

विज्ञप्ति

• v1.1 - +19 bytes- फिक्स्ड समाधान पुनरावर्ती नहीं हो रहा है।
• v1.0 -  33 bytes- प्रारंभिक समाधान।

Comments

मैं c # I upvote

— Nelz

@NelsonCasanova मेरी तरह लगता है।

— मेटोनीम

Replaceपुनरावर्ती प्रतिस्थापन करता है ?

— लकोनी 23

@ लायकोनी नं। मसलन, "((())())())".Replace("()", "")रिटर्न (()))।

— अयुमन

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

— लैकोनी

Answer 8

प्रसंस्करण, 75 72 बाइट्स

void g(String a,String[]s){for(;a!=(a=a.replace(s[0],s[1])););print(a);}

परिणाम प्रिंट करता है। जैसे बुलाओg("llllrrrr", new String[]{"lr","rl"});

void Q110278(String a, String[]s){             //a is the string to be replaced
                                               //s is the array containing the subsitution

  for(; a!=                                    
            (a = a.replace(s[0], s[1])) ;);

  //for-loop where we continuously perform substitution on a
  //until a is equal to substituted a


  //at the end, print the final version of a
  print(a);
}

Answer 9

गणितज्ञ, ३५ ३२ बाइट्स

#//.x_:>StringReplace[x,#2->#3]&

अनुक्रम के रूप में दिए गए तर्क। कभी भी growउदाहरण के लिए समाप्त नहीं होता है, उदाहरण के लिए लौटता loopहै loop। मार्टिन के सुझाव के लिए थ्री बाइट्स।

Comments

FixedPointबहुत लंबा हो जाता है और इसके साथ अनुकरण किया जा सकता है //.:#//.x_:>StringReplace[x,#2->#3]&

— मार्टिन एंडर

धन्यवाद @MartinEnder यह ReplaceRepeatedस्ट्रिंग्स के लिए काम करने का एक अच्छा तरीका है !

— एक सीमन्स

btw, यह केवल लूप $RecursionLimitसमय होगा, जो 2^16कि डिफ़ॉल्ट रूप से है, ऐसा नहीं है कि यह आपके उत्तर को प्रभावित करता है

— ngenisis

@ngenesis मुझे यकीन नहीं है कि ReplaceRepeatedइसके द्वारा नियंत्रित किया जाता है $RecursionLimit- मैंने इसे केवल 20 की सीमा निर्धारित करके परीक्षण किया है और कार्यक्रम अभी भी खुशी से गैर-समाप्ति इनपुट के लिए लूप करता है ..

— एक सीमन्स

इसके लिए ReplaceRepeatedएक अलग विकल्प (जिसे //.सिंटैक्स के साथ इस्तेमाल नहीं किया जा सकता है ) कहा जाता है MaxIterations। यह एक 2 ^ 16 के लिए चूक। (cc @ngenisis)

— मार्टिन

Answer 10

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

->a,b,c{1while a.gsub! b,c;a}

3 तर्कों को देखते हुए, प्रतिस्थापन को पहले लागू करें जब तक कि अब विकल्प नहीं है।

व्याख्या

• 1इससे पहले कि whileबस एक झपकी है
• gsub!स्ट्रिंग लौटाता है या nilयदि कोई प्रतिस्थापन नहीं हुआ है

Answer 11

Pyke, 6 बाइट्स

hVQtX:

यहाँ यह कोशिश करो!

Answer 12

/// , 3 बाइट्स

///

पहली स्लैश के बाद स्ट्रिंग बी रखो, दूसरे के बाद सी और अंत में ए, यानी:

/<B>/<C>/<A>

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

Comments

मुझे नहीं लगता कि यह इनपुट लेने का एक स्वीकार्य तरीका है

— लियो

मेरे ज्ञान के लिए, ///किसी अन्य तरीके से इनपुट स्वीकार नहीं करता है।

— steenbergh

खैर, मुझे लगता है कि यह चर्चा करना दिलचस्प होगा कि क्या यह स्वीकार्य है या नहीं, फिर भी :) वैसे भी, मैंने आपके प्रस्तुत करने के साथ एक और समस्या देखी है: यह काम नहीं करता है यदि कोई /इनपुट स्ट्रिंग में मौजूद है

— लियो

Answer 13

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 48 या उससे पहले), 43 बाइट्स

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

रिवर्स ऑर्डर में करी गई दलीलें लेती हैं। फ़ायरफ़ॉक्स में एक गैर-मानक तीसरा पैरामीटर होता था replaceजिसमें रेगेक्स फ्लैग निर्दिष्ट होते थे। यह पैरामीटर फ़ायरफ़ॉक्स 49 में हटा दिया गया था।

Answer 14

स्माइलबासिक, 72 68 बाइट्स

I=0DEF R A,B,C
I=INSTR(A,B)?A*(I<0)A=SUBST$(A,I,LEN(B),C)R A,B,C
END

दुर्लभ मामलों में से एक जहां एक समारोह बना रहा है वास्तव में स्माइलबासिक में शॉर्टर है।

Answer 15

जावास्क्रिप्ट 130 बाइट्स

f=(a,b,c)=>a.indexOf(b)<0?a:f(eval("a.replace(/"+b.replace(/([\/\,\!\\\^\$\{\}\[\]\(\)\.\*\+\?\|\<\>\-\&])/g,"\\$&")+"/g,c)"),b,c)

जावास्क्रिप्ट केवल एक साथ सभी को प्रतिस्थापित करेगा यदि आप इसे एक रेगेक्स देते हैं। सभी मूल्यों के लिए इस regex को काम करने के लिए, regex के लिए उपयोग किए जाने वाले सभी वर्णों को बच गए संस्करण के साथ बदलने की आवश्यकता है। अंत में, प्रतिस्थापित का मूल्यांकन B के सभी उदाहरणों को C के साथ बदलने के लिए किया जाता है और उस फ़ंक्शन को फिर से पास किया जाता है।

Answer 16

क्यू, 15 बाइट्स

{ssr[;y;z]/[x]}

उदाहरण:

q){ssr[;y;z]/[x]}["llllrrrr";"lr";"rl"]
"rrrrllll"

संपर्कदुभाषिया डाउनलोड करने के लिए

स्पष्टीकरण: ssr , / (अभिसरण)

Answer 17

चेडर, 37 बाइट्स

(a,b,c)f->a has b?f(a.sub(b,c),b,c):a

फोन पर तो TIO लिंक को जोड़ना थोड़ा मुश्किल है। मूल रूप से पुनरावर्तन का उपयोग करता है जबकि चेकिंग बी एक में है। समाधान हो सकता है (a,b,c)->a.sub(Regex{b,"cr"},c)लेकिन किसी कारण से काम नहीं करता है।

Comments

उप सब या सिर्फ पहले की जगह लेता है?

— f --n

@LliwTelracs क्योंकि वे तार हैं। सब जगह लेगा

— डाउगाट

यह काम नहीं लगता है? इसे ऑनलाइन आज़माएं!

— कॉनर ओ'ब्रायन

@ ConorO'Brien बकवास मूर्खतापूर्ण गलतियों के पक्ष में हैं

— डाउनगेट

Answer 18

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

{$^b;$^c;($^a,{S:g/$b/$c/}...*eq*)[*-1]}

इसे आज़माएं (यदि tio.run अपडेट हो जाता है)
एक परिवर्तित संस्करण आज़माएं

विस्तारित:

{
  $^b;           # declare second parameter ( not used here )
  $^c;           # declare third parameter  ( not used here )

  (

    $^a,         # declare first parameter, and use it to seed the sequence

    {S:g/$b/$c/} # replace globally

    ...          # keep doing that

    * eq *       # until there are two that match

  )[*-1]
}

Answer 19

PHP, 46 बाइट्स

function g($a,$b,$c){echo strtr($a,[$b=>$c]);}

Answer 20

PHP, 102 बाइट्स

list($n,$s,$a,$b)=$argv;$f=str_replace($a,$b,$s);while($s!=$f){$s=$f;$f=str_replace($a,$b,$s);}echo$f;

परीक्षण के मामले (कार्यात्मक)

लूप त्रुटि के साथ टेस्ट केस

Comments

नमस्ते! आमतौर पर, एक फ़ंक्शन सबमिट करते समय, आपको फ़ंक्शन को परिभाषित करने के लिए आवश्यक सभी चीज़ों को बायटेकाउंट में जोड़ना चाहिए (आपके मामले में function replace(...){...}, अन्यथा आपका सबमिशन केवल एक स्निपेट है, जो डिफ़ॉल्ट रूप

— लियो

@ लियो को यह नहीं पता था, मेरे जवाब को संपादित किया;)

— roberto06

Answer 21

जावा - 157 बाइट्स

String r(String f){if(f.length()<1)return "";String[]x=f.split("/");if(x[0].contains(x[1]))return r(x[0].replace(x[1],x[2])+'/'+x[1]+'/'+x[2]);return x[0];}

खाली इनपुट के लिए यह एक खाली स्ट्रिंग देता है।

खाली StackOverflowExceptionहोने पर त्रुटि के साथ क्रैश Bया इसे इस तरह से डेटा के साथ खिलाया जाता हैA/A/A ।

यह काम किस प्रकार करता है:

r("ABCD/A/F") returns value of r("FBCD/A/F") which returns FBCD
If there is no more characters to be replaced it returns the final output

टिप्पणियों के साथ अघोषित कोड कोड:

String r (String f) {
    if(f.length() < 1)
        return ""; // For empty input return empty output
    String[] x = f.split("/"); // Get all 3 parameters
    if (x[0].contains(x[1])) // If input contains replaced value
        return r(x[0].replace(x[1],x[2])+'/'+x[1]+'/'+x[2]); // Return value of r() with one character replaced
    return x[0]; // If nothing to replace return the output(modified input)
}

Answer 22

ऑटोहॉटकी, 87 बाइट्स

StringCaseSense,On
Loop{
IfNotInString,1,%2%,Break
StringReplace,1,1,%2%,%3%
}
Send,%1%

%1%, %2%और %3%एक फ़ंक्शन के लिए दिए गए पहले 3 तर्क हैं।
यदि कोई फ़ंक्शन किसी वैरिएबल तर्क की अपेक्षा करता है, तो %s को गिरा दिया जाता है
, केस-सेंसिटिविटी सेटिंग को बदलने में 19 बाइट्स का खर्च आता है, लेकिन इसके बिना, आपको चीजें मिलती हैं downpercase is down।