Palindromes นั้นสนุก แต่สตริงอื่น ๆ บางส่วนเริ่มรู้สึกไม่ดี เราสามารถเปลี่ยนสตริงเหล่านั้นให้เป็นpalindromes ก้อนโดยแยกพวกมันออกเป็นอาร์เรย์ palindromic ของชิ้น

ยกตัวอย่างเช่นสตริง"abcabca"ไม่ palindrome ถ้าเราอ่านทีละอักขระ แต่เรามีสามวิธีที่แตกต่างกันในการทำมันอ้วน palindrome:

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

อย่างที่คุณเห็น Palindromicness อ้วน ๆ เป็นแนวคิดที่ครอบคลุมมาก สตริงทุกตัวสามารถเปลี่ยนเป็น palindrome แบบก้อนได้อย่างน้อยหนึ่งวิธี

งาน

เขียนโปรแกรมหรือฟังก์ชั่นที่รับสตริงเป็นอินพุตและส่งคืนพาลินโดรมิกของก้อนนั่นคือจำนวนพาร์ติชันที่เป็นอาร์เรย์พาลินโดรมิก

กรณีทดสอบ

 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"

กฎเพิ่มเติม

• คุณอาจสมมติว่าข้อมูลที่ป้อนจะประกอบด้วยอักขระ ASCII ที่พิมพ์ได้ 42 หรือน้อยกว่าโดยมีตัวเลือกล้อมรอบด้วยตัวคั่นสตริงของภาษาและ / หรือตามด้วยบรรทัดใหม่

• สำหรับสตริงอินพุตที่ถูกต้องแต่ละรหัสของคุณจะต้องเสร็จสิ้นในเวลาไม่ถึงหนึ่งนาทีบนเครื่องของฉัน (Intel Core i7-3770, 16 GiB RAM, Fedora 21)

  ด้วยอัลกอริธึมที่เพียงพอมันควรจะง่ายที่จะปฏิบัติตามการ จำกัด เวลานี้ อย่างไรก็ตามคุณจะไม่สามารถวนซ้ำทุกพาร์ติชันของสตริงอินพุตได้

• หากคุณเลือกที่จะพิมพ์ผลลัพธ์ไปยัง STDOUT มันอาจตามมาด้วยบรรทัดใหม่เดียว

• ใช้กฎมาตรฐานของกอล์ฟ

Pyth, 40 34 27 22 ไบต์

Lhsmy:bd_df!xb>TbS/lb2

ลองในล่ามออนไลน์

หนักลงจากรุ่นเริ่มต้น 40 ไบต์ ขอบคุณ FryAmTheEggman สำหรับการชี้ให้เห็นตัวดำเนินการที่มีประโยชน์ (เอกสารยากต่อการค้นหา!) ที่ช่วยฉันทั้งหมด 6 ไบต์ ขอขอบคุณที่เดนนิสสำหรับการประหยัดโดยการตีความผลมาจากการไบต์เดี่ยวฉลาดxเป็น truthy / ค่า falsy มากกว่าดัชนี - มากกว่า!xb>Tbq<bT>Tb

มันทำงานอย่างไร:

เรากำหนดฟังก์ชั่นyที่กำหนด chunkiness ของสตริงโดยซ้ำเรียกตัวเองในสตริงของb bฟังก์ชั่นจะถูกบันทึกโดยอัตโนมัติใน Pyth ดังนั้นการเรียกซ้ำมีค่าใช้จ่ายน้อยมากในแง่ของเวลา

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 ไบต์)

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

การสาธิตออนไลน์

นี่คือ "กระตือรือร้น" ในแง่ที่พบว่าจำนวน palindromes ที่เป็นก้อนสำหรับสตริง "ส่วนกลาง" แต่ละอัน (เช่นผลลัพธ์ของการลบจำนวนอักขระที่เหมือนกันจากปลายทั้งสองของสตริงเดิม) แต่เนื่องจากใช้การบันทึกอัตโนมัติjตัวดำเนินการแต่ละตัวจะถูกคำนวณเพียงครั้งเดียวให้โปรแกรมที่รวดเร็วมาก

ขอบคุณเดนนิสสำหรับการบันทึกหนึ่งไบต์

Mathematica, 77 72 57 ไบต์

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

Perl, 86 ไบต์

โค้ด 84 ไบต์ + 2 สวิตช์

มีวิธีที่สั้นกว่านี้ แต่จะไปที่:

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

รับอินพุตจาก STDIN หนึ่งสตริงต่อบรรทัด

คำอธิบาย: สำหรับค่า1<=$i<length(input string)ให้ใช้ regex /^(.{$i})(.*)\1$/เพื่อรับส่วนซ้ายและขวาและเพิ่มจำนวน จากนั้นทำซ้ำสำหรับส่วนตรงกลางของสตริง