Écrivez un programme ou une fonction qui duplique des lettres dans un mot, de sorte que toutes les lettres dupliquées disposées de gauche à droite dans le mot forment le tableau d'entrée.

Par exemple:

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

Contribution

• Le mot de départ (par exemple chameleon)
• Un tableau de caractères ( [c,a,l,n]) ou une chaîne pour représenter un tableau ( caln), ou quelque chose de similaire
• L'entrée peut se faire via des paramètres de fonction, STDIN ou des équivalents de langue
• Toutes les entrées seront des lettres minuscules (az)

Sortie

• Le mot changé

• S'il existe plusieurs solutions, toutes peuvent être imprimées

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

• Vous pouvez supposer que le mot d'entrée (pas nécessairement le tableau) aura les lettres dans le tableau (dans l'ordre)

• Vous pouvez également supposer que les entrées n'ont pas de lettres consécutives qui sont les mêmes (PAS pomme, geek, vert, verre, porte ...)

Exemples

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.

Le programme le plus court gagne!

Classement (merci à Martin Büttner pour l'extrait)

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

s+L&@d<Q1.(QZz

Manifestation.

Style d'entrée:

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

Explication:

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 avec caractères imprimables en entrée)

Compatible avec le bff d' Alex Pankratov (interprète brainfuck utilisé sur SPOJ et ideone) et le BFI de Thomas Cort (utilisé sur Anarchy Golf).

La version imprimable prend d'abord le tableau sous forme de chaîne, suivie d'un onglet, suivie de la chaîne de départ sans retour à la ligne.

Démonstration sur ideone.

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

Nous pouvons enregistrer quelques octets en utilisant \x00comme séparateur au lieu de tabulation:

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

CJam, 15 octets

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

Essayez-le en ligne.

Comment ça marche

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 octets

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

Eh bien, c'est étonnamment compétitif.

Nous définissons une fonction f(char*, char*)qui prend la chaîne comme première entrée et le tableau de caractères à dupliquer comme deuxième entrée.

Quelques codes de test:

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

Quelles impressions:

oonomaatoopeia

Essayez-le en ligne !

S'il est acceptable de soumettre une macro plutôt qu'une fonction, ce qui suit #define g(s,c)n'est que de 58 octets , mais nécessite set cdoit être de véritables pointeurs:

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

CJam, 15 octets

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

Une approche CJam alternative. Essayez-le en ligne

Explication

Pour chaque caractère de la deuxième chaîne, nous faisons deux choses.

1. Fractionnez le suffixe actuel de la chaîne par le caractère, par exemple "beeper" "e" -> ["b" "" "p" "r"]

2. Annule la première chaîne du tableau, insère deux du caractère, puis rejoint le reste du tableau avec le caractère, par exemple "b" "ee" "eper". La dernière chaîne est le nouveau suffixe.

Rétine, 33 octets

Plus d'informations sur la rétine.

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

Cela attend les deux chaînes sur STDIN, séparées par une nouvelle ligne.

À des fins de comptage, chaque ligne va dans un fichier distinct, \ndoit être remplacée par un caractère de nouvelle ligne réel (0x0A). Si vous voulez vraiment tester cela, il est plus pratique de le mettre dans un seul fichier où il \nreste tel quel, puis d'appeler Retina avec l' -soption avant de passer le fichier.

Explication

(Obsolète ... J'ai réussi à me débarrasser du marqueur ... Je le mettrai à jour plus tard.)

Chaque paire de lignes est une substitution d'expression régulière (première ligne le motif, deuxième ligne la substitution).

^
#

Cela place un #comme marqueur au début de la chaîne d'entrée.

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

Cela trouve la première lettre dans l'entrée (après le marqueur) correspondant à la lettre suivante à dupliquer, duplique cette lettre, déplace le marqueur derrière elle et supprime le premier caractère de la deuxième chaîne. L' +`avant indique à Retina de le faire à plusieurs reprises jusqu'à ce que la chaîne cesse de changer (dans ce cas, car la deuxième chaîne est vide et toutes les lettres requises ont été dupliquées).

#
<empty>

Enfin, nous nettoyons la chaîne en laissant tomber le marqueur.

Python, 61

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

Une solution récursive gourmande. Enregistre bsi la première lettre de la chaîne sest la première lettre de la chaîne lde lettres à doubler. Si c'est le cas, prenez une de ces lettres et ajoutez-la à l'appel récursif avec le reste de s, en supprimant le premier élément de l. Sinon b, faites de même, mais ne doublez pas la lettre et n'enlevez pas l.

Le code vérifie s[:1]==l[:1]plutôt que s[0]==l[0]d'éviter une erreur d'index hors limites lorsque sou lest vide.

Prolog, 95 83 79 56 octets

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

Exemple:

d(`chameleon`,`caln`).

résultats

cchaamelleonn

Edit: 4 octets enregistrés grâce à Oliphaunt

Edit2: 20 octets enregistrés à l'aide du put/1prédicat obsolète SWI-Prolog au lieu de writef. Enregistré en remplacement d' un octet à la fin de récursion prédicat d([],_).à d(_,_).. Ne fonctionnera pas si l'ordre des deux définitions de dest inversé, mais nous ne nous en soucions pas dans le code golfé. Sauvegardé encore 2 octets en supprimant les parenthèses autourH=[A|T],put(A),d(S,T)

Python 2, 83 74 72 65 octets

Pas de véritables astuces spéciales ici. xest la chaîne, yest le tableau de caractères qui sont dupliqués.Pour clarifier si cela ne se copie pas correctement, le premier niveau de retrait est un espace, le suivant est un onglet.

Édition 1: 9 octets enregistrés en utilisant la manipulation de chaînes au lieu de pop ().

Edit 2: enregistré 2 octets en utilisant -~pour incrémenter gde 1.

Edit 3: économisé 7 octets en utilisant une y[:1]astuce, merci à xnor pour cela!

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

Vérifiez le ici.

Bien formaté et expliqué:

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 octets

Ceci est ma première entrée sur CodeGolf, donc j'espère que ça va.

Vous entrez le mot d'entrée dans A1, puis les lettres à remplacer dans B1 et le mot résultant s'affiche dans une boîte de message.

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 octets

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

Exemple d'utilisation:

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

Comment ça marche:

Si une chaîne est vide, le résultat est la première chaîne. Sinon: si les premiers caractères des chaînes correspondent, prenez-le deux fois et ajoutez un appel récursif avec la queue des chaînes. Si les caractères ne correspondent pas, prenez le premier caractère de la première chaîne et ajoutez un appel récursif avec la queue de la première chaîne et la même deuxième chaîne.

Pyth, 18 17 octets

sm?+d.(QZqd&QhQdz

Démo en direct.

1 octet enregistré grâce à @Jakube.

Explication:

                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.

Version originale:

jkm?+d.(QZqd&QhQdz

Démo en direct pour l'original.

Javascript, 47 octets

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

Profitant de certaines fonctionnalités ES6.

Pyth, 16 octets

u|pH<GJxGH>GJwz

Essayez-le en ligne: démonstration

C'est assez hacky. Les langues basées sur la pile pourraient avoir un avantage ici.

Explication

                   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 octets

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

Suppose que sc'est un tableau["c","a","l","n"]

> <> (Poisson) , 68 34 octets

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

Vous pouvez l'exécuter sur http://fishlanguage.com/playground saisissant la chaîne comme pile initiale (avec "marks, ie" cameleon ") et le tableau de lettres supplémentaires comme pile d'entrée (no" marks ie caln).

N'oubliez pas d'appuyer sur le bouton Give pour amorcer la pile d'entrée.

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

EDIT: réduit de moitié! :)

R, 119

D'après la réponse de @ Alex , celui-ci est plus court de quelques octets:

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

Une approche entièrement nouvelle donne de bien meilleurs résultats. Pourtant, je parie que cela peut être plus court.

Appelez le f('coconut', ['c','o']).

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

Pour chaque caractère du tableau, recherchez la première occurrence et dupliquez-la, puis mettez tout en majuscule. Retournez ensuite la chaîne entière, convertie en minuscules.

EDIT: rasé quelques autres personnages en se débarrassant de shiftet pop.

La version précédente:

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

Rubis, 52 47 octets

Solution:

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

Exemple:

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

Explication:

Forme Proc d'une méthode qui prend une chaîne comme premier argument et un tableau de caractères comme deuxième argument. Mappe un bloc sur un tableau de caractères dans l'argument chaîne, qui vérifie chaque caractère par rapport au premier élément du tableau de comparaison, et s'il existe une correspondance, supprime le premier élément du tableau de comparaison et le double.

mise à jour

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

Perl, 51 octets

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

L'entrée est fournie via STDIN. La première entrée est le mot de départ (par exemple chameleon), la deuxième entrée est les lettres sous forme d'une seule chaîne (par exemple caln).

Ce qui précède est juste une façon obscurcie (lire "plus jolie") de faire ce qui suit:

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

Au fur et à mesure que nous parcourons chaque lettre, nous remplaçons depuis le début du mot jusqu'à la lettre du mot source par juste la nouvelle lettre et ajoutons la correspondance (stockée dans $& ) à notre résultat. Étant donné que la correspondance comprend la lettre et est ensuite remplacée par la lettre, chaque lettre finit par apparaître deux fois.

Parce que STDIN ajoute un nouveau caractère de ligne à nos deux entrées, nous sommes garantis de capturer les restes du mot complet sur la dernière correspondance, c'est-à-dire le nouveau caractère de ligne.

REGXY, 24 octets

Utilise REGXY , un langage basé sur la substitution d'expression régulière . L'entrée est supposée être le mot de départ et le tableau, séparés par des espaces (par exemple "cameleon caln").

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

Le programme fonctionne en faisant correspondre un caractère de la première chaîne avec le premier caractère après un espace. Si cela correspond, le caractère est répété dans la substitution et le caractère dans le tableau est supprimé (enfin, pas ajouté à nouveau dans la chaîne). Le traitement passe à la deuxième ligne, qui n'est qu'un pointeur vers la première ligne, ce qui provoque la répétition du traitement sur le résultat de la substitution précédente. Finalement, il n'y aura plus de caractères après l'espace, à quel point la deuxième branche de l'alternance correspondra, supprimant l'espace de fin du résultat. Le regex échouera alors à correspondre, le traitement est terminé et le résultat est retourné.

Si cela peut vous aider, les étapes d'exécution itératives sont les suivantes:

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

Le programme compile et s'exécute correctement avec l'exemple d'interpréteur dans le lien ci-dessus, mais la solution est peut-être un peu effrontée car elle repose sur une hypothèse dans le flou de la spécification de langue. La spécification indique que le premier jeton sur chaque ligne (avant le /) agit comme une étiquette, mais l'hypothèse est qu'un pointeur d'étiquette nul pointera vers la première commande du fichier avec une étiquette nulle (ou en d'autres termes, que 'null' est une étiquette valide). Une solution moins effrontée serait:

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

Soit 27 octets

JavaScript ES6, 72 octets

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

Il s'agit d'une fonction anonyme qui prend 2 paramètres: le mot de départ sous forme de chaîne et les caractères à étirer sous forme de tableau. Code non golfé qui utilise ES5 et testez l'interface utilisateur ci-dessous.

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

Appelez comme:

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

J'ai peut-être mal compris le nombre d'octets ... Utilise un mélange d'espaces et de tabulations.

rs, 39 octets

Plus d'informations sur rs.

Il y a déjà une réponse Retina, mais je pense que celle-ci utilise une approche légèrement différente. Ils ont également été créés séparément: lorsque j'ai commencé à travailler sur celui-ci, cette réponse n'avait pas été publiée.

De plus, celui-ci est de 6 octets de plus de toute façon. :)

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

Démo en direct et suite de tests.

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)