इनपुट:

दो तार बिना न्यूलाइन्स या व्हाट्सएप के।

आउटपुट:

अलग पंक्ति में दोनों इनपुट तार, रिक्त स्थान जहां आवश्यक साथ ^† दो तार में से एक के लिए। और पात्रों के साथ एक तीसरी लाइन A, R, Mऔर प्रतिनिधित्व जोड़ा , हटाया , संशोधित , और अपरिवर्तित ।

^† हम या तो ऊपर या नीचे इनपुट स्ट्रिंग (यदि हमें करना है) के लिए रिक्त स्थान जोड़ते हैं । इस चुनौती का लक्ष्य कम से कम परिवर्तनों ( ARM) के साथ उत्पादन करना है, जिसे लेवेंसहाइट दूरी भी कहा जाता है ।

उदाहरण:

मान लें कि इनपुट स्ट्रिंग्स हैं ABCDEFऔर AFBECDफिर, आउटपुट यह होगा:

A B CDEF
AFBECD  
 A A  RR

यहाँ उदाहरण के रूप में कुछ अन्य संभावित अवैध आउटपुट हैं (और भी बहुत कुछ हैं):

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

इनमें से किसी में भी केवल चार बदलाव नहीं हैं, इसलिए केवल A B CDEF\nAFBECD \n A A RRइस चुनौती के लिए एक वैध आउटपुट है।

चुनौती नियम:

आप यह मान सकते हैं कि इनपुट स्ट्रिंग्स में कोई नई लाइनें या स्थान नहीं होंगे।
दो इनपुट तार अलग-अलग लंबाई के हो सकते हैं।
वैकल्पिक अग्रणी / अनुगामी स्थानों को छोड़कर, दो इनपुट स्ट्रिंग्स में से एक जैसा होना चाहिए।
यदि आपकी भाषा ASCII के अलावा किसी चीज का समर्थन नहीं करती है, तो आप मान सकते हैं कि इनपुट में केवल मुद्रण योग्य ASCII वर्ण होंगे।
इनपुट और आउटपुट प्रारूप लचीला है। आपके पास तीन अलग स्ट्रिंग्स हो सकते हैं, एक स्ट्रिंग सरणी, नई लाइनों के साथ एक स्ट्रिंग, 2 डी चरित्र सरणी, आदि।
आपको इसके बजाय कुछ और का उपयोग करने की अनुमति है ARM, लेकिन आपने जो उपयोग किया है उसे बताएं (जैसे 123, या abc., आदि)
यदि एक से अधिक मान्य आउटपुट एक ही राशि के परिवर्तनों ( ARM) के साथ संभव है , तो आप यह चुन सकते हैं कि क्या संभव आउटपुट या उनमें से सभी को आउटपुट करने के लिए।

अग्रणी और अनुगामी स्थान वैकल्पिक हैं:

A B CDEF
AFBECD
 A A  RR

या

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

सामान्य नियम:

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा फोन।
डिफ़ॉल्ट लूपोल्स निषिद्ध हैं।
यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
इसके अलावा, यदि आवश्यक हो तो एक स्पष्टीकरण जोड़ें।

परीक्षण के मामलों:

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

code-golf string

— केविन क्रूज़सेन
स्रोत

हास्केल , 192 181 174 161 158 150 147 143 158 ¹ बाइट्स

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

इसे ऑनलाइन आज़माएं! उदाहरण उपयोग: "ABCDEF" & "AFBECD"। तीन तार की सूची लौटाता है। यह साधारण लेवेन्सहाइट दूरी प्रश्न के लिए मेरे पुनरावर्ती समाधान का विस्तार है ।

स्पष्टीकरण:

से प्राप्त करने के लिए न्यूनतम संशोधनों की गणना करने के "xyz"लिए "yw", हम दोनों तारों के पहले चरित्र पर ध्यान केंद्रित करते हैं। तीन संभावनाएं हैं:

निकालें: ड्रॉप xपहली स्ट्रिंग से और रिकर्सिवली संशोधनों से प्राप्त करने के लिए की गणना "yz"करने के लिए "yw"। इससे तीनों रेखाएँ निकलती हैं ["yz","yw"," M"]। xपहले एक में जोड़ें , दूसरे के लिए एक स्थान और Rतीसरे में एक। हमें मिला
```
xyz
YW
आर एम
```
जोड़ें:y दूसरे स्ट्रिंग से ड्रॉप करें और गणना करें "xyz" & "w", जो परिणाम देता है ["xyz","w","MRR"]। हमें पहली पंक्ति yमें दूसरी और Aतीसरी पंक्ति में एक स्थान जोड़ना होगा :
```
 xyz
YW
AMRR
```
संशोधित / अपरिवर्तित: हम उन दो मामलों को जोड़ सकते हैं क्योंकि दोनों को दोनों तारों के पहले चरित्र को छोड़ने और शेष तारों के बीच न्यूनतम संशोधनों की गणना करने की आवश्यकता है "yz" & "w":। परिणाम के लिए ["yz","w","MR"], हम xपहले और yदूसरी पंक्ति में उसे जोड़ते हैं । केवल अंतिम पंक्ति के लिए हमें यह अंतर करने की आवश्यकता है कि क्या प्रारंभिक वर्ण समान हैं। यदि वे समान हैं, तो तीसरी पंक्ति में एक स्थान जोड़ा जाता है, अन्यथा (क्योंकि इस मामले में x \= y) एक Mजोड़ा जाता है:
```
xyz
YW
एमएमआर
```

