# I don't like change!

## JavaScript (ES6), ~~413~~ ... ~~343~~ 342 bytes

*Saved 5 bytes by tweaking the loop indices, as suggested by @KevinCruijssen*

Takes input as 2 strings in currying syntax. Returns an array of 3 strings.

```
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]}
```

### Test cases

```
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`);
```

### Less golfed

```
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
]
}
```

### Example

Below is the initial matrix for ** b = "foo"** and

**:**

*a = "ok"*```
// 'o' 'k'
[ [ [ '', 0 ], [ 'A', 1 ], [ 'AA', 2 ] ],
[ [ 'R', 1 ], (undefined), (undefined) ], // 'f'
[ [ 'RR', 2 ], (undefined), (undefined) ], // 'o'
[ [ 'RRR', 3 ], (undefined), (undefined) ] ] // 'o'
```

and here is the final matrix after all iterations:

```
// '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'
```

The final modification string along with the Levenshtein distance are stored in the bottom-right cell.

## Haskell, ~~192~~ ~~181~~ ~~174~~ ~~161~~ ~~158~~ ~~150~~ ~~147~~ ~~143~~ 158^{1} bytes

```
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
```

Try it online! Example usage: `"ABCDEF" & "AFBECD"`

. Returns a list of three strings. This is an extension of my recursive solution to the ordinary Levenshtein distance question.

### Explanation:

To compute the minimal modifications to get from `"xyz"`

to `"yw"`

, we focus on the first character of both strings. There are three possibilities:

*Remove:*Drop`x`

from the first string and recursively compute the modifications to get from`"yz"`

to`"yw"`

. This yields the three lines`["yz","yw"," M"]`

. Add`x`

to the first one, a space to the second one and`R`

to the third one. We getxyz yw R M

*Add:*Drop`y`

from the second string and compute`"xyz" & "w"`

, which returns the result`["xyz","w","MRR"]`

. We need to add a space on the first line,`y`

to the second and`A`

to the third line:xyz yw AMRR

*Modified/Unchanged:*We can combine those two cases because both require to drop the first character of both strings and compute the minimal modifications between the remaining strings:`"yz" & "w"`

. To the result`["yz","w","MR"]`

, we add`x`

on he first and`y`

on the second line. Only for the last line we need to differentiate whether the initial characters are the same. If they are the same, a space is added to the third line, otherwise (as in this case because`x \= y`

) an`M`

is added:xyz yw MMR

From those three candidates, we need to find the one with the fewest modifications. This is equivalent to having the most spaces on the third line. Therefore we convert each candidate `s`

(a list of three strings) to a tuple `([1|' '<-s!!2],s)`

, where `s`

appears as second component and the first component is a list with as many elements as there are spaces in the third line of `s`

(`s!!2`

because of 0-indexing). As list element `1`

is used, but the actual element is irrelevant as long as it is the same for all candidates.

Altogether, this yields the list of tuples

[([1],["xyz"," yw","R M"]),([],[" xyz","yw","AMRR"]),([],["xyz","yw","MMR"])]The build-in

`maximum`

selects the largest element of this list, where tuples are compared lexicographically, that is component-wise from left to right. As `[1]`

is larger than `[]`

, the first tuple is selected, and `snd`

returns the second of component, that is the list of lines, of the tuple.
_{1 +15 bytes to fix a bug where A-changes at the end of a string would be displayed as R-changes}

## Python 2, ~~548~~ ~~536~~ ~~484~~ ~~500~~^{1} ~~488~~ ~~447~~ ~~381~~^{2} ~~373~~ ~~371~~ ~~357~~ 350 bytes

^{1}

^{2}

```
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
```

Try it online!

Uses `'ARM_'`

instead of `'ARM '`

Works by building up the Levenshtein matrix, ~~and then traversing backwards to find the operations~~. Now builds the operation-string at the same time as the Levenshtein matrix, as in Arnauld's JS answer

_{1: More bytes, as it did not work if the first string was a single character.}

_{2: Switched to building the combinations in the Levenshtein matrix.}