단어에서 문자를 왼쪽에서 오른쪽으로 정렬하여 입력 배열을 형성하도록 단어의 문자를 복제하는 프로그램 또는 함수를 작성하십시오.

예를 들면 다음과 같습니다.

input: chameleon, [c,a,l,n]
output: cchaamelleonn

입력

• 시작 단어 (예를 들어 chameleon)
• 문자 배열 ( [c,a,l,n]) 또는 배열 ( caln) 을 나타내는 문자열 또는 이와 유사한 것
• 함수 매개 변수, STDIN 또는 해당 언어를 통해 입력 가능
• 모든 입력은 소문자 (az)입니다.

산출

• 변경된 단어

• 여러 솔루션이있는 경우 모든 솔루션을 인쇄 할 수 있습니다

  input: banana [n,a]  
  possible outputs: bannaana, banannaa
                       |-|---------|-|--->[n,a]
  

• 입력 단어 (배열 일 필요는 없음)가 배열의 문자를 순서대로 가질 것이라고 가정 할 수 있습니다.

• 입력에 동일한 연속 문자가 없다고 가정 할 수도 있습니다 (애플, 괴짜, 녹색, 유리, 문 ...)

예

input: abcdefghij, [a,b,c]
output: aabbccdefghij

input: lizard, [i,a,r,d]
output: liizaarrdd

input: coconut, [c,o]
ouput: ccooconut or coccoonut or ccocoonut

input: onomatopoeia, [o,o,a,o,o]
output: oonoomaatoopooeia

input: onomatopoeia, [o,a,o]
output: oonomaatoopoeia or onoomaatoopoeia or oonomaatopooeia etc.

최단 프로그램이 승리합니다!

리더 보드 (스 니펫에 대한 Martin Büttner에게 감사)

/* Configuration */

var QUESTION_ID = 51984; // 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";

/* App */

var answers = [], page = 1;

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 getAnswers() {
  jQuery.ajax({
    url: answersUrl(page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      if (data.has_more) getAnswers();
      else process();
    }
  });
}

getAnswers();

var SIZE_REG = /\d+(?=[^\d&]*(?:<(?:s>[^&]*<\/s>|[^&]+>)[^\d&]*)*$)/;
var NUMBER_REG = /\d+/;
var LANGUAGE_REG = /^#*\s*([^,]+)/;

function shouldHaveHeading(a) {
  var pass = false;
  var lines = a.body_markdown.split("\n");
  try {
    pass |= /^#/.test(a.body_markdown);
    pass |= ["-", "="]
              .indexOf(lines[1][0]) > -1;
    pass &= LANGUAGE_REG.test(a.body_markdown);
  } catch (ex) {}
  return pass;
}

function shouldHaveScore(a) {
  var pass = false;
  try {
    pass |= SIZE_REG.test(a.body_markdown.split("\n")[0]);
  } catch (ex) {}
  return pass;
}

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

