Çoğu dil, belirli bir alt dizinin tüm oluşumları için bir dize aramak ve bunları bir diğeriyle değiştirmek için yerleşik olarak gelir. Bu kavramı (mutlaka bitişik değil) alt dillere genelleyen herhangi bir dil bilmiyorum. Demek bu görevde senin görevin bu.

Giriş üç teli oluşacak A, Bve C, burada Bve Caynı uzunluğa sahip olduğu garanti edilir. Bir ek olarak Bgöründüğünde, Aile değiştirilmelidir C. İşte basit bir örnek:

A: abcdefghijklmnopqrstuvwxyz
B: ghost
C: 12345

Böyle işlenirdi:

abcdefghijklmnopqrstuvwxyz
      ||      |   ||
abcdef12ijklmn3pqr45uvwxyz

Bir ek olarak bulmanın birkaç yolu varsa B, en soldaki yerine yavaşça değiştirmelisiniz:

A: abcdeedcba
B: ada
C: BOB

Result:   BbcOeedcbB
and NOT:  BbcdeeOcbB

Aynı şey Bbirden fazla ayrık yerde de bulunabilirse geçerlidir :

A: abcdeedcbaabcde
B: ed
C: 12

Result:   abcd1e2cbaabcde
and NOT:  abcd112cbaabc2e (or similar)

Ne zaman Bgörünmez Açıkış gerektiği, Adeğişmez.

kurallar

Yukarıda belirtildiği gibi, üç dizeleri almak A, Bve Cgirdi olarak ve sol-en tekrarlamasını değiştirmek Bde bir alt diziyle olarak Asahip Cherhangi varsa,.

STDIN (veya en yakın alternatif), komut satırı argümanı veya işlev argümanı yoluyla giriş alarak ve sonucu STDOUT (veya en yakın alternatif), fonksiyon dönüş değeri veya function (out) parametresi ile çıktı alarak bir program veya işlev yazabilirsiniz.

Üç dizeyi, cevabınızda belirtmeniz gereken tutarlı bir sıraya göre alabilirsiniz. Bunu varsayabilir Bve Caynı uzunlukta olabilirsiniz. Tüm dizeler sadece alfasayısal karakterler içerecektir.

Standart kod-golf kuralları geçerlidir.

Test Kılıfları

Her bir test durumda dört hatları A, B, Csonuç takip eder.

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

Liderler Sıralaması

Bu yazının altındaki Yığın Parçacığı, cevaplardan a) dil başına en kısa çözümün bir listesi olarak ve b) genel bir lider tablosu olarak oluşturur.

Cevabınızın göründüğünden emin olmak için, lütfen aşağıdaki Markdown şablonunu kullanarak cevabınızı bir başlık ile başlatın:

## Language Name, N bytes

Gönderinizin Nbüyüklüğü nerede ? Puanınızı artırmak varsa, olabilir onları içinden vurarak, başlığa eski hesapları tutmak. Örneğin:

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

Başlığınıza birden fazla sayı eklemek istiyorsanız (örneğin, puanınız iki dosyanın toplamı olduğundan veya tercüman bayrağı cezalarını ayrı ayrı listelemek istediğiniz için), gerçek puanın başlıktaki son sayı olduğundan emin olun :

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

Dil adını, daha sonra pasajda görünecek bir bağlantı da yapabilirsiniz:

## [><>](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>

Jöle , 23 22 21 bayt

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

Çevrimiçi deneyin! Son iki test durumunun hafızasının tükeneceğini unutmayın.

Doğrulama

$ 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)

Nasıl çalışır

='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.

Python 2,8 bayt

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>'']

Üç dizgiyi alan ve sonucu STDOUT'a veren bir işlev. İşlev, dizgeden bir tane geçirir, uygun karakteri alır ve b,cdevam ettikçe güncellenir .

Test için ( printile değiştirdikten sonra return):

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

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

Java 7, 141

Sanırım bu konuda daha fazla şey yapabilirim, ama şimdilik kaçmalıyım. Sadece basit bir yineleme / değiştirme, A ve B'de bir dizin tutuyor

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;}

Zevkiniz için boşluklu:

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;
}

Lua, 121 Bayt

Basit çözüm, gsub her karakter üzerinde tam olarak bir kez yinelememize ve bunları dizenin yeni bir örneğinde değiştirmemize olanak tanır.

3 komut satırı argümanı ile girdi alır ve STDOUT a dize çıkar.

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

Python 3, 127 bayt.

Katenkyo sayesinde 16 bayt kaydedildi.

Hala bu konuda biraz çalışıyor, adam düşündüğümden daha acayipti.

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

Açıklama: Evet, özyineleme.

Test durumları:

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

Python 3.5, 87 bayt

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

Tüm test durumları doğrulamak için repl.it .

Nasıl çalışır

