55

हम परिभाषित खाली स्थान के तीन वर्णों के किसी भी, टैब (0x09), न्यू लाइन (0x0A) या अंतरिक्ष (0x20) किया जाना है।

इस चुनौती के लिए, आपको एक ही प्रोग्रामिंग भाषा में दो कार्यक्रम या फ़ंक्शन लिखने हैं, जो निम्नलिखित कार्य करते हैं:

किसी दिए गए स्ट्रिंग में व्हाट्सएप वर्णों की गणना करें। उदाहरण के लिए, इनपुट
```
  123 -_-   abc
def
```
7 लौटेंगे (बशर्ते कि कोई नई सीमा न हो)।
व्हॉट्सएप के लगातार रन पर दिए गए स्ट्रिंग को विभाजित करें। यदि स्ट्रिंग व्हाट्सएप से शुरू होती है या समाप्त होती है, तो छोर पर कोई खाली तार नहीं लौटाया जाना चाहिए। उदाहरण के लिए, एक ही इनपुट
```
  123 -_-   abc
def
```
लौट आएंगे ["123", "-_-", "abc", "def"]।

किसी भी स्थिति में आप STDIN के माध्यम से इनपुट ले सकते हैं, कमांड-लाइन तर्क या फ़ंक्शन तर्क परिणाम लौटा सकते हैं या इसे STDOUT प्रिंट कर सकते हैं। दूसरे कार्यक्रम के लिए, यदि आप STDOUT पर प्रिंट करना चुनते हैं, तो कृपया प्रत्येक स्ट्रिंग को अपनी पंक्ति में, बिना आसपास के उद्धरणों के प्रिंट करें।

दोनों कार्यक्रमों के लिए आप मान सकते हैं कि इनपुट में केवल मुद्रण योग्य ASCII (0x20 से 0x7E) और व्हॉट्सएप शामिल हैं।

अब यहाँ पकड़ है:

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

यह कोड गोल्फ है। आपका स्कोर दोनों समाधानों के आकार का योग है (बाइट्स में)। सबसे कम स्कोर जीतता है।

लीडरबोर्ड

निम्नलिखित स्टैक स्निपेट एक नियमित लीडरबोर्ड और भाषा द्वारा विजेताओं के अवलोकन दोनों को उत्पन्न करता है। यहां तक कि अगर आपकी पसंद की भाषा आपको पूरी चुनौती जीतने नहीं देती है, तो दूसरी सूची पर स्पॉट छीनने की कोशिश क्यों न करें? मुझे यह देखने में बहुत दिलचस्पी होगी कि लोग विभिन्न भाषाओं में इस चुनौती से कैसे निपटते हैं!

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

आपके जमा करने का कुल आकार कहां Nहै । यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

आप कुल गणना से पहले व्यक्तिगत गणना भी शामिल कर सकते हैं, जैसे

# Python 2, 35 + 41 = 76 bytes

आखिरी नंबर जो कि मारा नहीं गया है, स्निपेट द्वारा उपयोग किया जाएगा।

<script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>site = 'meta.codegolf',postID = 5314,isAnswer = true,QUESTION_ID = 42253;jQuery(function(){var u='https://api.stackexchange.com/2.2/';if(isAnswer)u+='answers/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJeRCD';else u+='questions/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJO6t)';jQuery.get(u,function(b){function d(s){return jQuery('<textarea>').html(s).text()};function r(l){return new RegExp('<pre class="snippet-code-'+l+'\\b[^>]*><code>([\\s\\S]*?)<\\/code><\/pre>')};b=b.items[0].body;var j=r('js').exec(b),c=r('css').exec(b),h=r('html').exec(b);if(c!==null)jQuery('head').append(jQuery('<style>').text(d(c[1])));if (h!==null)jQuery('body').append(d(h[1]));if(j!==null)jQuery('body').append(jQuery('<script>').text(d(j[1])))})})</script>

स्निपेट का विस्तार करें

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

26

वह लीडरबोर्ड मस्त है!

— डिजिटल ट्रामा

5

किसी भी व्हॉट्सएप जवाब की तरह लगता है नियम 1 का पालन करेगा;)

— nyuszika7h

1

@ nyuszika7h वास्तव में यह होगा, लेकिन यह वैसे भी विशेष रूप से कम नहीं होगा।

— मार्टिन एंडर

7

महत्वपूर्ण

— व्हाट्सएप

1

तो क्या बाश को स्ट्रिंग शाब्दिक के रूप में गिना जाता है?

— jimmy23013

15

पायथ, 16 + 15 = 31 बाइट्स

इसे यहाँ आज़माएँ ।

काउंटर:

L@,cb)sm!cd)b1 0

स्प्लिटर:

L@,cb)sm!cd)b10

ये प्रत्येक एक फ़ंक्शन को परिभाषित करते हैं y, जो वांछित कार्य को हल करने के लिए एक स्ट्रिंग इनपुट लेता है।

एक चरित्र को दाढ़ी करने के लिए सूचियों में मॉड्यूलर अनुक्रमण के पायथ की सुविधा का उपयोग करने के विचार के लिए @FryAmTheEggman का धन्यवाद।

परीक्षण के मामलों:

L@,cb)sm!cd)b1 0y++"abc def"b"gh ij k"
L@,cb)sm!cd)b10y++"abc def"b"gh ij k"

स्पष्टीकरण:

