Viết chương trình hoặc hàm sao chép các chữ cái trong một từ để tất cả các chữ cái trùng lặp được sắp xếp từ trái sang phải trong từ sẽ tạo thành mảng đầu vào.

Ví dụ:

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

Đầu vào

• Từ bắt đầu (ví dụ chameleon)
• Một mảng các ký tự ( [c,a,l,n]) hoặc một chuỗi để biểu thị một mảng ( caln) hoặc một cái gì đó tương tự
• Đầu vào có thể thông qua các tham số chức năng, STDIN hoặc tương đương ngôn ngữ
• Tất cả các đầu vào sẽ là chữ thường (az)

Đầu ra

• Từ đã thay đổi

• Nếu có nhiều giải pháp, bất kỳ giải pháp nào cũng có thể được in

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

• Bạn có thể giả sử rằng từ đầu vào (không nhất thiết là mảng) sẽ có các chữ cái trong mảng (theo thứ tự)

• Bạn cũng có thể cho rằng các đầu vào không có các chữ cái liên tiếp giống nhau (KHÔNG phải táo, geek, xanh lá cây, kính, cửa ...)

Ví dụ

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.

Chương trình ngắn nhất sẽ thắng!

Bảng xếp hạng (cảm ơn Martin Büttner cho đoạn trích)

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

Bình thường, 14 byte

s+L&@d<Q1.(QZz

Trình diễn.

Kiểu đầu vào:

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

Giải trình:

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 với các ký tự có thể in trong đầu vào)

Tương thích với bff của Alex Pankratov (trình thông dịch brainfuck được sử dụng trên SPOJ và ideone) và Thomas Cort's BFI (được sử dụng trên Anarchy Golf).

Phiên bản có thể in lấy mảng đầu tiên dưới dạng chuỗi, tiếp theo là tab, theo sau là chuỗi bắt đầu không có dòng mới.

Trình diễn về ideone.

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

Chúng ta có thể lưu một số byte bằng cách sử dụng \x00làm dấu phân cách thay vì tab:

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

CJam, 15 byte

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

Hãy thử trực tuyến.

Làm thế nào nó hoạt động

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

Vâng, đây là cạnh tranh đáng ngạc nhiên.

Chúng tôi định nghĩa một hàm f(char*, char*)lấy chuỗi làm đầu vào đầu tiên của nó và mảng các ký tự để nhân đôi làm đầu vào thứ hai của nó.

Một số mã kiểm tra:

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

Bản in nào:

oonomaatoopeia

Hãy thử trực tuyến !

Nếu có thể chấp nhận gửi macro thay vì hàm, thì sau đây #define g(s,c)chỉ là 58 byte , nhưng yêu cầu svà cphải là con trỏ thực tế:

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

CJam, 15 byte

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

Một cách tiếp cận khác của CJam. Dùng thử trực tuyến

Giải trình

Đối với mỗi nhân vật trong chuỗi thứ hai, chúng tôi làm hai việc.

1. Chia hậu tố hiện tại của chuỗi cho ký tự, vd "beeper" "e" -> ["b" "" "p" "r"]

2. Uncons chuỗi đầu tiên trong mảng, chèn hai trong số những nhân vật, sau đó nối lại phần còn lại của mảng với các nhân vật, ví dụ "b" "ee" "eper". Chuỗi cuối cùng là hậu tố mới.

Võng mạc, 33 byte

Thêm thông tin về Retina.

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

Điều này hy vọng hai chuỗi trên STDIN, được phân tách bằng một dòng mới.

Đối với mục đích đếm, mỗi dòng đi vào một tệp riêng biệt, \nnên được thay thế bằng một ký tự dòng mới thực tế (0x0A). Nếu bạn thực sự muốn kiểm tra điều này, sẽ thuận tiện hơn khi đặt tệp này vào một tệp duy nhất \nvẫn giữ nguyên và sau đó gọi Retina với -stùy chọn trước khi truyền tệp.

Giải trình

(Đã lỗi thời ... Tôi đã tìm cách loại bỏ điểm đánh dấu ... Tôi sẽ cập nhật thông tin này sau.)

Mỗi cặp dòng là một thay thế regex (dòng đầu tiên mẫu, dòng thứ hai thay thế).

^
#