उन तीन उम्मीदवारों से, हमें सबसे कम संशोधनों के साथ एक को खोजने की आवश्यकता है। यह तीसरी पंक्ति में सबसे अधिक रिक्त स्थान होने के बराबर है। इसलिए हम प्रत्येक उम्मीदवार s(तीन स्ट्रिंग्स की एक सूची) को एक ट्यूपल में परिवर्तित करते हैं ([1|' '<-s!!2],s), जहां sदूसरा घटक के रूप में प्रकट होता है और पहला घटक एक सूची है जिसमें कई तत्व हैं s( तीसरी s!!2-अनुक्रमण के कारण)। जैसा कि सूची तत्व 1का उपयोग किया जाता है, लेकिन वास्तविक तत्व तब तक अप्रासंगिक होता है जब तक कि सभी उम्मीदवारों के लिए समान हो।

कुल मिलाकर, यह टुपल्स की सूची तैयार करता है

[([१], ["xyz", "yw", "RM"]], ([], ["xyz", "yw", "AMRR"]], ([], ["xyz," YW "," एमएमआर "])]

बिल्ड-इन maximumइस सूची के सबसे बड़े तत्व का चयन करता है, जहां ट्यूप्स की तुलना शाब्दिक रूप से की जाती है, जो कि घटक से बाएं से दाएं है। जैसा [1]कि बड़ा है [], पहला टपल चयनित है, और sndघटक के दूसरे को लौटाता है, जो कि टुपल की लाइनों की सूची है।

_{¹ +15 बाइट्स एक बग को ठीक करने के लिए जहां Aएक स्ट्रिंग के अंत में R-चंगे को -चेंज के रूप में प्रदर्शित किया जाएगा}

— Laikoni
स्रोत

योग्य यह बनाता है कि उपयोगकर्ताओं को लगता है कि यह 1 बाइट है

— हाइपरनेट्रोइनो

8

जावास्क्रिप्ट (ईएस 6), 413 ... 343 342 बाइट्स

लूप सूचकांकों को ट्विट करके 5 बाइट्स बचाए, जैसा कि @KevinCruijssen द्वारा सुझाया गया है

करी सिंटैक्स में 2 स्ट्रिंग्स के रूप में इनपुट लेता है। 3 स्ट्रिंग्स की एक सरणी देता है।

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

परीक्षण के मामलों

कोड स्निपेट दिखाएं

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

स्निपेट का विस्तार करें

कम गोल्फ वाला

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

उदाहरण

नीचे b = "foo" और a = "ok" के लिए प्रारंभिक मैट्रिक्स है :

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

और यहाँ सभी पुनरावृत्तियों के बाद अंतिम मैट्रिक्स है:

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

लेवेंसहाइट दूरी के साथ अंतिम संशोधन स्ट्रिंग नीचे-दाएं सेल में संग्रहीत किया जाता है।

— Arnauld
स्रोत

उसी परिवर्तन को मैंने 1 बाइट को बचाने के लिए 1 / + 1 के बारे में सुझाव दिया था jऔर xअभी भी आपके नवीनतम संपादन पर लागू होता है:

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

:)

— केविन क्रूज़सेन

1

@ केविनक्रूजसेन I ने आपके विचार को एक कदम आगे ले जाकर 5 बाइट्स बचाए। धन्यवाद!

— अरनौलद

4

पायथन 2 , 548 536 484 500 ¹ 488 447 381 ² 373 371 357 350 बाइट्स

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

इसे ऑनलाइन आज़माएं!

के 'ARM_'बजाय का उपयोग करता है'ARM '

Levenshtein मैट्रिक्स का निर्माण करके काम करता है, ~~और फिर संचालन खोजने के लिए पीछे की ओर जाता है~~ । अब ऑपरेशन-स्ट्रिंग को उसी समय लेवेन्स्हेटीन मैट्रिक्स के रूप में बनाता है, जैसा कि अरनॉल्ड के जेएस उत्तर में है

_{1: अधिक बाइट्स, क्योंकि यह काम नहीं करता था यदि पहला स्ट्रिंग एकल वर्ण था।}

_{2: Levenshtein मैट्रिक्स में संयोजनों के निर्माण के लिए स्विच किया गया।}

— TFeld
स्रोत

+1 मेरे प्रारंभिक (असफल) प्रयास योग्य जैसे 6 वर्ण शब्दों के लिए 60 सेकंड से कम समय लेने के लिए

— HyperNeutrino

अच्छा उत्तर! मुझ से +1। चूँकि मैं पायथन में कभी भी कार्यक्रम नहीं करता, इसलिए मैं वास्तव में गोल्फिंग के साथ आपकी मदद नहीं कर सकता, सिवाय एक बात के: m+i+1हो सकता है m-~i।

— केविन क्रूज़सेन

आप लाइन 7. पर डबल स्पेस के बजाय एक टैब का उपयोग कर सकते हैं

— स्टीफन

आप एक लाइन में

while i+j<n+m:v,A=(L[i]+[m,m])[j:j+2];R,M=(L[i+1]+[m,m])[j:j+2];d=min(A,R,M);q=M==d or(R==d)*2;r+=' '*(d==v==M)or'AMR'[q];i+=q>0;j+=q<2

— वाइल

1

पायथन 2 , 310 बाइट्स

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])

