30

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

इनपुट में तीन स्ट्रिंग्स शामिल होंगे A, Bऔर C, जहां Bऔर Cएक ही लंबाई के होने की गारंटी है। यदि इसमें Bएक अनुगामी के रूप में प्रकट होता है, तो Aइसे बदल दिया जाना चाहिए C। ये रहा एक सरल उदाहरण:

A: abcdefghijklmnopqrstuvwxyz
B: ghost
C: 12345

इसे इस तरह संसाधित किया जाएगा:

abcdefghijklmnopqrstuvwxyz
      ||      |   ||
abcdef12ijklmn3pqr45uvwxyz

यदि Bअनुवर्ती के रूप में खोजने के कई तरीके हैं , तो आपको बाईं ओर सबसे बाईं ओर लालच करना चाहिए:

A: abcdeedcba
B: ada
C: BOB

Result:   BbcOeedcbB
and NOT:  BbcdeeOcbB

एक ही लागू होता है यदि Bकई स्थानों पर पाया जा सकता है:

A: abcdeedcbaabcde
B: ed
C: 12

Result:   abcd1e2cbaabcde
and NOT:  abcd112cbaabc2e (or similar)

जब Bप्रकट नहीं होता है A, तो आपको Aअपरिवर्तित आउटपुट करना चाहिए ।

नियम

जैसा कि ऊपर कहा, तीन तार ले A, Bऔर Cइनपुट के रूप में और के बाएं सबसे घटना की जगह Bमें किसी परिणाम के रूप में Aसाथ Cहै, अगर वहाँ है किसी भी।

आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट ले रहे हैं और STDOUT (या निकटतम विकल्प), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) पैरामीटर के माध्यम से परिणाम लिख सकते हैं।

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

मानक कोड-गोल्फ नियम लागू होते हैं।

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

: प्रत्येक परीक्षण का मामला चार लाइनें है A, B, Cपरिणाम के बाद।

abcdefghijklmnopqrstuvwxyz
ghost
12345
abcdef12ijklmn3pqr45uvwxyz

abcdeedcba
ada
BOB
BbcOeedcbB

abcdeedcbaabcde
ed
12
abcd1e2cbaabcde

121
121
aBc
aBc

abcde
acb
123
abcde

ABC
ABCD
1234
ABC

012345678901234567890123456789
42
TT
0123T5678901T34567890123456789

edcbaedcbaedcbaedcba
abcde
12345
edcbaedcbaedcbaedcba

edcbaedcbaedcbaedcbaedcba
abcde
12345
edcb1edc2aed3bae4cba5dcba

daccdedca
ace
cra
dcrcdadca

aacbcbabcccaabcbabcaabbbbca
abaaaccbac
1223334444
aacbcbabcccaabcbabcaabbbbca

aacbcbabcccaabcbabcaabbbbcac
abaaaccbac
1223334444
1ac2cb2bccc33b3bab4aa4bbbc44

लीडरबोर्ड

इस पोस्ट के निचले भाग में स्टैक स्निपेट उत्तर से लीडरबोर्ड उत्पन्न करता है) ए प्रति भाषा में सबसे छोटे समाधान की सूची के रूप में और बी) एक समग्र लीडरबोर्ड के रूप में।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

## Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

## Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो बाद में स्निपेट में दिखाई देगा:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

कोड स्निपेट दिखाएं

/* Configuration */

var QUESTION_ID = 77719; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 8478; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "http://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "http://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    else console.log(body);
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    lang = jQuery('<a>'+lang+'</a>').text();
    
    languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang_raw.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
    if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="language-list">
  <h2>Shortest Solution by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

Expand snippet

code-golf string subsequence

— मार्टिन एंडर
स्रोत

क्या इनपुट / आउटपुट के लिए एकल वर्ण स्ट्रिंग्स की सूची ठीक होगी?

— फ्राईमईएग्गमैन

@FryAmTheEggman Hm, एकमात्र सर्वसम्मति जो मैं पा सकता हूं वह यह है कि एकल-स्ट्रिंग स्ट्रिंग की सूचियों को मान्य स्ट्रिंग प्रतिनिधित्व के रूप में संबोधित नहीं करता है। एक मेटा पोस्ट बनाने के लायक हो सकता है (विशेषकर क्योंकि मुझे लगता है कि यह भी xnor की नवीनतम चुनौती पर आया था)। मैं अभी के लिए नहीं कहने जा रहा हूँ।

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

चरित्र सरणियों के बारे में क्या? ऐसा लगता है कि भाषा के उचित प्रकार होने पर भी उन्हें अनुमति दी जाती है।

— डेनिस

@ डेनिस हाँ, कैरेक्टर एरे ठीक हैं, लेकिन सिंगलटन स्ट्रिंग्स एक पूर्णांक की तरह ले रहा है [[1], [2], [3]]।

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

ठीक है, कि ऊपर समाशोधन के लिए धन्यवाद।

— डेनिस

3

जेली , 23 22 21 बाइट्स

='T€ŒpfṢ€$ḢṬœp³ż⁵$³Ḋ?

इसे ऑनलाइन आज़माएं!ध्यान दें कि पिछले दो परीक्षण मामले स्मृति से बाहर चलेंगे।

सत्यापन

$ head -n 5 test-cases
abcdefghijklmnopqrstuvwxyz
ghost
12345
abcdef12ijklmn3pqr45uvwxyz

$ cat subseq-short
while read s; do
        read p; read r; read o; echo $o; read
        timeout 1s jelly eun $1 "='T€ŒpfṢ€$ḢṬœp³ż⁵$³Ḋ?" "'$s'" "'$p'" "'$r'"
        (($?)) && echo '(killed)'
