I palindromi sono divertenti, ma alcune delle altre corde stanno iniziando a sentirsi escluse. Possiamo trasformare quelle corde in grossi palindromi dividendoli in schiere palindromiche di grossi pezzi.

Ad esempio, la stringa "abcabca"non è un palindromo se la leggiamo carattere per carattere, ma abbiamo tre diversi modi per renderlo un grosso palindromo:

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

Come puoi vedere, la palindromicità pesante è un concetto molto inclusivo; ogni stringa può essere trasformata in un grosso palindromo in almeno un modo.

Compito

Scrivi un programma o una funzione che riceve una stringa come input e restituisce il suo chunkiness palindromico , cioè il numero delle sue partizioni che sono array palindromici.

Casi test

 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"

Regole aggiuntive

Si può presumere che l'input sarà composto da 42 o meno caratteri ASCII stampabili, facoltativamente circondati dai delimitatori di stringa della propria lingua e / o seguiti da una nuova riga.
Per ogni stringa di input valida, il mio codice deve terminare in meno di un minuto sulla mia macchina (Intel Core i7-3770, 16 GiB RAM, Fedora 21).

Con un algoritmo adeguato, dovrebbe essere facile rispettare questo limite di tempo. Tuttavia, molto probabilmente non sarai in grado di iterare su tutte le partizioni della stringa di input.
Se si sceglie di stampare l'output su STDOUT, potrebbe essere seguito da una nuova riga.
Si applicano le regole standard del code-golf .

— Dennis
fonte

4

Pyth, 40 34 27 22 byte

Lhsmy:bd_df!xb>TbS/lb2

Provalo nell'interprete online .

Molto pesantemente ridotto dalla versione iniziale di 40 byte. Grazie a FryAmTheEggman per aver segnalato un paio di operatori utili (i documenti sono difficili da cercare!) Che mi hanno risparmiato 6 byte in totale. Grazie a Dennis per un intelligente risparmio a singolo byte interpretando il risultato xcome valore di verità / falsità anziché come indice - !xb>Tbpiuttosto che q<bT>Tb.

Come funziona:

Definiamo una funzione yche determina il grosso di una stringa bchiamando ricorsivamente se stesso su sottostringhe di b. Le funzioni vengono memorizzate automaticamente in Pyth, quindi la ricorsione ha un sovraccarico minimo in termini di tempo.

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)

— Sam Cappleman-Lynes
fonte

Sì, la maggior parte dell'apprendimento di Pyth è in comune / prova ed errore / lettura del lexer, buon lavoro con il golf molto di più! :)

— FryAmTheEggman,

1

1. È possibile salvare due byte inviando la funzione. Non è necessario chiamarlo con yz. 2. Invece di due mappe e un filtro, è possibile utilizzare una singola mappa e un condizionale ( collegamento ), che consente di salvare tre byte.

— Dennis,

2

CJam ( 41 39 byte)

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

Demo online

Questo è "desideroso" nel senso che trova il numero di palindromi grossi per ogni stringa "centrale" (cioè il risultato della rimozione dello stesso numero di caratteri da entrambe le estremità della stringa originale), ma perché utilizza l'auto-memoising jl'operatore viene calcolato una sola volta, fornendo un programma molto veloce (e salvando alcuni caratteri su un'implementazione non memorizzata).

Grazie a Dennis per il risparmio di un byte.

— Peter Taylor
fonte

1

Mathematica, 77 72 57 byte

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

— alephalpha
fonte

1

Perl, 86 byte

84 byte codice + 2 switch

Deve esserci un metodo più breve, ma qui va:

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

Riceve input da STDIN, una stringa per riga.

Spiegazione: Per i valori 1<=$i<length(input string), utilizza regex /^(.{$i})(.*)\1$/per ottenere i blocchi destro e sinistro e incrementa il conteggio. Quindi ricorsivamente fa lo stesso per la parte centrale della stringa.

— svsd
fonte

Palindromi grossi