iBug gần đây có một thanh dài làm bằng vật liệu composite, nhưng có giá trị. Thanh quá dài đến nỗi iBug không thể dễ dàng bán nó để lấy tín dụng, vì vậy anh ấy muốn cắt nó. Thanh được làm bằng các vật liệu mỏng manh và ma thuật đến nỗi, nếu một phần bị phá vỡ, tất cả các phần của thanh làm từ cùng một vật liệu cũng sẽ bị vỡ, khiến bạn khó có thể cắt tùy ý.

iBug muốn cắt thanh thành nhiều mảnh nhất có thể. Anh ấy cũng thích các chương trình rất ngắn và chơi golf mã, vì vậy anh ấy đã thực hiện một phân tích trừu tượng về vấn đề của mình.

Thanh ma thuật của iBug được biểu diễn dưới dạng một chuỗi (hoặc một mảng hoặc một chuỗi các ký tự nếu bạn thích), như thế này:

aaabbccccccbbbaaacccccaabbbaaaaa

Mỗi chữ cái trong chuỗi đại diện cho một vật liệu ma thuật. Thanh luôn khớp với RegEx ^\w*$, vì vậy có thể có tới 63 tài liệu trong thanh. "Phần" là một chuỗi liên tiếp của bất kỳ ký tự nào không được phân tách bằng dấu cách.

iBug muốn bạn viết một chương trình tính toán các phần tối đa mà anh ta có thể nhận được, nếu không hoặc nhiều bộ ký tự được loại bỏ hoàn toàn (thay thế bằng khoảng trắng) và báo cho iBug số đó.

Ví dụ 1:

In:  aaabbccccccbbbaaacccccaabbbaaaaa
Out: 4

Mô tả: Nếu bđược gỡ bỏ hoàn toàn khỏi thanh, iBug có thể nhận được 4 phần. Anh ta cũng có thể có được 4 phần bằng cách loại bỏ bvà c, như được hiển thị dưới đây

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

Và đó là số phần tối đa iBug có thể nhận được từ thanh này

Ví dụ 2:

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

Mô tả: Bằng cách chỉ xóa phần gạch dưới, iBug có thể nhận được 6 phần từ thanh và đó là mức tối đa.

Ví dụ 3:

In:  __________
Out: 1

Mô tả: Cái gì? Bạn muốn cắt cái này? Chỉ có thể nhận được 1 phần nếu bạn không cắt nó.

Ví dụ 4:

In:  
Out: 0

Mô tả: Không có gì để cắt, vì vậy không.

Cũng có một số quy tắc mà iBug muốn các chương trình tuân theo:

1. iBug không thích sơ hở tiêu chuẩn và chúng bị cấm.

2. Miễn là nó hoạt động, nó không cần phải là một chương trình đầy đủ. Hàm lấy đầu vào từ một tham số và cung cấp đầu ra thông qua giá trị trả về cũng được chấp nhận.

3. Đầu vào và đầu ra linh hoạt được cho phép. Chương trình hoặc chức năng của bạn có thể lấy một chuỗi, hoặc một mảng các ký tự hoặc bất cứ thứ gì bạn thấy dễ xử lý nhất. Bạn có thể cung cấp đầu ra bằng cách in số hoặc trả lại.

Các trường hợp thử nghiệm mẫu (nhưng không giới hạn ở những trường hợp này)

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

Vì đây là môn đánh gôn , chương trình ngắn nhất (tính bằng byte) trong mỗi ngôn ngữ sẽ thắng!

Thêm

iBug đánh giá rất cao nếu bạn có thể đưa ra lời giải thích cho chương trình của mình, mặc dù điều đó không ảnh hưởng đến việc ghi điểm của bạn (nó vẫn có độ dài tính bằng byte).

Haskell , 73 71 70 byte

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

^{Cảm ơn Laikoni vì đã tiết kiệm 1 byte!}

Hãy thử trực tuyến!

JavaScript (ES6), 109 90 byte

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

Hơi chậm trên 123456789trường hợp thử nghiệm. Câu trả lời 109 byte trước đó không giới hạn ở !/\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 byte

-21 byte cảm ơn Kirill L.

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

Hãy thử trực tuyến!

Thạch ,  13  11 byte

^{Quá nhiều hướng dẫn 2 byte}
-2 nhờ Zgarb (sử dụng nhanh sản phẩm bên ngoàiþ>. <)

eþŒPŒr¬S€ṀḢ

Một liên kết đơn âm chấp nhận danh sách các ký tự và trả về một số nguyên không âm.

Hãy thử trực tuyến!

Làm sao?

Đối với mỗi phần tiếp theo của đầu vào (các bộ chúng ta có thể loại bỏ, cộng với các phần tương đương dự phòng) sẽ có một danh sách tồn tại để xác định phần nào được loại bỏ sau đó tìm thấy hiệu quả số lượng 0 còn lại và mang lại mức tối đa. Phần cuối hoạt động theo một cách hơi kỳ lạ vì tôi thấy nó chơi golf hơn các giải pháp thay thế ngây thơ hơn - nó tìm thấy các lần chạy như [element, count]cặp, phủ định để xác định các số 0 là số, tổng tìm thấy tối đa sau đó lấy đầu (tổng các phần tử thay vì đếm ).

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 byte

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

Hãy thử trực tuyến!

_{^{nhỏ hơn và chậm hơn trước!}}

Về cơ bản là một cổng của câu trả lời Javascript của @ Neil

Ungolfed và chú thích

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

Hãy thử trực tuyến!

Husk , 12 11 byte

▲mȯ#€0gM€¹Ṗ

Hãy thử trực tuyến! Điều này hoạt động bằng lực lượng vũ phu và khá chậm. Thêm uvào đầu bên phải để làm cho nó chạy nhanh hơn, mà không thay đổi ngữ nghĩa.

Giải trình

▲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 , (phiên bản cũ hơn) -p -I., 52 49 43 byte

Đếm kiểu cũ: +3for -p: 46byte (vì nó phải nằm trong một chương trình, nó không thể được chạy bằng cách sử dụng -e)

barsplit.pl:

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

Chạy với chuỗi trên STDIN:

echo aaabcccdedaaabefda | ./barsplit.pl; echo

Hãy thử trực tuyến!

Các -I.tùy chọn là có để làm cho công việc cũng này trên perls gần đây, nơi theo mặc định .là không còn nữa trong @INC. Trong các phiên bản cũ hơn của perl, tùy chọn đó là không cần thiết. Tôi đã kiểm tra rằng trên một máy cũ hơn vẫn còn perl 5.20, vì vậy điểm số dựa trên điều đó (nếu không tôi cũng nên tính .đối số -I)

Phiên bản nhanh ( 49byte):

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

Ngôn ngữ Wolfram (Mathicala) , 77 byte

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

Hãy thử trực tuyến!