花了一些时间在这个网站上，我开始享受尽可能短的事情。这可能就是为什么我最近被包含多个相同字符的字符串冒犯的原因。您的工作是编写根据以下规则压缩给定字符串的函数或程序：

• 从0压缩开始，即寻找相同字符的第一对（最左边），中间还有0个其他字符。如果找到了这样的一对，请删除两个字符之一，然后通过执行另一个0压缩来重新启动算法。如果找不到这样的对，请继续下一步。示例：
  programming-C0-> programing
aabbcc-C0-> abbcc
test-C0->test

• 然后执行1压缩，即寻找第一对相同的字符，它们之间还有1个其他字符。如果找到了这样的一对，请删除其中的一个以及它们之间的所有字符，然后以0缩进重新开始。如果找不到这样的对，请继续下一步。示例：
  abacac-C1-> acac
java-C1->ja

• 继续进行2-缩合，依此类推，直到n缩合，其中n为原始字符串的长度，每次在缩合除去一些字母后重新启动。示例：
  programing-C2-> praming
abcdafg-C3->afg

生成的字符串称为压缩字符串，每个字符串最多包含一次。

输入：

可打印的ascii字符的小写字符串。

输出：

所述冷凝根据上述规则的字符串。

例子：

examples     -> es
programming  -> praming
puzzles      -> puzles
codegolf     -> colf
andromeda    -> a
abcbaccbabcb -> acb
if(x==1):x++ -> if(x+
fnabnfun     -> fun
abcdefae     -> abcde

详细示例以阐明算法的工作原理：

fnabnfun -C0-> fnabnfun -C1-> fnabnfun -C2-> fnfun -C0-> fnfun -C1-> fun -C0-> fun 
 -C1-> fun -C2-> ... -C8-> fun

abcbaccbabcb -C0-> abcbacbabcb -C0-> abcbacbabcb -C1-> abacbabcb -C0-> abacbabcb 
 -C1-> acbabcb -C0-> acbabcb -C1-> acbcb -C0-> acbcb -C1-> acb -C0-> acb 
 -C1-> ... -C12-> acb

只要您的解决方案和算法为所有允许的输入返回相同的输出，您的方法就不必从上面实现算法。这是一个代码高尔夫挑战。

感谢@Linus提供有用的沙箱评论！

JavaScript（ES6），74个字节

f=
(s,n=0,m=s.match(`(.).{${n}}\\1`))=>s[n]?m?f(s.replace(...m)):f(s,n+1):s
;

<input oninput=o.textContent=f(this.value)><pre id=o>

Perl，38 31 30 29字节

这应该使非高尔夫语言远远落后...

-1 $-[0]感谢赖利

-1 @{-}感谢Dada

包括+1的 -p

在STDIN上输入

condense.pl：

#!/usr/bin/perl -p
s/(.)\K.{@{-}}\1// while/./g

这个27字节的版本应该可以使用，但是不能，因为perl不会@-在正则表达式中进行插值（请参阅/programming/39521060/why-are-etc-not-interpolated-in-strings）

#!/usr/bin/perl -p
s/(.)\K.{@-}\1// while/./g

CJam，35个字节

rL{_,{{(_@_@#I={I)>]sj}*}h]s}fI}j

在线尝试！

rL{                            }j   | run recursion on input
   _,{                      }fI     | for I from 0 to length(input)
      {                 }h]s        | one pass & clean up
       (_@                          | slice and store leading element A
          _@#I={      }*            | if next A is I steps away
                I)>                 | slice off I+1 element
                   ]sj              | clean up & recursion

您可以通过插入来查看各个缩合ed

Python 2中，117个 104 101字节

递归地进行必要的替换。我动态构建正则表达式。

import re
def f(s,i=0):t=re.sub(r"(.)%s\1"%("."*i),r"\1",s);e=s==t;return i>len(t)and t or f(t,i*e+e)

在线尝试

Perl 53 52

包括+1的-p

for($i=0;$i<length;){$i=(s/(.).{$i}\1/\1/)?0:$i+1;}

在ideone上尝试一下。

Mathematica，101个字节

NestWhile[i=0;StringReplace[#,a_~~_~RepeatedNull~i++~~a_:>a,1]&,#,SameQ,2,ByteCount@#]&~FixedPoint~#&

应该有一种方法可以缩短这个时间...

PHP，90字节

for($s=$argv[$c=1];$s[$i=++$i*!$c];)$s=preg_replace("#(.).{{$i}}\\1#","$1",$s,1,$c);echo$s;

或92个字节

for($s=$argv[1];$s[$i];$i=++$i*!$c)$s=preg_replace("#(.).{".+$i."}\\1#","$1",$s,1,$c);echo$s;   

Ruby，75 64 57字节

（56个字节的代码+ p命令行选项。）

在正则表达式中使用字符串插值来控制要替换的匹配项的长度。

i=0
~/(.).{#{i}}\1/?sub($&,$1)&&i=0: i+=1while i<$_.size

测试：

$ ruby -p condense.rb <<< fnabnfun
fun

Haskell，97 88字节

(0?)
(a:s)!(b:t)|a==b=a:t|1<3=a:s!t
s!_=s
m?s|length s<m=s|a<-s!drop m s=sum[m+1|a==s]?a

在线尝试！

旧的97字节bersion：

(a:s)!(b:t)|a==b=a:t|1<3=a:s!t
s!_=s
m?s|length s==m=s|a<-s!drop m s=(last$0:[m+1|a==s])?a
c=(0?)

在ideone上尝试一下。

说明：

(a:s)!(b:t)|a==b = a:t         --perform condensation
           |1<3  = a:s!t       --recursively compare further
 s   ! _         = s           --no condensation performed

所述(!)功能执行一个正缩合时给定的一个字符串一次整体并且一旦移除了前n个字符，例如abcdbe和cdbe通过递归地比较两个前导字符用于2缩合，。

m?s|length s==m   = s         --stop before performing length-s-condensation
   |a <- s!drop m s           --a is the m-condensation of s
    = (last$0:[m+1|a==s])?a   --disguised conditional:
                              -- if a==s       if the m-condensation did not change s
                              -- then (m+1)?a  then perform m+1-condensation
                              -- else 0?a      else restart with a 0-condensation

c=(0?)                        -- main function, initialise m with 0