L                  define a function, y, which takes one input, b.
 @                 Index into
  ,                2-tuple of
   cb)             b.split()                          (solution to splitter)
   s               sum over                           (solution to counter)
    m              map, with input d, to
     !cd)          logical negation of d.split()      (empty list is falsy)
     b             over b.
                   Index is either:
   10
   1
                   Indexing is modulo the length of the list in Pyth.
 0                 In one case, a 0 with a leading space is outside the function.
                   Leading space suppresses print, so the 0 is invisible.

— isaacg
स्रोत

52

पायथन, 54 + 56 = 110 बाइट्स

काउंटर:

m=lambda x:sum(y.isspace()for y in x)
+1
0<9or x.split()

स्प्लिटर:

m=lambda x:sum(y.isspace()for y in x)+10<9or x.split()

काउंटर के लिए, हम इस तथ्य का उपयोग करते हैं कि पायथन केवल एक लाइन पर एक अभिव्यक्ति होने के साथ ठीक है। यह अलग करने के लिए आवश्यक है +1और 0<9or x.split()एक को रोकने के लिए NameErrorफेंके जाने से, के रूप में 0<9किया जा रहा है Trueरोकता है x.split()लघु सर्किटिंग के कारण मूल्यांकन किया जा रहा से।

फाड़नेवाला के लिए, चूंकि व्हॉट्सएप की संख्या हमेशा nonnegative होती है, sum(y.isspace()for y in x)+10<9हमेशा होती है Falseऔर विभाजन कार्य खेल में आता है।

वैकल्पिक 1, 59 + 60 = 119 बाइट्स

काउंटर:

m=lambda x:[x.split(),sum(y.isspace()for y in x)][min([1])]

स्प्लिटर:

m=lambda x:[x.split(),sum(y.isspace()for y in x)][m in([1])]

गिनती और विभाजन दोनों के परिणाम दो-तत्व सूची में संग्रहीत किए जाते हैं। इस सूची को या तो अनुक्रमित किया गया है min([1]), जिसमें एक तत्व की न्यूनतम सूची शामिल है 1, या m in([1]), जो रिटर्न False(समतुल्य 0) के रूप mमें समाहित नहीं है [1]।

वैकल्पिक 2, 67 + 69 = 136 बाइट्स

काउंटर:

ted=1;s=lambda x:[x.split(),sum(y.isspace()for y in x)][not s or ted]

स्प्लिटर:

ted=1;s=lambda x:[x.split(),sum(y.isspace()for y in x)][not sorted]

ऊपर की तरह, गिनती और विभाजन दोनों के परिणाम दो-तत्व सूची में संग्रहीत होते हैं। sortedएक अंतर्निहित फ़ंक्शन है जो एक सत्य मूल्य है, इसलिए not sortedरिटर्न False(बराबर 0)। के लिए not s or ted, के बाद से s, एक समारोह है और यह भी truthy है not sहै Falseऔर ted = 1दिया जाता है।

वैकल्पिक 3, 59 + 60 = 119 बाइट्स

काउंटर:

def f(s):a=s.split();a1=len(s)-len((s*0).join(a));return a1

स्प्लिटर:

def f(s):a=s.split();a1=len(s)-len((s*0).join(a));return a
1

यह एक फ़ंक्शन है जहां स्प्लिटर का परिणाम चर में संग्रहीत किया जाता है a, और काउंटर का परिणाम चर में संग्रहीत किया जाता है a1। पहले की तरह, पायथन ठीक है, इस मामले में केवल एक लाइन पर एक अभिव्यक्ति है 1। बंटवारा a1निर्धारित करता है कि फ़ंक्शन से क्या लौटना है।

— Sp3000
स्रोत

22

मैं +1 फिर से करूंगा not sorted।

— मार्टिन एंडर

के बीच की नई लाइन +1और 0<9or x.split()जरूरत है?

— इसहाक

1

@ आइसाकग यदि आप अपवादों की परवाह करते हैं, तो हाँ

— Sp3000

आप 3 बाइट्स से दाढ़ी बना सकते हैं m=lambda x:sum(y.isspace()for y in x)+00and x.split()और m=lambda x:sum(y.isspace()for y in x)+0;0and x.split()(उस अर्धविराम को पाठ्यक्रम की एक नई

— रेखा बना सकते हैं

@ मुझे लगता है कि अगर कोई व्हॉट्सएप नहीं है तो पहला एक अलगानेवाला के रूप में काम करता है

— Sp3000

16

जावा 8, 239 + 240 = 479

व्हॉट्सएप की गिनती करें (रिटर्न इंटेगर)

Object f(String s){String r=new String(new char[]{92,'s'}),e=new String();int intx=0;intx=1;return intx>0?s.chars().filter(c->c==9|c==10|c==32).count():java.util.Arrays.stream(s.split(r)).map(t->t.replaceAll(r,e)).filter(t->t.length()>0);}

व्हाट्सएप पर विभाजन (रिटर्न स्ट्रीम <स्ट्रिंग>)

Object f(String s){String r=new String(new char[]{92,'s'}),e=new String();int intx=0;int x=1;return intx>0?s.chars().filter(c->c==9|c==10|c==32).count():java.util.Arrays.stream(s.split(r)).map(t->t.replaceAll(r,e)).filter(t->t.length()>0);}

स्पष्टीकरण:

Object f(String s){
    String r=new String(new char[]{92,'s'}),e=new String();  // init regex'es

    int intx=0;     // critical variable

    intx=1;         // change intx to 1
              OR
    int x=1;        // new, unused variable

    return intx>0 ? // test variable to decide what to do
      s.chars().filter(c->c==9|c==10|c==32).count() :
      java.util.Arrays.stream(s.split(r)).map(t->t.replaceAll(r,e)).filter(t->t.length()>0);
}

— Ypnypn
स्रोत

मेरे लिए, यह शानदार दिखता है। +1

— रोडोल्फो डायस

बहुत अच्छा, यह देखते हुए कि जावा को कोड गोल्फिंग के लिए सबसे खराब भाषा होना चाहिए ।

— tbodt

13

व्हॉट्सएप, 75 + 153 = 228

क्रमशः एसटीएल द्वारा प्रतिस्थापित स्पेस, टैब और न्यूलाइन्स, और लेगबिलिटी के लिए मुड़ा हुआ है। के साथ एक उचित व्हॉट्सएप फ़ाइल में कनवर्ट करें tr -d \\n | sed 'y/STL/ \t\n/'।

काउंटर

SSSLLSSLSSSTSSSSSLSLSSLSTLTSTTTSLSLTSSLTSSTLTTLSSSTLTSSSLSLLLSSSLS
LLSLLTLST

फाड़नेवाला

SSSTLSSSLTTSLSSTLSSSLSLSTLTSTTTSLSSLSLTSLSSSTSSSSTLTSSTLTTTTLSSSTL
SLSTTSLSLSLLSSTTLSSSTSTSLSSSTLTTTLTSTSLTLSSSSSTLSSSLTTSLSSTSLLSLTL
LSSSLTLSSLSLTLLSSLLLL

— ninjalj
स्रोत

2

मैं सोच रहा था कि यह कितना समय लगेगा ...?)