function process() {
  answers = answers.filter(shouldHaveScore)
                   .filter(shouldHaveHeading);
  answers.sort(function (a, b) {
    var aB = +(a.body_markdown.split("\n")[0].match(SIZE_REG) || [Infinity])[0],
        bB = +(b.body_markdown.split("\n")[0].match(SIZE_REG) || [Infinity])[0];
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  answers.forEach(function (a) {
    var headline = a.body_markdown.split("\n")[0];
    //console.log(a);
    var answer = jQuery("#answer-template").html();
    var num = headline.match(NUMBER_REG)[0];
    var size = (headline.match(SIZE_REG)||[0])[0];
    var language = headline.match(LANGUAGE_REG)[1];
    var user = getAuthorName(a);
    if (size != lastSize)
      lastPlace = place;
    lastSize = size;
    ++place;
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", user)
                   .replace("{{LANGUAGE}}", language)
                   .replace("{{SIZE}}", size)
                   .replace("{{LINK}}", a.share_link);
    answer = jQuery(answer)
    jQuery("#answers").append(answer);

    languages[language] = languages[language] || {lang: language, user: user, size: size, link: a.share_link};
  });

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

  langs.sort(function (a, b) {
    if (a.lang > b.lang) return 1;
    if (a.lang < b.lang) 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: 50%;
  float: left;
}

#language-list {
  padding: 10px;
  width: 50%px;
  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="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>
<div id="language-list">
  <h2>Winners 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>
<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>

Pyth, 14 바이트

s+L&@d<Q1.(QZz

데모.

입력 스타일 :

banana
["b","a","n","a"]

설명:

s+L&@d<Q1.(Q0z
                  Implicit: z = input(); Q = eval(input())
 +L          z    Map (lambda d) over z, adding the result to each character.
    @d<Q1         Intersection of d with Q[:1], up to the first element of Q.
   &              Logical and - if the first arg is truthy, evaluate and
                  return the second arg, otherwise return first arg.
         .(Q0     Q.pop(0)
                  The addition will either be the empty string, for the empty
                  intersection, or the character that was Q[0] otherwise.

s                 Concatenate and print.

Brainfuck, 46 45 (인쇄 가능한 문자가 입력 된 63)

Alex Pankratov의 bff (SPOJ 및 ideone에서 사용되는 brainfuck 인터프리터) 및 Thomas Cort의 BFI (Anarchy Golf에서 사용 )와 호환 됩니다.

인쇄 가능한 버전은 배열을 먼저 문자열로, 탭이 뒤 따르는 줄 바꿈없이 시작 문자열을 사용합니다.

이데온에 대한 데모 .

-[+>,---------]
<[++++++++<]
<,+
[
  -.
  [>+>-<<-]
  >>
  [
    <[>+<-]
  ]
  <[.[-]]
  ,+
]

\x00탭 대신 구분자 로 사용하여 일부 바이트를 저장할 수 있습니다 .

,[>,]
<[<]
<,+
[
  -.
  [>+>-<<-]
  >>
  [
    <[>+<-]
  ]
  <[.[-]]
  ,+
]

CJam, 15 바이트

rr{_C#)/(C@s}fC

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

작동 원리

rr              e# Read two whitespace-separated tokens from STDIN.
  {         }fC e# For each character C in the second string.
   _            e#   Duplicate the first string.
    C#          e#   Compute the index of the character in the string.
      )/        e#   Add 1 and split the string in slice of that size.
        (       e#   Shift out the first slice.
         C      e#   Push the character.
          @     e#   Rotate the remainder of the string in top of the stack.
           s    e#   Stringify (concatenate the slices).

C, 62 바이트

f(char*s,char*c){while(*s-*c||putchar(*c++),*s)putchar(*s++);}

글쎄, 이것은 놀랍게도 경쟁적입니다.

f(char*, char*)문자열을 첫 번째 입력으로 사용하고 문자 배열을 두 번째 입력으로 복제 하는 함수 를 정의합니다 .

일부 테스트 코드 :

int main (int argc, char** argv) {
    f("onomatopeia", "oao");
    return 0;
}

어떤 지문 :

oonomaatoopeia

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

이 함수가 아니라 매크로를 제출 받아 들일 경우, 다음은 #define g(s,c)그냥 58 바이트 만 필요 s하고 c실제 포인터 수 :

#define g(s,c)while(*s-*c||putchar(*c++),*s)putchar(*s++);

CJam, 15 바이트

rr{:X/(XX+@X*}/

대안적인 CJam 접근법. 온라인으로 사용해보십시오

설명

두 번째 문자열의 각 문자에 대해 두 가지 작업을 수행합니다.

1. 문자열의 현재 접미사를 문자로 나눕니다. 예 : "beeper" "e" -> ["b" "" "p" "r"]

2. 배열의 첫 번째 문자열을 uncons하고 문자 중 두 개를 삽입 한 다음 나머지 배열을 문자와 다시 결합합니다 (예 :) "b" "ee" "eper". 마지막 문자열은 새로운 접미사입니다.

레티 나, 33 바이트

Retina에 대한 추가 정보.

+`(?=(.))(((.)(?<!\4.))+\n)\1
$1$2

이것은 STDIN의 두 문자열을 줄 바꿈으로 구분하여 기대합니다.

계산을 위해 각 줄은 별도의 파일로 들어가 \n므로 실제 줄 바꿈 문자 (0x0A)로 바꿔야합니다. 실제로 이것을 테스트하려면이 파일을 \n그대로 있는 단일 파일에 넣고 Retina를 호출하는 것이 더 편리 합니다.-s 파일을 전달하기 전에 옵션으로 합니다.

설명

(구식입니다 ... 마커를 제거했습니다 ... 나중에 업데이트하겠습니다.)

각 쌍의 줄은 정규식 대체입니다 (첫 번째 줄은 패턴, 두 번째 줄은 대체).

^
#

이두고 #입력 문자열의 시작 마커로.

+`#(.*?(.))(.*\n)\2
$1$2#$3

그러면 복제 할 다음 문자에 해당하는 입력 (표식 뒤)에서 첫 번째 문자를 찾고 해당 문자를 복제하고 마커를 그 뒤로 이동하고 두 번째 문자열의 첫 번째 문자를 삭제합니다. +`앞에 문자열이 변경 멈출 때까지 (이 경우 두 번째 문자열이 비어 필요한 모든 문자가 중복 되었기 때문에,)를 반복해서이 작업을 수행하기 위해 망막을 알려줍니다.

#
<empty>

마지막으로 마커를 삭제하여 문자열을 정리합니다.

파이썬, 61

def f(s,l):b=s[:1]==l[:1];return s and-~b*s[0]+f(s[1:],l[b:])

욕심 많은 재귀 솔루션. b문자열 s의 첫 번째 l문자가 두 배 의 문자열 중 첫 번째 문자인지 저장합니다 . 그렇다면 해당 문자 중 하나를 가져 와서 나머지 부분이있는 재귀 호출 앞에 추가 s하여에서 첫 번째 요소를 제거하십시오 l. 그렇지 않은 경우 b똑같이하지만 문자를 두 배로 늘리지 말고에서 제거하지 마십시오 l.

이 코드는 또는 비어 있을 때 범위를 벗어난 인덱스 오류를 피하기 s[:1]==l[:1]보다는 검사합니다 .s[0]==l[0]sl

프롤로그, 95 83 79 56 바이트

d([A|S],H):-put(A),H=[A|T],put(A),d(S,T);d(S,H).
d(_,_).

예:

d(`chameleon`,`caln`).

보고

cchaamelleonn

편집 : Oliphaunt 덕분에 4 바이트 절약

Edit2 : put/1대신 사용되지 않는 SWI-Prolog 조건자를 사용하여 20 바이트를 절약했습니다 writef. 재귀 끝 조건 d([],_).자를로 바꾸는 1 바이트를 저장 했습니다 d(_,_).. d그러나 두 정의의 순서가 바뀌면 작동하지 않지만 골프 코드에서는 신경 쓰지 않습니다. 괄호를 제거하여 다른 2 바이트를 저장했습니다.H=[A|T],put(A),d(S,T)

파이썬 2, 83 74 72 65 바이트

여기서 특별한 트릭은 없습니다. x문자열이고, y중복 된 문자 배열입니다.이것이 제대로 복사되지 않는지를 명확히하기 위해 첫 번째 들여 쓰기 수준은 공백이고 다음은 탭입니다.

편집 1 : pop () 대신 문자열 조작을 사용하여 9 바이트를 저장했습니다.

편집 2 : -~증가 를 사용하여 2 바이트 저장g 1 시켜 했습니다.

편집 3 : y[:1]xnor 덕분에 트릭 을 사용하여 7 바이트 를 절약했습니다!

def f(x,y,s=''):
 for c in x:g=y[:1]==c;s+=c*-~g;y=y[g:]
 print s

여기서 확인하십시오.

올바른 형식과 설명 :

def f(x,y,s=''):           # Defining a function that takes our input,
                           # plus holds a variable we'll append to.
  for c in x:              # For every character in 'x', do the following:
    g = y[:1] == c         # Get the first element from the second string, will
                           # return an empty string if there's nothing left.
                           # Thanks to xnor for this trick!
    s += c * -~g           # Since int(g) would either evaluate to 0 or 1, we
                           # use the -~ method of incrementing g to multiply
                           # the character by 1 or 2 and append it to 's'
    y = y[g:]              # Again, since int(g) would either evaluate to 0
                           # or 1, use that to cut the first value off y, or
                           # keep it if the characters didn't match.
  print s                  # Print the string 's' we've been appending to.

Excel VBA, 110 바이트

이것이 CodeGolf에 대한 첫 번째 항목이므로 이것이 좋기를 바랍니다.

A1에 입력 단어를 입력 한 다음 B1에서 대체 할 문자를 입력하면 결과 단어가 메시지 상자에 표시됩니다.

w = Cells(1, 1)
l = Cells(2, 1)
For i = 1 To Len(w)
x = Left(w, 1)
R = R + x
If InStr(l, x) > 0 Then
R = R + x
End If
w = Right(w, Len(w) - 1)
Next
MsgBox R

하스켈, 42 바이트

(a:b)#e@(c:d)|a==c=a:a:b#d|1<2=a:b#e
a#_=a

사용 예 :

*Main> "coconut" # "co"
"ccooconut"
*Main> "lizard" # "iard"
"liizaarrdd"
*Main> "onomatopoeia" # "ooaoo"
"oonoomaatoopooeia"

작동 방식 :

하나의 문자열이 비어 있으면 결과는 첫 번째 문자열입니다. 그렇지 않으면 : 문자열의 첫 문자가 일치하면 두 번 가져와 문자열의 꼬리를 재귀 호출에 추가하십시오. 문자가 일치하지 않으면 첫 번째 문자열의 첫 번째 문자를 사용하여 첫 번째 문자열의 꼬리와 동일한 두 번째 문자열로 재귀 호출을 추가하십시오.

Pyth, 18 17 바이트

sm?+d.(QZqd&QhQdz

라이브 데모.

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

설명:

                z  Read the first line of input.
 m                 For each character in that line
  ?      qd&QhQ    If (?) the first char of the stretch list (`&QhQ`) 
                   and the current character are equal,
   +d.(QZ          Then double the current character and pop an element off
                   the stretch list.
               d   Otherwise, just return the same character.
s                  Join all the characters together.

원본 버전 :

jkm?+d.(QZqd&QhQdz

원본 라이브 데모.

자바 스크립트, 47 바이트

(a,b)=>a.replace(/./g,d=>b[0]!=d?d:d+b.shift())

일부 ES6 기능을 활용합니다.

Pyth, 16 바이트

u|pH<GJxGH>GJwz

온라인으로 사용해보십시오 : 데모

이것은 꽤 해키입니다. 스택 기반 언어가 여기에 유리할 수 있습니다.

설명

                   implicit: z = 1st input line, w = 2nd
u             wz   reduce, start with G = z
                   for each H in w, update G to:
        xGH          index of H in G
       h             +1
      J              store in J
    <GJ              substring: G[:J] (everything before index J)
  pH                 print substring then H (without newlines)
 |                   afterwards (actually or, but p always returns 0)
           >GJ       substring: G[J:] (everything from index J to end)
                     update G with ^
                   afterwards implicitly print the remainder G

자바 스크립트 ES6, 47 바이트

(w,s)=>w.replace(/./g,c=>c==s[0]?c+s.shift():c)

s배열이라고 가정["c","a","l","n"]

> <> (물고기) , 68 34 바이트

ri&:o&:&=\
l&io& /!?/
?!;20.\l!\

당신은 그것을 실행할 수 있습니다 http://fishlanguage.com/playground ( "마크, 즉,"카멜레온과 함께 ") 초기 스택과 문자열 (아무 입력 스택과 같은 추가 문자의 배열"마크 즉 caln)를 입력.

Give 버튼을 눌러 입력 스택을 시드하는 것을 잊지 마십시오.

r       reverses the stack
i&      reads in the first input, and stores it in the register
:o      copies the top of the stack, and outputs the top of the stack
&:&     puts register value on stack, copies it, then puts top stack into register
=       checks if the top two values are equal, if yes push 1, else push 0
?       if top value is non-zero, execute next instruction
!       skips the following instruction (unless it was skipped by the previous ?)

If yes, then we proceed on the same line
&o      puts register value on stack, and outputs it
i&      reads in the first input, and stores it in the register
l       puts length of stack on stack, then proceed to lowest line

If no, we go directly to the last line
l       As above.
?!;     If zero value (from length), then end execution
20.     Push 2 and 0 onto stack, then pop top two values, and go to that position (2,0) (i.e. next instruction is at (3,0))

편집 : 반으로! :)

제 119 화

Based on @Alex's answer, this one is a couple of bytes shorter:

function(s,a){message(unlist(lapply(strsplit(s,"")[[1]],function(x){if(length(a)&x==a[1]){a<<-a[-1];c(x,x)}else x})))}

Ungolfed:

function(s, a) {
  message(                             # Prints to output
    unlist(                            # Flattens list to vector
      lapply(                          # R's version of map
        strsplit(s,"")[[1]],           # Split vector to characters
        function (x) {
          if (length(a) & x == a[1]) { # If there are still elements in a
                                       # and there's a match
            a <<- a[-1]                # Modify a
            c(x, x)                    # And return the repeated character
          } else x                     # Otherwise just return it
        }
      )
    )
  )
}

Perl, 73 62 59 56

Entirely new approach yields much better results. Still, I bet it can be shorter.

Call as f('coconut', ['c','o']).

sub f{($s,$a)=@_;$s=~s/(.*?)($_)/\U$1$2$2/ for@$a;lc$s}

For each character in the array, find the first occurrence and duplicate it, and turn everything up to it to uppercase. Then return the entire string, converted to lowercase.

EDIT: shaved a couple of more characters by getting rid of shift and pop.

The previous version:

sub f{join '',map{shift @{$_[0]}if s/($_[0][0])/$1$1/;$_}split //,shift}

Ruby, 52 47 bytes

Solution:

f=->(s,a){s.chars.map{|c|c==a[0]?a.shift*2:c}.join}

Example:

p f.call('banana', ['n','a']) # => "bannaana"

Explanation:

Proc form of a method which takes a string as the first argument, and an array of characters as the second argument. Maps a block onto an array of the characters in the string argument, which checks each character against first element of the comparison array, and if there is a match, removes the first element of the comparison array, and doubles it.

update

f=->s,a{s.chars.map{|c|c==a[0]?a.shift*2:c}*''}

Perl, 51 bytes

$s=<>;$s=~s=^.*$_=$_=,$,.=$&for split"",<>;print$,;

Input is provided via STDIN. First input is the starting word (e.g. chameleon), second input is the letters as a single string (e.g. caln).

The above is just an obfuscated (read "prettier") way of doing the following:

$word = <>;
for $letter(split "", <>) {
   $word =~ s/^.*$letter/$letter/;
   $result .= $&;
}
print $result;

As we go through each letter, we replace from the start of the word up to the letter in the source word with just the new letter, and append the match (stored in $&) to our result. Since the match includes the letter and then gets replaced with the letter, each letter ends up appearing twice.

Because STDIN appends a new line character to both of our inputs, we're guaranteed to capture the remnants of the full word on the last match, i.e. the new line character.

REGXY, 24 bytes

Uses REGXY, a regex substitution based language. Input is assumed to be the starting word and the array, space separated (e.g. "chameleon caln").

/(.)(.* )\1| /\1\1\2/
//

The program works by matching a character in the first string with the first character after a space. If this matches, the character is repeated in the substitution and the character in the array is removed (well, not appended back into the string). Processing moves on to the second line, which is just a pointer back to the first line, which causes processing to repeat on the result of the previous substitution. Eventually, there will be no characters after the space, at which point the second branch of the alternation will match, removing the trailing space from the result. The regex will then fail to match, processing is completed and the result is returned.

If it helps, the iterative steps of execution are as follows:

chameleon caln
cchameleon aln
cchaameleon ln
cchaameleonn n
cchaameleonn  (with trailing space)
cchaameleonn

The program compiles and executes correctly with the sample interpreter in the link above, but the solution is perhaps a bit cheeky as it relies on an assumption in the vagueness of the language specification. The spec states that the first token on each line (before the /) acts as a label, but the assumption is that a null label-pointer will point back to the first command in the file with a null label (or in other words, that 'null' is a valid label). A less cheeky solution would be:

a/(.)(.* )\1| /\1\1\2/
b//a

Which amounts to 27 bytes

JavaScript ES6, 72 bytes

(s,a,i=0,b=[...s])=>a.map(l=>b.splice(i=b.indexOf(l,i+2),0,l))&&b.join``

This is an anonymous function that takes 2 parameters: the starting word as a string and the characters to stretch as an array. Ungolfed code that uses ES5 and test UI below.

f=function(s,a){
  i=0
  b=s.split('')
  a.map(function(l){
    i=b.indexOf(l,i+2)
    b.splice(i,0,l)
  })
  return b.join('')
}

run=function(){document.getElementById('output').innerHTML=f(document.getElementById('s').value,document.getElementById('a').value.split(''))};document.getElementById('run').onclick=run;run()

<label>Starting word: <input type="text" id="s" value="onomatopoeia" /></label><br />
<label>Leters to duplicate: <input type="text" id="a" value="oao"/></label><br />
<button id="run">Run</button><br />Output: <output id="output"></output>

Python 2, 77

def f(x,y,b=''):
 for i in x:
    try:
     if i==y[0]:i=y.pop(0)*2
    except:0
    b+=i
 print b

Call as:

f('onomatopoeia',['o','a','o'])

I may have got the byte count horribly wrong... Uses a mixture of spaces and tabs.

rs, 39 bytes

More information about rs.

There's already a Retina answer, but I think this one uses a slightly different approach. They were also created separately: when I began working on this one, that answer hadn't been posted.

Besides, this one is 6 bytes longer anyway. :)

#
+#(\S)(\S*) ((\1)|(\S))/\1\4#\2 \5
#/

Live demo and test suite.

JavaScript, 92 characters

function f(s,c){r="";for(i=0;i<s.length;i++){r+=s[i];if(c.indexOf(s[i])>-1)r+=s[i]}return r}

Unobfuscated version:

function stretch(str, chars) {
    var ret = "";
    for(var i = 0; i < str.length; i++) {
        ret += str[i];
        if(chars.indexOf(str[i]) > -1) {
            ret += str[i];
        }
    }
    return ret;
}

R, 136 128 122 bytes

function(s,a){p=strsplit(s,"")[[1]];for(i in 1:nchar(s))if(length(a)&&(x=p[i])==a[1]){p[i]=paste0(x,x);a=a[-1]};message(p)}

This creates an unnamed function that accepts a string and a character vector as input and prints a string to STDOUT. To call it, give it a name.

Ungolfed + explanation:

f <- function(s, a) {
    # Split s into letters
    p <- strsplit(s, "")[[1]]

    # Loop over the letters of s
    for (i in 1:nchar(s)) {

        # If a isn't empty and the current letter is the first in a
        if (length(a) > 0 && p[i] == a[1]) {

            # Replace the letter with itself duplicated
            p[i] <- paste0(p[i], p[i])

            # Remove the first element from a
            a <- a[-1]
        }
    }

    # Combine p back into a string and print it
    message(p)
}

Examples:

> f("coconut", c("c","o"))
ccooconut

> f("onomatopoeia", c("o","a","o"))
oonomaatoopoeia

Saved 8 bytes thanks to MickeyT and another 3 thanks to jja!

Bash+sed, 51

sed "`sed 's/./s!^[^&]*&!\U\&&!;/g'<<<$1`s/.*/\L&/"

Input from stdin; characters to be doubled as a single argument:

$ echo chameleon | strtech caln
cchaamelleonn

This works by constructing a sed program from $2 and then executing it against $1. The sed program replaces the first occurrence of each replacement letter with two copies of its uppercase version, and downcases the whole lot at the end. For the example above, the generated sed program is

s!^[^c]*c!\U&C!;s!^[^a]*a!\U&A!;s!^[^l]*l!\U&L!;s!^[^n]*n!\U&N!;s/.*/\L&/

pretty-printed:

# if only sed had non-greedy matching...
s!^[^c]*c!\U&C!
s!^[^a]*a!\U&A!
s!^[^l]*l!\U&L!
s!^[^n]*n!\U&N!
s/.*/\L&/

I use the uppercase to mark characters processed so far; this avoids re-doubling characters that have already been doubled, or applying a doubling earlier than the previous one.

Earlier version, before clarification that order of replacement list is significant (44 chars):

sed "`sed 's/./s!&!\U&&!;/g'<<<$1`s/.*/\L&/"

Python, 53 92 bytes

Found my solution to be the same length in both Python 2 and 3.

EDIT: Man, fixing that case when doing multiple replaces of the same letter (while still using the same method) took a bit of work.

Python 2:

Try it here

def f(s,t):
 for c in t:s=s.replace(c,'%',1)
 print s.replace('%','%s')%tuple(x*2for x in t)

Python 3:

s,*t=input()
for c in t:s=s.replace(c,'%',1)
print(s.replace('%','%s')%tuple(x*2for x in t))

Mathematica, 66 bytes

""<>Fold[Most@#~Join~StringSplit[Last@#,#2->#2<>#2,2]&,{"",#},#2]&

Example:

In[1]:= f = ""<>Fold[Most@#~Join~StringSplit[Last@#,#2->#2<>#2,2]&,{"",#},#2]&

In[2]:= f["banana", {"n", "a"}]

Out[2]= "bannaana"

Lua, 76 78 76 75 58 53 bytes

New, completely reworked solution with help from wieselkatze and SquidDev! come on guys, we can beat brainfuck :P

function f(a,b)print((a:gsub("["..b.."]","%1%1")))end

Explanation coming tommorow. Try it here.

Original solution: Saved 2 bytes thanks to @kirbyfan64sos!

Lua is a pretty terrible language to golf in, so I think I did pretty good for this one.

function f(x,y)for i=1,#x do g=y:sub(i,i)x=x:gsub(g,g..g,1)end print(x)end

Code explanation, along with ungolfed version:

function f(x,y) --Define a function that takes the arguements x and y (x is the string to stretch, y is how to stretch it)
  for i=1,#x do --A basic for loop going up to the length of x
    g=y:sub(i,i) -- Define g as y's "i"th letter
    x=x:gsub(g,g..g,1) --Redefine x as x with all letter "g"s having an appended g after them, with a replace limit of 1.
  end
  print(x)
end

Try it here. (Outdated code but same concept, just less golfed, will update tommorow)