• '(.*?)'.join(p) değiştirilecek sırayı ve elemanları arasında bir şey uyan bir arama paterni oluşturur.

  Niceleyiciler tembel olduğundan, her biri (.*?)mümkün olduğunca az karakterle eşleşir.

  Desen için ghost, oluşturulan regex g(.*?)h(.*?)o(.*?)s(.*?)t.

• '\g<%d>'.join(r)%(*range(1,len(r)),) dize biçimlendirmesini kullanarak değiştirme dizesini oluşturur.

  Her \g<n>atıfta n ^inci gibi, yakalanan grubun \nederim.

  Değiştirme için 12345, oluşturulan dize 1\g<1>2\g<2>3\g<3>4\g<4>5.

• re.sub(...,...,s,1)dizede en fazla bir değiştirme işlemi gerçekleştirir s.

Pyth, 27

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

Test odası

Test paketi, son iki durumu göz ardı eder çünkü hafızası tükenir. Burada kullanılan algoritma, ilk dizgideki ikinci dizgideki her karakterin tüm dizinlerini bulmak, daha sonra bu dizgelerin tüm olası sıralarını bulmak ve yalnızca sıralı sırayla dizgileri almaktır. Ardından, üçüncü dizeden gelen değerlerle güncellemek için ilk dizideki dizinlerin listesi olarak bunlardan ilki sıralı sırayla kullanın.

Şundan kısa bir şeyler olması gerektiğini düşünüyorum .nM*F.

MATL , 33 bayt

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

Çevrimiçi deneyin!

açıklama

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)

JavaScript (ES6), 84 bayt

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

Açıklama / Test

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`);

JavaScript (ES6), 84 76 bayt

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

Çünkü bunun RegExp için bir iş olduğuna emindim.

Düzenleme: @ MartinBüttner ♦ sayesinde 8 bayt kaydedildi.

@ KevinLau'nun Ruby cevabının limanı 82 byte aldı:

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

Ayrıca özyinelemeli bir RegExp çözümü denedim ama bu 90 bayt aldı:

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

Julia, 89 70 bayt

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

iModel / değiştirme dizgileri boyunca ilerledikçe yinelenmek için bir dizin kullanır . @Dennis sayesinde -19 bayt!

C, 98 bayt

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;}

/ * Genişletilmiş kod * /

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;
}

Argümanlar: i nput string, o utput buffer, s earch string, r eplacement.

Girdi ve çıkışın başlangıcını hatırladıktan sonra, girişte yürüdüğümüzde, yerine geçenleri değiştirip ilerletiriz. Sonunda, değiştirmelerimiz bittiyse, çıktı tamponunu, değiştirilmemiş girişi geri döndürün.

/ * Testler * /

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;
}

R, 76 bayt

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

kullanımları subilk eşleşmeyi değiştirmek için

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

C ++, 204 bayt

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;
}

Retina , 63 bayt

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

G2=`.

Girdi sırayla alınır B, C,A , hat beslemeleri ile birbirlerinden ayrılmıştır.

Çevrimiçi deneyin.

Haskell, 87 bayt

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#)

Bir Haskell cevabının eksikliğini fark ettim ve düzeltmeye karar verdim. Bu, !argüman sırasına göre kalıp değiştirme dizesini içeren bir üçlü işlevi tanımlar . Burada dene.

açıklama

Yardımcı işlev , karakter çiftlerinin #bir listesini x(desen ve değiştirme) ve bir dizeyi alır y. Eğer "kalıp" karakterleri xbir sırasını oluşturuyorsa y, boş listeyi ve yher kalıp karakterinin karşılığı ile değiştirilir. Aksi takdirde pariteyi döndürür (x,y). Fonksiyon !içine desen ve yedek dizeleri fermuarlar xgeçerlidir, #için xve üçüncü dize ve sonucun ikinci bileşenini döndürür.

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.

Desen dizenin bir alt dizisiyse, kod içinde çalışır. bir alt dizisiyse O (n) zamanında , dizenin içinden özyinelemeli bir geçiş yapılır ve işlemin yerine büyük bir şekilde yapılır. Bununla birlikte, eğer kalıp bir sıra değilse , en kötü durumda O (2 ⁿ ) zamanda çalışır . Bunun nedeni, kalıbın ve dizginin eşleşen bir karaktere sahip olduğu her pozisyonda, fonksiyonun, kalıbın gerçekten bir aldatmaca olup olmadığını kontrol etmek için kendisini çağırması, bunun olmadığını tespit etmesi ve sonucu gerçekten hesaplamak için kendisini ikinci kez çağırmasıdır.

JavaScript (ES6), 100 95 bayt

