伸展单词

32

编写一个程序或函数来复制单词中的字母，以便该单词中从左到右排列的所有重复字母都将构成输入数组。

例如：

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.

最短的程序获胜！

排行榜（感谢MartinBüttner的摘录）

显示代码段

code-golf  string  subsequence 
— 弹力狂人
source
@AlexA。仅一个实例，因为否则由重复字母组成的数组将是[c,o,c,o]而不是[c,o]。
— 拉伸疯子
是的，很抱歉，再次阅读它是显而易见的。谢谢。
— Alex
2
看到这个答案有很多答案，并且有许多相同的语言，您是否有兴趣添加排行榜摘要？如果是这样，我很乐意对其进行编辑并修改不使用所需标题格式的答案。
— 马丁·恩德
@MartinBüttner我忘记了！添加。我不得不改变#answer-list和#language-list宽度50%，以避免在您的片段重叠列。
— 拉伸疯子
1
澄清（请参阅我的bash+ sed答案）：banana, na=> 是否非法baannana？我相信，“你可以假设所有的投入将有数组中的字母（按顺序）”是指允许，但不要求，答案顺序处理两个列表，但@manatwork解释不同的看法。
— Toby Speight 2015年

Answers:

5

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.
— 伊萨格
source
43

Brainfuck，46 45（输入中有可打印字符的63）

与Alex Pankratov的bff（在SPOJ和ideone上使用的brainfuck解释器）和Thomas Cort的BFI（在Anarchy Golf上使用）兼容。

可打印版本首先将数组作为字符串，然后是制表符，然后是没有尾随换行符的起始字符串。

示范的ideone。

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

我们可以使用一些\x00分隔符代替制表符来节省一些字节：

,[>,]
<[<]
<,+
[
  -.
  [>+>-<<-]
  >>
  [
    <[>+<-]
  ]
  <[.[-]]
  ,+
]
— 米奇·施瓦兹（Mitch Schwartz）
source
22
BF比我的Python代码短时的那种感觉.. :(
— Kade 2015年
6
我通常不关心Brainfuck，但这太棒了！
— 丹尼斯
这很漂亮。
— Joshpbarron 2015年
14

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).
— 丹尼斯
source
这是CJams的战斗！您和Sp都有15个字节的CJam答案，而15是当前最短的答案。:)
— Alex A.15年
3
@AlexA。只需等待Pyth。您只需等待...
— Sp3000
2
听起来您最好学习Pyth。;）
— Alex A.
12

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++);
— 脑钢
source
1
感谢您让我查找逗号运算符。这很有用！
— Oliphaunt-恢复莫妮卡2015年
11

CJam，15个字节

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

另一种CJam方法。在线尝试

说明

对于第二个字符串中的每个字符，我们做两件事。

  1. 用字符分割字符串的当前后缀，例如 "beeper" "e" -> ["b" "" "p" "r"]

  2. 取消约束数组中的第一个字符串，插入两个字符，然后用字符重新加入数组的其余部分，例如"b" "ee" "eper"。最后一个字符串是新的后缀。

— Sp3000
source
9

视网膜，33字节

有关视网膜的更多信息。

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

这需要STDIN上的两个字符串，用换行符分隔。

为了进行计数，每行进入一个单独的文件，\n应替换为实际的换行符（0x0A）。如果您实际上要测试它，将它放在\n保持原样的单个文件中，然后-s在传递文件之前使用选项调用Retina 更为方便。

说明

（已过时...我设法摆脱了标记...稍后会对此进行更新。）

每对线都是正则表达式替换（第一行是模式，第二行是替换）。

^
#

这会将a #作为标记放在输入字符串的开头。

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

