대부분의 언어에는 문자열이 제공되어 특정 하위 문자열이 나타나는 모든 항목을 검색하고 다른 하위 문자열로 대체합니다. 나는이 개념을 (연속적인 것은 아니지만) 서브 시퀀스로 일반화하는 언어를 모른다. 이것이 바로이 도전의 과제입니다.

입력은 세 문자열로 구성된다 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 (또는 가장 가까운 대안), 함수 리턴 값 또는 함수 (out) 매개 변수를 통해 결과를 출력하는 프로그램 또는 함수를 작성할 수 있습니다.

세 문자열을 일관된 순서로 받아 답에 명시해야합니다. 당신은 가정 수 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

리더 보드

이 게시물의 맨 아래에있는 스택 스 니펫은 답변 a) 언어별로 가장 짧은 솔루션 목록으로, b) 전체 리더 보드로 답변에서 리더 보드를 생성합니다.

답변이 표시되도록하려면 다음 마크 다운 템플릿을 사용하여 헤드 라인으로 답변을 시작하십시오.

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

젤리 , 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.

파이썬 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

자바 7, 141

나는 이것으로 할 수있는 일이 더 있다고 생각하지만 지금은 도망 가야합니다. A와 B의 인덱스를 유지하면서 단순한 반복 / 교체 일뿐입니다.

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

루아, 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)

언 골프

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

파이썬 3, 127 바이트

Katenkyo 덕분에 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'

파이썬 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 ^번째 캡처 그룹을 나타냅니다 \n.

  대체 12345를 위해 생성 된 문자열은 1\g<1>2\g<2>3\g<3>4\g<4>5입니다.

• re.sub(...,...,s,1)문자열에서 최대 하나의 대체를 수행합니다 s.

피스, 27

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

테스트 스위트

테스트 스위트는 메모리가 부족하여 마지막 두 경우를 생략합니다. 여기에 사용 된 알고리즘은 첫 번째 문자열에서 두 번째 문자열에서 각 문자의 모든 인덱스를 찾은 다음 해당 인덱스의 가능한 모든 순서를 찾고 정렬 된 순서로만 정렬합니다. 그런 다음이 중 첫 번째 문자열을 첫 번째 문자열의 인덱스 목록으로 정렬 된 순서대로 사용하여 세 번째 문자열의 값으로 업데이트하십시오.

나는 것보다 짧은 것이 있어야한다고 생각합니다 .nM*F...

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)

자바 스크립트 (ES6), 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`);

자바 스크립트 (ES6), 84 76 바이트

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

이것이 RegExp의 일이라고 확신했기 때문입니다.

편집 : @ MartinBüttner ♦ 덕분에 8 바이트가 절약되었습니다.

@KevinLau의 Ruby 응답 포트는 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

줄리아, 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우리가 가서 패턴 / 대체 문자열을 통해 반복합니다. @Dennis 덕분에 -19 바이트!

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

인수는 : 나는 캐릭터 nput, O utput 버퍼링 이야 earch 문자열 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;
}

R, 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첫 번째 경기를 대체

언 골프

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 바이트

골프

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

언 골프

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

레티 나 , 63 바이트

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

G2=`.

입력을 위해 촬영 B, C, A, 개행 문자에 의해 분리된다.

온라인으로 사용해보십시오.

하스켈, 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#)

나는 Haskell 답변이 없다는 것을 알았고 그것을 고치기로 결정했습니다. !인수 순서 pattern-replacement-string 으로 삼항 함수 를 정의 합니다. 여기에서 시도하십시오.

설명