— मार्टिन एंडर

4

व्हॉट्सएप के साथ, यह दो अलग-अलग कोड गोल्फिंग चुनौतियां बन जाती हैं।

— tbodt

13

मारबेलस, 103 + 92 = 195

काउंटर:

@0      @200@1@3
]]&1]]3W
  \\!!?001
        &0  >W@1
>W    @2/\  /\@3+A
00&0      &1
          Dp
@0//

स्प्लिटर:

@0  @200@1    @3
]]&1]]  3W    \\
  !!    ?001&0
>W@1>W@2
/\  /\@3+A00&0
          &1Dp@0
//

इन कार्यक्रमों का यहां परीक्षण करें। बेलनाकार बोर्डों, पुस्तकालयों को शामिल करें, और रिक्त कोशिकाओं के लिए रिक्त स्थान सभी की जांच होनी चाहिए।

इनपुट और आउटपुट STDIN / STDOUT के माध्यम से हैं।

व्याख्या

काउंटर:

काउंटर स्रोत

नीले रंग का रास्ता इनपुट प्राप्त करता है। यदि वर्ण एक व्हाट्सएप चरित्र है (0x21 से कम एएससीआई मूल्य), तो काला पथ लिया जाता है, जो बैंगनी पथ के साथ सिंक्रनाइज़ होता है।

बैंगनी पथ बस एक संगमरमर को संक्रमीक में संग्रहित करता है, &1जब हर बार काला रास्ता लिया जाता है।

एक बार अधिक इनपुट न होने पर, व्हाट्सएप वर्णों की संख्या को प्रिंट करने और बाहर निकलने के लिए, लाल पथ लिया जाता है।

स्प्लिटर:

स्प्लिटर स्रोत

कार्यक्रम की शुरुआत नीले रास्ते से होती है, जो तब तक लूप करता है जब तक कि एक गैर-व्हाट्सएप चरित्र नहीं मिल जाता है।

एक बार एक गैर-व्हाट्सएप चरित्र को पुनर्प्राप्त करने के बाद, काला रास्ता लिया जाता है, जो इस चरित्र को प्रिंट करता है और निष्पादन को हरे रंग के पथ पर ले जाता है, जो एक व्हाट्सएप-चरित्र प्राप्त होने तक लूप और प्रिंट करता है। निष्पादन तब बैंगनी मार्ग पर जारी रहता है, जिसमें 3Wतीन-तरफा विभाजन होता है।

बाईं शाखा नीले रंग के पथ पर निष्पादन ले जाती है (और व्हॉट्सएप को तब तक छोड़ दिया जाता है जब तक कि एक गैर-व्हाट्सएप चरित्र नहीं मिलता है)।

मध्य शाखा के साथ 0 के लिए इनपुट की प्रति सेट ?0(के बीच एक यादृच्छिक संख्या उत्पन्न 0और 0), और कहते हैं 10 ( 0x0A= newline), जो तब outputted है।

सही रास्ता छोड़ दिया है।

— es1024
स्रोत

ऐसा लगता है कि अगर वहां व्हॉट्सएप चल रहा है तो स्प्लिटर समाप्त नहीं होता है।

— मार्टिन एंडर

12

CJam, 26 + 27 = 53 59 61 73 77 बाइट्स

काउंटर

'!q_,\SN9c++SerS%:Qs,-QN*?

फाड़नेवाला

' !q_,\SN9c++SerS%:Qs,-QN*?

यह काम किस प्रकार करता है

यह विचार सरल है, दोनों व्हाट्सएप की संख्या की गणना करें और व्हाट्सएप के लगातार रन पर स्ट्रिंग को विभाजित करें। फिर उनमें से एक निम्नलिखित तथ्य यह है कि के आधार पर चयन ' !का मतलब है not of space character, जो falsy है, जबकि '!है !चरित्र है, जो truthy है।

विस्तारित कोड:

