Bir sözcükteki harfleri çoğaltan bir program veya işlev yazın; böylece sözcükteki soldan sağa düzenlenen tüm yinelenen harflerin giriş dizisini oluşturabilmesini sağlayın.

Örneğin:

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

Giriş

• Başlangıç ​​sözcüğü (örn. chameleon)
• Bir karakter dizisi ( [c,a,l,n]) veya bir diziyi ( caln) temsil eden bir dize veya benzeri bir şey
• Giriş, fonksiyon parametreleri, STDIN veya dil eşdeğerleri aracılığıyla olabilir
• Tüm girişler küçük harfler olacaktır (az)

Çıktı

• Değişen kelime

• Birden fazla çözüm varsa, herhangi bir basılabilir

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

• Giriş sözcüğünün (mutlaka dizinin olması gerekmez) dizideki harflerin (sırayla) olacağını varsayabilirsiniz.

• Girdilerin aynı ardışık harflere sahip olmadığını da varsayabilirsiniz (elma, inek, yeşil, cam, kapı ... DEĞİL)

Örnekler

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.

En kısa program kazanır!

Afiş (snippet için Martin Büttner sayesinde)

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

s+L&@d<Q1.(QZz

Gösteri.

Giriş stili:

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

Açıklama:

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 (girişinde yazdırılabilir karakterlerle 63)

Alex Pankratov en uyumlu bff (SPOJ ve ideone kullanılan brainfuck tercüman) ve Thomas Cort en BFI (Anarşi Golf kullanılır).

Yazdırılabilir sürüm, diziyi önce bir dize, ardından bir sekme, ardından izleyen yeni satır olmadan başlangıç ​​dizesi olarak alır.

Gösteri ideone üzerinde.

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

\x00Sekme yerine ayırıcı olarak bazı baytları kaydedebiliriz :

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

CJam, 15 bayt

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

Çevrimiçi deneyin.

Nasıl çalışır

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 bayt

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

Peki, bu şaşırtıcı bir şekilde rekabetçi.

f(char*, char*)Dizeyi ilk giriş olarak alan ve ikinci giriş olarak çoğaltılacak karakter dizisini alan bir işlev tanımlarız .

Bazı test kodu:

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

Hangi yazdırır:

oonomaatoopeia

Deneyin çevrimiçi !

Bir işlev yerine bir makro gönderilmesi kabul edilebilirse, aşağıdakiler #define g(s,c)yalnızca 58 bayttır , ancak gerçek işaretçiler gerektirir sve colmaları gerekir:

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

CJam, 15 bayt

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

Alternatif bir CJam yaklaşımı. Çevrimiçi deneyin

açıklama

İkinci dizgideki her karakter için iki şey yaparız.

1. Dizenin geçerli sonekini karakterle bölme, örneğin "beeper" "e" -> ["b" "" "p" "r"]

2. Dizideki ilk dizgiyi açıp, karakterin ikisini ekleyin, ardından dizinin geri kalanını karakteriyle birleştirin, örn "b" "ee" "eper". Son dize yeni sonektir.

Retina, 33 bayt

Retina hakkında daha fazla bilgi.

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

Bu, STDIN'de iki satırın yeni bir satırla ayrılmasını bekler.

Sayma amacıyla, her satır ayrı bir dosyaya gider, \ngerçek bir yeni satır karakteri (0x0A) ile değiştirilmelidir. Bunu gerçekten test etmek istiyorsanız, olduğu gibi \nkaldığı tek bir dosyaya koymak -sve dosyayı geçmeden önce seçeneği ile Retina'yı çağırmak daha uygun olur .

açıklama

(Eski ... İşaretleyiciden kurtulmayı başardım ... Bunu daha sonra güncelleyeceğim.)

Her bir çizgi çifti bir regex ikamesidir (ilk satır deseni, ikinci satır değişikliği).

^
#

Bu #giriş dizesinin başında bir işaretleyici olarak koyar .

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

Bu, girilen ilk harfi, çoğaltılacak bir sonraki harfe karşılık gelen (işaretçiden sonra) bulur, bu harfi çoğaltır, işaretçiyi arkasına taşır ve ikinci dizenin ilk karakterini bırakır. +`Ön dize değişen durana kadar (bu durumda ikinci dize boş ve gerekli tüm harfler çoğaltılamaz olmasından dolayı,) defalarca bunu Retina söyler.

#
<empty>

Sonunda, işaretçiyi bırakarak dizgiyi temizledik.

Python, 61

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

Açgözlü özyinelemeli bir çözüm. bDizenin silk harfinin, likiye katlanan harf dizesinin ilk harfi olup olmadığını kaydeder . Eğer öyleyse, o mektubu birini alın ve geri kalanı ile silk elemanı kaldırarak özyinelemeli çağrıya hazırlayın l. Değilse b, aynısını yapın, ancak mektubu iki katına çıkarmayın ve kaldırmayın l.

Kod , boş veya boşken bir dizin dışı hata hatasını önlemek s[:1]==l[:1]yerine kontrol eder .s[0]==l[0]sl

Prolog, 95 83 79 56 bayt

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

Örnek:

d(`chameleon`,`caln`).

döner

cchaamelleonn

Düzenleme: Oliphaunt sayesinde 4 bayt kaydedildi

Düzen2: Yerine kullanımdan kaldırılan put/1SWI-Prolog yüklemini kullanarak 20 bayt kaydedildi writef. Özyineleme bitişi d([],_).değerini değiştirmek yerine bir bayt kaydedildi d(_,_).. İki tanımın dsırasını yine de değiştirilirse işe yaramaz, ancak golf kodunda bunu umursamıyoruz. Parantezi kaldırarak başka 2 bayt kaydedildiH=[A|T],put(A),d(S,T)

Python 2, 83 74 72 65 Bayt

Burada özel bir püf noktası yok. xdize, yçoğaltılan karakter dizisidir. Bunun düzgün kopyalanıp kopyalanmadığını netleştirmek için, ilk girinti düzeyi boşluk, diğeri sekmedir.

Düzenleme 1: pop () yerine string manipülasyon kullanarak 9 bayt kaydedildi.

Düzenleme 2: 1 -~artırmak için kullanarak 2 bayt kaydedildi g.

Düzenleme 3: y[:1]hile kullanarak 7 bayt kurtardı, bunun için xnor'a teşekkürler!

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

Buradan kontrol edin.

Düzgün biçimlendirilmiş ve açıklanmıştır:

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 bayt

Bu benim CodeGolf'a ilk girişim, umarım bu iyidir.

Girdi kelimesini A1'e girdikten sonra B1'de değiştirilecek harfleri girersiniz ve elde edilen kelime bir mesaj kutusunda görüntülenir.

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 bayt

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

Kullanım örneği:

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

Nasıl çalışır:

Bir dize boşsa, sonuç ilk dizedir. Başka: dizelerin ilk karakterleri eşleşirse, iki kez al ve dizelerin kuyruklarına tekrarlı bir çağrı ekle. Karakterler eşleşmezse, ilk dizenin ilk karakterini alın ve ilk dizenin kuyruğunu ve aynı ikinci dizeyi tekrarlayan bir çağrı ekleyin.

Pyth, 18 17 bayt

sm?+d.(QZqd&QhQdz

Canlı demo.

@Jakube sayesinde 1 bayt kaydedildi.

Açıklama:

                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.

Orijinal versiyon:

jkm?+d.(QZqd&QhQdz

Orijinal için canlı demo.

Javascript, 47 bayt

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

Bazı ES6 özelliklerinden yararlanarak.

Pyth, 16 bayt

u|pH<GJxGH>GJwz

Çevrimiçi deneyin: Gösteri

Bu oldukça sahte. Yığın tabanlı dillerin burada bir avantajı olabilir.

açıklama

                   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 bayt

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

sBir dizi olduğunu varsayar["c","a","l","n"]

> <> (Balık) , 68 34 Bayt

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

Dizeyi ilk yığın olarak ("işaretler, yani" bukalemun "ile) ve giriş yığını olarak fazladan harflerin dizilişini (no" işaretler yani caln) girerek http://fishlanguage.com/playground adresinde çalıştırabilirsiniz .

Giriş yığınını tohumlamak için Ver düğmesine basmayı unutmayın.

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: Yarı yarıya! :)

R, 119

@ Alex'in cevabına göre , bu bir kaç bayt daha kısa:

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

Tamamen yeni yaklaşım daha iyi sonuçlar veriyor. Yine de bahse girerim daha kısa olabilir.

Olarak arayın f('coconut', ['c','o']).

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

Dizideki her karakter için, ilk oluşumu bulun ve çoğaltın ve her şeyi büyük harfe çevirin. Ardından, küçük harfe dönüştürülen dizenin tamamını döndürün.

EDIT: shiftve kurtularak birkaç karakter daha traş pop.

Önceki sürüm:

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

Yakut, 52 47 bayt

Çözüm:

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

Örnek:

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

Açıklama:

İlk argüman olarak bir dize ve ikinci argüman olarak bir karakter dizisi alan bir proc formu. Bir dizgiyi dize argümanındaki karakter dizisine eşleştirir, her bir karakteri karşılaştırma dizisinin ilk öğesine göre denetler ve bir eşleşme varsa, karşılaştırma dizisinin ilk öğesini kaldırır ve onu iki katına çıkarır.

güncelleştirme

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

Perl, 51 bayt

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

Giriş STDIN ile sağlanır. İlk giriş, başlangıç ​​sözcüğüdür (örn. chameleon), İkinci giriş, tek bir dize gibi harflerdir (örn. caln).

Yukarıdakiler, aşağıdakileri yapmanın sadece şaşkın (okuma "güzel") bir yoludur:

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

Her bir mektubu gözden geçirirken, kelimenin başlangıcından kaynak kelimedeki mektuba kadar sadece yeni harfle değiştiririz ve eşleşmeyi (depolanan $&) sonucumuza ekleriz. Maç, mektubu içerdiğinden ve ardından harfle değiştirildiğinden, her harf iki kez belirir.

STDIN, her iki girişimize de yeni bir satır karakteri eklediğinden, son kelimenin tam anlamıyla kalanını, yani yeni satır karakterini yakalayacağımızı garanti ediyoruz.

REGXY, 24 bayt

Regex ikamesi temelli bir dil olan REGXY'yi kullanır . Girişin başlangıç ​​sözcüğü ve dizinin boşlukla ayrıldığı varsayılır (örn. "Bukalemun caln").

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

Program, ilk dizgideki bir karakteri boşluktan sonraki ilk karakterle eşleştirerek çalışır. Bu eşleşirse, karakter yerine karakter tekrar edilir ve dizideki karakter kaldırılır (dizeye geri eklenmez). İşlem, ikinci satıra geçer, bu sadece ilk satıra geri dönen bir işaretçidir ve işlemin önceki ikamenin sonucu üzerinde tekrarlanmasına neden olur. Sonunda, boşluktan sonra hiçbir karakter olmayacak, bu noktada değişimin ikinci dalı eşleşecek, izleyen boşluk sonuçtan çıkarılacak. Daha sonra regex eşleşemez, işleme tamamlanır ve sonuç döndürülür.

Yardımcı olursa, yinelemeli yürütme adımları aşağıdaki gibidir:

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

Program, yukarıdaki linkteki örnek yorumlayıcı ile doğru bir şekilde derlenir ve yürütülür, ancak çözüm, dil belirtiminin belirsizliğindeki bir varsayıma dayandığından, belki de biraz yanaklıdır. Spesifikasyon, her satırdaki ilk belirtecin (/ işaretinden önce) bir etiket gibi davrandığını, ancak boş bir etiket işaretçisinin, boş bir etiketle (veya başka bir deyişle, dosyadaki ilk komutu) göstereceğini varsaymaktadır. bu 'null' geçerli bir etikettir). Daha az arsız bir çözüm şöyle olurdu:

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

Bu 27 bayt tutarında

JavaScript ES6, 72 bayt

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

Bu, 2 parametre alan adsız bir işlevdir: bir dize olarak başlangıç ​​sözcüğü ve bir dizi olarak genişletilecek karakterler. ES5 kullanan ve aşağıda UI test eden Ungolfed kod.

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

Çağrı yap:

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

Bayt sayısını çok yanlış yapmış olabilirim ... Boşlukların ve sekmelerin bir karışımını kullanır.

rs, 39 bayt

Rs hakkında daha fazla bilgi.

Zaten bir Retina cevabı var, ama bence bu biraz farklı bir yaklaşım kullanıyor. Ayrıca ayrı ayrı yaratılmışlardı: bunun üzerinde çalışmaya başladığımda, bu cevap gönderilmemişti.

Ayrıca, bu zaten 6 bayt daha uzun. :)

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

Canlı demo ve test paketi.

JavaScript, 92 karakter

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}

Unffccated sürüm:

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 bayt

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

Bu, bir dizgeyi ve karakter vektörünü girdi olarak kabul eden ve bir dizgiyi STDOUT'a basan isimsiz bir işlev yaratır. Aramak için bir isim verin.

Ungolfed + açıklama:

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

Örnekler:

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

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

MickeyT ve bir başka 3 sayesinde 8 byte kurtarıldı jja!

Bash + sed, 51

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

Stdin'den girdi; tek bir argüman olarak ikiye katlanacak karakterler:

$ echo chameleon | strtech caln
cchaamelleonn

Bu, bir sed programı oluşturarak $2ve daha sonra da onu çalıştırarak çalışır $1. Sed programı, her değiştirme mektubunun ilk harfini büyük harfli versiyonunun iki nüshasıyla değiştirir ve sonunda tüm partiyi düşürür. Yukarıdaki örnekte, oluşturulan sed programı

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

hoş yazı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&/

Şimdiye kadar işlenen karakterleri işaretlemek için büyük harf kullanıyorum; bu, daha önce iki katına çıkmış olan karakterleri tekrar iki katına çıkarmak veya bir öncekinden daha önce bir katlama yapmaktan kaçınır.

Daha önceki sürümde, değişiklik listesinin sıralanmasının önemli olduğunu açıklamadan önce (44 karakter):

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

Python, 53 92 bayt

Çözümümü hem Python 2 hem de 3'te aynı uzunlukta buldum.

EDIT: Adam, aynı mektubun birden fazla yerini alırken bu davayı düzeltmek (hala aynı yöntemi kullanırken), biraz çalışma gerektirdi.

Python 2:

Burada dene

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 bayt

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

Örnek:

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 bayt

Wieselkatze ve SquidDev'in yardımıyla yeni, tamamen elden geçirilmiş bir çözüm! hadi beyler, beynini yenebiliriz: P

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

Açıklama yarın geliyor. Burada dene.

Orijinal çözüm: @ kirbyfan64sos sayesinde 2 bayt kurtarıldı!

Lua golf oynamak için oldukça berbat bir dil, bu yüzden bunun için oldukça iyi olduğumu düşünüyorum.

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

Kod açıklaması, ungolfed versiyonu ile birlikte:

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

Burada dene. (Eski kod ama aynı konsept, daha az golf oynadı, yarın güncellenecek)