iBug最近获得了由复合材料但有价值的材料制成的长条。该栏太长了，以至于iBug不能轻易将其出售以换取积分，因此他想削减它。杆由易碎的魔术材料制成，如果零件断裂，则由相同材料制成的杆的所有部分也会断裂，从而难以任意切割。

iBug希望将标尺切成尽可能多的片段。他还喜欢很短的程序和代码编程，因此对他的问题进行了抽象分析。

iBug的魔力棒表示为字符串（或者，如果愿意，可以表示为数组或字符序列），如下所示：

aaabbccccccbbbaaacccccaabbbaaaaa

字符串中的每个字母代表一种魔术材料。该条始终与RegEx相匹配^\w*$，因此条中最多可以包含63种材料。“部分”是由空格分隔的任何字符的连续序列。

iBug希望您编写一个程序，如果完全删除了零个或多个字符集（用空格代替），则可以计算出他可以得到的最大部分，并告诉iBug该数字。

范例1：

In:  aaabbccccccbbbaaacccccaabbbaaaaa
Out: 4

说明：如果b将其从工具栏中完全卸下，则iBug可以分为4个部分。他还可以通过删除b和来获得4个部分c，如下所示

aaabbccccccbbbaaacccccaabbbaaaaa  # Original string
aaa  cccccc   aaacccccaa   aaaaa  # Remove 'b'
aaa           aaa     aa   aaaaa  # Remove 'b' and 'c'

这就是iBug可以从该栏获得的最大零件数

范例2：

In:     111aa___9999____aaa99111__11_a_aa999
Result: 111aa   9999    aaa99111  11 a aa999
Out:    6

说明：通过仅删除下划线，iBug可以从条中获得6个部分，这是最大数目。

范例3：

In:  __________
Out: 1

说明：什么？你想剪这个吗？如果根本不切割，则只能得到1个零件。

范例4：

In:  
Out: 0

说明：没有要削减的内容，因此为零。

iBug还希望程序遵守一些规则：

1. iBug不喜欢标准漏洞，因此被禁止。

2. 只要有效，就不必是完整程序。也接受从参数获取输入并通过返回值提供输出的函数。

3. 允许灵活的输入和输出。您的程序或函数可以采用字符串或字符数组，也可以采用最简单的处理方法。您可以通过打印数字或返回数字来提供输出。

样本测试用例（但不限于这些）

aaabbbaaa           = 2
123456789           = 5
AaAaAaAa            = 4
aaabcccdedaaabefda  = 6
________            = 1
(empty)             = 0

由于这是一个代码高尔夫，因此每种语言中最短的程序（以字节为单位）将获胜！

额外

iBug非常感谢您能为您的程序提供解释，即使它不会影响评分（仍然是字节长度）。

Haskell，73 71 70字节