'! / ' !                              "Get truthy or falsy value";
        q_                            "Read the input, make a copy";
          ,\                          "Take the length of the copy and swap";
            SN9c++                    "Get a string comprised of all Whitespaces";
                  Ser                 "Replace any occurrence of any character of"
                                      "the above string with space";
                     S%               "Split on one or more runs of space";
                       :Qs,           "Store this in Q, flatten to a string and take length";
                           -          "Subtract from total length to get count";
                            QN*       "Put the splitted array on stack and join newline";
                               ?      "Base on the truthy or falsy value, pick one to print";

इनपुट STDIN से है और आउटपुट STDOUT से है

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

10

गणितज्ञ, 44 + 43 = 87 97 बाइट्स

मैंने सोचा कि मैं मिश्रण में एक और भाषा जोड़ूंगा।

काउंटर:

StringCount[#,Whitespace]+0 1StringSpli t@#&

स्प्लिटर:

String Count[#,Whitespace]+01StringSplit@#&

यह Mathematica की विशेषता का उपयोग करता है कि अंतरिक्ष पृथक्करण गुणा के समान है। और यह कि 0 के साथ कुछ गुणा करना हमेशा 0 होता है, और 0 को कुछ से जोड़ना हमेशा ही बेकार होता है।

काउंटर के लिए, हम पहले व्हॉट्सएप की गिनती करते हैं, और हम जोड़ते हैं 0*1*StringSpli*t@#। StringSpliऔर tपरिभाषित नहीं किया जाता है, लेकिन गणितज्ञ प्रतीकात्मक गणना का उपयोग करता है, इसलिए यह सिर्फ एक अज्ञात चर और कार्य के रूप में व्यवहार करता है। 1*Idempotent (बस के रूप में है 0+), 0*एक शून्य में बदल जाता। यह StringSplitदो चर में अलग करने के लिए आवश्यक है , क्योंकि 0कई बार एक सूची को अदिश-वेक्टर गुणन के रूप में माना जाता है जिसके परिणामस्वरूप शून्य का वेक्टर (सूची) होता है।

फाड़नेवाला के लिए, मैं इस तथ्य का उपयोग कर रहा हूं जो Countमौजूद है लेकिन तार में नहीं दिखता है। यह पैटर्न से मेल खाते सभी उप अभिव्यक्तियों को गिनने की कोशिश करता है , लेकिन Whitespaceएक ऐसा पैटर्न है जो केवल स्ट्रिंग सामग्री पर लागू होता है। तो Countहमेशा लौटेगा 0, जो Stringगायब हो जाता है। विभाजित सरणी का गुणन 01 = 1फिर से उदासीन है।

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

10

रूबी, 107 91 बाइट्स

फाड़नेवाला (46 बाइट्स)

p
p=gets(p).split
puts p||$_.size-pp.join.size

काउंटर (45 बाइट्स)

pp=gets(p).split
puts p||$_.size-pp.join.size

pएक पूर्वनिर्धारित विधि है, जिसमें कोई तर्क नहीं है, बस वापस आता है nil। हम इसका कई तरह से उपयोग करते हैं। फाड़नेवाला में, प्रारंभिक pकुछ भी नहीं करता है। gets(p)मानक इनपुट से सब कुछ में पढ़ता है, क्योंकि सीमांकक अशक्त है। हम उस पर अंतर्निहित विभाजन विधि को कॉल करते हैं, और परिणाम को असाइन करते pहैं, इसलिए अब जब यह तर्क नहीं दिया जाता है तो इसे एक चर के रूप में पार्स किया जाएगा। puts p||...शॉर्ट-सर्किट और pचर के प्रत्येक तत्व को अपनी लाइन में प्रिंट करता है ।

काउंटर में, हम पहली नई पंक्ति को हटाते हैं ताकि विभाजन सरणी को ppइसके बजाय सौंपा जाए । चूंकि हमने इसे नहीं सौंपा है p, यह अभी भी शून्य-वापसी की विधि है इसलिए ||मूल्यांकन के दूसरे भाग का मूल्यांकन किया जाता है और इसे पारित किया जाता है puts। $_का एक जादू चर है, जिसके परिणाम में getsव्हॉट्सएप की कुल मात्रा उस शून्य से गैर-व्हाट्सएप वर्ण का आकार है, जो ppइसमें शामिल हैं। मुझे ऐसा लगता है कि मतगणना करने का एक छोटा तरीका होना चाहिए, लेकिन मुझे एक नहीं मिल रहा है, और किसी भी दर पर काउंटर सरणी में विभाजन का उपयोग करना मजेदार है।

— histocrat
स्रोत

7

अजगर, 169

पायथन में ऐसा करना लगभग आसान है!

काउंटर:

def x(s):
 def y(s):
  return sum(map(str.isspace,s))
  return s.split()
 return y(s)

स्प्लिटर:

def x(s):
 def y(s):
  return sum(map(str.isspace,s))
 return s.split()
 return y(s)

वे केवल एक स्थान में भिन्न होते हैं, और मैं किसी भी चालबाजी की तरह नहीं कर रहा हूं जैसे कि संख्या को विभाजित करना या आधे में एक चर नाम :)

— जेम्स एलेगन
स्रोत

6

सी, 138 + 136 = 274

प्रत्येक मामले में, कोड एक प्रोग्राम है जो बिल्कुल एक कमांड-लाइन तर्क को स्वीकार करता है और परिणाम को प्रिंट करने के लिए प्रिंट करता है। \tएक टैब चरित्र के साथ प्रतिस्थापित किया जाना चाहिए। यदि आप टैब और newlines युक्त तर्क पास करना चाहते हैं, तो यह पता लगाना आपका काम है;)।