(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

Bu geçerli bir JavaScript Lambda işlevidir. İşlev olarak çıktı verir return. Üç argüman alır ( a,b,c). f=Başlangıçta ekleyin ve benzeri çağırır 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")))

C (gcc), 67 62 61 59 bayt

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

Çevrimiçi deneyin!

Oktav, 97 bayt

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;

Yerine koyma sırasını yineleyin; ilk karakterin ilk oluşumunu bulun, kalan dizgede bir sonraki karakteri bulun, tekrarlayın. Bunun ilginç bir kısmı:

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

İdeone hala isimleri '' dışında isimlerle kabul etmediğinden, burada çalışan bir örnek bırakacağım. Girdiler yalnızca kısalıklık için ilk birkaç test durumu için gösterilmektedir. keybeklenen çıktı, ansişlev çıktıdır.

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

Python 3, 123 Bayt

Paylaşmak istediğim farklı bir yaklaşım, birkaç byte daha kısa. Standart kütüphane / regex'e karşı kural yok, değil mi?

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)

PS. Bu benim ilk golf. Herhangi bir sorun / iyileştirme hakkında bana bildirin.

Pyth, 22 bayt

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

Pyth Derleyicisindeki tüm test durumlarını doğrulayın .

Arka fon

Ekleyerek $ve ekleyerek kalıptan bir regex oluştururuz.(.*?)Tüm karakterlerin arasına . Bu regex, değiştirilecek sırayı ve elemanları arasındaki herhangi bir şeyi ve dizenin sonuna kadar olanı eşleştirir.

Niceleyiciler tembel olduğundan, her biri (.*?)mümkün olduğunca az karakterle eşleşir.

Desen hayalet için, inşa regex g(.*?)h(.*?)o(.*?)s(.*?)t(.*?)$.

Desen girişle eşleşirse, yerleşik r<str><regex>3 ön prematüre (sonuçtan önceki her şey), yakalanan tüm gruplara (sıradan sonra ve sonraki her şey) ve posta eşlemesine (boş dize) sahip bir dizi döndürür.

Kalıp uyuşmuyorsa, yerleşik orijinal girişi içeren bir singleton dizisi döndürür.

Nasıl çalışır

|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.

Jöle , 23 bayt

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

Bu benim diğer Jelly cevabımdan iki byte daha uzun , fakat anında bitiyor. Çevrimiçi deneyin!

Doğrulama

$ 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

Nasıl çalışır

⁴='-;ç\ñ⁴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.

CJam, 29 bayt

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

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Java 7, 102 bayt

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++];}

Detaylı burada deneyin

// 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++];
}

Julia, 93 90 86 bayt

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

Maç başarılı olsaydı ayrı ayrı test etmek zorunda kaldıysanız skoru mahvederdi. Bir oyuncu değişikliğiBase.SubstitutionString , muhtemelen buna değmeyecek ...

Test sürüşü

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"

Julia, 62 59 58 bayt

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

G / Ç, karakter dizileri biçimindedir.

Doğrulama

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"

PHP, 130 109 bayt

Hala daha kısa olmasını isterdim; içermediği garanti ""<edilirse B, 3 byte ( ) tasarruf sağlayabilir 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;

komut satırından argümanları alır. İle koş-r .

Karakterleri bulduğunda değiştirir;
Tüm karakterler değiştirilmişse kopyayı basar; başka.

Ruby, 70 64 59 58 bayt

Anonim işlev aBir sonraki karaktere göre harfleri değiştirilen yeni bir dize oluşturmak için dize boyunca yürüyün bve cardından içerideki tüm karakterler bbitmişse, yeni oluşturulan dizeyi döndürün, aksi takdirde orijinal dizeyi döndürün.

@ histokrat 6 bayttan tasarruf sağladı gsub.

@Cyoce sayesinde 1 bayt kaydedildi.

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

Çevrimiçi deneyin!

Perl, 80 + 1 = 81 bayt

-pBayrakla koş

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

Çevrimiçi deneyin!

Kod yordamsal olarak daha sonra son kodunda çalıştırılan bir arama ve değiştirme regex komutu oluşturur.

Dize ghostilk örnekte dize dönüştü alır g(.*?)h(.*?)o(.*?)s(.*?)t(.*?)bir anlamı, gbir tarafından, 0 veya daha fazla karakter tarafından takip ardından hvb ardından 0 veya daha fazla karakter ardından *?arama silip süpürmek "olmayan açgözlü ve olması gerektiği miktar belirleyici araçlarının msgstr "" "mümkün olduğunca az karakter, mümkün olduğunca eşleştirmenin varsayılanı yerine.

Dize 12345sonra dönüşür1 .$1.2 .$2.3 .$3.4 .$4.5 .$5 , regex yapıldıktan sonra değerlendirilen bir hal alır. Her $1,$2,$3,$4,$5biri aslında ilk dizgeden bir parantez grubuna (parantez içinde) verilen bir geri dönüş niteliğindedir.

Clojure, 113 bayt

#(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))

Temel reduce, bütün uzun olanlar pek de mutlu görünmüyor first, restve conjişlev çağrıları. Daha iyi bir yaklaşım görmeyi umuyorum.