เรากำหนดช่องว่างให้เป็นหนึ่งในสามของตัวละครแท็บ (0x09), ขึ้นบรรทัดใหม่ (0x0A) หรือเว้นวรรค (0x20)

สำหรับความท้าทายนี้คุณต้องเขียนสองโปรแกรมหรือฟังก์ชั่นในภาษาการเขียนโปรแกรมเดียวกันซึ่งทำงานดังต่อไปนี้:

1. นับอักขระช่องว่างในสตริงที่กำหนด ตัวอย่างเช่นการป้อนข้อมูล

     123 -_-   abc
   def
   

   จะส่งคืน 7 (หากไม่มีบรรทัดใหม่ต่อท้าย)

2. แยกสตริงที่กำหนดที่ช่องว่างที่ต่อเนื่องกัน หากสตริงเริ่มต้นหรือลงท้ายด้วย whitespace ไม่ควรมีสตริงว่างที่ส่งคืนที่สิ้นสุด ตัวอย่างเช่นอินพุตเดียวกัน

     123 -_-   abc
   def
   

   ["123", "-_-", "abc", "def"]จะกลับมา

ไม่ว่าในกรณีใดคุณสามารถป้อนข้อมูลผ่าน STDIN อาร์กิวเมนต์บรรทัดคำสั่งหรือฟังก์ชันอาร์กิวเมนต์ส่งคืนผลลัพธ์หรือพิมพ์ STDOUT สำหรับโปรแกรมที่สองหากคุณเลือกที่จะพิมพ์ไปยัง STDOUT โปรดพิมพ์แต่ละสตริงในบรรทัดของตัวเองโดยไม่ต้องใส่เครื่องหมายอัญประกาศ

สำหรับทั้งสองโปรแกรมคุณอาจสมมติว่าอินพุตมีเฉพาะ ASCII ที่พิมพ์ได้ (0x20 ถึง 0x7E) และช่องว่าง

ตอนนี้ที่นี่คือการจับ:

• หากช่องว่างทั้งหมดถูกลบออกจากทั้งสองโปรแกรม / ฟังก์ชั่นสตริงผลลัพธ์จะต้องเหมือนกัน นั่นคือสองส่งของคุณอาจเพียง แต่แตกต่างกันในจำนวนและตำแหน่งของตัวอักษรช่องว่าง
• โปรแกรม / ฟังก์ชั่นอาจไม่มีสตริงหรือตัวอักษร regex ใด ๆ (ตัวอักษรตัวอักษรไม่เป็นไรหากภาษาของคุณมีประเภทตัวอักษรที่กำหนด)
• โปรแกรม / ฟังก์ชั่นอาจไม่มีความคิดเห็นใด ๆ
• คุณต้องไม่อ่านซอร์สโค้ดของโปรแกรมไม่ว่าโดยตรงหรือโดยอ้อม

นี่คือรหัสกอล์ฟ คะแนนของคุณคือผลรวมของขนาดของทั้งสองวิธี (เป็นไบต์) คะแนนต่ำสุดชนะ

ลีดเดอร์

Stack Snippet ต่อไปนี้สร้างทั้งกระดานผู้นำปกติและภาพรวมของผู้ชนะตามภาษา ดังนั้นแม้ว่าภาษาที่คุณเลือกจะไม่ยอมให้คุณชนะการท้าทายทั้งหมดทำไมไม่ลองคว้าอันดับหนึ่งในรายการที่สองล่ะ? ฉันสนใจมากที่จะเห็นว่าผู้คนจัดการกับความท้าทายนี้ในภาษาต่างๆได้อย่างไร!

เพื่อให้แน่ใจว่าคำตอบของคุณปรากฏขึ้นโปรดเริ่มคำตอบด้วยหัวข้อโดยใช้เทมเพลต Markdown ต่อไปนี้:

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

Pyth, 16 + 15 = 31 ไบต์

ลองมันนี่

เข้าชม:

L@,cb)sm!cd)b1 0

Splitter:

L@,cb)sm!cd)b10

แต่ละอันจะกำหนดฟังก์ชั่นyซึ่งใช้อินพุตสตริงเพื่อแก้ไขงานที่ต้องการ

ขอบคุณ @FryAmTheEggman สำหรับแนวคิดในการใช้คุณสมบัติของ Pyth ในการจัดทำดัชนีแบบแยกส่วนในรายการเพื่อโกนหนวดอักขระ

กรณีทดสอบ:

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.

Python 54 + 56 = 110 ไบต์

เข้าชม:

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

Splitter:

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