Điều này đặt #làm điểm đánh dấu ở đầu chuỗi đầu vào.

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

Điều này tìm thấy chữ cái đầu tiên trong đầu vào (sau điểm đánh dấu) tương ứng với chữ cái tiếp theo được sao chép, sao chép chữ cái đó, di chuyển điểm đánh dấu phía sau nó và bỏ ký tự đầu tiên của chuỗi thứ hai. Ở +`phía trước bảo Retina thực hiện việc này nhiều lần cho đến khi chuỗi dừng thay đổi (trong trường hợp này, vì chuỗi thứ hai trống và tất cả các chữ cái bắt buộc đã được sao chép).

#
<empty>

Cuối cùng, chúng tôi dọn sạch chuỗi bằng cách thả điểm đánh dấu.

Con trăn, 61

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

Một giải pháp đệ quy tham lam. Lưu vào bxem chữ cái đầu tiên của chuỗi scó phải là chữ cái đầu tiên của chuỗi lký tự tăng gấp đôi hay không. Nếu vậy, hãy lấy một trong những chữ cái đó và gửi nó vào cuộc gọi đệ quy với phần còn lại s, loại bỏ phần tử đầu tiên khỏi l. Nếu không b, làm tương tự nhưng không nhân đôi chữ cái và không xóa khỏi l.

Mã kiểm tra s[:1]==l[:1]thay vì s[0]==l[0]để tránh lỗi ngoài chỉ mục khi shoặc ltrống.

Prolog, 95 83 79 56 byte

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

Thí dụ:

d(`chameleon`,`caln`).

trả lại

cchaamelleonn

Chỉnh sửa: Đã lưu 4 byte nhờ vào Oliphistic

Edit2: Đã lưu 20 byte bằng cách sử dụng put/1vị từ SWI-Prolog không dùng nữa thay vì writef. Đã lưu một byte thay thế vị từ kết thúc đệ quy d([],_).thành d(_,_).. Sẽ không hoạt động nếu thứ tự của hai định nghĩa dđược hoán đổi, nhưng chúng tôi không quan tâm đến điều đó trong mã golf. Đã lưu 2 byte khác loại bỏ dấu ngoặc đơn xung quanhH=[A|T],put(A),d(S,T)

Python 2, 83 74 72 65 byte

Không có thủ thuật đặc biệt thực sự ở đây. xlà chuỗi, ylà mảng các ký tự được nhân đôi. Để làm rõ nếu điều này không sao chép đúng, mức thụt đầu tiên là một khoảng trắng, tiếp theo là một tab.

Chỉnh sửa 1: Đã lưu 9 byte bằng cách sử dụng thao tác chuỗi thay vì pop ().

Chỉnh sửa 2: Đã lưu 2 byte bằng cách sử dụng -~để tăng thêm g1.

Chỉnh sửa 3: Đã lưu 7 byte bằng cách sử dụng y[:1]thủ thuật, nhờ xnor cho việc này!

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

Kiểm tra nó ở đây.

Định dạng và giải thích chính xác:

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.

VBA Excel, 110 byte

Đây là mục nhập đầu tiên của tôi vào CodeGolf vì vậy tôi hy vọng điều này là ổn.

Bạn nhập từ đầu vào trong A1 và sau đó các chữ cái sẽ được thay thế trong B1 và ​​từ kết quả được hiển thị trong hộp thông báo.

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

Ví dụ sử dụng:

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

Làm thế nào nó hoạt động:

Nếu một chuỗi trống, kết quả là chuỗi đầu tiên. Khác: nếu các ký tự đầu tiên của chuỗi khớp với nhau, hãy thực hiện hai lần và nối thêm một cuộc gọi đệ quy với các đuôi của chuỗi. Nếu các ký tự không khớp, lấy ký tự đầu tiên của chuỗi đầu tiên và nối một cuộc gọi đệ quy với đuôi của chuỗi đầu tiên và cùng chuỗi thứ hai.

Bình thường, 18 17 byte

sm?+d.(QZqd&QhQdz

Bản thử trực tiếp.

Đã lưu 1 byte nhờ @Jakube.

Giải trình:

                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.

Phiên bản gốc:

jkm?+d.(QZqd&QhQdz

Bản demo trực tiếp cho bản gốc.

Javascript, 47 byte

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

Tận dụng một số tính năng ES6.

Bình thường, 16 byte

u|pH<GJxGH>GJwz

Dùng thử trực tuyến: Trình diễn

Điều này là khá hack. Các ngôn ngữ dựa trên ngăn xếp có thể có một lợi thế ở đây.

Giải trình

                   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)

Giả sử slà một mảng["c","a","l","n"]

> <> (Cá) , 68 34 byte

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

Bạn có thể chạy nó ở http://fishlanguage.com/playground nhập chuỗi như ngăn xếp ban đầu (với "nhãn hiệu, tức là 'tắc kè hoa') và các mảng của các chữ cái phụ như ngăn xếp đầu vào (không có" dấu tức là caln).

Đừng quên nhấn nút Cho để chọn ngăn xếp đầu vào.

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: Giảm một nửa! :)

R, 119

Dựa trên câu trả lời của @ Alex , cái này ngắn hơn một vài byte:

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

Ung dung:

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

Cách tiếp cận hoàn toàn mới mang lại kết quả tốt hơn nhiều. Tuy nhiên, tôi cá là nó có thể ngắn hơn.

Gọi như f('coconut', ['c','o']).

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

Đối với mỗi ký tự trong mảng, tìm lần xuất hiện đầu tiên và nhân đôi nó, và biến mọi thứ thành chữ hoa. Sau đó trả lại toàn bộ chuỗi, chuyển đổi thành chữ thường.

EDIT: cạo một vài nhân vật bằng cách loại bỏ shiftvà pop.

Phiên bản trước:

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

Hồng ngọc 52 47 byte

Dung dịch:

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

Thí dụ:

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

Giải trình:

Dạng Proc của một phương thức lấy một chuỗi làm đối số thứ nhất và một mảng các ký tự làm đối số thứ hai. Ánh xạ một khối vào một mảng các ký tự trong đối số chuỗi, kiểm tra từng ký tự dựa vào phần tử đầu tiên của mảng so sánh và nếu có khớp, loại bỏ phần tử đầu tiên của mảng so sánh và nhân đôi nó.

cập nhật

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

Perl, 51 byte

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

Đầu vào được cung cấp qua STDIN. Đầu vào đầu tiên là từ bắt đầu (ví dụ chameleon), đầu vào thứ hai là các chữ cái dưới dạng một chuỗi (ví dụ caln).

Trên đây chỉ là một cách làm khó hiểu (đọc "prettier") như sau:

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

Khi chúng tôi đi qua từng chữ cái, chúng tôi thay thế từ đầu của từ cho đến chữ cái trong từ nguồn chỉ bằng chữ cái mới và nối phần khớp (được lưu trữ $&) vào kết quả của chúng tôi. Vì trận đấu bao gồm chữ cái và sau đó được thay thế bằng chữ cái, mỗi chữ cái kết thúc xuất hiện hai lần.

Vì STDIN nối thêm một ký tự dòng mới cho cả hai đầu vào của chúng tôi, chúng tôi đảm bảo sẽ ghi lại phần còn lại của từ đầy đủ trong trận đấu cuối cùng, tức là ký tự dòng mới.

ĐĂNG KÝ, 24 byte

Sử dụng REGXY , một ngôn ngữ dựa trên regex thay thế. Đầu vào được coi là từ bắt đầu và mảng, khoảng cách được phân tách (ví dụ: "tắc kè hoa caln").

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

Chương trình hoạt động bằng cách khớp một ký tự trong chuỗi đầu tiên với ký tự đầu tiên sau một khoảng trắng. Nếu điều này khớp, ký tự được lặp lại trong thay thế và ký tự trong mảng bị loại bỏ (tốt, không được nối lại vào chuỗi). Quá trình xử lý chuyển sang dòng thứ hai, chỉ là một con trỏ quay lại dòng đầu tiên, điều này khiến quá trình xử lý lặp lại trên kết quả của sự thay thế trước đó. Cuối cùng, sẽ không có ký tự nào sau dấu cách, tại đó, nhánh thứ hai của phép xen kẽ sẽ khớp với nhau, loại bỏ khoảng trắng ở cuối kết quả. Regex sau đó sẽ không khớp, xử lý hoàn tất và kết quả được trả về.

Nếu nó giúp, các bước lặp thực hiện như sau:

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

Chương trình biên dịch và thực thi chính xác với trình thông dịch mẫu trong liên kết ở trên, nhưng giải pháp có lẽ hơi táo tợn vì nó dựa vào một giả định trong sự mơ hồ của đặc tả ngôn ngữ. Thông số kỹ thuật nói rằng mã thông báo đầu tiên trên mỗi dòng (trước /) hoạt động như một nhãn, nhưng giả định là con trỏ nhãn null sẽ quay lại lệnh đầu tiên trong tệp có nhãn null (hay nói cách khác là rằng 'null' là nhãn hợp lệ). Một giải pháp ít táo tợn hơn sẽ là:

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

Số tiền lên tới 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``

Đây là một hàm ẩn danh có 2 tham số: từ bắt đầu dưới dạng một chuỗi và các ký tự kéo dài thành một mảng. Mã không sử dụng ES5 và giao diện người dùng thử bên dưới.

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>

Con trăn 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

Gọi như:

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

Tôi có thể đã có số byte sai lầm khủng khiếp ... Sử dụng hỗn hợp các khoảng trắng và tab.

rs, 39 byte

Thêm thông tin về rs.

Đã có câu trả lời Retina, nhưng tôi nghĩ rằng câu trả lời này sử dụng một cách tiếp cận hơi khác. Chúng cũng được tạo riêng: khi tôi bắt đầu làm việc trên cái này, câu trả lời đó đã không được đăng.

Bên cạnh đó, cái này dài hơn 6 byte. :)

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

Bản demo và bộ thử nghiệm trực tiếp.

JavaScript, 92 ký tự

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}

Phiên bản chưa được kích hoạt:

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

Điều này tạo ra một hàm không tên chấp nhận một chuỗi và một vectơ ký tự làm đầu vào và in một chuỗi thành STDOUT. Để gọi nó, đặt tên cho nó.

Ungolfed + giải thích:

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

Ví dụ:

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

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

Đã lưu 8 byte nhờ MickeyT và 3 byte khác nhờ jja!

Bash + sed, 51

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

Đầu vào từ stdin; các ký tự được nhân đôi thành một đối số duy nhất:

$ echo chameleon | strtech caln
cchaamelleonn

Điều này hoạt động bằng cách xây dựng một chương trình sed từ $2và sau đó thực hiện nó chống lại $1. Chương trình sed thay thế lần xuất hiện đầu tiên của mỗi chữ cái thay thế bằng hai bản sao của phiên bản chữ hoa và viết tắt toàn bộ lô ở cuối. Đối với ví dụ trên, chương trình sed được tạo là

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

in đẹp:

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

Tôi sử dụng chữ hoa để đánh dấu các ký tự được xử lý cho đến nay; điều này tránh việc nhân đôi lại các ký tự đã được nhân đôi hoặc áp dụng nhân đôi sớm hơn so với nhân vật trước đó.

Phiên bản trước đó, trước khi làm rõ rằng thứ tự của danh sách thay thế là đáng kể (44 ký tự):

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

Python, 53 92 byte

Tìm thấy giải pháp của tôi có cùng độ dài trong cả Python 2 và 3.

EDIT: Man, sửa trường hợp đó khi thực hiện nhiều thay thế của cùng một chữ cái (trong khi vẫn sử dụng cùng một phương thức) mất một chút công việc.

Con trăn 2:

Hãy thử nó ở đây

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

Con trăn 3:

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

Toán học, 66 byte

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

Thí dụ:

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

Giải pháp mới, hoàn toàn được làm lại với sự giúp đỡ từ w Dieselkatze và SquidDev! Thôi nào các bạn, chúng ta có thể đánh bại brainfuck: P

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

Giải thích sắp tới. Hãy thử nó ở đây.

Giải pháp ban đầu: Đã lưu 2 byte nhờ @ kirbyfan64sos!

Lua là một ngôn ngữ khá tệ để chơi gôn, vì vậy tôi nghĩ rằng tôi đã làm khá tốt cho môn này.

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

Giải thích mã, cùng với phiên bản chưa được chỉnh sửa:

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

Hãy thử nó ở đây. (Mã lỗi thời nhưng cùng một khái niệm, chỉ cần ít chơi gôn hơn, sẽ cập nhật tommorow)