Ingresso:

Due stringhe senza newline o spazi bianchi.

Produzione:

Entrambe le stringhe di input su righe separate, con spazi ove necessario ^† per una delle due stringhe. Ed una terza linea con i personaggi A, R, Me , in rappresentanza aggiunto , rimosso , modificato , e invariato .

^† Aggiungiamo spazi alla stringa di input superiore o inferiore (se necessario). L'obiettivo di questa sfida è quello di produrre con il minor numero possibile di modifiche ( ARM), noto anche come distanza di Levenshtein .

Esempio:

Diciamo che le stringhe di input sono ABCDEFe AFBECD, quindi l'output sarebbe questo:

A B CDEF
AFBECD  
 A A  RR

Ecco alcuni altri possibili output non validi come esempio (e ce ne sono molti altri):

ABCDEF
AFBECD
 MMMMM

A BCDEF
AFBECD 
 A MMMR

AB CDEF
AFBECD 
 MAMMMR

ABC DEF
AFBECD 
 MMAMMR

ABC  DEF
AFBECD  
 MMAA RR

ABCDEF 
AFB ECD
 MMR MA

 AB CDEF   // This doesn't make much sense,
AFBECD     // but it's to show leading spaces are also allowed
AM A  RR

Nessuno di questi ha solo quattro modifiche, quindi A B CDEF\nAFBECD \n A A RRè solo un output valido per questa sfida.

Regole della sfida:

• Puoi supporre che le stringhe di input non contengano nuove righe o spazi.
• Le due stringhe di input possono avere lunghezze diverse.
• Una delle due stringhe di input dovrebbe rimanere così com'è, ad eccezione degli spazi iniziali / finali opzionali.
• Se le tue lingue non supportano nulla oltre a ASCII, puoi supporre che l'input contenga solo caratteri ASCII stampabili.
• Il formato di input e output è flessibile. Puoi avere tre stringhe separate, una matrice di stringhe, una singola stringa con nuove righe, una matrice di caratteri 2D, ecc.
• Ti è permesso usare qualcos'altro invece di ARM, ma indica ciò che hai usato (cioè 123, o abc., ecc.)
• Se è possibile più di un output valido con la stessa quantità di modifiche ( ARM), è possibile scegliere se emettere uno dei possibili output o tutti.

• Gli spazi iniziali e finali sono facoltativi:

  A B CDEF
  AFBECD
   A A  RR
  

  o

  "A B CDEF\nAFBECD\n A A  RR"
                   ^
                   Note there are no spaces here
  

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si prega di aggiungere una spiegazione, se necessario.

Casi test:

In: "ABCDEF" & "AFBECD"

Output (4 changes):
A B CDEF
AFBECD  
 A A  RR                  

In: "This_is_an_example_text" & "This_is_a_test_as_example"

Possible output (13 changes):
This_is_an       _example_text
This_is_a_test_as_example     
         MAAAAAAA        RRRRR

In: "AaAaABBbBBcCcCc" & "abcABCabcABC"

Possible output (10 changes):
AaAaABBbBBcCcCc
 abcABCab cABC 
R MM  MMMR MM R

In: "intf(){longr=java.util.concurrent.ThreadLocalRandom.current().nextLong(10000000000L);returnr>0?r%2:2;}" & "intf(){intr=(int)(Math.random()*10);returnr>0?r%2:2;}"

Possible output (60 changes):
intf(){longr=java.util.concurrent.ThreadLocalRandom.current().nextLong(10000000000L);returnr>0?r%2:2;}
intf(){i ntr=(      i    n      t)(M  ath.r   andom        ()*         10          );returnr>0?r%2:2;}
       MR M  MRRRRRR RRRR RRRRRR MMMRR MMMMRRR     RRRRRRRR  MRRRRRRRRR  RRRRRRRRRR 

In: "ABCDEF" & "XABCDF"

Output (2 changes):
 ABCDEF
XABCD F 
A    R 

In: "abC" & "ABC"

Output (2 changes):
abC
ABC
MM 

Haskell , 192 181 174 161 158 150 147 143 158 ¹ byte

e@(a:r)&f@(b:s)=snd$maximum[([1|' '<-s!!2],s)|s<-z(z(:))[a:" R",' ':b:"A",a:b:last("M":[" "|a==b])][r&f,e&s,r&s]]
x&y=[x,y,"RA"!!(0^length x)<$x++y]
z=zipWith

Provalo online! Esempio di utilizzo: "ABCDEF" & "AFBECD". Restituisce un elenco di tre stringhe. Questa è un'estensione della mia soluzione ricorsiva alla normale domanda a distanza di Levenshtein .

Spiegazione:

Per calcolare le minime modifiche per ottenere da "xyz"a "yw", ci concentriamo sul primo carattere di entrambe le stringhe. Esistono tre possibilità:

• Rimuovere: Goccia xdalla prima stringa e ricorsivamente calcolare le modifiche per ottenere da "yz"a "yw". Questo produce le tre linee ["yz","yw"," M"]. Aggiungi xal primo, uno spazio al secondo e Ral terzo. Noi abbiamo

  xyz
  yw
  RM

