Escriba un programa o función que duplique letras en una palabra, de modo que todas las letras duplicadas dispuestas de izquierda a derecha en la palabra formen la matriz de entrada.

Por ejemplo:

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

Entrada

• La palabra inicial (p chameleon. Ej. )
• Una matriz de caracteres ( [c,a,l,n]) o una cadena para representar una matriz ( caln), o algo similar
• La entrada puede ser a través de parámetros de función, STDIN o equivalentes de lenguaje
• Todas las entradas serán letras minúsculas (az)

Salida

• La palabra cambiada

• Si hay varias soluciones, se puede imprimir cualquiera

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

• Puede suponer que la palabra de entrada (no necesariamente la matriz) tendrá las letras en la matriz (en orden)

• También puede suponer que las entradas no tienen letras consecutivas que sean iguales (NO manzana, geek, verde, vidrio, puerta ...)

Ejemplos

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.

¡El programa más corto gana!

Tabla de clasificación (gracias a Martin Büttner por el fragmento)

/* 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 bytes

s+L&@d<Q1.(QZz

Demostración.

Estilo de entrada:

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

Explicación:

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 con caracteres imprimibles en la entrada)

Compatible con bff de Alex Pankratov (intérprete de brainfuck usado en SPOJ e ideone) y BFI de Thomas Cort (usado en Anarchy Golf).

La versión imprimible toma la matriz primero como una cadena, seguida de una pestaña, seguida de la cadena inicial sin nueva línea final.

Demostración sobre ideona.

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

Podemos guardar algunos bytes utilizando \x00como separador en lugar de tabulador:

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

CJam, 15 bytes

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

Pruébalo en línea.

Cómo funciona

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 bytes

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

Bueno, esto es sorprendentemente competitivo.

Definimos una función f(char*, char*)que toma la cadena como su primera entrada y la matriz de caracteres para duplicar como su segunda entrada.

Algún código de prueba:

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

Que imprime:

oonomaatoopeia

Pruébalo en línea !

Si es aceptable enviar una macro en lugar de una función, los siguientes #define g(s,c)son solo 58 bytes , pero requieren sy cdeben ser punteros reales:

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

CJam, 15 bytes

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

Un enfoque alternativo de CJam. Pruébalo en línea

Explicación

Para cada personaje en la segunda cadena, hacemos dos cosas.

1. Dividir el sufijo actual de la cadena por el carácter, p. Ej. "beeper" "e" -> ["b" "" "p" "r"]

2. Descomprime la primera cadena de la matriz, inserta dos de los caracteres y luego vuelve a unir el resto de la matriz con el carácter, por ejemplo "b" "ee" "eper". La última cadena es el nuevo sufijo.

Retina, 33 bytes

Más información sobre Retina.

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

Esto espera las dos cadenas en STDIN, separadas por una nueva línea.

Para fines de conteo, cada línea entra en un archivo separado, \ndebe reemplazarse con un carácter de nueva línea real (0x0A). Si realmente quiere probar esto, es más conveniente poner esto en un solo archivo donde \npermanece como está y luego invocar a Retina con la -sopción antes de pasar el archivo.

Explicación

(Anticuado ... logré deshacerme del marcador ... actualizaré esto más tarde).

Cada par de líneas es una sustitución de expresiones regulares (primera línea el patrón, segunda línea la sustitución).

^
#

Esto pone un #como marcador al comienzo de la cadena de entrada.

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

Esto encuentra la primera letra en la entrada (después del marcador) correspondiente a la siguiente letra que se duplicará, duplica esa letra, mueve el marcador detrás de ella y suelta el primer carácter de la segunda cadena. El +`en el frente le dice a Retina que haga esto repetidamente hasta que la cadena deje de cambiar (en este caso, porque la segunda cadena está vacía y todas las letras requeridas se han duplicado).

#
<empty>

Finalmente, limpiamos la cuerda soltando el marcador.

Python, 61

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

Una solución recursiva codiciosa. Guarda bsi la primera letra de la cadena ses la primera letra de la cadena lde letras que se duplica. Si es así, tome una de esas letras y añádala a la llamada recursiva con el resto de s, eliminando el primer elemento de l. Si no b, haga lo mismo pero no duplique la letra y no la quite l.

Los controles de código s[:1]==l[:1]en lugar de s[0]==l[0]para evitar un error de índice de fuera de límites cuando so lestá vacía.

Prolog, 95 83 79 56 bytes

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

Ejemplo:

d(`chameleon`,`caln`).

devoluciones

cchaamelleonn

Editar: Guardado 4 bytes gracias a Oliphaunt

Edit2: se guardaron 20 bytes utilizando el put/1predicado SWI-Prolog en desuso en lugar de writef. Se guardó un byte reemplazando el predicado final de recursión d([],_).en d(_,_).. Sin dembargo, no funcionará si se intercambia el orden de las dos definiciones de , pero eso no nos importa en el código de golf. Guardado otros 2 bytes eliminando el paréntesisH=[A|T],put(A),d(S,T)

Python 2, 83 74 72 65 Bytes

No hay trucos especiales reales aquí. xes la cadena, yes la matriz de caracteres que se duplican. Para aclarar si esto no se copia correctamente, el primer nivel de sangría es un espacio, el siguiente es una pestaña.

Edición 1: guardado 9 bytes mediante la manipulación de cadenas en lugar de pop ().

Edición 2: se guardaron 2 bytes al usar -~para incrementar gen 1.

Edición 3: ¡Guarde 7 bytes usando y[:1]truco, gracias a xnor por esto!

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

Compruébalo aquí.

Formateado y explicado adecuadamente:

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 bytes

Esta es mi primera entrada a CodeGolf, así que espero que esté bien.

Ingrese la palabra de entrada en A1 y luego las letras que se reemplazarán en B1 y la palabra resultante se muestra en un cuadro de mensaje.

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

Haskell, 42 bytes

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

Ejemplo de uso:

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

Cómo funciona:

Si una cadena está vacía, el resultado es la primera cadena. De lo contrario: si los primeros caracteres de las cadenas coinciden, tómalo dos veces y agrega una llamada recursiva con las colas de las cadenas. Si los caracteres no coinciden, tome el primer carácter de la primera cadena y agregue una llamada recursiva con la cola de la primera cadena y la misma segunda cadena.

Pyth, 18 17 bytes

sm?+d.(QZqd&QhQdz

Demo en vivo.

Guardado 1 byte gracias a @Jakube.

Explicación:

                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.

Versión original:

jkm?+d.(QZqd&QhQdz

Demo en vivo para original.

Javascript, 47 bytes

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

Aprovechando algunas características de ES6.

Pyth, 16 bytes

u|pH<GJxGH>GJwz

Pruébelo en línea: demostración

Esto es bastante hacky. Los lenguajes basados ​​en pila pueden tener una ventaja aquí.

Explicación

                   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

JavaScript ES6, 47 bytes

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

Asume que ses una matriz["c","a","l","n"]

> <> (Pez) , 68 34 Bytes

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

Puede ejecutarlo en http://fishlanguage.com/playground ingresando la cadena como la pila inicial (con "marcas, es decir," camaleón ") y la matriz de letras adicionales como la pila de entrada (sin" marcas, es decir, caln).

No olvide presionar el botón Dar para sembrar la pila de entrada.

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

EDITAR: a la mitad! :)

R, 119

Según la respuesta de @ Alex , este es un par de bytes más corto:

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

Sin golf:

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

Un enfoque completamente nuevo produce resultados mucho mejores. Aún así, apuesto a que puede ser más corto.

Llamar como f('coconut', ['c','o']).

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

Para cada carácter de la matriz, encuentre la primera aparición y duplíquela, y convierta todo en mayúsculas. Luego devuelva la cadena completa, convertida a minúsculas.

EDITAR: afeitó un par de personajes más al deshacerse de shifty pop.

La versión anterior:

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

Rubí, 52 47 bytes

Solución:

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

Ejemplo:

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

Explicación:

Forma de proceso de un método que toma una cadena como primer argumento y una matriz de caracteres como segundo argumento. Asigna un bloque a una matriz de caracteres en el argumento de cadena, que comprueba cada carácter con el primer elemento de la matriz de comparación y, si hay una coincidencia, elimina el primer elemento de la matriz de comparación y lo duplica.

actualizar

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

Perl, 51 bytes

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

La entrada se proporciona a través de STDIN. La primera entrada es la palabra inicial (p chameleon. Ej. ), La segunda entrada son las letras como una sola cadena (p caln. Ej .).

Lo anterior es solo una forma ofuscada (léase "más bonita") de hacer lo siguiente:

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

A medida que avanzamos por cada letra, reemplazamos desde el comienzo de la palabra hasta la letra en la palabra fuente con solo la nueva letra, y agregamos la coincidencia (almacenada $&) a nuestro resultado. Como la coincidencia incluye la letra y luego se reemplaza con la letra, cada letra termina apareciendo dos veces.

Debido a que STDIN agrega un nuevo carácter de línea a nuestras dos entradas, estamos garantizados para capturar los restos de la palabra completa en la última coincidencia, es decir, el nuevo carácter de línea.

REGXY, 24 bytes

Utiliza REGXY , un lenguaje basado en la sustitución de expresiones regulares. Se supone que input es la palabra inicial y la matriz, separados por espacios (por ejemplo, "camaleón caln")

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

El programa funciona haciendo coincidir un carácter en la primera cadena con el primer carácter después de un espacio. Si esto coincide, el carácter se repite en la sustitución y el carácter de la matriz se elimina (bueno, no se vuelve a agregar a la cadena). El procesamiento pasa a la segunda línea, que es solo un puntero a la primera línea, lo que hace que el procesamiento se repita en el resultado de la sustitución anterior. Eventualmente, no habrá caracteres después del espacio, en cuyo punto coincidirá la segunda rama de la alternancia, eliminando el espacio final del resultado. La expresión regular no coincidirá, se completará el procesamiento y se devolverá el resultado.

Si ayuda, los pasos iterativos de ejecución son los siguientes:

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

El programa compila y se ejecuta correctamente con el intérprete de muestra en el enlace anterior, pero la solución es quizás un poco descarada ya que se basa en una suposición en la imprecisión de la especificación del lenguaje. La especificación establece que el primer token en cada línea (antes de /) actúa como una etiqueta, pero se supone que un puntero de etiqueta nulo apuntará de nuevo al primer comando en el archivo con una etiqueta nula (o en otras palabras, ese 'nulo' es una etiqueta válida). Una solución menos descarada sería:

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

Que asciende a 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``

Esta es una función anónima que toma 2 parámetros: la palabra inicial como una cadena y los caracteres para estirar como una matriz. Código no protegido que usa ES5 y prueba la interfaz de usuario a continuación.

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>

Pitón 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

Llamar como:

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

Es posible que el byte cuente horriblemente mal ... Usa una mezcla de espacios y pestañas.

rs, 39 bytes

Más información sobre rs.

Ya hay una respuesta de Retina, pero creo que esta usa un enfoque ligeramente diferente. También se crearon por separado: cuando comencé a trabajar en este, esa respuesta no se había publicado.

Además, este es 6 bytes más largo de todos modos. :)

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

Demostración en vivo y conjunto de pruebas.

JavaScript, 92 caracteres

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}

Versión no ofuscada:

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

Esto crea una función sin nombre que acepta una cadena y un vector de caracteres como entrada e imprime una cadena en STDOUT. Para llamarlo, dale un nombre.

Ungolfed + explicación:

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

Ejemplos:

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

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

¡Ahorré 8 bytes gracias a MickeyT y otros 3 gracias a jja!

Bash + sed, 51

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

Entrada de stdin; caracteres que se duplicarán como argumento único:

$ echo chameleon | strtech caln
cchaamelleonn

Esto funciona construyendo un programa sed $2y luego ejecutándolo $1. El programa sed reemplaza la primera aparición de cada letra de reemplazo con dos copias de su versión en mayúsculas, y descarta todo el lote al final. Para el ejemplo anterior, el programa sed generado es

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

bonito estampado:

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

Uso mayúsculas para marcar los caracteres procesados ​​hasta ahora; Esto evita volver a duplicar los caracteres que ya se han duplicado, o aplicar una duplicación anterior a la anterior.

Versión anterior, antes de aclarar que el orden de la lista de reemplazo es significativo (44 caracteres):

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

Python, 53 92 bytes

Encontré que mi solución tenía la misma longitud en Python 2 y 3.

EDITAR: Hombre, arreglar ese caso al hacer múltiples reemplazos de la misma letra (mientras todavía se usa el mismo método) tomó un poco de trabajo.

Python 2:

Pruébalo aquí

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

Ejemplo:

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

¡Nueva solución completamente reelaborada con la ayuda de wieselkatze y SquidDev! vamos chicos, podemos vencer a brainfuck: P

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

Explicación que viene mañana. Pruébalo aquí.

Solución original: ¡Ahorré 2 bytes gracias a @ kirbyfan64sos!

Lua es un lenguaje bastante terrible para el golf, así que creo que lo hice bastante bien para este.

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

Explicación del código, junto con la versión sin golf:

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

Pruébalo aquí. (El código desactualizado pero el mismo concepto, solo que menos golfizado, actualizará mañana)