done < test-cases
$ ./subseq-short
abcdef12ijklmn3pqr45uvwxyz
abcdef12ijklmn3pqr45uvwxyz
BbcOeedcbB
BbcOeedcbB
abcd1e2cbaabcde
abcd1e2cbaabcde
aBc
aBc
abcde
abcde
ABC
ABC
0123T5678901T34567890123456789
0123T5678901T34567890123456789
edcbaedcbaedcbaedcba
edcbaedcbaedcbaedcba
edcb1edc2aed3bae4cba5dcba
edcb1edc2aed3bae4cba5dcba
dcrcdadca
dcrcdadca
aacbcbabcccaabcbabcaabbbbca
(killed)
1ac2cb2bccc33b3bab4aa4bbbc44
(killed)

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

='T€ŒpfṢ€$ḢṬœp³ż⁵$³Ḋ?  Main link. Arguments: string s, pattern p, replacement r

='                     Compare each character of s with each character of p.
                       This yields a 2D list. Each row corresponds to a char in p.
  T€                   Compute the truthy indices of each row, i.e., the indices
                       of all occurrences of that char in s.
   Œp                  Compute the Cartesian product of the lists of indices.
        $              Combine the two links to the left into a monadic chain:
      Ṣ€                 Sort each list of indices.
     f                   Filter, removing all non-sorted lists of indices.
         Ḣ             Head; take the first (sorted) list of indices.
          Ṭ            Truth; generate a list with 1's at those indices.
           œp³         Partition; split s at all 1's, removing those characters.
                  Ḋ?   If the partition has more than more than one element:
              ż⁵$        Zip the partition with r.
                 ³       Else, return s.

— डेनिस
स्रोत

12

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

def f(a,b,c,o=""):
 for q in a:x=q==b[:1];o+=c[:x]or q;b=b[x:];c=c[x:]
 print[o,a][c>'']

एक फ़ंक्शन जो तीन स्ट्रिंग्स में लेता है और परिणाम को STDOUT में आउटपुट करता है। फ़ंक्शन केवल स्ट्रिंग पर एक पास करता है, उपयुक्त चार ले रहा है और अपडेट कर रहा हैb,c जैसे ही हम जाता है कर रहा है।

परीक्षण के लिए ( printसाथ बदलने के बाद return):

S = """
<test cases here>
"""

for T in S.split("\n\n"):
    A,B,C,D = T.split()
    assert f(A,B,C) == D

— Sp3000
स्रोत

9

जावा 7, 141

मुझे लगता है कि इसके साथ मैं कुछ और कर सकता हूं, लेकिन मैंने अभी के लिए दौड़ना शुरू कर दिया है। ए और बी में एक इंडेक्स रखते हुए यह केवल एक साधारण पुनरावृति / प्रतिस्थापन है।

char[]h(char[]a,char[]b,char[]c){char[]d=a.clone();int i=0,j=0,k=b.length;for(;i<a.length&j<k;i++)if(a[i]==b[j])d[i]=c[j++];return j==k?d:a;}

आपके आनंद के लिए व्हाट्सएप:

char[]h(char[]a,char[]b,char[]c){
    char[]d=a.clone();
    int i=0,j=0,k=b.length;
    for(;i<a.length&j<k;i++)
        if(a[i]==b[j])d[i]=c[j++];
    return j==k?d:a;
}

— Geobits
स्रोत

Whitespacedहाँ, यह पूरी तरह से पठनीय है

— बिल्ली

हालांकि यह नहीं है? मेरे द्वारा मल्टी-लाइन इंडेंटेड संस्करण जोड़ने का मुख्य कारण क्षैतिज स्क्रॉलिंग से बचना है, बस इसलिए इसे एक ही बार में देखा जा सकता है। इनलाइन

— व्हाट्सएप

[फ़ीचर-अनुरोध] और भी व्हॉट्सएप

— एलेक्स ए।

@AlexA। ये रहा!

— ज्योबिट्स

@Geobits अंत में एक बाइट को बचाएं यदि आप करते हैंj<k?a:d

— Xanderhall

7

लूआ, 121 बाइट्स

सीधा समाधान, gsub हमें प्रत्येक चरित्र पर एक बार ठीक से पुनरावृति करने और उन्हें स्ट्रिंग के एक नए उदाहरण में बदलने की अनुमति देता है।

यह 3 कमांड लाइन तर्क के माध्यम से इनपुट लेता है और एक स्ट्रिंग को STDOUT में आउटपुट करता है।

a,b,c=...d=a:gsub(".",function(s)if b:find(s)then b=b:sub(2)x=c:sub(1,1)c=c:sub(2)return x end end)print(b~=''and a or d)

Ungolfed

a,b,c=...               -- unpack the arguments into a, b and c
d=a:gsub(".",function(s)-- iterate over each character of the first argument
  if b:find(s)then      -- if the current character is in the set b
    b=b:sub(2)          -- remove it from b
    x=c:sub(1,1)        -- save the replacement character in x
    c=c:sub(2)          -- remove it from c
    return x            -- replace the current character with x
  end
end)
print(b~=''             -- if b is empty, we replaced all the character
      and a or d)       -- so output the result of gsub, else, output the first argument

— Katenkyo
स्रोत

6

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

16 बाइट्स काटेनको को धन्यवाद दिया।

अभी भी इस पर काम करना थोड़ा मुश्किल था, आदमी यह नास्टियर था जितना मैंने सोचा था कि यह होगा।

f=lambda a,b,c:a.replace(b[0],c[0],1)[:a.index(b[0])+1]+f(a[a.index(b[0])+1:],b[1:],c[1:])if b and all(x in a for x in b)else a

स्पष्टीकरण: Awww हाँ, पुनरावृत्ति।

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

assert f('abcdeedcba', 'ada', 'BOB') == 'BbcOeedcbB'
assert f('abcdeedcbaabcde', 'ed', '12') == 'abcd1e2cbaabcde'
assert f('012345678901234567890123456789', '42', 'TT') == '0123T5678901T34567890123456789'
assert f('ABC', 'ABCD', '1234') == 'ABC'

— मॉर्गन थ्रैप
स्रोत

