_{Questo è stato ispirato da una domanda CS.SE ora rimossa .}

Compito

Dato due stringhe di input non vuote A e B, emette la distanza minima da A a un palindromo che contiene B come sottostringa. La distanza è definita dal numero di sostituzioni di personaggi ( distanza di Hamming ).

restrizioni

• Input sensibile: esiste un palindromo. Questo significa | A | ≥ | B |.
• A e B contengono solo caratteri ASCII inferiori, le lettere minuscole e maiuscole sono distinte (come tutti gli altri caratteri).
• Se la tua lingua non è in grado di gestire i caratteri ASCII, puoi utilizzare anche numeri interi (o altri tipi di dati ragionevoli) e puoi scegliere di limitare l'intervallo a 128 elementi.
• Puoi prendere input da stdin, argomenti di funzione, argomenti della riga di comando, ecc.
• Puoi dare il risultato su stdout, valore di ritorno, ecc.
• Non è necessario fornire un palindromo di lavoro, la distanza minima da uno è sufficiente.

Esempi

A                   B            Output
thilloaoyreot       hello        4 (thelloaolleht)
benjonson           stack        9 (stackcats)
neversaynever!      odd          9 (neveroddoreven)
ppcggcpp            gg           0 (ppcggcpp)
stars               tat          1 (stats)

punteggio

Questo è il codice golf, vince il codice più corto in byte.

Pyth, 19 byte

hSmsnVQd/#z_I#^+Qzl

Dimostrazione

Approccio estremo alla forza bruta. Genera tutte le stringhe della lunghezza appropriata con caratteri in entrambe le stringhe, filtro per palindromi e per contenere il secondo input, mappa alla distanza di hamming dalla prima stringa, output più piccolo.

Spiegazione:

hSmsnVQd/#z_I#^+Qzl
hSmsnVQd/#z_I#^+QzlQ     Variable introduction
                         Q = string A, z = string B.
               +Qz       Concatenate A and B
              ^   lQ     Form every string of length equal to len(A)using
                         characters from the concatenation.
             #           Filter on
           _I            Invariance under reversal (palindrome)
         #               Filter on
        / z              Nonzero occurences of B
  m                      Map to
    nV                   !=, vectorized over
      Qd                 A and the map input
   s                     Sum (gives the hamming weight)
hS                       Min

Pyth, 45 byte

hSmsnVQdf}zTsmm+hc2KsXcd+Bklz1z_hc2PKh-lQlz_B

Provalo online. Suite di test.

Non sono ancora esattamente soddisfatto di come sia andata a finire. Ma almeno è abbastanza difficile da capire senza una spiegazione ora. (Successo, immagino?)

Spiegazione

• Prendi A come Qe B come z.
• m... _BQCalcola quanto segue sia per A che per il suo contrario come d:
  • m… h-ldlzCalcola quanto segue per tutti kda 0 a len(A) - len(B)inclusi:
    • +BklzPrendi la coppia k, k + len(B).
    • cdDividi din quegli indici.
    • X... 1zSostituisci la seconda parte (centrale) con B.
    • KsConcatena i pezzi e risparmia K. B è ora inserito nella posizione kin A o nel suo rovescio.
    • hc2Dividi la stringa risultante in due e mantieni il primo pezzo. Questo dà metà della stringa con l'eventuale carattere medio.
    • hc2PKRimuovi l'ultimo personaggio e fai la stessa divisione, mantenendo il primo pezzo. Questo dà metà della stringa senza il possibile carattere medio.
    • +... _Aggiungi il rovescio del pezzo più corto al pezzo più lungo. Ora abbiamo un palindromo.
• s Concatena i risultati per A e il suo contrario.
• f}zT Rimuovi tutte le stringhe che non contengono B.
• mCalcola quanto segue per tutte le stringhe risultanti d:
  • nVQd Ottieni la disuguaglianza a coppie con A. Questo dà True per le coppie che devono essere cambiate.
  • sSomma l'elenco. Questo dà la distanza di Hamming.
• hS Prendi il risultato minimo.

JavaScript (Firefox 30+), 152 146 byte

(A,B)=>Math.min(...[...Array(A[l='length']-B[l]+1)].map((_,i)=>[for(c of q=A.slice(j=t=0,i)+B+A.slice(i+B[l]))t+=(c!=A[j])+(c!=q[q[l]-++j])/2]|t))

Approccio a forza bruta: genera ogni possibile sovrapposizione di A e B, trasforma ciascuno in un palindromo, calcola le distanze di Hamming da A e prendi la più piccola delle distanze risultanti.

Probabilmente si potrebbe giocare a golf un po 'di più ...

Test snippet

f=(A,B)=>Math.min(...[...Array(A[l='length']-B[l]+1)].map((_,i)=>[for(c of q=A.slice(j=t=0,i)+B+A.slice(i+B[l]))t+=(c!=A[j])+(c!=q[q[l]-++j])/2]|t))
g=(A,B)=>console.log("A:",A," B:",B," f(A,B):",f(A,B))

g("thilloaoyreot", "hello")
g("benjonson", "stack")
g("neversaynever!", "odd")
g("ppcggcpp", "gg")

<input id=A value="amanaplanacanalrussia">
<input id=B value="panama">
<button onclick="g(A.value,B.value)">Run</button>