挑战

给定输入字符串和整数n-将连续字符的所有游程截断为最大n个长度。字符可以是任何字符，包括特殊字符。该函数应区分大小写，并且n的范围可以从0到无穷大。

输入/输出示例：

f("aaaaaaabbbccCCCcc", 2) //"aabbccCCcc" 
f("aaabbbc", 1) //"abc"
f("abcdefg", 0) //""
f("aaaaaaabccccccccCCCCCC@", 4) //"aaaabccccCCCC@"

计分

评分基于使用的字节数。从而

function f(s,n){return s.replace(new RegExp("(.)\\1{"+n+",}","g"),function(x){return x.substr(0, n);});}

将是104分。

打高尔夫球快乐！

编辑：删除语言限制，但我还是很想看看javascript答案

Python 2，52字节

lambda s,n:reduce(lambda r,c:r+c*(r[-n:]!=c*n),s,'')

写成程序（54字节）：

s,n=input();r=''
for c in s:r+=c*(r[-n:]!=c*n)
print r

遍历输入字符串s，将每个字符追加到输出字符串，r除非的最后一个n字符r是该字符。

我虽然失败了，n==0因为r[-0:]不是最后0个字符（空字符串），而是整个字符串。但是，它可以工作，因为字符串保持为空，因此它始终与0字符字符串匹配。

lambda由于重复，递归给出了56

f=lambda s,n:s and s[:f(s[1:],n)[:n]!=s[0]*n]+f(s[1:],n)

另一种防止i重复最后一个字符的策略也比直接检查最后一个n字符的时间更长。

C，81 78

修改传入的字符串。

c,a;f(p,n)char*p;{char*s=p;for(;*p;s+=c<n)*s=*p++,a^*s?c=0:++c,a=*s;c=a=*s=0;}

测试程序

需要两个参数，第一个是要截断的字符串，第二个是长度限制。

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main(int argc, const char **argv)
{
    char *input=malloc(strlen(argv[1])+1);
    strcpy(input,argv[1]);
    f(input,atoi(argv[2]));
    printf("%s\n",input);
    free(input);
    return 0;
}

说明：

c,a;                 //declare two global integers, initialized to zero.
                     //c is the run length, a is the previous character
f(char*p,int n){...} //define function f to truncate input
char*s=p;            //copy p to s; p is source, s is destination
for(;*p              //while there is a source character
;s+=c<n)             //increment copied pointer if run is under the limit
*s=*p++,             //copy from source to destination, increment source
a^*s?c=0:++c,        //if previous character != current then run=0 else increment run
a=*s;                //previous character = current source character
c=a=*s=0;            //after loop, terminate destination string with NUL and reset c and a.

之所以可行，是因为源指针将始终等于或大于目标指针，因此我们可以在解析字符串时覆盖它。

Haskell，36个字节

import Data.List
(.group).(=<<).take

的无点版本\n s -> concatMap (take n) (group s)。

JavaScript的ES6，60 54 55 43个字节

-12个字节，感谢@ TestSubject06和@Downgoat

(s,n)=>s.replace(/(.)\1*/g,x=>x.slice(0,n))

示例运行：

f("aaaaaaabbbccCCCcc"      , 2) -> "aabbccCCcc" 
f("aaabbbc"                , 1) -> "abc"
f("abcdefg"                , 0) -> ""
f("aaaaaaabccccccccCCCCCC@", 4) -> "aaaabccccCCCC@"
f("a"                      , 1) -> "a"

MATL，9个字节

Y'i2$X<Y"

在线尝试

说明

        % Implicitly grab input as a string
Y'      % Perform run-length encoding. Pushes the values and the run-lengths to the stack
i       % Explicitly grab the second input
2$X<    % Compute the minimum of the run lengths and the max run-length
Y"      % Perform run-length decoding with these new run lengths
        % Implicitly display the result

CJam，12个字节

