공백 은 탭 (0x09), 줄 바꿈 (0x0A) 또는 공백 (0x20)의 세 문자 중 하나로 정의 합니다.

이 과제를 해결하기 위해 다음과 같은 작업을 수행하는 동일한 프로그래밍 언어로 두 개의 프로그램 또는 함수를 작성해야합니다.

1. 주어진 문자열에서 공백 문자를 세십시오. 예를 들어, 입력

     123 -_-   abc
   def
   

   7을 리턴합니다 (후행 줄 바꿈이없는 경우).

2. 연속 된 공백에서 주어진 문자열을 분할합니다. 문자열이 공백으로 시작하거나 끝나는 경우 끝에 빈 문자열이 반환되지 않아야합니다. 예를 들어 같은 입력

     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>

Pyth, 16 + 15 = 31 바이트

여기에서 시도 하십시오 .

카운터:

L@,cb)sm!cd)b1 0

쪼개는 도구:

L@,cb)sm!cd)b10

이들은 각각 y원하는 작업을 해결하기 위해 문자열 입력을 받는 함수를 정의합니다 .

Pyth의 모듈 식 인덱싱 기능을 목록으로 사용하여 캐릭터를 면도한다는 아이디어에 대해 @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.

파이썬, 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()인한 단락으로 평가되는합니다.

스플리터의 경우 공백의 수가 항상 음수 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반환합니다 . 를 들어 , 이후 기능도 truthy이며, 입니다 및 반환됩니다.False0not s or tedsnot sFalseted = 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하면 기능에서 반환 할 내용이 결정됩니다.

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

공백으로 분할 (Stream <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

쪼개는 도구

SSSTLSSSLTTSLSSTLSSSLSLSTLTSTTTSLSSLSLTSLSSSTSSSSTLTSSTLTTTTLSSSTL
SLSTTSLSLSLLSSTTLSSSTSTSLSSSTLTTTLTSTSLTLSSSSSTLSSSLTTSLSSTSLLSLTL
LSSSLTLSSLSLTLLSSLLLL

놀라운, 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보다 작은 ASCII 값)이면 검은 색 경로가 사용되며 자주색 경로와 동기화됩니다.

자주색 경로 &1는 검은 색 경로를 취할 때마다 동기화 기에 저장된 대리석을 증가시킵니다 .

더 이상 입력이 없으면 빨간색 경로가 만들어져 공백 문자 수를 인쇄하고 종료됩니다.

쪼개는 도구:

프로그램은 공백이 아닌 문자가 발견 될 때까지 반복되는 파란색 경로로 시작합니다.

공백이 아닌 문자가 검색되면 검은 색 경로가 생성되어이 문자를 인쇄하고 실행을 녹색 경로로 이동합니다.이 경로는 공백 문자가 수신 될 때까지 반복되어 인쇄됩니다. 그런 다음 3W, 또는 3 방향 스플리터 가 포함 된 자주색 경로로 계속 실행 됩니다.

왼쪽 분기는 실행을 파란색 경로로 이동합니다 (공백은 공백이 아닌 문자가 발견 될 때까지 삭제됨).

중간 지점으로 0으로 입력 복사 설정 ?0(사이의 난수 생성 0및 0), 및 10 (추가 0x0A= 개행) 후 출력된다.

올바른 경로는 폐기됩니다.

CJam, 26 + 27 = 53 59 61 73 77 바이트

카운터

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

쪼개는 도구

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

작동 원리

아이디어는 간단합니다. 두 개의 공백을 계산하고 연속 된 공백으로 문자열을 분할하십시오. 그런 다음 다음과 같은 사실에 근거 중 하나를 선택 ' !을 의미 not of space character하면서, falsy 인을 '!은 IS !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에서

여기에서 온라인으로 사용해보십시오

수학, 44 + 43 = 87 97 바이트

믹스에 다른 언어를 추가 할 것이라고 생각했습니다.

카운터:

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

쪼개는 도구:

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

이것은 공간 분리가 곱셈과 동일하다는 Mathematica의 기능을 사용합니다. 그리고 0을 곱하는 것은 항상 0이며, 무언가에 0을 추가하는 것은 항상 dem 등합니다.