गिनती

#define strtok strpbrk
h=' \t\n';main(c,v,n)char**v;{for(n=- -c-1;v[n]=strtok(1[v],&h);n[v]++)v[!n]=0,puts(*v),c++;n*='d%';printf(&n,c-2);}

विभाजन

#define strtokstrpbrk
h=' \t\n';main(c,v,n)char**v;{for(n=--c-1;v[n]=strtok(1[v],&h);n[v]++)v[!n]=0,puts(*v),c++;n*='d%';printf(&n,c-2);}

— feersum
स्रोत

6

जावास्क्रिप्ट, 95 + 96 = 191 बाइट्स

काउंटर:

c=(a,v)=>{v
v=a=a.split(RegExp(String.fromCharCode(92,115)));return v?a.length-1:a.filter(j=>j)}

स्प्लिटर:

s=(a,v)=>{vv=a=a.split(RegExp(String.fromCharCode(92,115)));return v?a.length-1:a.filter(j=>!!j)}

Ungolfed:

s=(a,v)=>{

    v  // this `v` is ignored, or combined with the next line to make `vv`

    // split array and store it in `a` and `v` (or alternatively `vv`)
    v = a = a.split(RegExp(String.fromCharCode(92,115)));

    return v?
            a.length-1        // return number of whitespace chars
            :
            a.filter(j=>j)    // return array without empty strings
    }