สำหรับตัวนับเราใช้ความจริงที่ว่า Python ไม่เป็นไรกับการแสดงออกบนบรรทัด มันจำเป็นที่จะต้องแยก+1และ0<9or x.split()หยุดการNameErrorถูกโยนเนื่องจาก0<9การTrueป้องกันไม่ให้x.split()ถูกประเมินเนื่องจากการลัดวงจร

สำหรับตัวแยกเนื่องจากจำนวนของช่องว่างนั้นไม่เป็นค่าลบ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])]

Splitter:

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]

Splitter:

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เป็นหน้าที่และความจริง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

Splitter:

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

นี้เป็นฟังก์ชั่นที่ผลแยกของถูกเก็บไว้ในตัวแปรและผลที่เคาน์เตอร์ถูกเก็บไว้ในตัวแปรa a1เหมือนก่อนหน้านี้ Python ใช้ได้ดีกับการมีเพียงนิพจน์บนบรรทัดในกรณี1นี้ แยกขึ้นa1กำหนดสิ่งที่จะกลับมาจากฟังก์ชั่น

Java 8, 239 + 240 = 479

นับ whitespace (ส่งคืนจำนวนเต็ม)

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

แยกบนช่องว่าง (ส่งคืนสตรีม <String>)

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

ช่องว่าง, 75 + 153 = 228

ช่องว่างแท็บและบรรทัดใหม่แทนที่ด้วย STL ตามลำดับและพับเพื่อความชัดเจน tr -d \\n | sed 'y/STL/ \t\n/'แปลงไฟล์ช่องว่างที่เหมาะสมกับ

เคาน์เตอร์

SSSLLSSLSSSTSSSSSLSLSSLSTLTSTTTSLSLTSSLTSSTLTTLSSSTLTSSSLSLLLSSSLS
LLSLLTLST

Splitter

SSSTLSSSLTTSLSSTLSSSLSLSTLTSTTTSLSSLSLTSLSSSTSSSSTLTSSTLTTTTLSSSTL
SLSTTSLSLSLLSSTTLSSSTSTSLSSSTLTTTLTSTSLTLSSSSSTLSSSLTTSLSSTSLLSLTL
LSSSLTLSSLSLTLLSSLLLL

Marbelous, 103 + 92 = 195

เข้าชม:

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

Splitter:

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

ทดสอบโปรแกรมเหล่านี้ที่นี่ ต้องตรวจสอบบอร์ดรูปทรงกระบอกรวมถึงไลบรารีและช่องว่างสำหรับเซลล์ว่าง

อินพุตและเอาต์พุตผ่าน STDIN / STDOUT

คำอธิบาย

เข้าชม:

เส้นทางสีน้ำเงินรับอินพุต หากตัวละครนั้นเป็นตัวอักษรช่องว่าง (ค่า ascii น้อยกว่า 0x21) พา ธ สีดำจะถูกนำมาซึ่งจะประสานกับเส้นทางสีม่วง

เส้นทางสีม่วงเพียงแค่เพิ่มหินอ่อนที่เก็บไว้ใน&1synchronizer ทุกครั้งที่มีพา ธ สีดำ

เมื่อไม่มีอินพุตอีกแล้วพา ธ สีแดงจะถูกพิมพ์จำนวนของอักขระช่องว่างและออก

Splitter:

โปรแกรมเริ่มต้นด้วยพา ธ สีน้ำเงินซึ่งวนซ้ำจนกว่าจะพบอักขระที่ไม่ใช่ช่องว่าง

เมื่อดึงอักขระที่ไม่ใช่ช่องว่างออกมาพา ธ สีดำจะถูกพิมพ์ออกมาซึ่งจะพิมพ์อักขระนี้และย้ายการดำเนินการไปยังเส้นทางสีเขียวซึ่งจะวนซ้ำและพิมพ์จนกระทั่งได้รับอักขระช่องว่าง การดำเนินการต่อไปยังเส้นทางสีม่วงซึ่งประกอบด้วย3Wหรือตัวแยกสามทาง

สาขาด้านซ้ายจะย้ายการดำเนินการไปยังเส้นทางสีน้ำเงิน (และช่องว่างจะถูกยกเลิกจนกว่าจะพบอักขระที่ไม่ใช่ช่องว่าง)

สาขากลางตั้งสำเนาของอินพุตเป็น 0 ด้วย?0(สร้างตัวเลขสุ่มระหว่าง0และ0) และเพิ่ม 10 ( 0x0A= ขึ้นบรรทัดใหม่) ซึ่งเป็นเอาต์พุตแล้ว

