O desafio

Dada uma sequência de entrada e um número inteiro n - trunca quaisquer execuções de caracteres consecutivos até um máximo de n comprimento. Os caracteres podem ser qualquer coisa, incluindo caracteres especiais. A função deve fazer distinção entre maiúsculas e minúsculas e n pode variar de 0 a infinito.

Exemplos de entradas / saídas:

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

Pontuação

A pontuação é baseada no número de bytes usados. portanto

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

seria 104 pontos.

Feliz golfe!

Edit: removeu a restrição de idioma, mas ainda assim gostaria de ver respostas em javascript

Python 2, 52 bytes

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

Escrito como um programa (54 bytes):

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

Repete a sequência de entrada s, acrescentando cada caractere à sequência de saída, a rmenos que os últimos ncaracteres rsejam esse caractere.

Eu acho que isso falharia n==0porque r[-0:]não são os últimos 0 caracteres (sequência vazia), mas a sequência inteira. Mas, ele funciona porque a cadeia permanece vazia, mantendo a correspondência com a cadeia de 0 caracteres.

Um recursivo lambdadeu 56 por causa da repetição

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

Uma estratégia alternativa para manter um contador ide repetições do último caractere também ficou mais tempo do que apenas verificar os últimos ncaracteres diretamente.

C, 81 78

Modifica a sequência de entrada.

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

Programa de teste

Requer dois parâmetros, o primeiro é a sequência a ser truncada, o segundo é o limite de comprimento.

#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;
}

Explicação:

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.

Isso funciona porque o ponteiro de origem sempre será igual ou maior que o ponteiro de destino, para que possamos escrever sobre a string enquanto a analisamos.

Haskell, 36 bytes

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

Versão sem pontos de \n s -> concatMap (take n) (group s).

Javascript ES6, 60 54 55 43 bytes

-12 bytes graças a @ TestSubject06 e @Downgoat

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

Exemplo é executado:

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

MATL, 9 bytes

Y'i2$X<Y"

Experimente Online

Explicação

        % 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 bytes

{e`\af.e<e~}

Experimente online!

Explicação

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.

Pitão, 16 12 bytes

rm, hS, Qhdedrz8 9
ss <RQmM_Mrz8

Experimente online!

Python 2, 56 bytes

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

gs2, 6 bytes

Codificado no CP437 :

╠c╨<ΘΣ

Esta é uma função anônima (bloco) que espera um número no topo da pilha e uma string abaixo dela.

     Σ   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.

Experimente online. (O código aqui é lines, dump, read number, [the answer], run-block.)

Perl 6 ,  38  36 bytes

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

Explicação:

-> $_, \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
  }/
}

Teste:

#! /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")}

Reutiliza a expressão regular de Lynn em sua resposta em Python .

Perl 5, 50 bytes

Código de 46 bytes + 3 para -ie 1 para-p

Leva o número para truncar para via -i.

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

Uso

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

Bash 46 bytes

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

Uso: Digite o número de caracteres a serem limitados, pressione enter e digite a string. Ctrl+ Dpara sair sed(envie EOF).

Java 7, 107 106 bytes

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

Loop alternativo inline alternativo anterior para concatenação de String (que é 1 byte a mais do que String s="";for(int i=-1;++i<j;)s+="$1";infelizmente):

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

Casos não testados e de teste:

Experimente aqui.

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

Resultado:

aabbccCCcc
abc

aaaabccccCCCC@
@@@@@bbbbbcccddeegffsassss

Javascript (usando biblioteca externa) (115 bytes)

(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

Link para lib: https://github.com/mvegh1/Enumerable

Explicação do código: Carregue a string na biblioteca, que analisa internamente como matriz de caracteres. Aplique um acumulador na sequência, passando um objeto personalizado como um valor inicial. A propriedade a é o elemento atual, b é a cadeia acumulada e c é a contagem sequencial do elemento atual. O acumulador verifica se o valor atual da iteração, n, é igual ao valor do último elemento, ca. Caso contrário, redefinimos a contagem para 1 e configuramos o elemento atual. Se a contagem do elemento atual for menor ou igual ao comprimento desejado, acumulamos na string de retorno. Finalmente, retornamos a propriedade b, a string acumulada. Não é o código mais golfista, mas feliz por ter uma solução que funciona ...

J, 31 30 bytes

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

Agrupa a sequência de entrada em execuções (substrings) de caracteres idênticos e assume o mínimo do comprimento dessa execução e o comprimento máximo que foi inserido para truncar a sequência. Em seguida, copia o primeiro caractere de cada execução tantas vezes.

Uso

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

   4 f 'aaaaaaabccccccccCCCCCC@'
aaaabccccCCCC@

Explicação

((<.#@>)#{.@>@])]<;.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 bytes

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

Solicita ne aceita a string de entrada como argumento.

(a função tácita ...
    ∊achatar
    ⊢↑¨⍨cada elemento do argumento (ou seja, cada partição) truncado para
    ⎕⌊⍴¨o mínimo da entrada numérica e o comprimento atual
)[final da função tácita] aplicado à
⊢⊂⍨entrada particionada nos ᴛʀᴜᴇ s de
1, ᴛʀᴜᴇ prefixados a (o primeiro caractere não é igual ao seu antecessor não existente)
2≠/⊢o par não é igual a caracteres na entrada

Ruby, 32 bytes

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

TCC, 7 5 bytes

$~(;)

Entrada é uma sequência e um número, separados por espaço.

Experimente online!

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