RegExp(String.fromCharCode(92,115)लाइन खाली स्थान के मिलान regex बनाता /\s/regex या स्ट्रिंग शाब्दिक बिना।

प्रत्येक कार्यक्रम में, हम चर का उपयोग करते हैं vया vv। हम विभाजित चर को उस चर ( vया vv) में संग्रहीत करते हैं , और उसके बाद v(इस बीच, vvअनदेखा किया जाता है) के मूल्य पर हमारे व्यवहार को शाखा देते हैं । काउंटर में, vएक सत्य मूल्य है; फाड़नेवाला में इसका एक मिथ्या मूल्य है (क्योंकि vvइसके बदले मूल्य मिला है)।

वैकल्पिक: जावास्क्रिप्ट, 250 बाइट्स

मेरे पास एक और समाधान है जो संक्षिप्तता के लिए कोई पुरस्कार नहीं जीत रहा है, लेकिन मैंने सोचा कि यह जावास्क्रिप्ट के स्वचालित अर्धविराम सम्मिलन व्यवहार का दुरुपयोग करने के लिए एक दिलचस्प चुनौती थी।

काउंटर:

c=a=>{a=a.split(RegExp(String.fromCharCode(92,115)));x:for(i=2;i--;)for(o=i?a.length-1:a.filter(j=>j);1;){break x}return o}

स्प्लिटर:

s=a=>{a=a.split(RegExp(String.fromCharCode(92,115)));x:for(i=2;i--;)for(o=i?a.length-1:a.filter(j=>j);1;){break
x}return o}

अधूरा काउंटर:

s=a=>{
    a = a.split(
            RegExp(String.fromCharCode(92,115))   // split input on whitespace regex /\s/
        );  
    x:                             // x is a label for the outer loop
    for(i=2;i--;)                  // run this outer loop twice
        for(o=i?                   // if this is the first outer loop pass, 
               a.length-1          //    set `o` to number of whitespaces
               :                   // else, on second outer loop pass,
               a.filter(j=>j);     //    set `o` to split input (w/o empty strings)
            1;                     // 1 is truthy; run inner loop forever
            ) {
                break x;           // break out of outer loop
            }
    return o;                      // return `o`
}

फाड़नेवाला बिल्कुल वैसा ही है, लाइन को छोड़कर:

break x;

अब है

break
x;

जावास्क्रिप्ट के स्वचालित अर्धविराम सम्मिलन आमतौर पर मल्टी-लाइन स्टेटमेंट को जल्दी समाप्त नहीं करते हैं यदि उन्हें एक लाइन ब्रेक के बिना समझा जा सकता है, लेकिन यह लाइन ब्रेक के बाद return, continueया को बर्दाश्त नहीं करता है break। इसलिए, लाइन को बस के रूप में पढ़ा जाता है break, जो बाहरी लूप से बाहर निकलने के बजाय केवल आंतरिक लूप से बाहर निकलता है। "दूसरा-पास" व्यवहार o = a.filter(j=>j)तब निष्पादित किया जाता है (बनाम काउंटर में छोड़ दिया जा रहा है), क्योंकि बाहरी लूप को दूसरा पास दिया जाता है।

— apsillers
स्रोत

है !!xऑटो के लिए अलग अलग Boolपरिवर्तित?

— l4m2

@ l4m2 यह नहीं है! मैंने इसे हटा दिया है, क्योंकि filterऑटो-बल्स इसकी कॉलबैक रिटर्न उसी नियमों के अनुसार है !!। धन्यवाद!

— अप्सिलर्स

5

पायथन, 228 198 182 166 146 145 बाइट्स

काउंटर ( 72 बाइट्स ):

ior1=0
w=lambda i:i.split()if ior1 else sum(ord(c)in(9,10,32)for c in i)

स्प्लिटर ( 73 बाइट्स ):

ior1=0
w=lambda i:i.split()if i or 1else sum(ord(c)in(9,10,32)for c in i)

ior1एक मिथ्या चर है, लेकिन सत्य i or 1है। यही मुख्य चाल है।

— undergroundmonorail
स्रोत

यदि iफाड़नेवाला के लिए खाली तार नहीं है तो क्या यह नहीं टूटता ? को बदलकर तय किया जा सकता iorbहै ior1, जो आपको 1और के बीच के चरित्र को बचाने की सुविधा देता है else।

— isaacg

@ आईआईएसएसीजी मैं पूरी तरह से भूल गया कि आपके पास चर नामों में संख्या हो सकती है! धन्यवाद <3

— भूमिगत

5

Befunge 98, 61 + 59 = 120

काउंटर:

~:'!-0`#v_ >$1+#@ #. #
 @#,#$ #<_v#`0-!':~ # .#
  ,#$ #+55<v

स्प्लिटर:

~:'!-0`#v_ >$1+#@ #.#
 @#, #$#<_v#`0-!':~ #.#
  , #$#+55<v

— ninjalj
स्रोत

4

बैश, 75 + 79 = 154 बाइट्स

यह बैश पर निर्भर करता है ताकि निष्पादन को जारी रखने में सक्षम हो, भले ही कुछ लाइनें या स्क्रिप्ट की एक पंक्ति के कुछ भाग विकृत हो (कुछ परिस्थितियों में)। व्हॉट्सएप का उपयोग कुछ करीबी कोष्ठक के लिए पलायन को निष्क्रिय करने के लिए और एक नई लाइन पर पाइप को तोड़ने के लिए किया जाता है।

स्प्लिटर:

echo $((`echo $1|wc -w`+${#1}-$(\)\)\)
for a in $1;do echo $a;done|wc -c)))

काउंटर:

echo $((`echo $1|wc -w`+${#1}-$(\ )\ )\ )
for a in $1;do echo $a;done
|wc -c)))

इनपुट कमांडलाइन तर्क के माध्यम से होता है, आउटपुट स्टैडआउट के माध्यम से होता है।

क्योंकि यह bash त्रुटि व्यवहार पर निर्भर करता है, उपयोगकर्ता को stderr को अनदेखा करने की उम्मीद है।

उदाहरण रन (एक नई रेखा और कई सन्निहित स्थानों के साथ इनपुट दिखाते हुए):

# bash counter.sh "abc def
gh   ij k" 2>/dev/null
6
# bash splitter.sh "abc def
gh   ij k" 2>/dev/null
abc
def
gh
ij
k

— दंगा
स्रोत

4

रूबी, 114 + 116 107 + 109 = 216 बाइट्स

यह हिस्टोक्रेट द्वारा रूबी समाधान के साथ प्रतिस्पर्धा नहीं कर सकता है, लेकिन मुझे लगा कि यह वैसे भी डालने लायक होगा।

मैं प्रयोग किया जाता है $zके लिए nilऔर nil.to_sके लिएString.new

अतिरिक्त व्हाट्सएप चरित्र जो मैं इनपुट के अंत में जोड़ता हूं, अंतिम शब्द को सरणी में जोड़ने के लिए मजबूर करना है ( r) - एक शब्द केवल सरणी के अंत में जोड़ा जाता है जब एक व्हाट्सएप चरित्र एक गैर-व्हाट्सएप वर्ण का अनुसरण करता है। विकल्प ब्लॉक के r<<w if wबाद एक और जोड़ रहा था each_byte।

गिनती

->s{r=[]
n=-1
w=$z
(s+9.chr).each_byte{|b|if b<33
r<<w if w
w=$z
n+=1
else
w=w.to_s+b.chr
end}
$zorr ?r:n}

विभाजन

->s{r=[]
n=-1
w=$z
(s+9.chr).each_byte{|b|if b<33
r<<w if w
w=$z
n+=1
else
w=w.to_s+b.chr
end}
$z or r ?r:n}

— alexanderbird
स्रोत

आह, मुझे उस पर शासन करने के बारे में निश्चित नहीं था। मैंने इसे उपयोग करने के लिए बदल दिया है अगर-और के बजाय टर्नरी ऑपरेटर - कोई और अधिक स्ट्रिंग शाब्दिक नहीं।

— अलेक्जेंडरबर्ड

3

हास्केल , 53 + 55 = 108 36 + 38 = 74 बाइट्स

काउंटर

f=do
 pure(length.filter(<'!'))words

फाड़नेवाला

f=do
 pure(length.filter(<'!'))
 words

यह समाधान इस तथ्य का उपयोग करता है कि हास्केल फ़ंक्शंस में मोनाड टाइप क्लास का एक उदाहरण है और इस तरह से इसका उपयोग मोनेक क्रियाओं के रूप में किया जा सकता है।

पहले मामले में, डॉक-ब्लॉक का परिणामी फ़ंक्शन pure(जो constकि फ़ंक्शन प्रकार के लिए अनिवार्य रूप से है) का पहला तर्क है , जिससे काउंटर अंतिम परिणाम होता है और स्प्लिटर को खारिज कर दिया जाता है।

दूसरे मामले pureमें केवल एक ही तर्क पर लागू किया जाता है, जिससे यह एक फ़ंक्शन होता है जो दूसरे फ़ंक्शन (काउंटर) को लौटाता है। हालाँकि, परिणाम का उपयोग कभी नहीं किया जाता है और इस प्रकार त्याग दिया जाता है। अंतिम परिणाम डू-ब्लॉक की दूसरी पंक्ति है, फाड़नेवाला।

— सिराकुसा
स्रोत

अच्छा तरीका! [' ','\t','\n']को छोटा किया जा सकता है " \t\n"।

— लकोनी

@ लिकोनी वर्णन केवल चरित्र शाब्दिकों की अनुमति देता है, कोई स्ट्रिंग या रेगेक्स शाब्दिक नहीं

— सिराकुसा

2

क्योंकि चुनौती के लिए आपको अधिकांश नियंत्रण पात्रों को संभालने की आवश्यकता नहीं होती है, आप इसे व्हाट्सएप के (<'!')लिए परीक्षण करके छोटा कर सकते हैं ।

— अर्जन जोहानसन

2

जावा 8, 187 + 188 = 375

सबसे पहले, मैं यह कहना चाहूंगा कि यह उत्तर @ Ypnypn पर आधारित है। मैंने मूल रूप से कुछ हिस्सों को छोटे लोगों के साथ बदल दिया (व्हॉट्सएप-डिपेंडेंट पार्ट सहित, जो आईएमओ इस चुनौती में सबसे महत्वपूर्ण है), लेकिन कार्यात्मक कोड ज्यादातर समान है।

व्हॉट्सएप की गणना , 187 (रिटर्न int):

Object f(String s){String r=new String(new char[]{92,115});int a=0;return a--+a>0?s.chars().filter(c->c>8&c<11|c==32).count():java.util.Arrays.stream(s.split(r)).filter(t->t.length()>0);}

व्हाट्सएप पर विभाजित , 188 (रिटर्न Stream<String>):

Object f(String s){String r=new String(new char[]{92,115});int a=0;return a- -+a>0?s.chars().filter(c->c>8&c<11|c==32).count():java.util.Arrays.stream(s.split(r)).filter(t->t.length()>0);}

— PurkkaKoodari
स्रोत

2

जे, 48 + 49 = 97 चार

एक ही तर्क लेने और वापस करने के दो कार्य। क्रैपीस्ट तरीके का इस्तेमाल किया, जिसे मैं समान-लेकिन-व्हाट्सएप नियम को हरा देने के बारे में सोच सकता था, इसलिए संभव है कि उसके चारों ओर एक अधिक चतुर मार्ग ढूंढकर पात्रों को बचाया जाए।

(aa[aa=.+/@a=.a:-.~(e.u:)&9 10 32 :(<;._1~1,}.))      NB. count
(a a[aa=.+/@a=.a:-.~(e.u:)&9 10 32 :(<;._1~1,}.))     NB. split

हम क्रिया aको दो अलग-अलग क्रियाओं के लिए परिभाषित करते हैं , यह इस बात पर निर्भर करता है कि इसका उपयोग एक तर्क के साथ या दो के साथ किया जाता है। एक तर्क के साथ, यह है (e.u:)&9 10 32, जो जाँचता है कि प्रत्येक वर्ण व्हाट्सएप है या नहीं। दो तर्कों के साथ, यह वह है a:-.~(<;._1~1,}.), जो दाईं ओर एक बूलियन वेक्टर लेता है और उन पदों पर बाएं तर्क को काटता है, जिसके साथ कोई खाली कटौती करता है a:-.~।