เส้นทางที่ถูกทิ้งไป

CJam, 26 +27 = 53 59 61 73 77 ไบต์

เคาน์เตอร์

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

Splitter

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

มันทำงานอย่างไร

แนวคิดนี้ง่ายคำนวณจำนวนช่องว่างทั้งสองและแบ่งสตริงตามช่องว่างต่อเนื่อง จากนั้นเลือกหนึ่งในนั้นตามความจริงต่อไปนี้ซึ่ง' !หมายความว่าnot of space characterเป็นเท็จในขณะที่'!เป็น!ตัวละครซึ่งเป็นความจริง

รหัสขยาย:

'! / ' !                              "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

ลองออนไลน์ได้ที่นี่

Mathematica, 44 + 43 = 87 97ไบต์

ฉันคิดว่าฉันจะเพิ่มภาษาอื่นลงในมิกซ์นั้น

เข้าชม:

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

Splitter:

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

สิ่งนี้ทำให้การใช้งานคุณสมบัติของ Mathematica นั้นการแยกพื้นที่นั้นเหมือนกับการคูณ และการคูณบางสิ่งด้วย 0 จะเป็น 0 เสมอและการเพิ่ม 0 ลงในบางสิ่งนั้นจะเป็น idempotent เสมอ

0*1*StringSpli*t@#สำหรับเคาน์เตอร์แรกที่เรานับช่องว่างและเราเพิ่ม StringSpliและtไม่ได้ถูกนิยาม แต่ Mathematica ใช้การคำนวณเชิงสัญลักษณ์ดังนั้นมันจึงถือเป็นตัวแปรและฟังก์ชั่นที่ไม่รู้จัก 1*เป็น idempotent (เช่นเดียวกับที่0+) ที่0*จะเปลี่ยนมันเป็นศูนย์ มีความจำเป็นต้องแยกStringSplitตัวแปรออกเป็นสองตัวแปรเนื่องจาก0เวลาที่รายการถูกใช้เป็นการคูณสเกลาร์ - เวกเตอร์ซึ่งส่งผลให้มีเวกเตอร์ (รายการ) ของศูนย์

สำหรับตัวแยกฉันใช้ความจริงที่Countมีอยู่ แต่ไม่ได้ดูเป็นสายอักขระ มันจะพยายามนับนิพจน์ย่อยทั้งหมดที่ตรงกับรูปแบบ แต่Whitespaceเป็นรูปแบบที่ใช้กับเนื้อหาสตริงเท่านั้น ดังนั้นCountจะกลับมา0ซึ่งจะทำให้Stringหายไป การคูณอาเรย์แยกโดย01 = 1idempotent อีกครั้ง

Ruby, 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

pnilเป็นวิธีการที่กำหนดไว้ล่วงหน้าว่ามีข้อโต้แย้งไม่เพียงส่งกลับ เราใช้มันในหลายวิธี ในตัวแยกสัญญาณเริ่มต้นpไม่ทำอะไรเลย gets(p)อ่านทุกอย่างจากอินพุตมาตรฐานเนื่องจากตัวคั่นเป็นโมฆะ เราเรียกวิธีการแยกแบบบิวด์อินและกำหนดผลลัพธ์ให้pดังนั้นขณะนี้เมื่อไม่มีการกำหนดอาร์กิวเมนต์มันจะถูกวิเคราะห์คำเป็นตัวแปร puts p||...ลัดวงจรและพิมพ์แต่ละองค์ประกอบของpตัวแปรไปยังบรรทัดของตัวเอง

ในตัวนับเราลบ newline แรกเพื่อให้อาร์เรย์แบบแยกถูกกำหนดให้ppแทน เนื่องจากเรายังไม่ได้รับมอบหมายให้pก็ยังคงเป็นวิธีการศูนย์-กลับมาเพื่อให้ส่วนที่สองของการได้รับการประเมินผลและส่งผ่านไปยัง|| เป็นตัวแปรเวทมนต์ที่มีผลลัพธ์ดังนั้นจำนวนช่องว่างทั้งหมดคือขนาดของลบด้วยอักขระที่ไม่ใช่ช่องว่างซึ่งเป็นสิ่งที่มีอยู่ ฉันรู้สึกว่าควรมีวิธีที่สั้นกว่าในการนับ แต่ฉันไม่สามารถหาได้และในทุก ๆ การใช้อาร์เรย์แยกในเคาน์เตอร์ก็สนุกputs$_getspp

Python, 169