카운터의 경우 먼저 공백을 계산하고 추가 0*1*StringSpli*t@#합니다. StringSpli및 t규정되지 않지만 매쓰는 기호 계산을 사용하기 때문에 단지 미지의 변수와 함수들을 취급한다. (가) 1*멱등 (그냥 그대로 0+)에서,는 0*제로로 만들어 버린다. 리스트가 스칼라-벡터 곱셈으로 처리되어 벡터 (리스트)가 0이 StringSplit되기 때문에를 두 변수로 분리해야합니다 0.

스플리터의 경우, Count존재하지만 문자열을 보지 않는 사실을 사용하고 있습니다. 패턴과 일치하는 모든 하위 표현식 을 계산하려고 시도 하지만 Whitespace문자열 내용에만 적용되는 패턴입니다. 따라서 Count항상 반환 0되어 String사라집니다. 나누기 배열의 곱셈 01 = 1은 다시 dem 등입니다.

루비, 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)분리 문자가 널이므로 표준 입력에서 모든 것을 읽습니다. 내장 split 메소드를 호출하고 결과를에 할당 p하므로 인수가 주어지지 않으면 변수로 구문 분석됩니다. 변수 puts p||...의 각 요소를 단락시키고 p자체 행에 인쇄합니다 .

카운터에서 분할 배열이 pp대신 할당되도록 첫 번째 줄 바꿈을 삭제합니다 . 에 할당되지 않았기 때문에 p여전히 nil-returning 방법이므로 ||gets 의 두 번째 부분 이 평가되어 전달됩니다 puts. $_의 결과를 포함하는 마술 변수 gets이므로 공백의 총량은 공백이 아닌 문자를 뺀 크기입니다 pp. 계산을하는 더 짧은 방법이 있어야한다고 생각하지만 찾을 수 없으며 카운터에서 split 배열을 사용하는 것은 재미 있습니다.

파이썬, 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)

그들은 하나의 공간에서만 다르며 숫자 나 변수 이름을 반으로 나누는 것과 같은 속임수를 쓰지 않습니다. :)

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

자바 스크립트, 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)}

언 골프 드 :

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)줄은 /\s/정규식이나 문자열 리터럴없이 공백과 일치하는 정규식 을 만듭니다 .

각 프로그램에서, 우리는 변수를 사용 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}

쪼개는 도구:

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;

JavaScript의 자동 세미콜론 삽입은 일반적으로 줄 바꿈없이 이해할 수있는 경우 여러 줄 문을 일찍 종료하지 않지만 return, continue또는 , 후에 줄 바꿈을 허용하지 않습니다 break. 따라서 라인은 간단히로 읽히는 데 break, 이는 외부 루프를 벗어나지 않고 내부 루프 만 분리합니다. o = a.filter(j=>j)외부 루프에 두 번째 패스가 주어지기 때문에 "두 번째 패스"비헤이비어 가 실행됩니다 (카운터에서 건너 뛰는 대신).

파이썬 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진실입니다. 이것이 주요 트릭입니다.

베 펀지 98, 61 + 59 = 120

카운터:

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

쪼개는 도구:

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

배쉬, 75 + 79 = 154 바이트

이것은 bash가 스크립트의 일부 라인이나 라인의 일부가 잘못되어도 (일부 상황에서) 실행을 계속할 수 있어야합니다. 공백은 일부 괄호의 이스케이프를 비활성화하고 파이프를 새 줄에 배치하여 파이프를 끊는 데 사용됩니다.

쪼개는 도구:

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을 통해 이루어집니다.

이것은 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

루비, 114 + 116107 + 109 = 216 바이트

이것은 histocrat의 루비 솔루션과 경쟁 할 수는 없지만 어쨌든 가치가 있다고 생각했습니다.

내가 사용 $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}

하스켈 , 53 + 55 = 108 36 + 38 = 74 바이트

카운터

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

쪼개는 도구

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