x#z|z==x=' '|1<2=z
f x=maximum$length(words x):[f$(c#)<$>x|c<-x,c>' ']

^{感谢Laikoni节省了1个字节！}

在线尝试！

JavaScript（ES6），109个 90字节

f=s=>Math.max((s.match(/\s+/g)||[]).length,...[...s].map(c=>c>` `&&f(s.split(c).join` `)))

<input oninput=o.textContent=/\s/.test(this.value)?``:f(this.value)><pre id=o>0

123456789测试用例有些慢。先前的109字节答案不限于!/\s/：

f=
s=>(g=a=>Math.max(a.filter(s=>s).length,...[...a.join``].map(c=>g([].concat(...a.map(s=>s.split(c)))))))([s])

<input oninput=o.textContent=f(this.value)><pre id=o>0

Python 2中，111个 93 72字节

-21个字节，感谢KirillL。

f=lambda s:max([len(s.split())]+[f(s.replace(c,' '))for c in s if'/'<c])

在线尝试！

果冻， 13  11 字节

由于使用了Zgarb，所以 ^{2个字节的指令太多} -2（使用外部产品quickþ>。<）

eþŒPŒr¬S€ṀḢ

接受字符列表并返回非负整数的单子链接。

在线尝试！

怎么样？

对于输入的每个子序列（我们可能要删除的集合，以及多余的等价项）都会获得一个存在列表，以识别要删除的列表，然后有效地找到剩余的零次游程并得出最大值。最后一部分的工作方式有点奇怪，因为我发现它比更幼稚的替代品更具高尔夫性-它以[element, count]成对的方式找到行程，否定将零识别为1，求和找到最大值然后取头（元素之和而不是计数） ）。

eþŒPŒr¬S€ṀḢ - Link: list of characters        e.g. "aabcde"
  ŒP        - power-set - gets all subsequences    ["","a","a","b",...,"bd",...,"aabcde"]
 þ          - outer-product with:
e           -   exists in?                         [[0,0,0,0,0,0],[1,1,0,0,0,0],[1,1,0,0,0,0],[0,0,1,0,0,0],..,[0,0,1,0,1,0]...,[1,1,1,1,1,1]]
    Œr      - run-length encode                    [[[0,6]],[[1,2],[0,4]],[[1,2],[0,4]],[[0,2],[1,1],[0,3]],...,[[0,2],[1,1],[0,1],[1,1],[0,1]],...,[[1,6]]]
      ¬     - NOT                                  [[[1,0]],[[0,0],[1,0]],[[0,0],[1,0]],[[1,0],[0,0],[1,0]],...,[[1,0],[0,0],[1,0],[0,0],[1,0]],...,[[0,0]]]
        €   - for €ach:
       S    -   sum                                [[1,0],[1,0],[1,0],[2,0],...,[3,0],...,[0,0]]
         Ṁ  - maximum                              [3,0]
          Ḣ - head                                 3

Ruby，98 89 75 64 61字节

f=->s{[s.split.size,*s.scan(/\w/).map{|c|f[s.tr c,' ']}].max}

在线尝试！

_{^{比以前更小更慢！}}

基本上是@Neil Javascript答案的端口

取消标注和注释

def f(input_string)
    # splits by / +/ by default
    size0 = input_string.split.size
    # an array of all non-space characters in input_string
    characters = input_string.scan(/\w/)
    size1 = characters.map {|i|
        # all letters and digits and _ are "bigger" than /, space isn't
        if i > '/'
            # tr replaces every occurrence of i in input_string with space
            next_string = input_string.tr(i, ' ')
            f(next_string) # recursive call
        else
            0
        end
    }
    # max value between size0 and any element in size1
    return [size0, *size1].max
end

在线尝试！

外壳，12 11字节

▲mȯ#€0gM€¹Ṗ

在线尝试！ 这是蛮力的，非常慢。添加u到正确的一端以使其运行更快，而无需更改语义。

说明

▲mȯ#€0gM€¹Ṗ  Implicit input, say S = "abddccbdcaab"
          Ṗ  Powerset of S: P = ["","a","b","ab","d","ad"...,"abddccbdcaab"]
 m           Map this function over P:
              Argument is a subsequence, say R = "acc"
       M ¹    Map over S
        €     index of first occurrence in R: [1,0,0,0,2,2,0,0,2,1,1,0]
      g       Group equal elements: [[1],[0,0,0],[2,2],[0,0],[2],[1,1],[0]]
  ȯ#          Count the number of groups
    €0        that contain 0: 3
▲            Take maximum of the results: 4

Perl 5，（旧版本）-p -I.，，52 49 43字节

旧样式计数：+3for -p：46字节（因为它必须在程序中，所以不能使用来运行-e）

barsplit.pl：

#!/usr/bin/perl -pI.
$G[split]+=s%\S%do$0for s/$&/ /rg%eg;$_=$#G

在STDIN上运行字符串：

echo aaabcccdedaaabefda | ./barsplit.pl; echo

在线尝试！

该-I.选项可以使它也适用于默认情况下.不再存在的最新Perl @INC。在旧版本的perl中，不需要该选项。我在仍具有的旧计算机上进行了测试perl 5.20，因此分数基于该分数（否则，我也应该将的.参数计算在内-I）

快速版本（49字节）：

#!/usr/bin/perl -pI.
$G[split]+=s%.%$$_++||do$0for s/$&/ /rg%eg;$_=$#G

Wolfram语言（Mathematica），77字节

Max@Table[Tr[1^StringSplit[#,(##|##)..&@@s]],{s,Subsets@Union@Characters@#}]&

在线尝试！