{e`\af.e<e~}

在线尝试！

说明

e`   e# Run-length encode the input. Gives a list of pair [length character].
\a   e# Swap with maximum and wrap in an array.
f.e< e# For each run, clamp the run-length to the given maximum.
e~   e# Run-length decode.

Pyth，16 12字节

rm，hS，Qhdedrz8 9
ss <RQmM_Mrz8

在线尝试！

Python 2，56个字节

import re
lambda s,n:re.sub(r'(.)(\1{%d})\1*'%n,r'\2',s)

gs2，6个字节

在CP437中编码：

╠c╨<ΘΣ

这是一个匿名函数（块），期望在堆栈顶部有一个数字，在堆栈下面有一个字符串。

     Σ   Wrap previous five bytes in a block:
╠          Pop number into register A.
 c         Group string.
    Θ      Map previous two bytes over each group:
  ╨<         Take the first A bytes.

在线尝试。（这里的代码是lines, dump, read number, [the answer], run-block。）

Perl 6的， 38  36个字节

->$_,$n {S:g/(.)$0**{$n..*}/{$0 x$n}/}
->$_,\n{S:g/(.)$0**{n..*}/{$0 x n}/}

说明：

-> $_, \n { # pointy block lambda
  # regex replace ( return without modifying variant )
  # globally
  S:global /
    # a char
    (.)
    # followed by ｢n｣ or more identical chars
    $0 ** { n .. * }
  /{
    # repeat char ｢n｣ times
    $0 x n
  }/
}

测试：

#! /usr/bin/env perl6
use v6.c;
use Test;

my &truncate-char-runs-to = ->$_,\n{S:g/(.)$0**{n..*}/{$0 x n}/}

my @tests = (
  ("aaaaaaabbbccCCCcc", 2) => "aabbccCCcc",
  ("aaabbbc", 1) => "abc",
  ("abcdefg", 0) => "",
  ("aaaaaaabccccccccCCCCCC@", 4) => "aaaabccccCCCC@",
);

plan +@tests;

for @tests -> $_ ( :key(@input), :value($expected) ) {
  is truncate-char-runs-to(|@input), $expected, qq'("@input[0]", @input[1]) => "$expected"';
}

1..4
ok 1 - ("aaaaaaabbbccCCCcc", 2) => "aabbccCCcc"
ok 2 - ("aaabbbc", 1) => "abc"
ok 3 - ("abcdefg", 0) => ""
ok 4 - ("aaaaaaabccccccccCCCCCC@", 4) => "aaaabccccCCCC@"

Javascript ES5、73

function f(s,n){return s.replace(RegExp("(.)(\\1{"+n+"})\\1*","g"),"$2")}

从她的Python答案中重新使用Lynn的正则表达式。

Perl 5，50个字节

46个字节的代码+ 3个 -i和1个用于-p

将数字截断为via -i。

s!(.)\1+!$&=~s/(.{$^I}).+/$1/r!ge

用法

perl -i4 -pe 's!(.)\1+!$&=~s/(.{$^I}).+/$1/r!ge' <<< 'aaaaaaabccccccccCCCCCC@'
aaaabccccCCCC@

重击46个字节

read c;sed -r ":l;s/(.)(\1{$c})(.*)/\2\3/;t l"

用法：输入要限制的字符数，按Enter键并输入字符串。Ctrl+ D退出sed（发送EOF）。

Java 7中，107个 106字节

String c(String s,int i){String x="";for(int i=-1;++i<j;)x+="$1";return s.replaceAll("(.)\\1{"+i+",}",x);}

字符串连接的先前替代内联for循环（String s="";for(int i=-1;++i<j;)s+="$1";不幸的是，多1个字节）：

String c(String s,int i){return s.replaceAll("(.)\\1{"+i+",}",new String(new char[i]).replace("\0","$1")));}

非高尔夫球和测试用例：

在这里尝试。

class Main {
  static String c(String s, int i){
    String x="";
    for(int j = -1; ++j < i;){
      x += "$1";
    }
    return s.replaceAll("(.)\\1{"+i+",}", x);
  }

  public static void main(String[] a){
    System.out.println(c("aaaaaaabbbccCCCcc", 2));
    System.out.println(c("aaabbbc", 1));
    System.out.println(c("abcdefg", 0));
    System.out.println(c("aaaaaaabccccccccCCCCCC@", 4));
    System.out.println(c("@@@@@bbbbbcccddeegffsassss", 5));
  }
}

输出：

aabbccCCcc
abc

aaaabccccCCCC@
@@@@@bbbbbcccddeegffsassss

Javascript（使用外部库）（115字节）

(s,r)=>_.From(s).Aggregate((c,n)=>{if(c.a!=n){c.c=1;c.a=n}else{c.c++}if(c.c<=r){c.b+=n}return c},{a:"",b:"",c:0}).b

链接到lib：https : //github.com/mvegh1/Enumerable

代码说明：将字符串加载到库中，该库在内部解析为char数组。在序列上应用累加器，传入自定义对象作为种子值。属性a是当前元素，b是累积的字符串，c是当前元素的顺序计数。累加器检查当前迭代值n是否等于最后一个元素值ca，如果不相等，我们将计数重置为1并设置当前元素。如果当前元素的计数小于或等于所需的长度，则将其累加到返回字符串中。最后，我们返回属性b，即累积的字符串。不是最复杂的代码，但是很高兴我找到了一个可行的解决方案...

J，31 30字节

((<.#@>)#{.@>@])]<;.1~1,2~:/\]

将输入字符串分组为相同字符的游程（子字符串），并采用该游程长度的最小值和为截断字符串而输入的最大长度。然后多次复制每个运行的第一个字符。

用法

   f =: ((<.#@>)#{.@>@])]<;.1~1,2~:/\]
   2 f 'aaaaaaabbbccCCCcc'
aabbccCCcc
   1 f 'aaabbbc'
abc
   0 f 'abcdefg'

   4 f 'aaaaaaabccccccccCCCCCC@'
aaaabccccCCCC@

说明

((<.#@>)#{.@>@])]<;.1~1,2~:/\]  Input: k on LHS, s on RHS
                             ]  Get s
                        2~:/\   Test if each pair of consecutive chars are not equal
                      1,        Prepend a 1
                ]               Get s
                 <;.1~          Chop s where a 1 occurs to get the runs in s
    #@>                         Get the length of each run
  <.                            Take the min of the length and k
         {.@>@]                 Get the head of each run
        #                       Copy the head of each run min(k, len(run)) times
                                Return that string as the result

Dyalog APL，22 20 字节

(∊⊢↑¨⍨⎕⌊⍴¨)⊢⊂⍨1,2≠/⊢

提示输入n输入并将输入字符串作为参数。

(默认功能...
    ∊弄平
    ⊢↑¨⍨截断为参数（即，每个分区）中的每个元素
    ⎕⌊⍴¨的最小数值输入的和当前的长度
)[隐性功能的结束]施加到
⊢⊂⍨在所述划分的输入ᴛʀᴜᴇ第
1, ᴛʀᴜᴇ预置到（所述第一个字符不等于其不存在的前
2≠/⊢一个字符）输入中字符的成对不相等

Ruby，32个字节

->s,n{s.gsub(/(.)\1*/){$&[0,n]}}

TCC，7个 5字节

$~(;)

输入是一个字符串和一个数字，以空格分隔。

在线尝试！

       | Printing is implicit
$~     | Limit occurence
  (;   | First part of input
    )  | Second part of input