这将在输入中找到第一个字母（在标记之后），该字母对应于要复制的下一个字母，复制该字母，将标记移到其后，然后放下第二个字符串的第一个字符。该+`在前面讲述的Retina要做到这一点，直到串停止变化（在这种情况下，因为第二个字符串是空的，所有需要的字母都被复制）。

#
<empty>

最后，我们通过删除标记来清理字符串。

— 马丁·恩德
source
2
我认为视网膜将是一个很好的解决方案，我是对的，因为您找到了一个。另外，当我第一次浏览您的描述时，我读到的结尾是“我们通过放下麦克风来清理琴弦”。
— mbomb007
@ mbomb007我希望通过只复制没有重复的单个字母来摆脱“麦克风”，但是我不能少于33个字节。（修订历史记录中有一个坏掉的28字节版本。）
— Martin Ender
@ mbomb007仅供参考，我确实设法删除了标记，但是字节数仍然相同。虽然看起来仍然可以打高尔夫球。
— Martin Ender 2015年
— 一句
@ mbomb007是的，我知道。在实现一些更重要的出色功能后，我可能会添加一个。
— Martin Ender
8

Python，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]避免出现越界索引错误。sl

— 异或
source
6

Prolog，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

编辑：由于Oliphaunt而节省了4个字节

Edit2：使用已弃用的put/1SWI-Prolog谓词（而不是）保存了20个字节writef。保存了一个字节，将递归结束谓词替换d([],_).为d(_,_).。如果将两个定义的顺序d互换，将不会起作用，但是我们不关心高尔夫代码中的定义。保存了另外2个字节，删除了括号H=[A|T],put(A),d(S,T)

— 致命
source
1
我不太确定为什么这被否决了。也许在您的代码中添加一些解释？
— Alex A.
1
您可以通过隐式统一来节省四个字节：H=[A|T]。另外，为什么不通过用换行符代替空格来使其更具可读性呢？
— Oliphaunt-恢复莫妮卡2015年
@Oliphaunt感谢您的建议，最初修改代码以使用H = [A | T]子句后，我没有看到这种轻微的优化。
— 致命
5

Python 2，83 74 72 65字节

这里没有真正的特殊技巧。x是字符串，y是重复的字符数组。为了澄清这是否不能正确复制，第一个缩进级别是一个空格，下一个是制表符。

编辑1：通过使用字符串操作而不是pop（）保存了9个字节。

编辑2：使用-~递增g1，节省了2个字节。

编辑3：通过使用y[:1]技巧节省了7个字节，这要感谢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.
— 卡德
source
“您可以假设所有输入将在数组中按顺序包含字母。” 那应该为您节省很多字节。
— mbomb007
2
您可以从可能为空的字符串中获取第一个元素，例如y[:1]。
— xnor
我现在意识到，由于您的使用方式，您无法保存我想的那么多y=y[g:]，所以“很多”是一个夸张的说法。
— mbomb007
@ Vioz-我在想y[:1]==c。那样有用吗？
— xnor
@xnor是的，如果我把需要替换的字母代替了，就可以了。谢谢！
— 卡德2015年
5

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
— Wightboy
source
2
如果VBA对缩进不敏感，则可以消除所有缩进并节省一些字节。我认为您也可以删除逗号后和运算符周围的所有空格。可以为您节省一些字节。
— Fund Monica的诉讼
@QPaysTaxes感谢您的编辑。我按下回滚只是为了看看它会做什么。不确定这是否会使您损失积分或进行编辑？
— Wightboy
不，我仍然有+2，尽管我确实有点困惑。您可能想再次回滚；至少根据三位知名人士说，这是一个很好的编辑。
— 基金莫妮卡的诉讼
@QPaysTaxes我同意我喜欢编辑。认为我回滚了太多次了。
— Wightboy
我不知道 移动设备不能很好地显示内容。最终，重要的是代码，而不是格式。
— 基金莫妮卡的诉讼
4

Haskell，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"

怎么运行的：

如果一个字符串为空，则结果为第一个字符串。否则：如果字符串的前几个字符匹配，则将其取两次，然后在字符串的尾部附加一个递归调用。如果字符不匹配，则采用第一个字符串的第一个字符，并在第一个字符串的尾部和相同的第二个字符串的末尾附加一个递归调用。

— 妮米
source
4

Pyth，18个 17字节

sm?+d.(QZqd&QhQdz

现场演示。

感谢@Jakube，节省了1个字节。

说明：

                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

现场演示原始。

— kirbyfan64sos
source
4

Javascript，47个字节

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

利用某些ES6功能。

— 谷类
source
1
这是否正常工作了onomatopoeia，oao？
— Alex A.
1
@AlexA。输出：“ oonoomaatoopooeiaa”。啊我懂了。将修复
— 谷物2015年
我认为是固定的。添加了很多字符：(
— 谷物
相反b.indexOf(d)==0，请尝试~b.search(d)
— Ismael Miguel
@IsmaelMiguel search仅适用于字符串。必须将b更改为数组
— 谷物2015年
3

Pyth，16个字节

u|pH<GJxGH>GJwz

在线尝试：演示

这很hacky。基于堆栈的语言可能在这里具有优势。

说明

                   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
— 雅库比
source
@isaacg帮助吗？一定要短一些……
— Jakube
更优雅;-)
— Jakube
1
比CJam少14-1，是最好的地方。
— isaacg 2015年
3

JavaScript ES6，47个字节

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

假设s是一个数组["c","a","l","n"]

— 闪亮
source
2

> <>（鱼），68 34字节

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

您可以在http://fishlanguage.com/playground上运行它将字符串作为初始堆栈输入（带有“标记，即” chameleon“），并将多余的字母数组作为输入堆栈（没有”“标记，即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))

编辑：减半！:)

— 模样
source
2

R，119

根据@Alex的答案，这要短几个字节：

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
        }
      )
    )
  )
}
— ja
source
2

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}
— ja
source
新版本不再遵守字符顺序。（顺便说一句，“ foreach关键字实际上是关键字的同义词for，因此您可以使用。）– Foreach循环。）
— manatwork 2015年
@manatwork应该这样做。并感谢您的for提示。现在实际上更短了。
— 2015年
2

红宝石， 52 47个字节

解：

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

例：

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

说明：

方法的过程形式，该方法将字符串作为第一个参数，并将字符数组作为第二个参数。将一个块映射到string参数中的字符数组，该数组将每个字符与比较数组的第一个元素进行比较，如果匹配，则删除比较数组的第一个元素并将其加倍。

更新

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

— 布莱恩·戴维斯（Brian Davis）
source
您可以跳过参数周围的括号s,a。和*''等效于.join。那是保存了5个字节，但我还是打败了你一个（
— 暂时
2

Perl，51个字节

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

输入通过STDIN提供。第一个输入是起始词（例如chameleon），第二个输入是作为单个字符串的字母（例如caln）。

上面只是做以下事情的一种混淆（读作“漂亮”）方法：

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

遍历每个字母时，我们将从单词开头到源单词中的字母仅替换为新字母，然后将匹配项（存储在中$&）附加到我们的结果中。由于匹配包括字母，然后被替换为字母，因此每个字母最终出现两次。

由于STDIN在我们的两个输入中都添加了换行符，因此我们保证在最后一次匹配时捕获完整单词的剩余部分，即换行符。

— 艾伦·G
source
2

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个字节

— Jarmex
source
1

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和测试UI的非公开代码。

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>
展开摘要

— 忍者熊猴子
source
1

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

我可能字节计数严重错误...使用空格和制表符的混合。

— Beta衰变
source
1

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;
}
— SirPython
source
1

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

MickeyT节省了8个字节，jja节省了3个字节！

— 亚历克斯·A
source
您可以使用cat(p,sep='')一对夫妇直接向STDOUT输出
— MickyT 2015年
@MickyT：没想到！谢谢，编辑。:)
— Alex A.
1
实际上，message(p)是较短的。
— jja
@jja：我不知道message，太棒了！谢谢！编辑使用您的建议。
— Alex A.
1

Bash + sed，51岁

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

来自stdin的输入；要作为单个参数加倍的字符：

$ echo chameleon | strtech caln
cchaamelleonn

这是通过从构建sed程序$2，然后对sed程序执行的$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&/"
— 托比·斯皮特
source
不正确 strtech na <<< banana输出“ baannana”，但首先应将出现在“ n”上的内容加倍，只有在出现“ a”之后。
— manatwork 2015年
在那种情况下，我误解了这个问题。它不是明确的排序意味着之前的信件应该不会增加一倍，只需你将能够找到一个后续一到两倍。我将考虑满足此新要求的替代方案。
— Toby Speight 2015年
没问题，我第一次都没做对。我建议在思考时删除您的答案（您以后可以随时删除），以免被淘汰。
— manatwork 2015年
@manatwork：我已要求提问者进行澄清，并提供了一个替代的答案，可以满足阅读规则的要求（但这样做花了我7个字符）
— Toby Speight 2015年
0

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))
— mbomb007
source
0

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"
— Alephalpha
source
0

Lua, 76 78 76 75 58 53 bytes

New, completely reworked solution with help from wieselkatze and SquidDev! come on guys, we can beat brainfuck :P

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

Explanation coming tommorow. Try it here.

Original solution: Saved 2 bytes thanks to @kirbyfan64sos!

Lua is a pretty terrible language to golf in, so I think I did pretty good for this one.

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

Code explanation, along with ungolfed version:

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

Try it here. (Outdated code but same concept, just less golfed, will update tommorow)

Added on two bytes because I had to fix glitch where it would replace all letter defined in the array with their duplicates.
I think you can remove the newlines after function f(x,y) and after print(x), saving you two bytes.
— kirbyfan64sos
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.