มันง่ายเกินไปที่จะทำใน Python!

เข้าชม:

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

Splitter:

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

พวกเขาแตกต่างกันในพื้นที่เดียวและฉันไม่ได้ใช้เล่ห์เหลี่ยมใด ๆ เช่นการแยกตัวเลขหรือชื่อตัวแปรครึ่งตัว :)

C, 138 + 136 = 274

ในแต่ละกรณีรหัสคือโปรแกรมที่ยอมรับอาร์กิวเมนต์บรรทัดคำสั่งหนึ่งรายการและพิมพ์ผลลัพธ์เป็น stdout \tควรแทนที่ด้วยอักขระแท็บ หากคุณต้องการผ่านการโต้แย้งที่มีแท็บและการขึ้นบรรทัดใหม่มันเป็นงานของคุณที่จะหาวิธี;)

การนับ

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

JavaScript, 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)}

Splitter:

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ได้ค่าแทน)

ทางเลือก: JavaScript ขนาด 250 ไบต์

ฉันมีวิธีแก้ไขปัญหาอื่นที่ไม่ได้รับรางวัลใด ๆ สำหรับช่วงสั้น ๆ แต่ฉันคิดว่ามันเป็นความท้าทายที่น่าสนใจในการละเมิดพฤติกรรมการแทรกอัฒภาคอัตโนมัติของ JavaScript

เข้าชม:

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}

Splitter:

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}

เคาน์เตอร์ Ungolfed:

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;

JavaScript ของแทรกอัฒภาคอัตโนมัติตามปกติไม่ยุติงบหลายสายต้นถ้าพวกเขาสามารถเข้าใจได้โดยไม่ต้องแบ่งบรรทัด แต่มันไม่ยอมแบ่งบรรทัดหลังreturn, หรือcontinue breakดังนั้นบรรทัดจะอ่านอย่างง่ายbreakๆ ซึ่งแยกออกจากลูปด้านในเท่านั้นแทนที่จะแยกออกจากลูปด้านนอก พฤติกรรม "รอบที่สอง" o = a.filter(j=>j)นั้นจะถูกดำเนินการ (เมื่อเทียบกับการข้ามในตัวนับ) เพราะวงรอบนอกจะได้รับรอบที่สอง

Python, 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เป็นความจริง นั่นคือเคล็ดลับหลัก

Befunge 98, 61 + 59 = 120

เข้าชม:

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

Splitter:

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

Bash, 75 + 79 = 154 ไบต์

สิ่งนี้อาศัยการทุบตีที่สามารถดำเนินการต่อได้แม้ว่าบางบรรทัดหรือบางส่วนของบรรทัดของสคริปต์จะมีรูปแบบไม่ถูกต้อง (ในบางสถานการณ์) ช่องว่างถูกใช้เพื่อปิดการใช้งาน escapes สำหรับวงเล็บเหลี่ยมบางอันและเพื่อแบ่งท่อโดยวางไว้บนบรรทัดใหม่

Splitter:

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

อินพุตเป็นทางอาร์กิวเมนต์บรรทัดรับคำสั่งเอาต์พุตคือผ่าน stdout

เนื่องจากสิ่งนี้ขึ้นอยู่กับพฤติกรรมข้อผิดพลาดของทุบตีผู้ใช้จึงคาดว่าจะไม่สนใจ stderr

ตัวอย่างการรัน (แสดงอินพุตด้วย newline และช่องว่างที่ต่อเนื่องกันหลายช่อง):

# 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

Ruby, 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}

Haskell , 53 + 55 = 108 36 + 38 = 74 ไบต์

เคาน์เตอร์

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

Splitter

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

วิธีนี้ใช้ประโยชน์จากข้อเท็จจริงที่ว่าในฟังก์ชัน Haskell เป็นตัวอย่างของคลาสประเภท Monad และสามารถใช้เป็นการกระทำแบบ monadic ในการทำเครื่องหมาย

ในกรณีแรกฟังก์ชันผลลัพธ์ของ do-block เป็นอาร์กิวเมนต์แรกของpure(ซึ่งเป็นหลักconstสำหรับประเภทฟังก์ชัน) ทำให้ตัวนับผลลัพธ์สุดท้ายและตัวแยกสัญญาณถูกยกเลิก

ในกรณีที่สองpureจะใช้กับอาร์กิวเมนต์เดียวเท่านั้นทำให้เป็นฟังก์ชันที่ส่งคืนฟังก์ชันอื่น (ตัวนับ) อย่างไรก็ตามผลลัพธ์ไม่เคยถูกใช้และถูกละทิ้ง ผลลัพธ์สุดท้ายคือบรรทัดที่สองของ do-block ตัวแยก