फिर, हम aaपरिणाम में सच्चे मूल्यों की संख्या को परिभाषित करते हैं a, जो केवल एक तर्क के साथ समझ में आता है। अंत में, हम उपयोग करते हैं aaया a aनिर्भर करते हैं कि क्या हम स्ट्रिंग के व्हाट्सएप को गिनना या विभाजित करना चाहते हैं। aaउम्मीद के मुताबिक काम करता है।

कारण a aकाम करता है क्योंकि जब जे देखता है (f g)y, यह (f g)एक हुक पर विचार करता है और इसका मूल्यांकन करता है y f (g y)। इस मामले में, ऊपर fका डायडिक aहै जो कटिंग करता है, और gवह है a[aa, जो योग की गणना करता है aa, इसे बाहर फेंकता है, और aफिर से (मोनैडिक) गणना करता है ।

REPL में:

   (aa[aa=.+/@a=.a:-.~e.&(u:9 10 32) :(<;._1~1,}.))   '  123',TAB,'-_-   abc',LF,'def'
7
   (a a[aa=.+/@a=.a:-.~e.&(u:9 10 32) :(<;._1~1,}.))  '  123',TAB,'-_-   abc',LF,'def'
+---+---+---+---+
|123|-_-|abc|def|
+---+---+---+---+

— algorithmshark
स्रोत

2

बैश, 54 + 50 = 104 बाइट्स

काउंटर

a=$IFS
IFS=
cat()(tr -cd $a|wc -c)
printf %s \\n$1|cat

फाड़नेवाला

a=$IFSIFS=ca
t()(tr-cd$a|wc-c)
printf %s\\n $1|cat

— jimmy23013
स्रोत

1

पर्ल, 37 + 38 = 75

काउंटर :

sub f{($_)=@_;(y/   - //,[split])[0.1]}

फाड़नेवाला :

sub f{($_)=@_;(y/   - //,[split])[0 .1]}

— ninjalj
स्रोत

1

पर्ल 6, 31 + 32 = 63 बाइट्स

काउंटर

{?^1??.words!!+grep 33>*,.ords}

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

?^1की तरह पार्स किया जाता है ?^ 1जो बूलियन नेगनेशन ऑपरेटर को 1 पर लागू करता है, जिसके परिणामस्वरूप False।

फाड़नेवाला

{? ^1??.words!!+grep 33>*,.ords}

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

? ^1सीमा 0..0 को बूल में परिवर्तित करता है, जिसके परिणामस्वरूप True।

— nwellnhof
स्रोत

0

अजगर 2, 98

विभाजन (49)

एक सूची में टोकन लौटाता है।

f=lambda s:[sum(map(str.isspace,s))]and s.split()

गिनती (49)

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

f=lambda s:[sum(map(str.isspace,s))]
ands.split()

— feersum
स्रोत

0

सी (जीसीसी) , 88 + 89 = 177 बाइट्स

फाड़नेवाला

i,n,x,c;f(char*s){x=n=i=0;for(x+++n;c=*s++;c*x&&putchar(c))i=c<33?n++,c=i*10,0:1;x=n-1;}

फाड़नेवाला

काउंटर

i,n,x,c;f(char*s){x=n=i=0;for(x+ ++n;c=*s++;c*x&&putchar(c))i=c<33?n++,c=i*10,0:1;x=n-1;}

काउंटर

मंद होना

फ़ंक्शन तर्क के रूप में इनपुट लेता है। काउंटिंग फ़ंक्शन व्हॉट्सएप की संख्या लौटाता है। विभाजन समारोह अपने उत्पादन के लिए STDOUT का उपयोग करता है (लेकिन संयोग से व्हॉट्सएप माइनस एक के रूप में अच्छी तरह से रिटर्न देता है)।

i,                      Flag signalling whether we are inside a word.
n,                      Number of whitespace encountered.
x,                      Flag signalling whether or not we should output the words.
c;                      Current character.
f(char*s){              Take input string as an argument.
x=n=i=0;for(            Initialise everything and start loop.
x+++n;                  SPLITTER ONLY: Interpreted as x++ +n, meaning x is set to 1 and n stays 0.
x+ ++n;                 COUNTER ONLY: Inverse of the above. Sets n to 1, and x stays 0.
c=*s++;                 Sets c to current char and increment string pointer, end loop if end of string.
c*x&&putchar(c))        Only output c if x is 1 and c is non-zero, which only happens if we left a word.
i=c<33?                 Since input contains only printable ASCII or whitespace, anything below 33 is whitespace.
       n++,             ...if that is the case, increment the whitespace counter (n)
           c=i*10,      ...and set c to newline (10), but only if we just left a word (if i is 1)
                  0:    ...and set i to 0.
                    1;  If not a whitespace, set i to 1, signalling we are inside a word.
x=n-1;}                 Implicitly returns n-1, which is the number of whitespaces if we are in the counter function.

— gastropner
स्रोत

0

Zsh , 35 + 35 = 70 बाइट्स

किसी भी कार्यक्रम / फ़ंक्शन में कोई स्ट्रिंग या रेगेक्स शाब्दिक नहीं हो सकता है

मैं अनिश्चित हूं कि क्या यह [^$IFS]योग्य है, क्योंकि इसका उपयोग पैटर्न मिलान में किया जाता है। यह प्रतिबंधित है मामले में एक 45 + 45 समाधान है।

विभाजित करें:

:<<<${#1//[^$IFS]} 
:
<<<${(F)${=1}}

गणना:

:
<<<${#1//[^$IFS]}
:<<<${(F)${=1}}

:निर्मित करने के लिए बराबर है true, हम एक टिप्पणी और / dev / बातिल (के बाद से टिप्पणी की अनुमति नहीं है) यह करने के लिए अवांछित विस्तार पाइप द्वारा के बीच कुछ के रूप में उपयोग।

Zsh में व्हॉट्सएप पर बंटवारे के लिए एक बिलिन है, जो कि है ${=var}। यह केवल दोनों को निष्पादित करने और जिसे हम नहीं चाहते हैं उसे त्यागने के अलावा किसी भी प्रकार के तार्किक संयोजन को करना मुश्किल बनाता है।

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

— GammaFunction
स्रोत

महत्वपूर्ण व्हाट्सएप

लीडरबोर्ड

पायथ, 16 + 15 = 31 बाइट्स

पायथन, 54 + 56 = 110 बाइट्स

वैकल्पिक 1, 59 + 60 = 119 बाइट्स

वैकल्पिक 2, 67 + 69 = 136 बाइट्स

वैकल्पिक 3, 59 + 60 = 119 बाइट्स

जावा 8, 239 + 240 = 479

व्हॉट्सएप, 75 + 153 = 228

मारबेलस, 103 + 92 = 195

व्याख्या

CJam, 26 + 27 = 53 59 61 73 77 बाइट्स

गणितज्ञ, 44 + 43 = 87 97 बाइट्स

रूबी, 107 91 बाइट्स

अजगर, 169

सी, 138 + 136 = 274

जावास्क्रिप्ट, 95 + 96 = 191 बाइट्स

वैकल्पिक: जावास्क्रिप्ट, 250 बाइट्स

पायथन, 228 198 182 166 146 145 बाइट्स

Befunge 98, 61 + 59 = 120

बैश, 75 + 79 = 154 बाइट्स

रूबी, 114 + 116 107 + 109 = 216 बाइट्स

गिनती

विभाजन

हास्केल , 53 + 55 = 108 36 + 38 = 74 बाइट्स

जावा 8, 187 + 188 = 375

जे, 48 + 49 = 97 चार

बैश, 54 + 50 = 104 बाइट्स

काउंटर

फाड़नेवाला

पर्ल, 37 + 38 = 75

पर्ल 6, 31 + 32 = 63 बाइट्स

काउंटर

फाड़नेवाला

अजगर 2, 98

सी (जीसीसी) , 88 + 89 = 177 बाइट्स

फाड़नेवाला

काउंटर

मंद होना

Zsh , 35 + 35 = 70 बाइट्स