• Aggiungi: rilascia ydalla seconda stringa e calcola "xyz" & "w", che restituisce il risultato ["xyz","w","MRR"]. Dobbiamo aggiungere uno spazio sulla prima riga, ysulla seconda e Asulla terza riga:

   xyz
  yw
  AMRR

• Modificato / Invariato: Siamo in grado di combinare questi due casi perché entrambi richiedono di far cadere il primo carattere di entrambe le stringhe e calcolare le modifiche minime tra le altre stringhe: "yz" & "w". Al risultato ["yz","w","MR"], aggiungiamo xsu lui prima e ysulla seconda riga. Solo per l'ultima riga dobbiamo differenziare se i caratteri iniziali sono uguali. Se sono uguali, viene aggiunto uno spazio alla terza riga, altrimenti (come in questo caso perché x \= y) Mviene aggiunto un:

  xyz
  yw
  MMR

Di questi tre candidati, dobbiamo trovare quello con il minor numero di modifiche. Ciò equivale ad avere il maggior numero di spazi sulla terza riga. Pertanto convertiamo ciascun candidato s(un elenco di tre stringhe) in una tupla ([1|' '<-s!!2],s), dove sappare come secondo componente e il primo componente è un elenco con tanti elementi quanti sono gli spazi nella terza riga di s(a s!!2causa dell'indicizzazione 0). Come elemento di lista 1viene utilizzato, ma l'elemento reale è irrilevante purché sia ​​lo stesso per tutti i candidati.

Complessivamente, questo produce l'elenco delle tuple

[([1], ["xyz", "yw", "RM"]), ([], ["xyz", "yw", "AMRR"]), ([], ["xyz", " yw", "MMR"])]

_{¹ +15 byte per correggere un bug in cui A-cambia alla fine di una stringa verrebbe visualizzata come R-cambia}

JavaScript (ES6), 413 ... 343 342 byte

Salvato 5 byte modificando gli indici del loop, come suggerito da @KevinCruijssen

Accetta input come 2 stringhe nella sintassi del curry. Restituisce un array di 3 stringhe.

b=>a=>{m=[];x=a.length;y=b.length;for(i=j=0,c=d='';i<=y;c+=R='R')m[i]=[[c,i++]];for(;j++<x;)m[i=0][j]=[d+=A='A',j];for(;i<y;i++)for(j=0;j<x;)[C]=m[[X,S]=m[i][j],[Y,I]=m[i+1][j],[Z,D]=m[i][++j],Q=[Z+R,D+1],i+1][j]=b[i]==a[j-1]?[X+' ',S]:S<I?D<S?Q:[X+'M',S+1]:D<I?Q:[Y+A,I+1];return[(g=s=>C.replace(/./g,c=>c==s?' ':b[i++],i=0))(A),g(R,b=a),C]}

Casi test

let f =

b=>a=>{m=[];x=a.length;y=b.length;for(i=j=0,c=d='';i<=y;c+=R='R')m[i]=[[c,i++]];for(;j++<x;)m[i=0][j]=[d+=A='A',j];for(;i<y;i++)for(j=0;j<x;)[C]=m[[X,S]=m[i][j],[Y,I]=m[i+1][j],[Z,D]=m[i][++j],Q=[Z+R,D+1],i+1][j]=b[i]==a[j-1]?[X+' ',S]:S<I?D<S?Q:[X+'M',S+1]:D<I?Q:[Y+A,I+1];return[(g=s=>C.replace(/./g,c=>c==s?' ':b[i++],i=0))(A),g(R,b=a),C]}

console.log(f('ABCDEF')('AFBECD').join`\n`);
console.log(f('This_is_an       _example_text')('This_is_a_test_as_example').join`\n`);
console.log(f('AaAaABBbBBcCcCc')('abcABCabcABC').join`\n`);
console.log(f("intf(){longr=java.util.concurrent.ThreadLocalRandom.current().nextLong(10000000000L);returnr>0?r%2:2;}")("intf(){intr=(int)(Math.random()*10);returnr>0?r%2:2;}").join`\n`);
console.log(f('ABCDEF')('XABCDF').join`\n`);

Meno golf

b => a => {
  m = []; x = a.length; y = b.length;

  // initialize the leftmost column and the topmost row
  for(i = j = 0, c = d = ''; i <= y; c += R = 'R')
    m[i] = [[c, i++]];
  for(; j++ < x;)
    m[i = 0][j] = [d += A = 'A', j];

  // walk through the Levenshtein matrix
  for(; i < y; i++)
    for(j = 0; j < x;)
      [C] = m[                                // C = current string, once updated
        [X, S] = m[i][j],                     // substitution
        [Y, I] = m[i + 1][j],                 // insertion
        [Z, D] = m[i][++j],                   // deletion
        Q = [Z + R, D + 1],                   // precomputed update for deletion
        i + 1
      ][j] =
        b[i] == a[j - 1] ?
          [X + ' ', S]                        // unchanged character
        :
          S < I ?
            D < S ? Q : [X + 'M', S + 1]      // deletion or substitution
          :
            D < I ? Q : [Y + A, I + 1];       // deletion or insertion

  return [
    // g = helper function to format the output strings by inserting spaces
    (g = s => C.replace(/./g, c => c == s ? ' ' : b[i++], i = 0))(A),
    g(R, b = a),

    // final modification string, picked from the last visited cell
    C
  ]
}

Esempio

Di seguito è la matrice iniziale per b = "pippo" e a = "ok" :

//                     'o'           'k'
[ [ [ '',    0 ], [ 'A',   1 ], [ 'AA',  2 ] ],
  [ [ 'R',   1 ],  (undefined),  (undefined) ],  // 'f'
  [ [ 'RR',  2 ],  (undefined),  (undefined) ],  // 'o'
  [ [ 'RRR', 3 ],  (undefined),  (undefined) ] ] // 'o'

ed ecco la matrice finale dopo tutte le iterazioni:

//                     'o'           'k'
[ [ [ '',    0 ], [ 'A',   1 ], [ 'AA',  2 ] ],
  [ [ 'R',   1 ], [ 'M',   1 ], [ 'MA',  2 ] ],  // 'f'
  [ [ 'RR',  2 ], [ 'R ',  1 ], [ 'R A', 2 ] ],  // 'o'
  [ [ 'RRR', 3 ], [ 'RR ', 2 ], [ 'R M', 2 ] ] ] // 'o'

La stringa di modifica finale insieme alla distanza di Levenshtein sono memorizzate nella cella in basso a destra.

Python 2 , 548 536 484 500 ¹ 488 447 381 ² 373 371 357 350 byte

s,t=input()
n,m=len(s),len(t)
r=range
L=[[(j,'RA'[i<1]*j)for j in r(i,m-~i)]for i in r(n+1)]
for i in r(n):
 for j in r(m):M,R=L[i][j:j+2];A=L[i+1][j];v,V=min(A,R,M);x=('AR'[v in R],'M_'[s[i]==t[j]])[v in M];_=M;X=eval(x)[1]+x;L[i+1][j+1]=v+(x<'_'),X
for i in r(len(X)):s=s[:i]+' '*('B'>X[i])+s[i:];t=t[:i]+' '*('R'==X[i])+t[i:]
print s+'\n'+t+'\n'+X

Provalo online!

Utilizza 'ARM_'invece di'ARM '

Funziona costruendo la matrice di Levenshtein e quindi attraversando all'indietro per trovare le operazioni . Ora costruisce la stringa operativa contemporaneamente alla matrice di Levenshtein, come nella risposta JS di Arnauld

_{1: più byte, poiché non funzionava se la prima stringa era un singolo carattere.}

_{2: Passato alla creazione delle combinazioni nella matrice di Levenshtein.}

Python 2 , 310 byte

from difflib import*
a,b=input()
U,j=[],' '
for g,s,t,x,y in SequenceMatcher(0,a,b).get_opcodes():
	g,Y,T=g[0],y-x,t-s
	z,A,B=Y-T,a[s:t],b[x:y]
	if'q'<g:U+=[A+z*j,B+j*-z,'M'*min(T,Y)+'A'*z+'R'*-z]
	if'e'==g:U+=[A,B,j*Y]
	if'i'==g:U+=[j*Y,B,'A'*Y]
	if'e'>g:U+=[A,j*T,'R'*T]
for e in[0,1,2]:print''.join(U[e::3])

Provalo online!

Usandolo si difflib.SequenceMatchercalcola un allineamento tra due stringhe

Mathematica, 250 256 259 384 byte

~ 0.00035 secondi per la custodia del codice java.

(i=o=p="";a=Array;r=StringLength;If[Length@#>0,g=#&@@#;h=#[[2]];u=r@g;v=r@h;i=i<>g;o=o<>h;w=Abs[v-u];k=a[" "&,w];If[u<v,i=i<>k,o=o<>k];p=p<>a["M"&,u~Min~v];p=p<>a[If[u>v,"R","A"]&,w],i=i<>#;o=o<>#;p=p<>a[" "&,r@#]]&/@SequenceAlignment[#,#2];{i,o,p})&

Uso: f["ABCDE", "ABCDF"]

Provalo online!

Il codice si basa su un fatto che SequenceAlignmentfunziona per impostazione predefinita su

Con l'impostazione predefinita SimilarityRules-> Automatic, ogni corrispondenza tra due elementi contribuisce 1 al punteggio di somiglianza totale, mentre ogni mancata corrispondenza, inserimento o eliminazione contribuisce -1.

Vale a dire, il punteggio viene calcolato M, Ae R, di conseguenza.

Esempio:

D , 351 345 byte

-6 byte grazie a KevinCruijssen

string f(string a,string b){import std.algorithm;string x,y,z;size_t i,j,k;foreach(c;levenshteinDistanceAndPath(a,b)[1]){final switch(c)with(EditOp){case none:x~=a[i++];y~=b[j++];z~=" ";break;case substitute:x~=a[i++];y~=b[j++];z~="M";break;case insert:x~=" ";y~=b[j++];z~="A";break;case remove:x~=a[i++];y~=" ";z~="R";}}return x~"\n"~y~"\n"~z;}

Provalo online!