चुनौती

एक इनपुट स्ट्रिंग, और एक पूर्णांक 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 अंक होंगे।

हैप्पी गोल्फिंग!

संपादित करें: भाषा प्रतिबंध हटा दिया गया है, लेकिन मैं अभी भी जावास्क्रिप्ट जवाब देखना पसंद करूंगा

code-golf string

— TestSubject06
स्रोत

1

ईएस 6 की अनुमति क्यों नहीं?

— TuxCrafting

7

मैं भाषा की आवश्यकता को खोने की सलाह दूंगा। जावास्क्रिप्ट यहाँ सबसे आम भाषाओं में से एक है। आपको जो मिला, उसके साथ स्वयं का उत्तर देना शायद लोगों को गोल्फ में मदद करने के लिए आमंत्रित करेगा, या किसी अन्य दृष्टिकोण से आपको हरा देने की कोशिश करेगा। इसके अलावा, यदि आप पर्याप्त प्रतिष्ठा प्राप्त करते हैं, तो आप एक विशिष्ट भाषा को ध्यान में रखते हुए प्रश्न को बढ़ा सकते हैं। यदि वह आपके साथ अच्छी तरह से नहीं बैठता है, तो आप इस प्रश्न को एक टिप्स प्रश्न में संशोधित कर सकते हैं और विशिष्ट गोल्फिंग सहायता के लिए पूछ सकते हैं।

— FryAmTheEggman

परिणामस्वरूप भाषा प्रतिबंध और परिवर्तित स्कोरिंग नियम। मैं अभी भी जावास्क्रिप्ट प्रविष्टियों को देखना पसंद करूंगा, लेकिन मुझे लगता है कि मैं कुछ 4-5 चरित्र वाली गोल्फ भाषाओं के साथ रह सकता हूं।

— TestSubject06

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! डिफ़ॉल्ट रूप से बाइट्स में लंबाई द्वारा कोड गोल्फ चुनौतियां बनाई जाती हैं । वर्णों में लंबाई के अनुसार स्कोर करना संभव है, आप इस तरह के कुछ उत्तर प्राप्त करने के लिए बाध्य हैं ।

— डेनिस

हे भगवान। बाइट स्कोरिंग में बदल गया।

— TestSubject06

6

पायथन 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

इनपुट स्ट्रिंग के माध्यम से Iterates 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सीधे पिछले पात्रों की जांच करने की तुलना में लंबे समय तक चली गई ।

— XNOR
स्रोत

6

सी, 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.

यह काम करता है क्योंकि स्रोत पॉइंटर हमेशा गंतव्य पॉइंटर के बराबर या उससे अधिक होगा, इसलिए हम इसे पार्स करते हुए स्ट्रिंग पर लिख सकते हैं।

— owacoder
स्रोत

यह अद्भुत है, क्या आप इसे समझा सकते हैं?

— TestSubject06

@ TestSubject06 - एक स्पष्टीकरण जोड़ा गया।

— उल्लू

क्या यह n = 0 केस के साथ काम करता है? मैं इसे यहाँ पर परीक्षण करने के लिए संकलित नहीं कर सकता।

— TestSubject06

हाँ यह करता है। मैंने एक परीक्षण कार्यक्रम जोड़ा ताकि आप संकलन कर सकें।

— उल्लू

बहुत बढ़िया, कोई भी काउंटर उदाहरण नहीं मिल सका। लघु और यह काम करता है!

— TestSubject06

5

हास्केल, 36 बाइट्स

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

का पॉइंट-फ्री संस्करण \n s -> concatMap (take n) (group s)।

— लिन
स्रोत

4

जावास्क्रिप्ट ईएस 6, 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"

— Dendrobium
स्रोत

f ("a", 1) -> ""

— TestSubject06

1

के बाद से अपने रेगुलर एक्सप्रेशन गतिशील किसी भी तरह से नियंत्रित नहीं है आप रेगुलर एक्सप्रेशन ( "। () \\ 1 *", "जी") के साथ कुछ बाइट्स बचा सकता है -> /(.)\1*/g

— TestSubject06

1

में परिवर्तित RegExp("(.)\\1*","g")करें/(.)\1*/g

— Downgoat

1