Java 8, 187 + 188 = 375

ก่อนอื่นฉันอยากจะบอกว่าคำตอบนี้ขึ้นอยู่กับ @ Ypnypn อย่างมาก โดยทั่วไปฉันแทนที่บางส่วนด้วยชิ้นส่วนที่สั้นกว่า (รวมถึงส่วนที่ขึ้นอยู่กับช่องว่างซึ่ง IMO เป็นสิ่งที่สำคัญที่สุดในการท้าทายนี้) แต่โค้ดการทำงานส่วนใหญ่จะเหมือนกัน

นับ whitespace , 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);}

J, 48 + 49 = 97 ถ่าน

สองฟังก์ชั่นการและกลับอาร์กิวเมนต์เดียว ใช้วิธี crappiest ที่ฉันสามารถคิดที่จะเอาชนะกฎเดียวกัน แต่ช่องว่างดังนั้นจึงอาจมีตัวละครที่จะได้รับการบันทึกโดยการค้นหาเส้นทางที่ฉลาดกว่านั้น

(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ให้เป็นจำนวนค่า True ในผลลัพธ์ของaซึ่งทำให้เหมาะสมกับอาร์กิวเมนต์เดียวเท่านั้น ในที่สุดเราใช้aaหรือa aขึ้นอยู่กับว่าเราต้องการที่จะนับหรือแยกช่องว่างของสตริง aaทำงานตามที่คาดไว้

เหตุผลที่a aทำงานเพราะเมื่อเห็นเจ(f g)yจะมีการพิจารณาตะขอและประเมินมันเหมือน(f g) y f (g y)ในกรณีนี้fคือ dyadic aด้านบนซึ่งทำการตัดและgคือa[aaซึ่งคำนวณผลรวมจากการaaขว้างมันออกมาและคำนวณ (monadic) 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|
+---+---+---+---+

Bash, 54 + 50 = 104 ไบต์

เคาน์เตอร์

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

Splitter

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

Perl, 37 + 38 = 75

เคาน์เตอร์ :

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

แยก :

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

Perl 6, 31 + 32 = 63 ไบต์

เคาน์เตอร์

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

ลองออนไลน์!

?^1จะแยกกันเช่น?^ 1ที่ใช้ประกอบการปฏิเสธแบบบูล 1 Falseผลใน

Splitter

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

ลองออนไลน์!

? ^1แปลง 0..0 ช่วงการ Bool Trueผลใน

Python 2, 98

แยก (49)

ส่งคืนโทเค็นในรายการ

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

นับ (49)

ส่งคืนรายการความยาวหนึ่งที่มีจำนวนอักขระเว้นวรรค ส่วนใหญ่จะทำให้เกิดข้อผิดพลาด runtime แต่ฟังก์ชั่นfสามารถนำมาใช้หลังจากรันรหัส

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

C (gcc) , 88 + 89 = 177 ไบต์

Splitter

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

Splitter

เคาน์เตอร์

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

เคาน์เตอร์

rundown

รับอินพุตเป็นอาร์กิวเมนต์ของฟังก์ชัน ฟังก์ชั่นการนับจะส่งกลับจำนวนช่องว่าง ฟังก์ชั่นการแยกใช้ 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.

Zsh , 35 + 35 = 70 ไบต์

• โปรแกรม / ฟังก์ชั่นอาจไม่มีสตริงหรือตัวอักษร regex ใด ๆ

ฉันไม่แน่ใจว่า[^$IFS]มีคุณสมบัติเนื่องจากใช้ในการจับคู่รูปแบบ นี่คือโซลูชัน 45 + 45 ในกรณีที่ถูกแบน

แบ่ง:

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

นับ:

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

:builtin จะเทียบเท่าการtrueที่เราใช้มันเป็นบางสิ่งบางอย่างระหว่างความคิดเห็นและ / dev / null (ตั้งแต่การแสดงความคิดเห็นไม่ได้รับอนุญาต) โดยท่อการขยายตัวที่ไม่พึงประสงค์ให้กับมัน

zsh ${=var}มีในตัวสำหรับการแยกในช่องว่างที่ว่าเป็น สิ่งนี้ทำให้ยากที่จะทำการรวมกันแบบลอจิคัลชนิดใด ๆ นอกเหนือจากการดำเนินการทั้งสองอย่างและละทิ้งสิ่งที่เราไม่ต้องการ

ลองออนไลน์!