Напишите программу или функцию, которая дублирует буквы в слове, чтобы все дублированные буквы, расположенные слева направо в слове, образовывали входной массив.

Например:

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

вход

• Начальное слово (например chameleon)
• Массив символов ( [c,a,l,n]) или строка для представления array ( caln), или что-то подобное
• Ввод может быть через параметры функции, STDIN или языковые эквиваленты
• Все входные данные будут состоять из строчных букв (az)

Выход

• Измененное слово

• Если есть несколько решений, любое может быть напечатано

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

• Вы можете предположить, что входное слово (не обязательно массив) будет иметь буквы в массиве (по порядку)

• Вы также можете предположить, что входные данные не имеют одинаковых последовательных букв (НЕ apple, geek, green, glass, door ...)

Примеры

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.

Самая короткая программа выигрывает!

Таблица лидеров (спасибо Мартину Бюттнеру за фрагмент)

/* Configuration */

var QUESTION_ID = 51984; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";

/* App */

var answers = [], page = 1;

function answersUrl(index) {
  return "http://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

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

getAnswers();

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

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

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

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

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

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

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

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

  langs.sort(function (a, b) {
    if (a.lang > b.lang) return 1;
    if (a.lang < b.lang) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 50%;
  float: left;
}

#language-list {
  padding: 10px;
  width: 50%px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

Pyth, 14 байт

s+L&@d<Q1.(QZz

Демонстрация.

Стиль ввода:

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

Объяснение:

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

s                 Concatenate and print.

Brainfuck, 46 45 (63 с печатными символами на входе)

Совместим с bff Алекса Панкратова (интерпретатор brainfuck, используемый на SPOJ и ideone) и BFI Томаса Корта (используется на Anarchy Golf).

Версия для печати сначала берет массив в виде строки, затем следует вкладка, за которой следует начальная строка без завершающей строки.

Демонстрация на идеоне.

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

Мы можем сохранить несколько байтов, используя \x00вместо табуляции разделитель:

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

CJam, 15 байтов

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

Попробуйте онлайн.

Как это работает

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

C, 62 байта

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

Ну, это на удивление конкурентно.

Мы определяем функцию, f(char*, char*)которая принимает строку в качестве первого ввода и массив символов для дублирования в качестве второго ввода.

Некоторый тестовый код:

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

Какие отпечатки:

oonomaatoopeia

Попробуйте онлайн !

Если допустимо передавать макрос, а не функцию, следующее #define g(s,c)- это всего лишь 58 байтов , но оно требует sи cдолжно быть фактическим указателем:

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

CJam, 15 байтов

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

Альтернативный подход CJam. Попробуйте онлайн

объяснение

Для каждого символа во второй строке мы делаем две вещи.

1. Разделить текущий суффикс строки на символ, например "beeper" "e" -> ["b" "" "p" "r"]

2. Разъединяет первую строку в массиве, вставляет два символа, затем воссоединяет остальную часть массива с символом, например "b" "ee" "eper". Последняя строка - это новый суффикс.

Сетчатка, 33 байта

Больше информации о Retina.

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

Это предполагает две строки в STDIN, разделенные новой строкой.

For counting purposes, each line goes into a separate file, \n should be replaced with an actual newline character (0x0A). If you actually want to test this, it's more convenient to put this in a single file where \n remains as it is and then invoke Retina with the -s option before passing the file.

Explanation

(Outdated... I managed to get rid of the marker... I'll update this later.)

Each pair of lines is a regex substitution (first line the pattern, second line the substitution).

^
#

This puts a # as a marker at the start of the input string.

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

This finds the first letter in the input (after the marker) corresponding to the next letter to be duplicated, duplicates that letter, moves the marker behind it, and drops the first character of the second string. The +` at the front tells Retina to do this repeatedly until the string stops changing (in this case, because the second string is empty and all required letters have been duplicated).

#
<empty>

Finally, we clean up the string by dropping the marker.

Python, 61

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

A greedy recursive solution. Saves to b whether the first letter of the string s is the first letter of the string l of letters to double. If so, take one of that letter and prepend it to the recursive call with the rest of s, removing the first element from l. If not b, do the same but don't double the letter and don't remove from l.

The code checks s[:1]==l[:1] rather than s[0]==l[0] to avoid an index-out-of-bounds error when s or l is empty.

Prolog, 95 83 79 56 bytes

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

Example:

d(`chameleon`,`caln`).

returns

cchaamelleonn

Edit: Saved 4 bytes thanks to Oliphaunt

Edit2: Saved 20 bytes using the deprecated put/1 SWI-Prolog predicate instead of writef. Saved one byte replacing the recursion end predicate d([],_). to d(_,_).. Won't work if the ordering of the two definitions of d is swapped though, but we don't care about that in golfed code. Saved another 2 bytes removing the parenthesis around H=[A|T],put(A),d(S,T)

Python 2, 83 74 72 65 Bytes

No real special tricks here. x is the string, y is the array of characters that are duplicated. To clarify if this doesn't copy properly, the first indentation level is a space, the next is a tab.

Edit 1: Saved 9 bytes by using string manipulation instead of pop().

Edit 2: Saved 2 bytes by using -~ to increment g by 1.

Edit 3: Saved 7 bytes by using y[:1] trick, thanks to xnor for this!

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

Check it out here.

Properly formatted and explained:

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

This is my first entry to CodeGolf so I hope this is ok.

You enter the input word in A1 and then the letters to be replaced in B1 and the resulting word is displayed in a message box.

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

Usage example:

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

How it works:

If one string is empty, the result is the first string. Else: if the first characters of the strings match, take it two times and append a recursive call with the tails of the strings. If the characters don't match, take the first character of the first string and append a recursive call with the tail of the first string and the same second string.

Pyth, 18 17 bytes

sm?+d.(QZqd&QhQdz

Live demo.

Saved 1 byte thanks to @Jakube.

Explanation:

                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.

Original version:

jkm?+d.(QZqd&QhQdz

Live demo for original.

Javascript, 47 bytes

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

Taking advantage of some ES6 features.

Pyth, 16 байт

u|pH<GJxGH>GJwz

Попробуйте онлайн: демонстрация

Это довольно глупо. Языки, основанные на стеке, могут иметь здесь преимущество.

объяснение

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

JavaScript ES6, 47 байт

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

Предполагается, что sмассив["c","a","l","n"]

> <> (Рыба) , 68 34 байта

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

Вы можете запустить его на http://fishlanguage.com/playground вводя строку в качестве начального стека (с «отметками, т.е.« хамелеон ») и массивом дополнительных букв в качестве входного стека (без« отметок », то есть caln).

Не забудьте нажать кнопку Give, чтобы заполнить входной стек.

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

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

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

РЕДАКТИРОВАТЬ: вдвое! :)

R 119

Исходя из ответа @ Алекса , этот на пару байтов короче:

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

Абсолютно новый подход дает гораздо лучшие результаты. Тем не менее, я уверен, что это может быть короче.

Звоните как f('coconut', ['c','o']).

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

Для каждого символа в массиве найдите первое вхождение, продублируйте его и переведите все в верхний регистр. Затем верните всю строку, преобразованную в нижний регистр.

РЕДАКТИРОВАТЬ: побрил еще пару персонажей, избавившись от shiftи pop.

Предыдущая версия:

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

Рубин, 52 47 байт

Решение:

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

Пример:

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

Объяснение:

Proc форма метода, который принимает строку в качестве первого аргумента и массив символов в качестве второго аргумента. Сопоставляет блок с массивом символов в строковом аргументе, который проверяет каждый символ по первому элементу массива сравнения и, если есть совпадение, удаляет первый элемент массива сравнения и удваивает его.

Обновить

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

Perl, 51 байт

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

Ввод осуществляется через STDIN. Первый ввод - начальное слово (например chameleon), второй ввод - буквы в виде одной строки (например caln).

Вышесказанное является просто обфусцированным (читай "красивее") способом сделать следующее:

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

Проходя каждую букву, мы заменяем от начала слова до буквы в исходном слове только новую букву и добавляем совпадение (сохраненное в $&) к нашему результату. Поскольку совпадение включает в себя букву, а затем заменяется буквой, каждая буква заканчивается дважды.

Поскольку STDIN добавляет символ новой строки к обоим нашим входам, мы гарантированно фиксируем остатки полного слова в последнем совпадении, то есть символ новой строки.

REGXY, 24 байта

Использует REGXY , язык подстановки регулярных выражений. Предполагается, что входными данными являются начальное слово и массив, разделенные пробелом (например, «хамелеон калн»).

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

Программа работает путем сопоставления символа в первой строке с первым символом после пробела. Если это соответствует, символ повторяется в подстановке, и символ в массиве удаляется (ну, не добавляется обратно в строку). Обработка переходит ко второй строке, которая является просто указателем на первую строку, что приводит к повторению обработки по результату предыдущей замены. В конце концов, после пробела не будет символов, после чего вторая ветвь чередования будет совпадать, удаляя завершающий пробел из результата. Затем регулярное выражение не будет соответствовать, обработка завершена и результат будет возвращен.

Если это помогает, итеративные шаги выполнения следующие:

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

Программа компилируется и выполняется правильно с помощью примера интерпретатора по ссылке выше, но решение, возможно, немного дерзкое, поскольку оно основано на допущении в неопределенности языковой спецификации. Спецификация утверждает, что первый токен в каждой строке (перед /) действует как метка, но предполагается, что нулевой указатель метки будет указывать на первую команду в файле с нулевой меткой (или другими словами, это 'null' является допустимой меткой). Менее нахальное решение было бы:

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

Что составляет 27 байтов

JavaScript ES6, 72 байта

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

Это анонимная функция, которая принимает 2 параметра: начальное слово в виде строки и символы для растяжения в виде массива. Разгруженный код, который использует ES5 и тестовый интерфейс ниже.

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

Звоните как:

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

Возможно, я неправильно подсчитал количество байтов ... Использует смесь пробелов и табуляции.

RS, 39 байт

Больше информации о rs.

Уже есть ответ Retina, но я думаю, что этот использует немного другой подход. Они также были созданы отдельно: когда я начал работать над этим, этот ответ не был опубликован.

Кроме того, этот в любом случае на 6 байт длиннее. :)

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

Живая демо-версия и тестовый набор.

JavaScript, 92 символа

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}

Необъясненная версия:

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 байтов

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

Это создает безымянную функцию, которая принимает строку и символьный вектор в качестве входных данных и печатает строку в STDOUT. Чтобы назвать это, дать ему имя.

Ungolfed + объяснение:

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

Примеры:

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

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

Благодаря MickeyT сэкономлено 8 байт, а jja - еще 3!

Баш + Сед, 51

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

Ввод от stdin; символы, которые должны быть удвоены как один аргумент:

$ echo chameleon | strtech caln
cchaamelleonn

Это работает путем построения программы sed из $2и затем выполнения ее против$1 . Программа sed заменяет первое вхождение каждой буквы замены двумя копиями ее заглавной версии, а в конце преуменьшает значение всей партии. Для приведенного выше примера сгенерированная программа sed

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

довольно отпечатанный:

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

Я использую прописные буквы, чтобы отметить символы, обработанные до сих пор; это позволяет избежать повторного удвоения символов, которые уже были удвоены, или применения удвоения раньше, чем предыдущий.

Более ранняя версия, перед уточнением, что порядок замены списка является значительным (44 символа):

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

Python, 53 92 байта

Нашел мое решение одинаковой длины в Python 2 и 3.

РЕДАКТИРОВАТЬ: Человек, исправление этого случая, когда выполнение нескольких замен одной и той же буквы (при этом все еще используя тот же метод) потребовалось немного работы.

Python 2:

Попробуй здесь

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 байт

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

Пример:

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

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

Out[2]= "bannaana"

Луа, 76 78 76 75 58 53 байта

Новое, полностью переработанное решение с помощью wieselkatze и SquidDev! давай, ребята, мы можем победить мозговой трах: P

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

Объяснение грядущего завтра. Попробуй это здесь.

Оригинальное решение: экономия 2 байта благодаря @ kirbyfan64sos!

Lua - довольно ужасный язык для игры в гольф, так что, думаю, я неплохо справился с этим.

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

Объяснение кода вместе с негольфированной версией:

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

Попробуй это здесь. (Устаревший код, но та же концепция, чуть менее удачная, обновит завтра)