이 솔루션은 Haskell 함수에서 Monad 유형 클래스의 인스턴스이므로 do-notation에서 monadic 조치로 사용될 수 있다는 사실을 이용합니다.

첫 번째 경우 do-block의 결과 함수 pure는 (기본적 const으로 함수 유형에 대한 )의 첫 번째 인수이므로 카운터를 최종 결과로 만들고 스플리터를 버립니다.

두 번째 경우 pure에는 단일 인수에만 적용되므로 다른 함수 (카운터)를 반환하는 함수가됩니다. 그러나 결과는 사용되지 않으므로 폐기됩니다. 최종 결과는 do-block의 두 번째 줄인 splitter입니다.

자바 8,187 + 188 = 375

우선, 나는이 답변이 @ Ypnypn에 크게 의존한다고 말하고 싶습니다. 나는 기본적으로 일부 부품을 짧은 부품으로 교체했지만 (공백에 의존하는 부분을 포함하여 IMO가 가장 중요합니다) 기능 코드는 거의 동일합니다.

공백 을 세 어라 187 (returns 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가 하나의 인수와 함께 사용되는지 아니면 두 가지로 사용되는지에 따라 두 가지 다른 동작을 갖도록 정의합니다 . 하나의 인수로 is는 (e.u:)&9 10 32각 문자가 공백인지 여부를 확인합니다. 두 개의 인수를 사용하면 a:-.~(<;._1~1,}.)오른쪽에 부울 벡터를 가져 와서 해당 위치에서 왼쪽 인수를 자르고와 함께 빈 컷을 버립니다 a:-.~.

그런 다음 aa의 결과에서 True 값의 개수로 정의 합니다 a. 이는 하나의 인수로만 의미가 있습니다. 마지막으로, 우리는 사용 aa또는 a a우리가 계산 또는 문자열의 공백을 분할 할 것인지 여부에 따라 달라집니다. aa예상대로 작동합니다.

a a작동 하는 이유 는 J가 볼 때 후크를 (f g)y고려 (f g)하여 평가하기 때문 y f (g y)입니다. 이 경우 절단을 수행하는 위 f의 2 차원 이며 ,에서의 합계를 계산하여 버리고 다시 계산합니다 (모노 딕) .aga[aaaaa

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

배쉬, 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

펄, 37 + 38 = 75

카운터 :

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

스플리터 :

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

펄 6, 31 + 32 = 63 바이트

카운터

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

온라인으로 사용해보십시오!

?^1?^ 1부울 부정 연산자를 1에 적용하는 것처럼 구문 분석 됩니다 False.

쪼개는 도구

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

온라인으로 사용해보십시오!

? ^1범위 0..0을 Bool로 변환하여 결과를 얻습니다 True.

파이썬 2, 98

스 플리 팅 (49)

목록에서 토큰을 반환합니다.

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

계산 (49)

공백 문자 수를 포함하는 길이 1의 목록을 리턴합니다. 런타임 오류가 발생할 가능성이 높지만 f코드를 실행 한 후에 함수를 사용할 수 있습니다.

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

C (gcc) , 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;}

카운터

개요

함수 인수로 입력을받습니다. 계산 함수는 공백 수를 반환합니다. splitting 함수는 출력에 STDOUT을 사용하지만 우연히 공백 수에서 1을 뺀 값을 반환합니다.

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 바이트

• 프로그램 / 함수에는 문자열 또는 정규식 리터럴이 포함될 수 없습니다

[^$IFS]패턴 일치에 사용되기 때문에 자격이 있는지 확실하지 않습니다 . 금지 된 경우 45 + 45 솔루션이 있습니다.

스플릿:

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

카운트:

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

:내장이에 equivilent되어 true우리가 그것을 원치 않는 확장 배관에 의해 코멘트와을 / dev / null (주석이 허용되기 때문에) 사이에 뭔가로 사용합니다.

Zsh에는 공백 분할을위한 내장 기능이 ${=var}있습니다. 이것은 단지 둘 다를 실행하고 원하지 않는 것을 버리는 것 이외의 모든 종류의 논리적 조합을 수행하는 것을 어렵게 만듭니다.

온라인으로 사용해보십시오!