Napisz program lub funkcję, która powiela litery w słowie, aby wszystkie zduplikowane litery ułożone od lewej do prawej słowa tworzyły tablicę wejściową.

Na przykład:

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

Wkład

• Słowo początkowe (np. chameleon)
• Tablica znaków ( [c,a,l,n]) lub ciąg znaków reprezentujący tablicę ( caln) lub coś podobnego
• Dane wejściowe mogą być wprowadzane za pomocą parametrów funkcji, STDIN lub odpowiedników językowych
• Wszystkie dane wejściowe będą pisane małymi literami (az)

Wydajność

• Zmienione słowo

• Jeśli istnieje wiele rozwiązań, można je wydrukować

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

• Możesz założyć, że słowo wejściowe (niekoniecznie tablica) będzie zawierać litery w tablicy (w kolejności)

• Możesz również założyć, że na wejściach nie ma kolejnych liter, które są takie same (NIE jabłko, maniak, zielony, szkło, drzwi ...)

Przykłady

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.

Najkrótszy program wygrywa!

Tabela liderów (podziękowania dla Martina Büttnera za fragment)

/* 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 bajtów

s+L&@d<Q1.(QZz

Demonstracja.

Styl wprowadzania:

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

Wyjaśnienie:

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 z wejściowymi znakami do wydrukowania)

Kompatybilny z bff Alexa Pankratova (interpreter pieprzenia mózgu używany na SPOJ i ideone) oraz BFI Thomasa Corta (używany na Anarchy Golf).

Wersja do wydruku najpierw przyjmuje tablicę jako ciąg, następnie tabulator, a następnie ciąg początkowy bez końca nowej linii.

Demonstracja na ideonie.

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

Możemy zapisać niektóre bajty, używając \x00jako separatora zamiast tab:

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

CJam, 15 bajtów

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

Wypróbuj online.

Jak to działa

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 bajty

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

Jest to zaskakująco konkurencyjne.

Definiujemy funkcję, f(char*, char*)która przyjmuje ciąg znaków jako pierwsze wejście, a tablicę znaków do skopiowania jako drugie wejście.

Niektóre kody testowe:

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

Które wydruki:

oonomaatoopeia

Wypróbuj online !

Jeśli dopuszczalne jest przesłanie makra zamiast funkcji, poniższe #define g(s,c)to tylko 58 bajtów , ale wymaga si cmusi być rzeczywistymi wskaźnikami:

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

CJam, 15 bajtów

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

Alternatywne podejście do CJam. Wypróbuj online

Wyjaśnienie

Dla każdego znaku w drugim ciągu wykonujemy dwie rzeczy.

1. Podziel aktualny sufiks ciągu na znak, np "beeper" "e" -> ["b" "" "p" "r"]

2. Odznacz pierwszy ciąg w tablicy, wstaw dwa znaki, a następnie ponownie dołącz do reszty tablicy ze znakiem, np "b" "ee" "eper". Ostatni ciąg to nowy przyrostek.

Siatkówka, 33 bajty

Więcej informacji o Retina.

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

Oczekuje to dwóch ciągów w STDIN, oddzielonych znakiem nowej linii.

Do celów zliczania każda linia przechodzi do osobnego pliku, \nnależy ją zastąpić rzeczywistym znakiem nowej linii (0x0A). Jeśli naprawdę chcesz to przetestować, wygodniej jest umieścić to w jednym pliku, w którym \npozostaje bez zmian, a następnie wywołać Retinę z -sopcją przed przekazaniem pliku.

Wyjaśnienie

(Nieaktualne ... Udało mi się pozbyć znacznika ... Zaktualizuję to później.)

Każda para linii jest podstawieniem wyrażenia regularnego (pierwsza linia wzoru, druga linia podstawienia).

^
#

To umieszcza #jako znacznik na początku ciągu wejściowego.

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

Znajduje pierwszą literę na wejściu (za znacznikiem) odpowiadającą następnej literze, która ma zostać powielona, ​​powtarza tę literę, przesuwa znacznik za nią i upuszcza pierwszy znak drugiego ciągu. Z +`przodu nakazuje Retinie powtarzanie tej czynności, aż łańcuch przestanie się zmieniać (w tym przypadku, ponieważ drugi łańcuch jest pusty i wszystkie wymagane litery zostały zduplikowane).

#
<empty>

Na koniec oczyszczamy sznurek, upuszczając znacznik.

Python, 61

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

Chciwe rekurencyjne rozwiązanie. Zapisuje, bczy pierwsza litera ciągu sjest pierwszą literą ciągu lliter, która ma zostać podwojona. Jeśli tak, weź jeden z tego listu i dołącz go do wywołania rekurencyjnego wraz z resztą s, usuwając z niego pierwszy element l. Jeśli nie b, zrób to samo, ale nie podwajaj litery i nie usuwaj z niej l.

Kod sprawdza, s[:1]==l[:1]zamiast s[0]==l[0]unikać błędu indeksu poza zakresem, gdy slub ljest pusty.

Prolog, 95 83 79 56 bajtów

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

Przykład:

d(`chameleon`,`caln`).

zwraca

cchaamelleonn

Edycja: Oszczędność 4 bajtów dzięki Oliphauntowi

Edycja2: Zapisano 20 bajtów przy użyciu przestarzałego put/1predykatu SWI-Prolog zamiast writef. Zapisano jeden bajt zastępując predykat końca rekurencji d([],_).na d(_,_).. Nie zadziała, jeśli kolejność dwóch definicji djest zamieniona, ale nie obchodzi nas to w kodzie golfowym. Zapisano kolejne 2 bajty usuwając nawias wokółH=[A|T],put(A),d(S,T)

Python 2, 83 74 72 65 Bajtów

Nie ma tu żadnych specjalnych trików. xjest ciągiem, yjest tablicą powielonych znaków. Aby wyjaśnić, czy nie powiela się to poprawnie, pierwszy poziom wcięcia to spacja, następny to tabulator.

Edycja 1: Zapisano 9 bajtów, używając manipulacji ciągami zamiast pop ().

Edycja 2: Zapisano 2 bajty, używając -~do zwiększenia go 1.

Edycja 3: Zaoszczędzono 7 bajtów za pomocą y[:1]sztuczki, dzięki xnor za to!

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

Sprawdź to tutaj.

Prawidłowo sformatowane i wyjaśnione:

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 bajtów

To mój pierwszy wpis do CodeGolf, więc mam nadzieję, że jest w porządku.

Wpisujesz słowo wejściowe w A1, a następnie litery, które chcesz zastąpić w B1, a słowo wynikowe jest wyświetlane w oknie komunikatu.

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 bajty

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

Przykład użycia:

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

Jak to działa:

Jeśli jeden ciąg jest pusty, wynikiem jest pierwszy ciąg. W przeciwnym razie: jeśli pierwsze znaki ciągów pasują do siebie, weź to dwa razy i dołącz rekurencyjne połączenie z ogonami ciągów. Jeśli znaki nie pasują, weź pierwszy znak pierwszego łańcucha i dołącz rekurencyjne wywołanie z ogonem pierwszego łańcucha i tym samym drugim łańcuchem.

Pyth, 18 17 bajtów

sm?+d.(QZqd&QhQdz

Demo na żywo.

Zapisano 1 bajt dzięki @Jakube.

Wyjaśnienie:

                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.

Orginalna wersja:

jkm?+d.(QZqd&QhQdz

Wersja demonstracyjna na żywo dla oryginału.

JavaScript, 47 bajtów

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

Korzystając z niektórych funkcji ES6.

Pyth, 16 bajtów

u|pH<GJxGH>GJwz

Wypróbuj online: demonstracja

To jest dość zuchwałe. Zaletą mogą być języki oparte na stosie.

Wyjaśnienie

                   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 bajtów

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

Zakłada, że sjest tablicą["c","a","l","n"]

> <> (Ryby) , 68 34 bajtów

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

Możesz uruchomić go na stronie http://fishlanguage.com/playground, wprowadzając ciąg znaków jako początkowy stos (ze znakami „tj.„ Kameleon ”) i tablicę dodatkowych liter jako stos wejściowy (brak znaków„ tj. Caln).

Nie zapomnij nacisnąć przycisku Daj, aby zapełnić stos wejściowy.

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

EDYCJA: O połowę! :)

R 119

Na podstawie @ Alexa odpowiedzi , ten jest kilka bajtów krócej:

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

Nie golfowany:

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

Całkowicie nowe podejście daje znacznie lepsze wyniki. Mimo to założę się, że może być krótszy.

Jak zadzwonić f('coconut', ['c','o']).

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

Dla każdego znaku w tablicy znajdź pierwsze wystąpienie i zduplikuj je, a następnie zmień wszystko na wielkie. Następnie zwróć cały ciąg, przekonwertowany na małe litery.

EDYCJA: ogoliłem kilka innych postaci, pozbywając się shifti pop.

Poprzednia wersja:

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

Rubin, 52 47 bajtów

Rozwiązanie:

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

Przykład:

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

Wyjaśnienie:

Proc postaci metody, która przyjmuje ciąg jako pierwszy argument, a tablica znaków jako drugi argument. Mapuje blok na tablicę znaków w argumencie łańcuchowym, który sprawdza każdy znak względem pierwszego elementu tablicy porównawczej, a jeśli istnieje dopasowanie, usuwa pierwszy element tablicy porównawczej i podwaja go.

aktualizacja

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

Perl, 51 bajtów

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

Dane wejściowe są dostarczane przez STDIN. Pierwsze wejście to słowo początkowe (np. chameleon), Drugie wejście to litery jako pojedynczy ciąg (np caln.).

Powyższe jest tylko zaciemnionym (czytaj „ładniejszym”) sposobem na wykonanie następujących czynności:

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

Podczas przeglądania każdej litery zastępujemy od początku słowa do litery w słowie źródłowym tylko nową literą i dołączamy dopasowanie (zapisane w $&) do naszego wyniku. Ponieważ dopasowanie obejmuje literę, a następnie zostaje zastąpione literą, każda litera pojawia się dwukrotnie.

Ponieważ STDIN dołącza nowy znak linii do obu naszych danych wejściowych, gwarantujemy, że przechwycimy resztki pełnego słowa z ostatniego dopasowania, tj. Nowy znak linii.

REGXY, 24 bajty

Używa REGXY , języka opartego na podstawieniu wyrażenia regularnego. Przyjmuje się, że wejście jest słowem początkowym i tablicą oddzieloną spacją (np. „Calele kameleona”).

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

Program działa poprzez dopasowanie znaku w pierwszym ciągu do pierwszego znaku po spacji. Jeśli to pasuje, znak jest powtarzany w podstawieniu, a znak w tablicy jest usuwany (cóż, nie jest dołączany z powrotem do łańcucha). Przetwarzanie przechodzi do drugiej linii, która jest tylko wskaźnikiem z powrotem do pierwszej linii, co powoduje, że przetwarzanie powtarza się na wyniku poprzedniego podstawienia. Ostatecznie po spacji nie będzie żadnych znaków, w którym to momencie dopasuje się druga gałąź alternacji, usuwając końcowe spacje z wyniku. Wyrażenie regularne nie będzie wtedy pasować, przetwarzanie zostanie zakończone, a wynik zostanie zwrócony.

Jeśli to pomoże, iteracyjne kroki wykonania są następujące:

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

Program kompiluje się i wykonuje poprawnie za pomocą przykładowego interpretera w powyższym linku, ale rozwiązanie może być nieco bezczelne, ponieważ opiera się na założeniu niejasności specyfikacji języka. Specyfikacja określa, że ​​pierwszy token w każdym wierszu (przed /) działa jako etykieta, ale założenie jest takie, że pusty wskaźnik-wskaźnik wskazuje z powrotem na pierwsze polecenie w pliku z pustą etykietą (lub innymi słowy, że „null” jest prawidłową etykietą). Mniej bezczelnym rozwiązaniem byłoby:

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

Co odpowiada 27 bajtom

JavaScript ES6, 72 bajty

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

Jest to anonimowa funkcja, która przyjmuje 2 parametry: słowo początkowe jako ciąg znaków oraz znaki, które rozciągają się jako tablica. Nieskluczony kod, który używa ES5 i testuje interfejs użytkownika poniżej.

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

Zadzwoń jako:

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

Mogłem mieć strasznie błędną liczbę bajtów ... Używa kombinacji spacji i tabulatorów.

rs, 39 bajtów

Więcej informacji o rs.

Istnieje już odpowiedź Retina, ale myślę, że ta metoda jest nieco inna. Zostały one również utworzone osobno: kiedy zacząłem nad tym pracować, ta odpowiedź nie została opublikowana.

Poza tym ten i tak jest o 6 bajtów dłuższy. :)

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

Demo na żywo i pakiet testowy.

JavaScript, 92 znaki

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}

Wersja nieobjawiona:

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 bajtów

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

Spowoduje to utworzenie nienazwanej funkcji, która przyjmuje ciąg znaków i wektor znaków jako dane wejściowe i drukuje ciąg znaków do STDOUT. Aby to nazwać, nadaj mu nazwę.

Niegolfowane + wyjaśnienie:

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

Przykłady:

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

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

Zaoszczędź 8 bajtów dzięki MickeyT i kolejne 3 dzięki Jja!

Bash + sed, 51

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

Dane wejściowe ze standardowego wejścia; znaki, które należy podwoić jako pojedynczy argument:

$ echo chameleon | strtech caln
cchaamelleonn

Działa to poprzez zbudowanie programu sed z, $2a następnie wykonanie go przeciwko $1. Program sed zastępuje pierwsze wystąpienie każdej litery zastępczej dwiema kopiami jej wielkiej wersji, a na końcu zmniejsza całą partię. W powyższym przykładzie wygenerowany program sed to

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

ładnie wydrukowane:

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

Używam wielkich liter do oznaczania znaków przetworzonych do tej pory; pozwala to uniknąć ponownego podwojenia postaci, które zostały już podwojone, lub zastosowania podwojenia wcześniejszego niż poprzedni.

Wcześniejsza wersja, przed wyjaśnieniem, że kolejność listy zamienników jest znacząca (44 znaki):

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

Python, 53 92 bajty

Stwierdziłem, że moje rozwiązanie ma tę samą długość zarówno w Pythonie 2, jak i 3.

EDYCJA: Człowieku, naprawienie tego przypadku przy wykonywaniu wielu zamian tej samej litery (wciąż przy użyciu tej samej metody) zajęło trochę pracy.

Python 2:

Wypróbuj tutaj

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 bajtów

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

Przykład:

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 bajtów

Nowe, całkowicie przerobione rozwiązanie z pomocą wieselkatze i SquidDev! chodźcie chłopaki, możemy pokonać bzdury: P

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

Wyjaśnienie nadchodzi jutro. Wypróbuj tutaj.

Oryginalne rozwiązanie: zaoszczędzono 2 bajty dzięki @ kirbyfan64sos!

Lua jest dość okropnym językiem do gry w golfa, więc myślę, że dobrze sobie z tym poradziłem.

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

Objaśnienie kodu wraz z wersją bez golfa:

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

Wypróbuj tutaj. (Nieaktualny kod, ale ta sama koncepcja, tylko mniej golfa, zaktualizuje jutro)