50 से गोल्फिंग के लिए +1, लेकिन चलते रहें! इसे मेरे जावा उत्तर को कम से कम हरा देना होगा;)

— ज्योबिट्स

7

@Geobits हाँ, मैं जावा से पहले कभी नहीं हारा हूँ। यह मेरी सबसे बड़ी शर्म है।

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

मैं वास्तव में अजगर में निपुण नहीं हूं, लेकिन all(x in a for x in b)यह भी जांचता है कि बी में तत्व और एक ही क्रम में प्रकट होता है, या केवल अगर वे यहां हैं?

— केटेनको

@Katenkyo केवल इतना ही है कि वे सभी वहाँ हैं, लेकिन जब हम पुनरावृत्ति करते हैं तो आदेश का ध्यान रखा जाता है।

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

ठीक है, भी, return a.replace(b[0],c[0],1)[:l(b[0])+1]+f(a[l(b[0])+1:],b[1:],c[1:])if b and all(x in a for x in b)else aतुम कुछ बाइट्स बचा नहीं होगा ?

— केटीन्को

5

पायथन 3.5, 87 बाइट्स

import re
lambda s,p,r:re.sub('(.*?)'.join(p),'\g<%d>'.join(r)%(*range(1,len(r)),),s,1)

सभी प्रकार के परीक्षण की पुष्टि करने के repl.it ।

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

'(.*?)'.join(p) एक खोज पैटर्न बनाता है जो उसके तत्वों के बीच की जगह और किसी भी चीज़ से मेल खाता है।

चूंकि क्वांटिफायर आलसी होते हैं, प्रत्येक (.*?)संभव के रूप में कुछ वर्णों से मेल खाएगा।

पैटर्न के लिए ghost, निर्मित रेगेक्स है g(.*?)h(.*?)o(.*?)s(.*?)t।
'\g<%d>'.join(r)%(*range(1,len(r)),) स्ट्रिंग स्वरूपण का उपयोग करके प्रतिस्थापन स्ट्रिंग बनाता है।

प्रत्येक एन ^{वें पर} कब्जा कर लिया समूह \g<n>को संदर्भित करता है , जैसे होगा।\n

प्रतिस्थापन के लिए 12345, निर्मित स्ट्रिंग है 1\g<1>2\g<2>3\g<3>4\g<4>5।
re.sub(...,...,s,1)स्ट्रिंग में अधिकांश एक प्रतिस्थापन पर प्रदर्शन करता है s।

— डेनिस
स्रोत

4

अजगर, २,

.xuXG.*HC,hSI#.nM*FxRcQ1zwQ

परीक्षण सूट

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

मुझे ऐसा लगता है कि इससे कुछ कम होना चाहिए .nM*F...

— FryAmTheEggman
स्रोत

4

MATL , 33 बाइट्स

y!=[]0b"@n:!<@*fX<h5Mt?}.]]?iw(}x

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

व्याख्या

y!      % Implicitly input first two strings. Duplicate the first and transpose
=       % Compare the two strings element-wise. Gives a 2D array with all combinations
[]      % Push empty array. Indices of matching elements will be appended to this
0       % Push a 0. This is the index of last character used up in first string
b       % Bubble up (rearrange elements in stack) to move 2D array to top
"       % For each column of that array (each char of the second string)
  @     %   Push current column
  n:!   %   Transform into column array of consecutive values starting from 1
  <     %   Compare with index of last character used up of first string
  @*    %   Push current column again. Multiply element-wise (logical AND)
  fX<   %   Find index of first matching character, or empty if there's none
  h     %   Append to array containing indices of matching elements
  5Mt   %   Push index of matching character again. Duplicate
  ?}    %   If it's empty
    .   %     Break loop
  ]     %   End if
]       % End for
        % The top of the stack now contains a copy of the index of last matching
        % character, or an empty array if there was no match
?       % If non-empty: all characters were matched
  i     %   Input third string
  w     %   Swap top two elements in stack
  (     %   Assign the characters of the third string to first string at found indices
}       % Else: the original string needs to be output
  x     %   Delete (partial) array of matching indices. Leave original string in stack
        % End if
        % Implicitly display (either modified string or original string)

— लुइस मेंडो
स्रोत

3

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

(a,b,c)=>[...b].every((q,i)=>r[p=a.indexOf(q,p)]=~p++&&c[i],p=0,r=[...a])?r.join``:a

स्पष्टीकरण / परीक्षण

कोड स्निपेट दिखाएं

var solution =

(a,b,c)=>
  [...b].every((q,i)=>
    r[p=a.indexOf(q,p)]=~p++&&c[i],
    p=0,
    r=[...a]
  )?r.join``
  :a

// Test
var testCases = `abcdefghijklmnopqrstuvwxyz
ghost
12345
abcdef12ijklmn3pqr45uvwxyz

abcdeedcba
ada
BOB
BbcOeedcbB

abcdeedcbaabcde
ed
12
abcd1e2cbaabcde

121
121
aBc
aBc

abcde
acb
123
abcde

ABC
ABCD
1234
ABC

012345678901234567890123456789
42
TT
0123T5678901T34567890123456789

edcbaedcbaedcbaedcba
abcde
12345
edcbaedcbaedcbaedcba

edcbaedcbaedcbaedcbaedcba
abcde
12345
edcb1edc2aed3bae4cba5dcba

daccdedca
ace
cra
dcrcdadca

aacbcbabcccaabcbabcaabbbbca
abaaaccbac
1223334444
aacbcbabcccaabcbabcaabbbbca

aacbcbabcccaabcbabcaabbbbcac
abaaaccbac
1223334444
1ac2cb2bccc33b3bab4aa4bbbc44`
.split`\n\n`.map(c=>c.split`\n`);
document.write("<pre>"+testCases.map(c=>(r=solution(c[0],c[1],c[2]))+" : "+(r==c[3]?"PASS":"FAIL")).join`\n`);

Expand snippet

— user81655
स्रोत