मुझे जेएस में यह छोटा नहीं लग रहा है, जब तक कि हम पूरी तरह से अलग कोण से नहीं आते। अच्छी नौकरी @ डेंड्रोबियम!

— TestSubject06

1

एक बाइट को बदलकर शेव (s,n)करें s=>n, और उपयोग हो जाता हैf("aaaaaaabbbccCCCcc")(2)

— पैट्रिक रॉबर्ट्स

3

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

— Suever
स्रोत

'@@@@@ bbbbcccddeegffsassss' 3 लौट आया '@@@ bbbcccddeegffsass' जो अंतिम 's' को याद कर रहा है

— TestSubject06

@ TestSubject06 यह इंगित करने के लिए धन्यवाद।

— स्वेवर

2

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.

— मार्टिन एंडर
स्रोत

2

पायथ, 16 12 बाइट्स

rm, hS, Qhdedrz8 9
एस एस <RQmM_Mrz8

इसे ऑनलाइन आज़माएं!

— लीक नन
स्रोत

2

पायथन 2, 56 बाइट्स

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

— लिन
स्रोत

2

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)

— लिन
स्रोत

1

पर्ल 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@"

— ब्रैड गिल्बर्ट b2gills
स्रोत

0

जावास्क्रिप्ट ईएस 5, 73

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

अपने पायथन जवाब से लिन के रेगेक्स का फिर से उपयोग करता है ।

— फ्राइअमईएग्गमैन को दर्शाता है
स्रोत

आपका कोड उस मामले को नहीं संभालता है जहां n शून्य है, यह सिर्फ पूरे मूल स्ट्रिंग को वापस करता है।

— TestSubject06

हाँ, फ़ायरफ़ॉक्स में, आप ब्रेसेस और रिटर्न स्टेटमेंट को ड्रॉप कर सकते हैं , हालाँकि वह वाक्यविन्यास (दुख की बात है) को हटा दिया गया है और इसे हटा दिया जाएगा (यह वास्तव में कुछ संस्करणों में अनुपस्थित था, एहसास नहीं था कि वे इसे वापस लाए हैं)।

— डेंड्रोबियम

आप newकीवर्ड को -4 बाइट्स के लिए भी छोड़ सकते हैं ।

— डेंड्रोबियम

@ TestSubject06 धन्यवाद, मैंने अपना उत्तर संपादित कर दिया है और मुझे विश्वास है कि यह अब परीक्षण मामलों को पारित करता है।

— FryAmTheEggman

0

पर्ल 5, 50 बाइट्स

46 बाइट्स कोड + के लिए 3 -iऔर 1 के लिए-p

संख्या के माध्यम से कम करने के लिए ले जाता है -i।

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

प्रयोग

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

— डोम हेस्टिंग्स
स्रोत

-pकेवल एक बाइट क्यों है ?

— someonewithpc

@someonewithpc जब इसे -eइन विकल्पों के साथ जोड़ा जा सकता है तो केवल 1 बाइट की खपत होती है। यदि स्क्रिप्ट को किसी फ़ाइल से चलाया जाना है, तो उस स्थान के लिए 3 लागत होती है और वह स्वयं ध्वजांकित करता है। वहाँ एक मेटा पोस्ट मैं कोशिश करूँगा और मिल जाएगा, लेकिन मैं अभी मोबाइल पर हूँ।

— डोम हेस्टिंग्स

@someonewithpc meta.codegolf.stackexchange.com/questions/273/…

— डोम हेस्टिंग्स

0

बैश 46 बाइट्स

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

उपयोग: सीमित करने के लिए वर्णों की संख्या दर्ज करें, Enter दबाएं और स्ट्रिंग दर्ज करें। Ctrl+ Dबाहर निकलने के लिए sed(ईओएफ भेजें)।

— someonewithpc
स्रोत

0

जावा 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);}

