एक पैलिंड्रोम की सबसे छोटी हैमिंग दूरी जिसमें एक विकल्प है

Question

_{यह अब निकाले गए CS.SE प्रश्न से प्रेरित था ।}

कार्य

दो गैर-रिक्त इनपुट स्ट्रिंग्स A और B को देखते हुए, A से एक पैलिंड्रोम की सबसे छोटी दूरी को आउटपुट करता है जिसमें B एक विकल्प के रूप में होता है। दूरी को वर्ण प्रतिस्थापन ( हैमिंग दूरी ) की संख्या से परिभाषित किया गया है ।

प्रतिबंध

• संवेदनशील इनपुट: एक पैलिंड्रोम मौजूद है। इसका मतलब है | A | | | बी |
• ए और बी में केवल कम ASCII वर्ण होते हैं, लोअरकेस और अपरकेस अलग हैं (जैसा कि सभी अन्य वर्ण हैं)।
• यदि आपकी भाषा ASCII वर्णों के साथ व्यवहार नहीं कर सकती है, तो आप पूर्णांक (या कुछ अन्य उचित डेटा प्रकार) का उपयोग कर सकते हैं, और आप सीमा को 128 तत्वों तक सीमित करने का विकल्प चुन सकते हैं।
• आप स्टड, फ़ंक्शन तर्क, कमांड लाइन तर्क आदि से इनपुट ले सकते हैं।
• आप परिणाम स्टडआउट, रिटर्न वैल्यू आदि पर दे सकते हैं।
• आपको एक कामकाजी पैलिंड्रोम देने की आवश्यकता नहीं है, एक के लिए सबसे छोटी दूरी पर्याप्त है।

उदाहरण

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

स्कोरिंग

यह कोड गोल्फ है, बाइट्स जीत में सबसे छोटा कोड है।

Answer 1

पायथ, 19 बाइट्स

hSmsnVQd/#z_I#^+Qzl

प्रदर्शन

अत्यधिक क्रूर बल दृष्टिकोण। या तो स्ट्रिंग में वर्णों के साथ उपयुक्त लंबाई के सभी तारों को उत्पन्न करें, palindromes के लिए फ़िल्टर करें और दूसरे इनपुट को शामिल करने के लिए, पहले स्ट्रिंग से दूरी कम करने के लिए मानचित्र, आउटपुट सबसे छोटा।

स्पष्टीकरण:

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

Comments

कुछ ऐसा है जो मैंने सोचा था, लेकिन फैसला किया ओ ((एम + एन) ^ एन) बहुत ओ (बुरा) था। : डी

— पुरकाकूदरी

Answer 2

पायथ, 45 बाइट्स

hSmsnVQdf}zTsmm+hc2KsXcd+Bklz1z_hc2PKh-lQlz_B

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

मैं अभी भी पूरी तरह से संतुष्ट नहीं हूँ कि यह कैसे निकला। लेकिन कम से कम अब स्पष्टीकरण के बिना समझना काफी कठिन है। (सफलता, मुझे लगता है?)

व्याख्या

• ए के रूप में Qऔर बी के रूप में ले लो z।
• m… _BQए और इसके विपरीत दोनों के लिए निम्न की गणना करें d:
  • m… 0 से समावेशी के h-ldlzलिए सभी की गणना करें : klen(A) - len(B)
    • +Bklzजोड़ी पाइए k, k + len(B)।
    • cddउन सूचकांकों पर विभाजित करें ।
    • X… 1zB के साथ दूसरा (मध्य) भाग बदलें।
    • Ksटुकड़े टुकड़े और बचाने के लिए K। B को अब kA या इसके विपरीत स्थिति में डाला गया है ।
    • hc2परिणामस्वरूप स्ट्रिंग को दो में विभाजित करें और पहला टुकड़ा रखें। यह संभव मध्य चरित्र के साथ स्ट्रिंग का आधा हिस्सा देता है।
    • hc2PKपहला पात्र रखते हुए, अंतिम वर्ण निकालें और समान विभाजन करें। यह संभव मध्य चरित्र के बिना स्ट्रिंग का आधा हिस्सा देता है।
    • +… _छोटे टुकड़े को लंबे टुकड़े में उल्टा जोड़ दें। अब हमारे पास एक palindrome है।
• s ए और उसके रिवर्स के लिए परिणामों को समेटें।
• f}zT उन सभी तारों को हटा दें जिनमें बी नहीं है।
• mसभी परिणामी तारों के लिए निम्नलिखित की गणना करें d:
  • nVQd ए के साथ जोड़ीदार असमानता प्राप्त करें। यह जोड़े के लिए सच है जिन्हें बदलने की आवश्यकता है।
  • sसूची में शामिल हों। इससे हेमिंग को दूरी मिलती है।
• hS न्यूनतम परिणाम लें।

Answer 3

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30+), 152 146 बाइट्स

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

जानवर बल दृष्टिकोण: ए और बी के प्रत्येक संभावित ओवरलैप उत्पन्न करते हैं, प्रत्येक को एक ताल में बनाते हैं, ए से हैमिंग दूरी की गणना करते हैं, और परिणामी दूरी की सबसे छोटी लेते हैं।

शायद थोड़ा और गोल्फ हो सकता है ...

टेस्ट स्निपेट

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>