我们将空格定义为三个字符中的任何一个，即制表符（0x09），换行符（0x0A）或空格（0x20）。

为了应对这一挑战，您将使用相同的编程语言编写两个程序或函数，它们将执行以下任务：

1. 计算给定字符串中的空白字符。例如，输入

     123 -_-   abc
   def
   

   将返回7（假设没有结尾的换行符）。

2. 在连续的空白处分割给定的字符串。如果字符串以空格开头或结尾，则结尾处不应返回任何空字符串。例如，相同的输入

     123 -_-   abc
   def
   

   会回来的["123", "-_-", "abc", "def"]。

无论哪种情况，您都可以通过STDIN，命令行参数或函数参数接受输入，然后返回结果或将其打印为STDOUT。对于第二个程序，如果选择打印到STDOUT，请在每个字符串的一行上打印它们，不要用引号引起来。

对于这两个程序，您都可以假定输入仅包含可打印的ASCII（0x20至0x7E）和空格。

现在是要抓住的地方：

• 如果从两个程序/功能中都删除了所有空格，则产生的字符串必须相同。也就是说，您的两个提交内容只能在空格字符的数量和位置上有所不同。
• 程序/函数均不能包含任何字符串或正则表达式文字（如果您的语言具有指定的字符类型，则文字文字可以使用）。
• 程序/功能均不得包含任何注释。
• 您不得直接或间接阅读程序的源代码。

这是代码高尔夫。您的分数是两种解决方案的总和（以字节为单位）。最低分获胜。

排行榜

以下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

分离器：

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

分离器：

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

分离器：

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是函数且也是真实的，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。和以前一样，在这种情况下，Python只需在一行上有一个表达式就可以了1。拆分a1确定从函数返回什么。

Java 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

Marbelous，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。

说明

计数器：

蓝色路径接收输入。如果该字符是空白字符（ascii值小于0x21），则采用黑色路径，该路径与紫色路径同步。

&1每次使用黑色路径时，紫色路径仅会增加存储在同步器中的大理石。

一旦没有更多输入，将采用红色路径，打印空白字符数并退出。

分离器：

程序以蓝色路径开始，该路径一直循环直到找到非空白字符。

检索到非空白字符后，将采用黑色路径，该黑色路径将打印出该字符并将执行移至绿色路径，绿色路径将循环并打印直到收到空白字符。然后执行继续到紫色路径，该路径包含3W或三路分配器。

左分支将执行移至蓝色路径（并且空格被丢弃，直到找到非空格字符）。

中间分支将输入的副本设置为，将的副本设置为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，而'!就是!人物，这是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

在这里在线尝试

Mathematica，44 + 43 = 87 97字节

我以为我会添加另一种语言。

计数器：

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

分离器：

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

这利用了Mathematica的功能，即空间分隔与乘法相同。将某物与0相乘始终为0，而​​向某物加0始终是幂等的。

对于计数器，我们首先计算空格，然后添加0*1*StringSpli*t@#。StringSpli并t没有定义，但是Mathematica使用符号计算，因此它只是将它们视为未知变量和函数。该1*是幂等的（正如0+），将0*它变成了零。有必要将StringSplit分为两个变量，因为0有时列表被视为标量向量乘法，导致向量（列表）为零。

对于分离器，我使用的事实是Count也存在但不考虑字符串。它尝试计算与该模式匹配的所有子表达式，但它Whitespace是仅适用于字符串内容的模式。因此，Count将始终返回0，这将String消失。分割数组的乘以01 = 1再次是幂等的。

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

p是一个预定义的方法，不带任何参数，仅返回nil。我们以几种方式使用它。在拆分器中，首字母p不执行任何操作。gets(p)由于分隔符为null，因此从标准输入中读取所有内容。我们在其上调用内置的split方法，并将结果分配给p，因此现在在不给其参数的情况下，它将被解析为变量。puts p||...短路并将p变量的每个元素打印到自己的行。

在计数器中，我们删除第一条换行符，以便将拆分数组分配给它pp。由于我们尚未分配给p，它仍然是nil-returning方法，因此||将评估第二部分并将其传递给puts。$_是一个魔术变量，包含的结果gets，因此，空格的总数等于该空格的大小减去所pp包含的非空格字符。我觉得应该有一种更短的计数方法，但我找不到一种方法，无论如何，在计数器中使用split数组很有趣。

Python，169

用Python做到这一点几乎太容易了！

计数器：

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

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

分离器：

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)然后执行“第二遍”行为（因为在计数器中被跳过），因为外部循环被第二遍了。

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

分离器：

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

Bash，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

Ruby，114 + 116107 + 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

分离器

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

该解决方案利用了一个事实，即Haskell函数是Monad类型类的实例，因此可以在do表示法中用作monadic动作。

在第一种情况下，do块的结果函数是的第一个参数pure（本质上是const针对函数类型），使计数器成为最终结果，并且拆分器被丢弃。

在第二种情况下pure，仅将其应用于单个参数，从而使其成为返回另一个函数（计数器）的函数。但是，永远不会使用结果，因此将其丢弃。最终结果是do块的第二行，分离器。

Java 8、187 + 188 = 375

首先，我想说这个答案很大程度上是基于@Ypnypn的。我基本上用较短的部分代替了某些部分（包括依赖于空格的部分，在此挑战中IMO最重要），但是功能代码基本相同。

计算空格 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个字符

带有并返回单个参数的两个函数。使用了我想到的最糟糕的方法来打破相同但又空白的规则，因此通过查找更聪明的方法可以节省字符。

(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有效，是因为当J看到时(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|
+---+---+---+---+

Bash，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

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。

分离器

{? ^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）

返回长度为一的列表，其中包含空格字符的数量。它很可能会导致运行时错误，但是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;}

计数器

撞倒

将输入作为函数参数。计数功能返回空格数。拆分功能将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字节

• 程序/函数均不得包含任何字符串或正则表达式文字

我不确定是否[^$IFS]合格，因为它用于模式匹配。在被禁止的情况下，这是一种45 + 45的解决方案。

分裂：

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

计数：

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

该:内建函数与等效true，我们通过将不需要的扩展传递给它，在注释和/ dev / null之间使用它（因为不允许注释）。

Zsh具有一个用于在空格上拆分的内置函数，即${=var}。除了仅执行两者并丢弃我们不想要的逻辑组合之外，这使得很难进行任何逻辑组合。

在线尝试！