Palindromes là niềm vui, nhưng một số chuỗi khác đang bắt đầu cảm thấy bị bỏ rơi. Chúng ta có thể biến những chuỗi đó thành các palindromes chunky bằng cách chia chúng thành các mảng palindromic của khối.

Ví dụ: chuỗi "abcabca"không phải là một palindrom nếu chúng ta đọc nó theo từng ký tự, nhưng chúng ta có ba cách khác nhau để biến nó thành một palindrom chunky :

["abcabca"]
["a" "bcabc" "a"]
["a" "bc" "a" "bc" "a"]

Như bạn có thể thấy, palindromic chunky là một khái niệm rất bao quát; mỗi chuỗi có thể được biến thành một palindrom chunky theo ít nhất một cách.

Bài tập

Viết một chương trình hoặc một hàm nhận một chuỗi làm đầu vào và trả về độ chụm của palindromic của nó , tức là số lượng phân vùng của nó là các mảng palindromic.

Các trường hợp thử nghiệm

 OUTPUT | INPUT
--------+---------------------------------------------
      1 | ""                                          
      1 | "a"                                         
      1 | "ab"                                        
      2 | "aa"                                        
      2 | "aaa"                                       
      3 | "abcabca"                                   
      4 | "abababab"                                  
     28 | "abcabcaabababababcabca"                    
      1 | "bbbbabababbbbababbbaaaaa"                  
     20 | "ababbaaaabababbbaaabbbaa"                  
      5 | "baaabaabababaababaaabbaab"                 
     62 | "bbaaababbabbabbbabaabaabb"                 
      2 | "a man a plan a canal panama"               
     25 | "ama nap lan aca nal pan ama"               
     93 | "SATOR   AREPO   TENET   OPERA   ROTAS"     
    976 | "abcabcaabcabcaabcabcaabcabcaabcabcaabcabca"
  28657 | "ababababababababababaababababababababababa"
2097152 | "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"

Quy tắc bổ sung

• Bạn có thể giả định rằng đầu vào sẽ bao gồm 42 ký tự ASCII có thể in hoặc ít hơn, được bao quanh tùy ý bởi các dấu phân cách chuỗi ngôn ngữ của bạn và / hoặc theo sau là một dòng mới.

• Đối với mỗi chuỗi đầu vào hợp lệ, mã của bạn phải hoàn thành sau chưa đầy một phút trên máy của tôi (Intel Core i7-3770, RAM 16 GiB, Fedora 21).

  Với một thuật toán thích hợp, nó sẽ dễ dàng tuân thủ giới hạn thời gian này. Tuy nhiên, rất có thể bạn sẽ không thể lặp lại trên tất cả các phân vùng của chuỗi đầu vào.

• Nếu bạn chọn in đầu ra thành STDOUT, nó có thể được theo sau bởi một dòng mới.

• Luật golf tiêu chuẩn được áp dụng.

Pyth, 40 34 27 22 byte

Lhsmy:bd_df!xb>TbS/lb2

Hãy thử nó trong phiên dịch trực tuyến .

Chơi golf nặng nề từ phiên bản 40 byte ban đầu. Cảm ơn FryAmTheEggman đã chỉ ra một vài toán tử hữu ích (tài liệu rất khó tìm kiếm!) Đã tiết kiệm cho tôi tổng cộng 6 byte. Cảm ơn Dennis vì đã tiết kiệm một byte thông minh bằng cách diễn giải kết quả của xgiá trị trung thực / giả mạo thay vì chỉ mục - !xb>Tbthay vì q<bT>Tb.

Làm thế nào nó hoạt động:

Chúng tôi xác định một hàm yxác định độ chụm của chuỗi bbằng cách gọi đệ quy chính nó trên chuỗi con của b. Các chức năng được tự động ghi nhớ trong Pyth, vì vậy đệ quy có rất ít chi phí về thời gian.

L                              def y(b): return ___
                 S/lb2         The range [1,2,...,len(b)/2]
          f!xb>Tb              Filter n for which b[:n] == b[-n:]
   m                           Map each n in the list to...
    y:bd_d                     y(b[d:-d])       
 hs                            Take the sum and add one (implicit return)

CJam ( 41 39 byte)

qM{_,2/,\f{\~_2$>@2$<@~)/(@=\M*j*}1b)}j

Bản demo trực tuyến

Điều này là "háo hức" theo nghĩa là nó tìm thấy số lượng palindromes chunky cho mỗi chuỗi "trung tâm" (nghĩa là kết quả của việc loại bỏ cùng một số ký tự từ cả hai đầu của chuỗi gốc), nhưng vì nó sử dụng tính năng tự động ghi nhớ jmỗi toán tử chỉ được tính một lần, đưa ra một chương trình rất nhanh (và lưu một vài ký tự qua một triển khai không ghi nhớ).

Cảm ơn Dennis vì đã tiết kiệm một byte.

Toán học, 77 72 57 byte

1+Tr[#0/@ReplaceList[#,{a__,b___,a__}:>{b}]]&@*Characters

Perl, 86 byte

Mã 84 byte + 2 công tắc

Có một phương pháp ngắn hơn, nhưng ở đây đi:

perl -lpe 'sub c{my($x,$i)=@_;$x=~/^(.{$i})(.*)\1$/&&c($2,0*++$s)while++$i<length$x}c$_;$_=++$s'

Lấy đầu vào từ STDIN, một chuỗi trên mỗi dòng.

Giải thích: Đối với các giá trị 1<=$i<length(input string), sử dụng biểu thức chính quy /^(.{$i})(.*)\1$/để lấy các phần bên trái và bên phải và tăng số đếm. Sau đó đệ quy làm tương tự cho phần trung tâm của chuỗi.