Scrivi un programma o una funzione che duplica le lettere in una parola, in modo che tutte le lettere duplicate disposte da sinistra a destra nella parola formino l'array di input.

Per esempio:

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

Ingresso

• La parola iniziale (ad es. chameleon)
• Una matrice di caratteri ( [c,a,l,n]) o una stringa per rappresentare una matrice ( caln) o qualcosa di simile
• L'input può avvenire tramite parametri di funzione, STDIN o equivalenti di lingua
• Tutti gli input saranno lettere minuscole (az)

Produzione

• La parola cambiata

• Se ci sono più soluzioni, è possibile stamparne tutte

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

• Si può presumere che la parola di input (non necessariamente l'array) avrà le lettere nell'array (in ordine)

• Puoi anche supporre che gli input non abbiano lettere consecutive uguali (NON apple, geek, green, glass, door ...)

Esempi

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.

Il programma più corto vince!

Classifica (grazie a Martin Büttner per lo snippet)

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

s+L&@d<Q1.(QZz

Dimostrazione.

Stile di input:

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

Spiegazione:

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 caratteri stampabili in input)

Compatibile con bff di Alex Pankratov (interprete brainfuck usato su SPOJ e ideone) e BFI di Thomas Cort (usato su Anarchy Golf).

La versione stampabile accetta prima l'array come stringa, seguito da una scheda, seguita dalla stringa iniziale senza una nuova riga finale.

Dimostrazione su ideone.

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

Possiamo salvare alcuni byte usando \x00come separatore anziché tab:

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

CJam, 15 byte

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

Provalo online.

Come funziona

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 byte

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

Bene, questo è sorprendentemente competitivo.

Definiamo una funzione f(char*, char*)che accetta la stringa come primo input e l'array di caratteri da duplicare come secondo input.

Alcuni codici di test:

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

Che stampa:

oonomaatoopeia

Provalo online !

Se è accettabile inviare una macro anziché una funzione, i seguenti #define g(s,c)sono solo 58 byte , ma richiedono se cdevono essere puntatori effettivi:

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

CJam, 15 byte

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

Un approccio alternativo a CJam. Provalo online

Spiegazione

Per ogni carattere nella seconda stringa, facciamo due cose.

1. Dividi il suffisso corrente della stringa per il carattere, ad es "beeper" "e" -> ["b" "" "p" "r"]

2. Scollega la prima stringa nell'array, inserisce due caratteri, quindi ricongiunge il resto dell'array con il carattere, ad es "b" "ee" "eper". L'ultima stringa è il nuovo suffisso.

Retina, 33 byte

Ulteriori informazioni su Retina.

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

Ciò prevede le due stringhe su STDIN, separate da una nuova riga.

Ai fini del conteggio, ogni riga va in un file separato, \ndeve essere sostituita con un carattere di nuova riga (0x0A). Se in realtà vuoi testarlo, è più conveniente metterlo in un singolo file dove \nrimane com'è e quindi invocare Retina con l' -sopzione prima di passare il file.

Spiegazione

(Non aggiornato ... Sono riuscito a sbarazzarmi del marcatore ... Lo aggiornerò più tardi.)

Ogni coppia di righe è una sostituzione regex (prima riga lo schema, seconda riga la sostituzione).

^
#

Questo mette un #come marcatore all'inizio della stringa di input.

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

Questo trova la prima lettera nell'input (dopo il marcatore) corrispondente alla lettera successiva da duplicare, duplica quella lettera, sposta il marcatore dietro di essa e rilascia il primo carattere della seconda stringa. Il +`davanti indica a Retina di farlo ripetutamente fino a quando la stringa non smette di cambiare (in questo caso, perché la seconda stringa è vuota e tutte le lettere richieste sono state duplicate).

#
<empty>

Infine, puliamo la corda facendo cadere il marker.

Python, 61

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

Una soluzione avida ricorsiva. Salva bse la prima lettera della stringa sè la prima lettera della stringa ldi lettere da raddoppiare. In tal caso, prendi una di quelle lettere e anteponila alla chiamata ricorsiva con il resto di s, rimuovendo il primo elemento da l. In caso contrario b, fai lo stesso ma non raddoppiare la lettera e non rimuoverla l.

Il codice controlla s[:1]==l[:1]piuttosto che s[0]==l[0]evitare un errore di fuori indice quando so lè vuoto.

Prolog, 95 83 79 56 byte

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

Esempio:

d(`chameleon`,`caln`).

ritorna

cchaamelleonn

Modifica: salvato 4 byte grazie a Oliphaunt

Edit2: salvato 20 byte utilizzando il put/1predicato SWI-Prolog obsoleto anziché writef. Salvataggio di un byte in sostituzione del predicato di fine ricorsione d([],_).in d(_,_).. dTuttavia, non funzionerà se l'ordinamento delle due definizioni di viene scambiato, ma non ci importa di questo nel codice golf. Salvati altri 2 byte rimuovendo la parentesiH=[A|T],put(A),d(S,T)

Python 2, 83 74 72 65 byte

Nessun vero trucco speciale qui. xè la stringa, yè l'array di caratteri duplicati. Per chiarire se questo non viene copiato correttamente, il primo livello di rientro è uno spazio, il successivo è una scheda.

Modifica 1: salvato 9 byte usando la manipolazione di stringhe invece di pop ().

Modifica 2: salvato 2 byte utilizzando -~per incrementare gdi 1.

Modifica 3: salvato 7 byte usando il y[:1]trucco, grazie a xnor per questo!

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

Controllalo qui.

Formattato e spiegato correttamente:

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 byte

Questa è la mia prima iscrizione a CodeGolf, quindi spero che vada bene.

Immettere la parola di input in A1 e quindi le lettere da sostituire in B1 e la parola risultante viene visualizzata in una finestra di messaggio.

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 byte

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

Esempio di utilizzo:

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

Come funziona:

Se una stringa è vuota, il risultato è la prima stringa. Altrimenti: se i primi caratteri delle stringhe corrispondono, prendilo due volte e aggiungi una chiamata ricorsiva con le code delle stringhe. Se i caratteri non corrispondono, prendi il primo carattere della prima stringa e aggiungi una chiamata ricorsiva con la coda della prima stringa e la stessa seconda stringa.

Pyth, 18 17 byte

sm?+d.(QZqd&QhQdz

Dimostrazione dal vivo.

Salvato 1 byte grazie a @Jakube.

Spiegazione:

                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.

Versione originale:

jkm?+d.(QZqd&QhQdz

Demo live per originale.

Javascript, 47 byte

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

Sfruttando alcune funzionalità ES6.

Pyth, 16 byte

u|pH<GJxGH>GJwz

Provalo online: dimostrazione

Questo è abbastanza confuso. Le lingue basate su stack potrebbero avere un vantaggio qui.

Spiegazione

                   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 byte

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

Presuppone sè una matrice["c","a","l","n"]

> <> (Pesce) , 68 34 byte

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

Puoi eseguirlo su http://fishlanguage.com/playground inserendo la stringa come stack iniziale (con "segni, cioè" camaleonte ") e l'array di lettere extra come stack di input (nessun" segno cioè caln).

Non dimenticare di premere il pulsante Give per eseguire il seeding dello stack di input.

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: Dimezzato! :)

R, 119

Basato sulla risposta di @ Alex , questo è un paio di byte più 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})))}

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