3

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

(a,b,c)=>a.replace(RegExp([...b].join`(.*?)`),c.replace(/\B/g,(_,i)=>'$'+i))

क्योंकि मुझे यकीन था कि यह RegExp के लिए एक नौकरी थी।

संपादित करें: @ मार्टिनबटनर to के लिए 8 बाइट्स धन्यवाद सहेजे गए।

@ केविनलाउ के रूबी जवाब का एक हिस्सा 82 बाइट ले गया:

([...a],[...b],[...c])=>(d=a.map(e=>e==b[0]?c.shift(b.shift()):e),b[0]?a:d).join``

मैंने भी एक पुनरावर्ती RegExp समाधान की कोशिश की, लेकिन 90 बाइट्स लिया:

f=(a,[b,...d],[c,...e])=>b?a.replace(RegExp(b+'(.*'+d.join`.*`+'.*)'),(_,s)=>c+f(s,d,e)):a

— नील
स्रोत

3

जूलिया, 89 70 बाइट्स

f(s,a,b,i=0)=(o=join(["$a "[i+1]!=c?c:b[i+=1]for c=s]);i<endof(a)?s:o)

iजैसे हम जाते हैं पैटर्न / प्रतिस्थापन तारों के माध्यम से पुनरावृति करने के लिए एक सूचकांक का उपयोग करता है । -19 बाइट्स @ डेनिस को धन्यवाद!

— Sp3000
स्रोत

2

सी, 98 बाइट्स

char*f(i,o,s,r)char*i,*o,*s,*r;{char*I=i,*O=o;for(;*i;++i,++o)*o=*i==*s?++s,*r++:*i;return*s?I:O;}

/ * विस्तारित कोड * /

char *f(i, o, s, r)
    char *i, *o, *s, *r;
{
    char *I=i, *O=o;
    for (;  *i;  ++i,++o)
        *o = (*i==*s) ? (++s,*r++) : *i;
    return *s ? I : O;
}

तर्क हैं: i nput string, o utput बफर, s earch string, r eplacement।

इनपुट और आउटपुट की शुरुआत को याद करने के बाद, हम इनपुट को बदलते हैं, जब भी हम एक को मारते हैं, तब प्रतिस्थापन की जगह और आगे बढ़ते हैं। अंत में, यदि हम सबस्टेशन से बाहर निकल गए हैं, तो आउटपुट बफर लौटाएं, अन्यथा अनमॉडिफाइड इनपुट।

/ * टेस्ट * /

struct T
{
    const char *input;
    const char *search;
    const char *replace;
    const char *expected;
};

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
    int i;
    static const struct T test[] = {
        { "abcdefghijklmnopqrstuvwxyz",
          "ghost",
          "12345",
          "abcdef12ijklmn3pqr45uvwxyz"},
        { "abcdeedcba",
          "ada",
          "BOB",
          "BbcOeedcbB"},
        { "abcdeedcbaabcde",
          "ed",
          "12",
          "abcd1e2cbaabcde"},
        { "121",
          "121",
          "aBc",
          "aBc"},
        { "abcde",
          "acb",
          "123",
          "abcde"},
        { "ABC",
          "ABCD",
          "1234",
          "ABC"},
        { "012345678901234567890123456789",
          "42",
          "TT",
          "0123T5678901T34567890123456789"},
        { "edcbaedcbaedcbaedcba",
          "abcde",
          "12345",
          "edcbaedcbaedcbaedcba"},
        { "edcbaedcbaedcbaedcbaedcba",
          "abcde",
          "12345",
          "edcb1edc2aed3bae4cba5dcba"},
        { "daccdedca",
          "ace",
          "cra",
          "dcrcdadca"},
        { "aacbcbabcccaabcbabcaabbbbca",
          "abaaaccbac",
          "1223334444",
          "aacbcbabcccaabcbabcaabbbbca"},
        { "aacbcbabcccaabcbabcaabbbbcac",
          "abaaaccbac",
          "1223334444",
          "1ac2cb2bccc33b3bab4aa4bbbc44"
        }
    };

    for (i = 0;  i < (sizeof test) / (sizeof test[0]);  ++i) {
        const struct T *t = test+i;
        char *out = malloc(strlen(t->input)+1);
        char *result = f(t->input, out, t->search, t->replace);
        if (strcmp(t->expected, result))
            printf("Failed test %d; result = \"%s\"\n", i, result);
    }
    return EXIT_SUCCESS;
}

— टोबी स्पाईट
स्रोत

2

आर, 76 बाइट्स

function(a,b,c){s=substr;for(x in 1:nchar(b)){a=sub(s(b,x,x),s(c,x,x),a)};a}

का उपयोग करता है subपहले मैच को बदलने के लिए है

Ungolfed

function(a,b,c){                    # function with 3 arguments as per description
  s=substr;                         # alias for substr (saves 1 byte)
   for(x in 1:nchar(b)){            # index 1 to number character in b
     a=sub(s(b,x,x),s(c,x,x),a)};   # replace first instance of b[x] in a  
                                    # with c[x] and reassign to a
 a}                                 # return a

— mnel
स्रोत

2

सी ++, 204 बाइट्स

golfed

#include<iostream>
#include<string>
int main(){std::string a, b, c;std::cin>>a>>b>>c;int t=0;for(int x=0;x<b.length();x++){t=a.find(b[x],t);if(t!=-1){a.replace(t,1,c.substr(x,1));}}std::cout<<a;return 0;}

Ungolfed

#include<iostream>
#include<string>

int main()
{
    std::string a, b, c;
    std::cin>>a>>b>>c;
    int t = 0;
    for (int x=0;x<b.length();x++) {
        t = a.find(b[x], t);
        if (t != -1) {
            a.replace(t,1,c.substr(x, 1));
        }
    }
    std::cout<<a;
    return 0;
}

— मिशेलफ्रांसिस बस्टिलोस
स्रोत