स्ट्रिंग संयोजन के लिए पिछला वैकल्पिक इनलाइन लूप (जो 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

— केविन क्रूज़सेन
स्रोत

0

जावास्क्रिप्ट (बाहरी पुस्तकालय का उपयोग करके) (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

लिंक ऑफ लिब: https://github.com/mvegh1/Enumerable

कोड स्पष्टीकरण: स्ट्रिंग को लाइब्रेरी में लोड करें, जो आंतरिक रूप से चार सरणी के रूप में पार्स करता है। अनुक्रम पर एक संचायक लागू करें, एक कस्टम ऑब्जेक्ट में बीज मान के रूप में गुजर रहा है। संपत्ति एक वर्तमान तत्व है, बी संचित स्ट्रिंग है, और सी वर्तमान तत्व की अनुक्रमिक गणना है। संचायक की जाँच करता है कि क्या वर्तमान पुनरावृत्ति मूल्य, n, अंतिम तत्व मान के बराबर है, यदि नहीं, तो हम गिनती को 1 पर रीसेट करते हैं और वर्तमान तत्व को सेट करते हैं। यदि वर्तमान तत्व की गिनती वांछित लंबाई से कम या बराबर है, तो हम इसे रिटर्न स्ट्रिंग में जमा करते हैं। अंत में, हम गुण b, संचित स्ट्रिंग लौटाते हैं। नहीं गोल्फ कोड, लेकिन खुश मैं एक समाधान है कि काम करता है ...

— applejacks01
स्रोत

0

जे, 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

— मील की दूरी पर
स्रोत

0

दिल्लोग एपीएल , 22 20 बाइट्स

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

N के लिए संकेत देता है और तर्क के रूप में इनपुट स्ट्रिंग लेता है।

(मौन समारोह ...
    ∊समतल
    ⊢↑¨⍨तर्क (यानी प्रत्येक विभाजन) तक छोटा कर दिया के प्रत्येक तत्व
    ⎕⌊⍴¨संख्यात्मक इनपुट की न्यूनतम और वर्तमान लंबाई
)[मौन समारोह के अंत] के लिए लागू
⊢⊂⍨इनपुट पर विभाजित ᴛʀᴜᴇ की रों
1, ᴛʀᴜᴇ प्रीपेंड को ( पहला चरित्र अपने गैर-अतिरिक्त पूर्ववर्ती के
2≠/⊢बराबर नहीं है ) इनपुट में जोड़ी-वार न के बराबर

— एडम
स्रोत

0

रूबी, 32 बाइट्स

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

— जॉर्डन
स्रोत

-1

टीसीसी, 7 5 बाइट्स

$~(;)

इनपुट एक स्ट्रिंग और एक संख्या है, जो अंतरिक्ष से अलग है।

इसे ऑनलाइन आज़माएं!

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

— brianush1
स्रोत

1

न तो आपके उत्तर के संशोधन ने tcc.luaटाइमस्टैम्प 16-07-25 16:57 यूटीसी के साथ फाइल में काम किया , जिसमें एक बार में कई इनपुट पढ़ने की क्षमता नहीं थी। यदि आपके उत्तर के लिए चुनौती का सामना करने वाली भाषा के एक संस्करण की आवश्यकता होती है, तो आपको इसे हेडर में गैर-प्रतिस्पर्धी के रूप में लेबल करना होगा । जब आप करोगे तो मैं अपना पदच्युत निकाल दूंगा।

— डेनिस

ट्रंकट लगातार चरित्र n लंबाई तक चलता है

चुनौती

स्कोरिंग

पायथन 2, 52 बाइट्स

सी, 81 78

परीक्षण कार्यक्रम

स्पष्टीकरण:

हास्केल, 36 बाइट्स

जावास्क्रिप्ट ईएस 6, 60 54 55 43 बाइट्स

MATL, 9 बाइट्स

CJam, 12 बाइट्स

व्याख्या

पायथ, 16 12 बाइट्स

पायथन 2, 56 बाइट्स

gs2, 6 बाइट्स

पर्ल 6 , 38 36 बाइट्स

स्पष्टीकरण:

परीक्षा:

जावास्क्रिप्ट ईएस 5, 73

पर्ल 5, 50 बाइट्स

प्रयोग

बैश 46 बाइट्स

जावा 7, 107 106 बाइट्स

जावास्क्रिप्ट (बाहरी पुस्तकालय का उपयोग करके) (115 बाइट्स)

जे, 31 30 बाइट्स

प्रयोग

व्याख्या

दिल्लोग एपीएल , 22 20 बाइट्स

रूबी, 32 बाइट्स

टीसीसी, 7 5 बाइट्स