Un approccio completamente nuovo produce risultati molto migliori. Scommetto che può essere più breve.

Chiama come f('coconut', ['c','o']).

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

Per ogni personaggio dell'array, trova la prima occorrenza e duplicalo, quindi trasforma tutto in maiuscolo. Quindi restituisce l'intera stringa, convertita in minuscolo.

EDIT: rasato un paio di altri personaggi eliminando shifte pop.

La versione precedente:

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

Rubino, 52 47 byte

Soluzione:

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

Esempio:

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

Spiegazione:

Proc forma di un metodo che accetta una stringa come primo argomento e una matrice di caratteri come secondo argomento. Mappa un blocco su un array di caratteri nell'argomento stringa, che controlla ogni carattere rispetto al primo elemento dell'array di confronto e, se esiste una corrispondenza, rimuove il primo elemento dell'array di confronto e lo raddoppia.

aggiornare

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

Perl, 51 byte

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

L'ingresso è fornito tramite STDIN. Il primo input è la parola iniziale (es. chameleon), Il secondo input sono le lettere come una singola stringa (es caln.).

Quanto sopra è solo un modo offuscato (leggi "più bello") di fare quanto segue:

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

Mentre esaminiamo ogni lettera, sostituiamo dall'inizio della parola fino alla lettera nella parola sorgente con solo la nuova lettera e aggiungiamo la corrispondenza (memorizzata in $&) al nostro risultato. Poiché la corrispondenza include la lettera e quindi viene sostituita con la lettera, ogni lettera finisce per apparire due volte.

Poiché STDIN aggiunge un nuovo carattere di linea a entrambi i nostri input, siamo certi di catturare i resti dell'intera parola nell'ultima corrispondenza, ovvero il nuovo carattere di linea.