मुझे नहीं लगता कि आप का उपयोग stdकरने के लिए काफी वारंट का उपयोग कर रहे हैं using namespace std;। का उपयोग करना std::cin, std::coutऔर std::string5 बाइट्स को बचाएंगे क्योंकि यह उन नामस्थानों का एकमात्र उपयोग प्रतीत होता है।

— वैल्यू इंक

@KevinLau धन्यवाद! आप बहुत सही हैं, मैंने सोचा कि, लेकिन वास्तव में यह एहसास नहीं था कि यह चार्ट को बचाएगा।

— मिशेलफ्रिस बस्टिलोस

ओह! एक बात और, क्योंकि यह महत्वपूर्ण है। फिर अपने कोड से अधिक पढ़ने के बाद मुझे एहसास हुआ कि आप लालच के भीतर प्रत्येक पत्र का सबसे बाईं ओर घटना स्थान ले रही हैं bमें a, लेकिन बाद में पत्र साथ ही पहले पत्र के बाद होना चाहिए। (परीक्षण के मामले 3 को देखें और अपने आउटपुट के साथ तुलना करें, मुझे लगता है कि आप पाएंगे कि abc21ed...अपेक्षित आउटपुट होने पर आपका कोड आउटपुट होगा abcd1e2...!)

— मूल्य इंक

10 मिनट पहले कोड के ऊपर "Adregffftd \ nA23 \ nzac \ n" के विचारक C ++ 14 संकलक इनपुट में, "Adregffftd" के बजाय "zdregffftd" का आउटपुट उत्पन्न करें

— RosLuP

2

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

.+$
$&¶;$&
+`^(.)(.*¶)(.)([^;]+);(.*?)\1
$2$4$5$3;
A1`
;

