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

Наприклад:

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

Вхідні дані

• Початкове слово (наприклад chameleon)
• Масив символів ( [c,a,l,n]) або рядок, який представляє масив ( caln), або щось подібне
• Введення можна через параметри функції, STDIN або мовні еквіваленти
• Усі входи будуть малі літери (az)

Вихід

• Змінене слово

• Якщо є кілька рішень, будь-яке можна роздрукувати

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

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

• Ви також можете припустити, що на входах немає однакових послідовних літер (НЕ яблуко, вуха, зелень, скло, двері ...)

Приклади

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>

Піт, 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 із символами для друку)

Сумісність з Alex Панкратова BFF (Brainfuck інтерпретатора , що використовується на SPOJ і ideone) і Томаса Корта в BFI (використовується на Anarchy Golf).

Версія для друку спочатку приймає масив як рядок, після чого - вкладка, а потім - початковий рядок, що не містить нового рядка.

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

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

Ми можемо зберегти деякі байти, використовуючи \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, розділених новим рядком.

З метою підрахунку кожен рядок переходить в окремий файл, його \nслід замінити фактичним символом нового рядка (0x0A). Якщо ви насправді хочете перевірити це, зручніше розмістити це в одному файлі, де \nзалишається таким, як є, а потім викликати Retina з -sможливістю, перш ніж передавати файл.

Пояснення

(Застаріло ... Мені вдалося позбутися маркера ... Я оновлю це пізніше.)

Кожна пара рядків є заміною регулярного виразка (перший рядок шаблону, другий рядок заміщення).

^
#

Це ставить #як маркер на початку вхідного рядка.

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

Це знаходить першу букву на вході (після маркера), відповідну наступній букві, що дублюється, дублює цю букву, переміщує маркер за нею та викидає перший символ другого рядка. +`На фронті говорить Retina , щоб зробити це кілька разів , поки рядок не перестає змінюватися (в даному випадку, тому що другий рядок порожня , і всі необхідні букви були продубльовані).

#
<empty>

Нарешті, очищаємо рядок, скидаючи маркер.

Пітона, 61

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

Жадібне рекурсивне рішення. Збережує, bчи є перша літера рядка sпершою літерою рядка lбукв, що подвоюється. Якщо так, візьміть один із цього листа і додайте його до рекурсивного дзвінка з рештою s, видаливши перший елемент з l. Якщо ні b, зробіть те ж саме, але не подвоюйте букву і не видаляйте її l.

Код перевіряє s[:1]==l[:1]замість того, s[0]==l[0]щоб уникнути помилки індексу поза межами, коли sабо lпорожній.

Пролог, 95 83 79 56 байт

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

Приклад:

d(`chameleon`,`caln`).

повертає

cchaamelleonn

Редагувати: Збережено 4 байти завдяки Oliphaunt

Edit2: Збережено 20 байт за допомогою застарілого put/1предиката SWI-Prolog замість writef. Збережений один байт замінює предикат кінця рекурсії d([],_).на d(_,_).. Не буде працювати, якщо впорядкування двох визначень dбуде замінено, але нас це не хвилює в коді для гольфу. Збережено ще 2 байти, видаливши круглі дужки навколоH=[A|T],put(A),d(S,T)

Пітон 2, 83 74 72 65 байт

Тут немає ніяких справжніх спеціальних хитрощів. xє рядок, yце масив символів, які дублюються.Для уточнення, якщо це не копіюється належним чином, перший рівень відступу - пробіл, наступний - вкладка.

Редагувати 1: Збережено 9 байт, використовуючи маніпуляції з рядками замість pop ().

Редагувати 2: збережено 2 байти за допомогою -~збільшенняg до 1.

Edit 3: Збережено 7 байт за допомогою y[:1]трюку, завдяки xnor за це!

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

Перевірте це тут.

Належне форматування та пояснення:

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

Це мій перший вступ до CodeGolf, тому я сподіваюся, що це нормально.

Ви вводите слово введення в A1, а потім літери, які слід замінити у B1, а отримане слово відображається у вікні повідомлення.

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

Хаскелл, 42 байти

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

Приклад використання:

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

Як це працює:

Якщо один рядок порожній, результат - перший рядок. Інше: якщо перші символи рядків збігаються, візьміть це два рази і додайте рекурсивний дзвінок з хвостами рядків. Якщо символи не збігаються, візьміть перший символ першого рядка та додайте рекурсивний виклик хвостом першого рядка та тим же другим рядком.

Піт, 18 17 байт

sm?+d.(QZqd&QhQdz

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

Збережено 1 байт завдяки @Jakube.

Пояснення:

                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.

Оригінальна версія:

jkm?+d.(QZqd&QhQdz

Демонстраційна демонстрація оригіналу.

Javascript, 47 байт

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

Користуючись деякими функціями ES6.

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 вводячи рядок як початковий стек (з "позначками, тобто" хамелеоном "), а масив додаткових літер як стек введення (немає" знаків, тобто кал).

Не забудьте натиснути кнопку "Дати", щоб завести вхідний стек.

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

Безголівки:

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

Перл, 73 62 59 56

Зовсім новий підхід дає набагато кращі результати. Все-таки, я вважаю, що це може бути коротшим.

Телефонувати як f('coconut', ['c','o']).

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

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

EDIT: поголив ще пару символів, позбувшись 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"

Пояснення:

Прока форма методу, який приймає рядок як перший аргумент, а масив символів як другий аргумент. Відображає блок на масив символів у рядковому аргументі, який перевіряє кожен символ проти першого елемента масиву порівняння, і якщо є відповідність, видаляє перший елемент масиву порівняння та подвоює його.

оновлення

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 , мову на основі заміщення регулярних виразів . Вхідними вважаються початкове слово та масив, пробіл розділений (наприклад, "хамелеон caln").

/(.)(.* )\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>

Пітон 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. Щоб зателефонувати, дайте ім’я.

Недоліковані + пояснення:

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

Збережено 8 байт завдяки MickeyT та ще 3 завдяки jja!

Bash + sed, 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&/"

Пітон, 53 92 байти

Я знайшов моє рішення однакової довжини в Python 2 та 3.

EDIT: Людина, виправлення цього випадку під час декількох підмінь однієї і тієї ж літери (при цьому все ще використовуючи один і той же метод) зайняло трохи роботи.

Пітон 2:

Спробуйте тут

def f(s,t):
 for c in t:s=s.replace(c,'%',1)
 print s.replace('%','%s')%tuple(x*2for x in t)

Пітон 3:

s,*t=input()
for c in t:s=s.replace(c,'%',1)
print(s.replace('%','%s')%tuple(x*2for x in t))

Математика, 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

Спробуйте тут. (Застарілий код, але та сама концепція, лише менша кількість гольфу, буде оновлена ​​завтра)