इसे ऑनलाइन आज़माएं!

इसका उपयोग करना difflib.SequenceMatcherदो तारों के बीच एक संरेखण की गणना करता है

— mdahmoune
स्रोत

यह कुछ अन्य परीक्षण मामलों के लिए कुछ गलत परिणाम देता है। और अधिक विशेष:"This_is_an_example_text","This_is_a_test_as_example"

— केविन क्रूज़सेन

@ केविनक्रूजसेन थैंक्स, मैंने अभी इसे ठीक किया ^ _ ^

— mdahmoune

अच्छा लगा, जीजे! लेकिन उम्म .. तीसरा टेस्ट केस (और चौथा) भी दुर्भाग्य से गलत है। दो लाइनों में से एक को unmodified (अग्रणी / अनुगामी स्थानों को छोड़कर) किया जाना चाहिए। दोनों पंक्तियों में वर्तमान में बीच में रिक्त स्थान हैं।

— केविन क्रूज़सेन

@ केविनक्रूजसेन थैंक्स फिर, मैं इसे ठीक कर रहा हूं

— mdahmoune

1

गणितज्ञ, २५० 256 259 384 बाइट्स

~ जावा कोड केस के लिए 0.00035 सेकंड।

(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})&

उपयोग: f["ABCDE", "ABCDF"]

इसे ऑनलाइन आज़माएं!

कोड एक ऐसे तथ्य पर आधारित है जो SequenceAlignmentडिफ़ॉल्ट रूप से काम करता है

डिफ़ॉल्ट सेटिंग के साथ समानता-> स्वचालित, दो तत्वों के बीच प्रत्येक मैच कुल समानता स्कोर में 1 योगदान देता है, जबकि प्रत्येक बेमेल, सम्मिलन या विलोपन -1 योगदान देता है।

अर्थात्, स्कोरिंग की गणना M, Aऔर R, तदनुसार।

उदाहरण:

— कीउ गण
स्रोत

2

हम्म, मैंने कभी भी मैथेमेटिका में प्रोग्राम नहीं किया है, लेकिन क्या 2 बाइट्स को कम i="";o="";p="";करने के i="";o=i;p=i;लिए बदलना संभव नहीं है ?

— केविन क्रूज़सेन

2

किस बारे में i=o=p=""?

— डेविड

@DavidC हां मुझे इस बात का एहसास था और इसे पहले ही बदल दिया है। वैसे भी धन्यवाद

— Keyu Gan

1

डी , 351 345 बाइट्स

-6 बाइट्स केविनक्रूजसेन को बाइट्स

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;}

इसे ऑनलाइन आज़माएं!

— mdahmoune
स्रोत

आप अंतिम को हटाकर छह बाइट्स गोल्फ कर सकते हैं break;। +1 हालांकि, पहली बार मैं प्रोग्रामिंग भाषा डी।

— केविन क्रूज़सेन

मुझे बदलाव पसंद नहीं है!

इनपुट:

आउटपुट:

उदाहरण:

चुनौती नियम:

सामान्य नियम:

परीक्षण के मामलों:

हास्केल , 192 181 174 161 158 150 147 143 158 1 बाइट्स

स्पष्टीकरण:

जावास्क्रिप्ट (ईएस 6), 413 ... 343 342 बाइट्स

परीक्षण के मामलों

कम गोल्फ वाला

उदाहरण

पायथन 2 , 548 536 484 500 1 488 447 381 2 373 371 357 350 बाइट्स

पायथन 2 , 310 बाइट्स

गणितज्ञ, २५० 256 259 384 बाइट्स

डी , 351 345 बाइट्स

हास्केल , 192 181 174 161 158 150 147 143 158 ¹ बाइट्स

पायथन 2 , 548 536 484 500 ¹ 488 447 381 ² 373 371 357 350 बाइट्स