G2=`.

इनपुट B, क्रम में लिया जाता है , और C, Aलाइनफीड द्वारा अलग किया जाता है।

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

— मार्टिन एंडर
स्रोत

2

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

x@((a,b):c)#(d:e)|a==d,([],z)<-c#e=([],b:z)|0<1=(d:)<$>x#e
x#y=(x,y)
a!b=snd.(zip a b#)

मैंने हास्केल उत्तर की कमी पर ध्यान दिया और इसे ठीक करने का निर्णय लिया। यह !तर्क क्रम पैटर्न-प्रतिस्थापन-स्ट्रिंग के साथ एक टर्नरी फ़ंक्शन को परिभाषित करता है । इसे यहाँ आज़माएँ।

व्याख्या

सहायक फ़ंक्शन चरित्र जोड़े (पैटर्न और प्रतिस्थापन) और एक स्ट्रिंग की #एक सूची लेता है । यदि "पैटर्न" अक्षर इसके बाद के रूप में बनते हैंxyxy , तो यह खाली सूची देता है और yप्रत्येक प्रतिरूप चरित्र को इसके समकक्ष द्वारा बदल दिया जाता है। अन्यथा, यह जोड़ी लौटाता है (x,y)। फ़ंक्शन !पैटर्न को बदलता है और प्रतिस्थापन स्ट्रिंग, तीसरे स्ट्रिंग xपर लागू होता #है xऔर परिणाम का दूसरा घटक देता है।

x@((a,b):c)#(d:e)  -- First case of #: both arguments nonempty.
  |a==d,           -- If the pattern char matches the string's head,
   ([],z)<-c#e     -- and the pattern's tail is a subsequence of the string's tail,
  =([],b:z)        -- tack the replacement char to the recursion result.
  |0<1             -- Otherwise,
  =(d:)<$>x#e      -- recurse with the same pairs and tack string's head to result.
x#y=(x,y)          -- If either argument is empty, just pair them.

यदि पैटर्न स्ट्रिंग की एक अनुवर्तीता है, तो कोड O (n) समय में चलता है , जिससे स्ट्रिंग के माध्यम से एक पुनरावर्ती पास बन जाता है और प्रक्रिया में प्रतिस्थापन का लालची निर्माण होता है। हालांकि, यदि पैटर्न एक अनुवर्ती नहीं है, तो यह अंदर चलता है ओ (2 ^एन ) समय में सबसे खराब स्थिति में चलता है। इसका कारण यह है कि हर स्थिति पर जहां पैटर्न और स्ट्रिंग का एक मिलान चरित्र होता है, फ़ंक्शन खुद को यह जांचने के लिए कॉल करता है कि क्या पैटर्न वास्तव में एक अनुवर्ती है, पता चलता है कि यह नहीं है, और वास्तव में परिणाम की गणना करने के लिए खुद को दूसरी बार कॉल करता है।

— Zgarb
स्रोत

2

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

(a,b,c)=>1?(t=[...a].map(e=>b[0]==e?(u=c[0],b=b.slice(1),c=c.slice(1),u):e).join``,b==""?t:a):a

यह एक मान्य जावास्क्रिप्ट लैम्बडा फ़ंक्शन है। फ़ंक्शन के रूप में आउटपुट return। तीन तर्कों में लेता है ( a,b,c)। f=शुरुआत में जोड़ें और जैसे आह्वान करें f(arg1,arg2,arg3)।

f=(a,b,c)=>1?(t=[...a].map(e=>b[0]==e?(u=c[0],b=b.slice(1),c=c.slice(1),u):e).join``,b==""?t:a):a

console.log(f(prompt("Value for A"),prompt("Value for B"),prompt("Value for C")))

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

— अर्जुन
स्रोत

PPCG में आपका स्वागत है! फ़ंक्शंस आम तौर पर स्वीकार्य होते हैं , इसलिए आपको f=तब तक ज़रूरत नहीं है जब तक कि आपका फ़ंक्शन पुनरावर्ती न हो, लेकिन ऐसा नहीं दिखता है।

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

@ मार्टिनबटनर धन्यवाद! :) मेरा जवाब अपडेट किया।

— अर्जुन

दुर्भाग्य से, यदि aपैटर्न शामिल नहीं है तो यह विफल हो जाएगा । मुझे यकीन नहीं है कि स्ट्रिंग्स का एक सरणी स्वीकार्य है।

— डेनिस

@ डेनिस मैंने अपना समाधान अपडेट कर दिया है। मुझे लगता है कि अब यह सही है। इस तरह के उत्तर और अपडेशन के लिए क्षमा करें। (मैंने सिर्फ आपकी टिप्पणी पर ध्यान दिया, इसलिए देरी हुई)

— अर्जुन

@MartinEnder जब मैं अपने सभी समाधानों से गुजर रहा था, मैंने पाया कि यह गलत था। लेकिन, मैंने इसे अब ठीक कर दिया है; और यह पांच बाइट्स छोटा है (क्योंकि मैंने कई गोल्फ वाले स्थानों को छोड़ दिया था, मैं उस समय एक नौसिखिया गोल था, ऐसा नहीं था कि मैं अब महान हूं, हालांकि: पी)। गलत समाधान पोस्ट करने के लिए क्षमा करें।

— अर्जुन

2

C (gcc), 67 62 61 59 बाइट्स

f(s,a,b)char*s,*a,*b;{*s==*a?*s=*b++,a++:1;*a&&f(s+1,a,b);}

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

— betseg
स्रोत

1

ऑक्टेव, 97 बाइट्स

function A=U(A,B,C)t=0;for s=B if p=find(A(t+1:end)==s,1) D(t=p+t)=~0;else return;end;end;A(D)=C;

बदलने के लिए बाद में खत्म; पहले चरित्र की पहली घटना खोजें, शेष स्ट्रिंग में अगला चरित्र ढूंढें, दोहराएं। इसमें से एक दिलचस्प सा है:

D(t=p+t)=~0

D(     )      %// D is a logical mask of characters to replace in the input string
  t=p+t       %// t is the current end of D 
              %// p is the location of the character to replace
              %// update t and use as index to grow D
        =~0   %// make it so, number 1

चूंकि विचारधारा अभी भी '' के अलावा अन्य नामों के साथ कार्यों को स्वीकार नहीं कर रही है, मैं सिर्फ यहां एक नमूना चलाऊंगा। इनपुट केवल संक्षिप्तता के लिए पहले कुछ परीक्षण मामलों के लिए दिखाए जाते हैं। keyअपेक्षित आउटपुट ansहै, फंक्शन आउटपुट है।

A = abcdefghijklmnopqrstuvwxyz
B = ghost
C = 12345
key = abcdef12ijklmn3pqr45uvwxyz
ans = abcdef12ijklmn3pqr45uvwxyz
A = abcdeedcba
B = ada
C = BOB
key = BbcOeedcbB
ans = BbcOeedcbB
A = abcdeedcbaabcde
B = ed
C = 12
key = abcd1e2cbaabcde
ans = abcd1e2cbaabcde
key = aBc
ans = aBc
key = abcde
ans = abcde
key = ABC
ans = ABC
key = 0123T5678901T34567890123456789
ans = 0123T5678901T34567890123456789
key = edcbaedcbaedcbaedcba
ans = edcbaedcbaedcbaedcba
key = edcb1edc2aed3bae4cba5dcba
ans = edcb1edc2aed3bae4cba5dcba
key = dcrcdadca
ans = dcrcdadca
key = aacbcbabcccaabcbabcaabbbbca
ans = aacbcbabcccaabcbabcaabbbbca
key = 1ac2cb2bccc33b3bab4aa4bbbc44
ans = 1ac2cb2bccc33b3bab4aa4bbbc44

— बीकर
स्रोत

अप्रत्याशित स्थानों में वे ऑक्टेव असाइनमेंट ( D(t=...)) मुझे

— गुदगुदाते

1

@LuisMendo haha ... यह लगभग एक स्टैक की तरह है ...! :)

— बीकर

1

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

एक अलग दृष्टिकोण जिसे मैं साझा करना चाहता था, जो कि कुछ बाइट्स कम है। मानक पुस्तकालय / रेगेक्स के खिलाफ कोई नियम नहीं हैं, है ना?

import re
j=''.join
m='(.*?)'
def f(A,B,C):
 *r,l=(re.findall(m+m.join(B)+'(.*)',A)or[[A]])[0]
 print(j(map(j,zip(r,C)))+l)

पुनश्च। यह मेरा पहला गोल्फ है। मुझे किसी भी मुद्दे / सुधार के बारे में बताएं।

— मार्क जे
स्रोत

1

पायथ, 22 बाइट्स

|eJ:Ej"(.*?)"+E\$3s.iJ

Pyth Compiler में सभी परीक्षण मामलों को सत्यापित करें ।

पृष्ठभूमि

हम पैटर्न से एक regex बनाते हैं $और एक जोड़कर(.*?) सभी वर्णों के बीच । यह रेगेक्स उसके तत्वों के बीच प्रतिस्थापित होने और कुछ भी करने के लिए, और स्ट्रिंग के अंत तक कुछ भी मैच करेगा।

चूंकि क्वांटिफायर आलसी होते हैं, प्रत्येक (.*?)संभव के रूप में कुछ वर्णों से मेल खाएगा।

पैटर्न भूत के लिए, निर्मित रेगेक्स है g(.*?)h(.*?)o(.*?)s(.*?)t(.*?)$।

यदि पैटर्न इनपुट से मेल खाता है, तो बिलिन r<str><regex>3एक सरणी लौटाएगा जिसमें आधार (उसके बाद का सब कुछ), सभी कैप्चर किए गए समूह (बाद में और बाद में सब कुछ), और पोस्टमैच (खाली स्ट्रिंग) होगा।

यदि पैटर्न मेल नहीं खाता है, तो अंतर्निहित इनपुट के साथ बिलियन एक सिंगलटन सरणी लौटाएगा।

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

|eJ:Ej"(.*?)"+E\$3s.iJQ  (implicit) Store the first line of input in Q.

             +E\$        Read the third line of input (pattern) and append '$'.
     j"(.*?)"            Join the result, separating by "(.*?)".
    E                    Read the third line of input (string).
   :             3       Match the string against the regex, as detailed above.
  J                      Save the returned array in J.
 e                       Extract the last element of J. This is an empty string
                         for a successful match or the original string.
|                        Logical OR; replace an empty string with the following:
                   .iJQ    Interleave J and the replacement.
                  s        Flatten the resulting array of strings.

— डेनिस
स्रोत

1

जेली , 23 बाइट्स

Ṭœpż⁵
0ẋai1
⁴='-;ç\ñ⁴P?

यह मेरे अन्य जेली उत्तर की तुलना में दो बाइट्स लंबा है , लेकिन यह तुरंत खत्म हो जाता है। इसे ऑनलाइन आज़माएं!

सत्यापन

$ head -n 5 test-cases
abcdefghijklmnopqrstuvwxyz
ghost
12345
abcdef12ijklmn3pqr45uvwxyz

$ cat subseq-fast
while read s; do
        read p; read r; read o; echo $o; read
        timeout 10s jelly eun $1 "Ṭœpż⁵¶0ẋai1¶⁴='-;ç\ñ⁴P?" "'$p'" "'$s'" "'$r'"
        (($?)) && echo '(killed)'
done < test-cases
$ ./subseq-fast
abcdef12ijklmn3pqr45uvwxyz
abcdef12ijklmn3pqr45uvwxyz
BbcOeedcbB
BbcOeedcbB
abcd1e2cbaabcde
abcd1e2cbaabcde
aBc
aBc
abcde
abcde
ABC
ABC
0123T5678901T34567890123456789
0123T5678901T34567890123456789
edcbaedcbaedcbaedcba
edcbaedcbaedcbaedcba
edcb1edc2aed3bae4cba5dcba
edcb1edc2aed3bae4cba5dcba
dcrcdadca
dcrcdadca
aacbcbabcccaabcbabcaabbbbca
aacbcbabcccaabcbabcaabbbbca
1ac2cb2bccc33b3bab4aa4bbbc44
1ac2cb2bccc33b3bab4aa4bbbc44

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

⁴='-;ç\ñ⁴P?  Main link. Arguments: pattern p, string s, replacement r

⁴='          Compare each character of s with each character of p.
             This yields a 2D list. Each row corresponds to a char in p.
   -;        Prepend -1 to the 2D list, yielding a ragged array.
     ç\      Cumulatively reduce the array by the second helper link.
         P?  If the product of the resulting list is non-zero:
       ñ       Call the first helper link with the list and s as arguments.
        ⁴      Else, return s.


Ṭœpż⁵        First helper link. Arguments: L (list of indices), r (replacement)

Ṭ            Truth; generate a list with 1's at those indices.
 œp          Partition; split s at all 1's, removing those characters.
   ż⁵        Zip the partition with r.


0ẋai1        Second helper link. Arguments: n (integer), B (list of Booleans)

0ẋ           Generate a list of n zeroes.
  a          Perform logical AND with B.
             This zeroes out the with n elements of B.
   i1        Compute the first index of 1.

— डेनिस
स्रोत

1

सीजेएम, 29 बाइट्स

l_ll.{2$#_3$<@+\)@>}s_2$,>@@?

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

— डेनिस
स्रोत

1

जावा 7, 102 बाइट्स

void L(char[]s,char[]l,char[]r){for(int x=0,y=0;x<s.length&&y<l.length;x++)if(s[x]==l[y])s[x]=r[y++];}

विस्तृत यहाँ देखें

// String, Lookup, Replacement
void L(char[]s, char[]l, char[]r)
{
    for(int x=0, y=0; x < s.length && y < l.length; x++)
        if(s[x] == l[y])
            s[x] = r[y++];
}

— Khaled.K
स्रोत

1

जूलिया, 93 90 86 बाइट्स

f(s,p,r)=(try s=join([match(Regex(join("^$p\$","(.*?)")),s).captures';[r...""]])end;s)

यदि मैच सफल था तो अलग से परीक्षण करने से स्कोर नष्ट हो जाता है। एक प्रतिस्थापन के लिए कास्टिंग की आवश्यकता होगी Base.SubstitutionString, जो शायद इसके लायक नहीं है ...

परीक्षण चालन

julia> f(s,p,r)=(try s=join([match(Regex(join("^$p\$","(.*?)")),s).captures';[r...""]])end;s)
f (generic function with 1 method)

julia> f("aacbcbabcccaabcbabcaabbbbca","abaaaccbac","1223334444")
"aacbcbabcccaabcbabcaabbbbca"

julia> f("aacbcbabcccaabcbabcaabbbbcac","abaaaccbac","1223334444")
"1ac2cb2bccc33b3bab4aa4bbbc44"

— डेनिस
स्रोत

1

जूलिया, 62 59 58 बाइट्स

f(s,p,r)=(try s[[i=findnext(s,c,i+1)for c=p]'],i=r,0end;s)

I / O चरित्र सरणियों के रूप में है।

सत्यापन

julia> f(s,p,r)=(try s[[i=findnext(s,c,i+1)for c=p]'],i=r,0end;s)
f (generic function with 2 methods)

julia> F(s,p,r)=join(f([s...],[p...],[r...])) # string/char array conversion
F (generic function with 1 method)

julia> F("aacbcbabcccaabcbabcaabbbbca","abaaaccbac","1223334444")
"aacbcbabcccaabcbabcaabbbbca"

julia> F("aacbcbabcccaabcbabcaabbbbcac","abaaaccbac","1223334444")
"1ac2cb2bccc33b3bab4aa4bbbc44"

— डेनिस
स्रोत

1

PHP, 130 109 बाइट्स

मैं अभी भी इसे कम पसंद करता हूं; ""<अगर Bनहीं होने की गारंटी दी गई थी तो 3 बाइट्स ( ) बचा सकता है 0।

for($s=($a=$argv)[1];""<$c=$a[2][$i++];)if($p=strpos(_.$s,$c,$p+1))$s[$p-1]=$a[3][$k++];echo$k<$i-1?$a[1]:$s;

कमांड लाइन से तर्क लेता है। साथ चलाना -r।

वर्णों को प्रतिस्थापित करता है जब यह उन्हें पाता है;
यदि सभी वर्णों को बदल दिया गया है तो प्रिंट की प्रतिलिपि; मूल और।

— टाइटस
स्रोत

1

रूबी, 70 64 59 58 बाइट्स

अनाम फ़ंक्शन। aअगले वर्ण के अनुसार प्रतिस्थापित अक्षरों के साथ एक नई स्ट्रिंग बनाने के लिए स्ट्रिंग के माध्यम से चलें bऔर cफिर, यदि सभी वर्ण bअंत में समाप्त हो जाते हैं, तो नवनिर्मित स्ट्रिंग वापस करें, अन्यथा मूल स्ट्रिंग वापस करें।

@ हिस्टोक्रेट ने 6 बाइट्स को बचाने में मदद की gsub।

@ ब्यॉय को 1 बाइट धन्यवाद दिया।

->a,b,c{i=0;s=a.gsub(/./){$&==b[i]?c[~-i+=1]:$&};b[i]?a:s}

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

— मूल्य स्याही
स्रोत

आप को बदल कर एक बाइट बचा सकता है -1+i+=1के साथ~-i+=1

— Cyoce

0

पर्ल, 80 + 1 = 81 बाइट्स

-pझंडे के साथ भागो

$a=join"(.*?)",split//,<>;$b.=$_." .\$".++$;."."for split//,<>;chop$b;s/$a/$b/ee

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

कोड प्रक्रियात्मक रूप से एक खोज और रीगेक्स कमांड को प्रतिस्थापित करता है, जिसे वह कोड के अंतिम बिट में निष्पादित करता है।

ghostपहले उदाहरण में स्ट्रिंग स्ट्रिंग में बदल जाती है g(.*?)h(.*?)o(.*?)s(.*?)t(.*?), जिसका अर्थ gहै 0 या उससे अधिक वर्णों का अनुसरण, उसके hबाद 0 या उससे अधिक वर्ण, उसके बाद आदि।*? क्वांटिफायर का अर्थ है कि खोज गैर-लालची और "गॉबल होना चाहिए। "जितना संभव हो उतना मिलान के डिफ़ॉल्ट के बजाय, संभव के रूप में कुछ वर्ण।

स्ट्रिंग 12345तब बदल जाती है 1 .$1.2 .$2.3 .$3.4 .$4.5 .$5, जिसका मूल्यांकन regex के प्रदर्शन के बाद हो जाता है। प्रत्येक $1,$2,$3,$4,$5वास्तव में पहले स्ट्रिंग से कैप्चर समूह (कोष्ठक में) के लिए एक बैकरेस्ट है।

— गेब्रियल बेनामी
स्रोत

मैं कुछ बाइट्स को बचाने के लिए इस कोड का सुझाव देता हूं perl -pe 'eval"s/".<>=~s/.\K/(.*?)/gr."/".<>=~s/.\K/"\${".++$i."}"/gre."/"':। अपने आप से इसके साथ आया, लेकिन यह आपके काफी करीब है, इसलिए मैं इसे पोस्ट नहीं करूंगा, यह दो बहुत ही करीबी जवाब होंगे, लेकिन आपका संपादन करने के लिए स्वतंत्र महसूस करें!

— दादा

बस इस पर जाना था क्योंकि मैंने इसे हाल की समस्या के लिए "संबंधित" प्रश्न के रूप में सूचीबद्ध देखा। मुझे सबसे अच्छा मिला

perl -E 'chomp(($f,$t,$s)=(<>));$f=join"(.*?)",split"",$f;@r=split"",$t;@t=shift@r;push@t,"\${",++$x,"}"for(@r);$t=join"",@t;say$s=~s/$f/$t/r;'

— विल क्रॉफर्ड

0

क्लोजर, 113 बाइट्स

#(apply str((reduce(fn[[b c r]a](if(=(first b)a)[(rest b)(rest c)(conj r(first c))][b c(conj r a)]))[%2%3[]]%)2))

एक बुनियादी reduce, उन सभी के बारे में बहुत खुश नहीं है first, restऔर conjफ़ंक्शन कॉल करते हैं। बेहतर दृष्टिकोण देखने की उम्मीद है।

— NikoNyrh
स्रोत

बाद में प्रतिस्थापन

नियम

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

लीडरबोर्ड

जेली , 23 22 21 बाइट्स

सत्यापन

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

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

जावा 7, 141

लूआ, 121 बाइट्स

Ungolfed

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

पायथन 3.5, 87 बाइट्स

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

अजगर, २,

MATL , 33 बाइट्स

व्याख्या

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

स्पष्टीकरण / परीक्षण

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

जूलिया, 89 70 बाइट्स

सी, 98 बाइट्स

/ * विस्तारित कोड * /

/ * टेस्ट * /

आर, 76 बाइट्स

सी ++, 204 बाइट्स

golfed

Ungolfed

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

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

व्याख्या

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

C (gcc), 67 62 61 59 बाइट्स

ऑक्टेव, 97 बाइट्स

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

पायथ, 22 बाइट्स

पृष्ठभूमि

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

जेली , 23 बाइट्स

सत्यापन

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

सीजेएम, 29 बाइट्स

जावा 7, 102 बाइट्स

जूलिया, 93 90 86 बाइट्स

परीक्षण चालन

जूलिया, 62 59 58 बाइट्स

सत्यापन

PHP, 130 109 बाइट्स

रूबी, 70 64 59 58 बाइट्स

पर्ल, 80 + 1 = 81 बाइट्स

क्लोजर, 113 बाइट्स