Meydan okuma

Bir giriş dizesi ve bir tamsayı n verildiğinde , ardışık karakterlerin tüm çalışmalarını maksimum n uzunluğa indirir. Karakterler, özel karakterler de dahil olmak üzere herhangi bir şey olabilir. İşlev büyük / küçük harfe duyarlı olmalıdır ve n 0 ile sonsuz arasında değişebilir.

Örnek girişler / çıkışlar:

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

puanlama

Puanlama, kullanılan bayt sayısına bağlıdır. Böylece

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

104 puan olur.

Mutlu golf!

Düzenleme: dil kısıtlaması kaldırıldı, ancak yine de javascript cevaplarını görmek isterim

Python 2, 52 bayt

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

Program olarak yazılır (54 bayt):

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

Son karakter o karakter değilse , giriş dizesi boyunca yinelenir ve sher karakteri çıkış dizesine rekler .nr

Son 0 karakter (boş dize) değil, tüm dize n==0çünkü bu başarısız olur r[-0:]. Ancak, dize boş kaldığı için çalışır, bu nedenle 0 karakterli dizeyle eşleşir.

Yineleme lambdanedeniyle tekrarlama 56 verdi

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

iSon karakterin tekrarlarını tutmak için alternatif bir strateji de son nkarakterleri doğrudan kontrol etmekten daha uzun çıktı .

C, 81 78

Gelen dizeyi değiştirir.

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

Test programı

İki parametre gerektirir, birincisi kısaltılacak dize, ikincisi uzunluk sınırıdır.

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

Açıklama:

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.

Bu, kaynak işaretçinin her zaman hedef işaretçiye eşit veya daha büyük olacağı için çalışır, böylece dizeyi ayrıştırırken dizenin üzerine yazabiliriz.

Haskell, 36 bayt

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

Noktasının noktasız versiyonu \n s -> concatMap (take n) (group s).

Javascript ES6, 60 54 55 43 bayt

@ TestSubject06 ve @Downgoat sayesinde -12 bayt

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

Örnek çalıştırmalar:

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

MATL, 9 bayt

Y'i2$X<Y"

Çevrimiçi Deneyin

açıklama

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

{e`\af.e<e~}

Çevrimiçi deneyin!

açıklama

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 bayt

rm, hS, Qhdedrz8 9
ss <RQmM_Mrz8

Çevrimiçi deneyin!

Python 2, 56 bayt

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

gs2, 6 bayt

CP437 ile kodlanmış :

╠c╨<ΘΣ

Bu, yığının üstünde bir sayı ve altında bir dize bekleyen anonim bir işlevdir (blok).

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

Çevrimiçi deneyin. (Buradaki kod lines, dump, read number, [the answer], run-block.)

Perl 6 ,  38  36 bayt

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

Açıklama:

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

Ölçek:

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

Lynn'in normal ifadesini Python'un cevabından tekrar kullanıyor .

Perl 5, 50 bayt

46 bayt kodu + 3 için -ive 1 için-p

İle kısaltılması gereken sayıyı alır -i.

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

kullanım

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

Bash 46 bayt

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

Kullanım: Sınırlanacak karakter sayısını girin, enter tuşuna basın ve dizeyi girin. çıkmak için Ctrl+ (EOF gönder).Dsed

Java 7, 107 106 bayt

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

Dize birleştirmesi için önceki alternatif satır içi for-loop ( String s="";for(int i=-1;++i<j;)s+="$1";maalesef 1 bayt fazla ):

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

Test edilmemiş ve test durumları:

Burada deneyin.

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

Çıktı:

aabbccCCcc
abc

aaaabccccCCCC@
@@@@@bbbbbcccddeegffsassss

Javascript (harici kitaplık kullanarak) (115 bayt)

(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 bağlantısı: https://github.com/mvegh1/Enumerable

Kod açıklaması: Dizeyi, char dizisi olarak dahili olarak ayrıştıran kitaplığa yükleyin. Özel bir nesneyi tohum değeri olarak ileterek diziye bir akümülatör uygulayın. Özellik a, geçerli öğedir, b birikmiş dizedir ve c, geçerli öğenin sıralı sayımıdır. Akümülatör, mevcut yineleme değerinin (n) son eleman değerine eşit olup olmadığını kontrol eder. Ca Değilse, sayıyı 1'e sıfırlar ve geçerli elemanı ayarlarız. Geçerli öğenin sayısı istenen uzunluktan küçük veya ona eşitse, onu dönüş dizesine biriktiririz. Son olarak, biriken dize olan b özelliğini döndürürüz. En golf kodu değil, ama mutlu çalışan bir çözüm var ...

J, 31 30 bayt

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

Giriş dizesini özdeş karakterlerin çalışma (alt dizeleri) olarak gruplandırır ve o dizinin uzunluğunu ve dizeyi kısaltmak için girilen maksimum uzunluğu alır. Sonra her çalışmanın ilk karakterini birçok kez kopyalar.

kullanım

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

   4 f 'aaaaaaabccccccccCCCCCC@'
aaaabccccCCCC@

açıklama

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

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

N için sorulur ve girdi dizesini bağımsız değişken olarak alır.

(zımni işlevi ...
    ∊düzleştirmek
    ⊢↑¨⍨için kesilmiş değişken (yani her bir bölüm) her elemanının
    ⎕⌊⍴¨sayısal giriş minimum ve mevcut uzunluğu
)[zımni fonksiyonunun son] uygulanan
⊢⊂⍨paylaştırıldı giriş ᴛʀᴜᴇ s
1, ᴛʀᴜᴇ verinin başına ( ilk karakter, mevcut olmayan selefine
2≠/⊢eşit değildir) girişteki karakterlerin çift olarak eşit olmaması

Ruby, 32 bayt

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

TCC, 7 5 bayt

$~(;)

Girdi, boşlukla ayrılmış bir dize ve bir sayıdır.

Çevrimiçi deneyin!

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