REGXY, 24 byte

Utilizza REGXY , un linguaggio basato sulla sostituzione regex. Si presume che l'input sia la parola iniziale e l'array, spazio separato (ad es. "Chameleon caln").

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

Il programma funziona abbinando un carattere nella prima stringa con il primo carattere dopo uno spazio. Se questo corrisponde, il carattere viene ripetuto nella sostituzione e il carattere nell'array viene rimosso (beh, non aggiunto alla stringa). L'elaborazione passa alla seconda riga, che è solo un puntatore alla prima riga, che fa sì che l'elaborazione si ripeta sul risultato della sostituzione precedente. Alla fine, non ci saranno caratteri dopo lo spazio, a quel punto il secondo ramo dell'alternanza corrisponderà, rimuovendo lo spazio finale dal risultato. La regex non riuscirà quindi a corrispondere, l'elaborazione è completata e il risultato viene restituito.

Se aiuta, le fasi iterative dell'esecuzione sono le seguenti:

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

Il programma viene compilato ed eseguito correttamente con l'interprete di esempio nel collegamento sopra, ma la soluzione è forse un po 'sfacciata in quanto si basa su un presupposto nella vaghezza delle specifiche del linguaggio. La specifica afferma che il primo token su ogni riga (prima di /) funge da etichetta, ma il presupposto è che un puntatore etichetta null farà riferimento al primo comando nel file con un'etichetta null (o in altre parole, che "null" è un'etichetta valida). Una soluzione meno sfacciata sarebbe:

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

Ciò equivale a 27 byte

JavaScript ES6, 72 byte

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

Questa è una funzione anonima che accetta 2 parametri: la parola iniziale come stringa e i caratteri che si estendono come matrice. Codice non golfato che utilizza ES5 e testare l'interfaccia utente di seguito.

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

Chiama come:

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

Potrei avere il conteggio dei byte orribilmente sbagliato ... Usa una combinazione di spazi e schede.

rs, 39 byte

Maggiori informazioni su rs.

C'è già una risposta Retina, ma penso che questa usi un approccio leggermente diverso. Sono stati anche creati separatamente: quando ho iniziato a lavorare su questo, quella risposta non era stata pubblicata.

Inoltre, questo è comunque più lungo di 6 byte. :)

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

Demo live e suite di test.

JavaScript, 92 caratteri

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}

Versione non protetta:

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 byte

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

Ciò crea una funzione senza nome che accetta una stringa e un vettore di caratteri come input e stampa una stringa su STDOUT. Per chiamarlo, dagli un nome.

Ungolfed + spiegazione:

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

Esempi:

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

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

Risparmiato 8 byte grazie a MickeyT e altri 3 grazie a jja!

Bash + sed, 51

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

Input da stdin; personaggi da raddoppiare come unico argomento:

$ echo chameleon | strtech caln
cchaamelleonn

Funziona costruendo un programma sed $2e quindi eseguendolo contro $1. Il programma sed sostituisce la prima occorrenza di ciascuna lettera sostitutiva con due copie della sua versione maiuscola e alla fine riduce l'intero lotto. Per l'esempio sopra, il programma sed generato è

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

pretty-stampati:

# 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 le lettere maiuscole per contrassegnare i caratteri elaborati finora; questo evita di raddoppiare i caratteri che sono già stati raddoppiati o di applicare un raddoppio prima del precedente.

Versione precedente, prima di chiarire che l'ordine dell'elenco di sostituzione è significativo (44 caratteri):

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

Python, 53 92 byte

Ho trovato la mia soluzione della stessa lunghezza in Python 2 e 3.

EDIT: Amico, risolvere quel caso quando si fanno più sostituzioni della stessa lettera (pur usando lo stesso metodo) ha richiesto un po 'di lavoro.

Python 2:

Provalo qui

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 byte

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

Esempio:

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 byte

Nuova soluzione completamente rielaborata con l'aiuto di wieselkatze e SquidDev! Forza ragazzi, possiamo battere il cervello: P

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

Spiegazione in arrivo domani. Provalo qui.

Soluzione originale: risparmiato 2 byte grazie a @ kirbyfan64sos!

Lua è una lingua piuttosto terribile in cui giocare a golf, quindi penso di aver fatto abbastanza bene per questo.

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

Spiegazione del codice, insieme alla versione non modificata:

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

Provalo qui. (Codice obsoleto ma lo stesso concetto, solo meno golfato, aggiornerà domani)