보조 함수 #는 x문자 쌍 (패턴 및 대체) 및 문자열 목록 을 가져옵니다 y. "패턴"문자가 x의 하위 시퀀스를 구성 y하면 비어있는 목록을 반환하고 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) 시간에 실행되어 문자열 을 하나의 재귀 패스로 만들고 프로세스에서 대체를 욕심스럽게 구성합니다. 그러나 패턴이 하위 시퀀스가 ​​아닌 경우 최악의 경우 O (2 ⁿ ) 시간에 실행됩니다 . 패턴과 문자열에 일치하는 문자가있는 모든 위치에서 함수는 패턴 자체가 실제로 서브 시퀀스인지 여부를 확인하기 위해 자체를 호출하고 패턴이 아닌지 확인하고 실제로 결과를 계산하기 위해 두 번째로 호출하기 때문입니다.

자바 스크립트 (ES6), 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

이것은 유효한 JavaScript Lambda 함수입니다. 함수로 출력합니다 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")))

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

온라인으로 사용해보십시오!

옥타브, 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

ideone은 여전히 ​​''이외의 이름을 가진 함수를 허용하지 않으므로 여기서 샘플 실행을 남겨 두겠습니다. 입력은 간결성을 위해 처음 몇 가지 테스트 사례에 대해서만 표시됩니다.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

파이썬 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)

추신. 이것은 나의 첫 번째 골프입니다. 문제 / 개선 사항을 알려주십시오.

Pyth, 22 바이트

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

Pyth Compiler 에서 모든 테스트 사례를 확인하십시오 .

배경

패턴을 추가 $하고 배치 하여 패턴에서 정규식을 작성합니다.(.*?)모든 문자 사이에 . 이 정규식은 대체 할 서브 시퀀스와 해당 요소 사이의 문자열 및 문자열의 끝까지의 모든 항목과 일치합니다.

수량자는 게으 르기 때문에 각 (.*?)문자는 가능한 한 적은 문자와 일치합니다.

패턴 고스트의 경우 생성 된 정규식은 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.

젤리 , 23 바이트

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

이것은 다른 Jelly 답변 보다 2 바이트 길지만 즉시 끝납니다. 온라인으로 사용해보십시오!

확인

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

CJam, 29 바이트

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

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

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

줄리아, 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"

줄리아, 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"

PHP, 130 109 바이트

나는 여전히 더 짧은 것을 좋아합니다. 포함하지 않을 ""<경우 3 바이트 ( )를 절약 할 수 B있습니다 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 .

찾을 때 문자를 바꿉니다.
모든 문자를 교체 한 경우 사본을 인쇄합니다. 다른 원본.

루비, 70 64 59 58 바이트

익명의 기능. 문자열을 통해 걸어 a에서 다음 문자에 따라 대체 문자로 새로운 캐릭터를 구축 b하고 c다음, 모든 문자의 경우b 끝에 가 소진되면 새로 구성된 문자열을 반환하거나 그렇지 않으면 원래 문자열을 반환합니다.

@histocrat는 6 바이트를 절약하는 데 도움이되었습니다. gsub .

@Cyoce 덕분에 1 바이트를 절약했습니다.

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

온라인으로 사용해보십시오!

펄, 80 + 1 = 81 바이트

-p플래그로 실행

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

온라인으로 사용해보십시오!

이 코드는 절차 적으로 검색 및 바꾸기 regex 명령을 생성 한 다음 마지막 코드에서 실행됩니다.

문자열 ghost제 1 실시 예에 관한 문자열로 점등되고 g(.*?)h(.*?)o(.*?)s(.*?)t(.*?)을 의미g 함으로써 0 이상의 문자 뒤에 이어 h등 뒤에 0 이상의 문자 뒤에*? 검색이 중얼 '비 탐욕되어야한다는 정량화 수단 "최대한 일치하는 기본값 대신 가능한 한 적은 문자.

그러면 문자열 12345이로 바뀌고 1 .$1.2 .$2.3 .$3.4 .$4.5 .$5정규 표현식이 수행 된 후 평가됩니다. 각각 $1,$2,$3,$4,$5은 실제로 첫 번째 문자열에서 캡처 그룹 (괄호로 묶음)에 대한 역 참조입니다.

클로저, 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함수 호출. 더 나은 접근 방식을 기대합니다.