सबसे लंबे समय तक उलट पलिंडोमिक डीएनए सबस्ट्रिंग

Question

जैसा कि आप जानते हैं, डीएनए में चार आधार होते हैं - एडेनिन ( A), साइटोसिन ( C), गुआनिन ( G) और थाइमिन ( T)। आमतौर पर Aके साथ बांड Tऔर Cसाथ बांड G, की "पायदान" बनाने डीएनए डबल हेलिक्स संरचना ।

हम एक आधार के पूरक को परिभाषित करते हैं कि यह किस आधार पर बंधता है - यानी का पूरक Aहै T, का पूरक Tहै A, का पूरक Cहै Gऔर का पूरक Gहै C। हम एक डीएनए स्ट्रिंग के पूरक को भी परिभाषित कर सकते हैं कि प्रत्येक आधार के साथ स्ट्रिंग हो, जैसे कि पूरक GATATCहै CTATAG।

डीएनए के दोहरे फंसे हुए ढांचे की वजह से, एक स्ट्रैंड के आधार दूसरे स्ट्रैंड के आधारों के पूरक हैं। हालाँकि डीएनए की एक दिशा होती है, और दो तरफ़ विपरीत दिशाओं में डीएनए ट्रांसक्रिप्शन होता है। इसलिए आणविक जीवविज्ञानी अक्सर डीएनए स्ट्रिंग के रिवर्स पूरक में रुचि रखते हैं - काफी शाब्दिक रूप से स्ट्रिंग के पूरक के रिवर्स।

हमारे पिछले उदाहरण का विस्तार करने के लिए, का उल्टा पूरक पीछे GATATCकी CTATAGओर है, इसलिए GATATC। जैसा कि आपने देखा होगा, इस उदाहरण में रिवर्स पूरक मूल स्ट्रिंग के बराबर है - हम ऐसे स्ट्रिंग को रिवर्स पैलिंड्रोम कहते हैं । *

डीएनए की एक स्ट्रिंग को देखते हुए, क्या आप सबसे लंबे प्रतिस्थापन को पा सकते हैं जो एक रिवर्स पैलिंड्रोम है?

^{* मैं रोज़लिंड से लिया गया "रिवर्स पलइंड्रोम" शब्द का उपयोग करता हूं , ताकि ताल के सामान्य अर्थ से अंतर किया जा सके।}

---

इनपुट

इनपुट एक एकल स्ट्रिंग होगी जिसमें ACGTऊपरी मामले में केवल वर्ण होंगे । आप इस चुनौती के लिए एक कार्य या पूर्ण कार्यक्रम लिख सकते हैं।

उत्पादन

आप मुद्रण या रिटर्न के माध्यम से आउटपुट का चयन कर सकते हैं (बाद वाला विकल्प केवल फ़ंक्शन के मामले में उपलब्ध है)।

यदि कोई अनूठा समाधान है, तो आपके प्रोग्राम को इनपुट स्ट्रिंग के सबसे लंबे समय तक रिवर्स पैलिंड्रोमिक आउटपुट का उत्पादन करना चाहिए। यदि कई समाधान मौजूद हैं, तो आप उनमें से किसी एक को या सभी को (आपकी पसंद) आउटपुट कर सकते हैं। यदि आप उन सभी को आउटपुट करना चुनते हैं तो डुप्लिकेट ठीक है।

इनपुट की गारंटी है कि कम से कम लंबाई 2 का समाधान होना चाहिए।

काम का उदाहरण

ATGGATCCG -> GGATCC

का उल्टा पूरक GGATCCस्वयं ( GGATCC --complement--> CCTAGG --reverse--> GGATCC) है, इसलिए GGATCCएक उल्टा ताल है। GATCयह भी एक उल्टा ताल है, लेकिन यह सबसे लंबा नहीं है।

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

AT -> AT
CGT -> CG
AGCA -> GC
GATTACA -> AT, TA
ATGGATCCG -> GGATCC
CCCCCGGGGG -> CCCCCGGGGG
ACATATATAGACT -> ATATAT, TATATA
ATTCGATCTATGTAAAGAGG -> TCGA, GATC
CGCACGTCTACGTACCTACGTAG -> CTACGTAG
TCAATGCATGCGGGTCTATATGCAT -> ATGCAT, GCATGC [, ATGCAT]
CGCTGAACTTTGCCCGTTGGTAGAACGGACTGATGTGAACGAGTGACCCG -> CG, GC, TA, AT [, GC, CG, CG, CG, CG]
CTCGCGTTTGCATAACCGTACGGGCGGAACAGTCGGCGGTGCCTCCCAGG -> CCGTACGG

स्कोरिंग

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

Comments

यह अच्छा होता अगर इन सभी की छपाई में किसी न किसी तरह का बोनस होता।

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र उन सभी को प्रिंट करने की तुलना में सिर्फ सबसे लंबे समय तक प्रिंट करना मुश्किल नहीं है?

— ट्राइकोप्लाक्स 15

या क्या आप सभी सबसे लंबे समय तक छपाई का मतलब है?

— ट्राइकोप्लाक्स

@githubphagocyte हाँ, आपकी दूसरी टिप्पणी।

— अनुकूलक

Answer 1

पायथ, 37 36 28 24 बाइट्स

ef&}TzqmaCd6T_mx4aCk6Tyz

FryAmTheEggman और पीटर से रिवर्स पैलिंड्रोम चेक ट्रिक के सुझावों को मिलाकर, यह एक सुपर शॉर्ट वर्जन है।

हालाँकि, यह केवल Pyth 3.0.1 के साथ काम करता है जिसे आप इस लिंक से डाउनलोड कर सकते हैं और पसंद कर सकते हैं

python3 pyth.py -c "ef&}TzqmaCd6T_mx4aCk6Tyz" <<< "ATTCGATCTATGTAAAGAGG"

(linux bash only। खिड़कियों पर, <<< की जगह एंटर दबाएं और फिर इनपुट टाइप करें)

---

यह मेरा पिछला सबमिशन है - 28 बाइट्स सॉल्यूशन

J"ACGT"ef&}TzqTjk_m@_JxJdTyz

इस संस्करण के लिए FryAmTheEggman को धन्यवाद। यह एक इनपुट डीएनए स्ट्रिंग के सभी संभावित सबसेट बनाता है, सबसेट को इस शर्त पर फ़िल्टर करता है कि सबसेट इनपुट का एक विकल्प है और ट्रांसफ़ॉर्म का रिवर्स सबसेट के बराबर है।

सभी संभावित उप-निर्माण के कारण, यह पीटर के जवाब से भी अधिक स्मृति लेता है।

---

यह मेरा पहला सबमिशन है - 36 बाइट समाधान।

J"ACGT"eolNfqTjk_m@_JxJdTm:zhkek^Uz2

यह मेरे सीजेएम उत्तर का सटीक अनुवाद है । मैं उम्मीद कर रहा था कि यह बहुत छोटा होगा लेकिन पता चलता है कि अनुवाद विधि की कमी ने इसे लगभग समान आकार दिया (अभी भी 2 बाइट्स छोटे हैं)

इसे यहाँ ऑनलाइन आज़माएँ

Comments

Uzके बराबर है Ulz।

— isaacg

J"ACGT"eolNf&}TzqTjk_m@_JxJdTyzyसबसेट का उपयोग करना और फिर ऐसे तारों को छानना जो zकम नहीं होते हैं: :)

— FryAmTheEggman

ओह, और यदि आप ऐसा करते हैं, तो आपको yक्रमबद्ध करने की आवश्यकता नहीं है क्योंकि पहले से ही लंबाई के अनुसार क्रमबद्ध है। आप बस कर सकते हैंef...

— FryAmTheEggman

Answer 2

GolfScript ( 35 34 बाइट्स)

]{{..(;\);}%)}do{{6&}%.{4^}%-1%=}?

परीक्षण प्रयोजनों के लिए आप उपयोग करना चाह सकते हैं

]{{..(;\);}%.&)}do{{6&}%.{4^}%-1%=}?

जो .&डुप्लिकेट प्रयास को कम करने के लिए एक जोड़ता है ।

विच्छेदन

]{         # Gather string into an array and do-while...
  {        #   Map over each string in the array
    ..     #     Make a couple of copies of the string
    (;     #     Remove the first character from one of them
    \);    #     Remove the last character from the other
  }%
  )        #   Extract the last string from the array
}do        # Loop until that last string is ''
           # Because of the duplication we now have an array containing every substring
           # of the original string, and if we filter to the first occurrence of each
           # string then they're in descending order of length
{          # Find the first element in the string satisfying the condition...
  {6&}%    #   Map each character in the string to its bitwise & with 6
  .{4^}%   #   Duplicate, and map each to its bitwise ^ with 4
           #   This serves to test for A <-> T, C <-> G
  -1%=     #   Reverse and test for equality
}?

Comments

q{]{__(;\);}%~}h]{:c:i6f&_4f^W%=}=CJam में। एक माप। 7 लंबाई इनपुट से अधिक के लिए ऑनलाइन कंपाइलर में इसे आज़माएं नहीं

— ऑप्टिमाइज़र

Answer 3

CJam, 39 38 बाइट्स

मुझे यकीन है कि इसे आगे बढ़ाया जा सकता है ...

q:Q,,_m*{~Q<>}%{,~}${_"ACGT"_W%erW%=}=

एसटीडीआईएन से डीएनए स्ट्रिंग लेता है और एसटीडीयूएसटी के लिए सबसे लंबे समय तक रिवर्स पैलिंड्रोमिक डीएनए को आउटपुट करता है

इसे यहाँ ऑनलाइन आज़माएँ

(स्पष्टीकरण जल्द ही) (बचाया 1 बाइट पीटर के लिए धन्यवाद)

Answer 4

पायथन 3, 125 चार्ट

S=input()
l=[]
while S:
 s=_,*S=S
 while s:l+=[s]*all(x+y in"ATA CGC"for x,y in zip(s,s[::-1]));*s,_=s
print(*max(l,key=len))

देखो माँ, कोई अनुक्रमण नहीं! (ठीक है, स्ट्रिंग को उलटने के अलावा, जो गिनती नहीं करता है।)

सब्सट्रेटिंग में फेरबदल तारांकित असाइनमेंट का उपयोग करके सामने और अंत से चार्ट को हटाकर किया जाता है । बाहरी लूप शुरू करने के लिए पात्रों को हटाता है S, और इस तरह के प्रत्येक प्रत्यय के लिए, sइसके सभी उपसर्गों पर लूप करता है, उन्हें एक-एक करके परीक्षण करता है।

रिवर्स पलिंड्रोम के लिए परीक्षण कोड द्वारा किया जाता है

all(x+y in"ATA CGC"for x,y in zip(s,s[::-1]))

जो यह जांचता है कि प्रत्येक प्रतीक और उसके उलटे-सीधे समकक्ष "एटी", "टीए", "सीजी" और "जीसी" में से एक हैं। मुझे एक सेट-बेस्ड सॉल्यूशन मिला, जो एक कैरेक्टर को छोटा करता था, लेकिन जब इस्तेमाल किया जाता है, तो बाहरी पारे की आवश्यकता पर दो चार्ट खो देता है।

set(zip(s,s[::-1]))<=set(zip("ACTG","TGAC"))

यह अभी भी लगता है कि इसे छोटा किया जा सकता है।

अंत में, सबसे लंबा पलिंडोम छपा हुआ है।

print(*max(l,key=len))

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

Comments

मैं इस प्रश्न के साथ और अधिक लचीला होना चाहता था इसलिए मैंने बंधे हुए समाधानों के लिए एक सटीक आउटपुट प्रारूप निर्दिष्ट नहीं किया। यदि यह स्पष्ट है कि समाधान क्या हैं तो यह ठीक है, इसलिए एक सूची ठीक है।

— Sp3000

Answer 5

जे (45)

{.@(\:#&.>)@,@(('ACGT'&(|.@]-:[{~3-i.)#<)\\.)

यह एक फ़ंक्शन है जो एक स्ट्रिंग लेता है:

   {.@(\:#&.>)@,@(('ACGT'&(|.@]-:[{~3-i.)#<)\\.) 'ATGGATCCG'
┌──────┐
│GGATCC│
└──────┘

स्पष्टीकरण:

{.@(\:#&.>)@,@(('ACGT'&(|.@]-:[{~3-i.)#<)\\.) 

              (                          \\.)  for each prefix of each suffix
               (                      #<)      include the argument if,
                        |.@]                      its reverse
                            -:                    is equal to
                'ACGT'&(      [{~3-i.)            the complement
            ,@                                 ravel
   (\:#&.>)@                                   sort by length of item
{.@                                            take the first one   

Answer 6

पर्ल - 59 बाइट्स

#!perl -p
$_=$_[~!map$_[length]=$_,/((.)(?R)?(??{'$Q5'^$+.-$+}))/gi]

शेबंग को एक के रूप में गिना, इनपुट से लिया गया है STDIN।

नमूना उपयोग:

$ echo CTCGCGTTTGCATAACCGTACGGGCGGAACAGTCGGCGGTGCCTCCCAGG | perl dna.pl
CCGTACGG

Answer 7

पायथन 2 - 177 बाइट्स

s=raw_input()
r,l,o=range,len(s),[]
for a in[s[i:j+1]for i in r(l)for j in r(i,l)]:q=['TC GA'.index(c)-2for c in a];o+=[a if[-n for n in q][::-1]==q else'']
print max(o,key=len)

सरल पाशविक बल। वास्तविक "रिवर्स पैलिंड्रोमिक" चेक एकमात्र दिलचस्प हिस्सा है। यहाँ इसे और अधिक आसानी से लिखा गया है:

check = ['TC GA'.index(c)-2 for c in substring]
if [-n for n in check][::-1] == check:
    # substring is reverse palindromic

मैं हर संभव विकल्प पर ऐसा करता हूं और अगर यह सच है तो उन्हें एक सूची में डाल दें। अगर यह गलत है, मैं इसके बजाय एक खाली स्ट्रिंग में डाल दिया। जब सभी जाँच हो जाती हैं तो मैं सूची का सबसे लंबा तत्व आउटपुट करता हूँ। मैंने एक खाली स्ट्रिंग का उपयोग किया क्योंकि यह कुछ भी नहीं डालने पर बाइट्स को बचाता है, लेकिन इसका मतलब यह भी है कि अगर कोई समाधान नहीं है तो कार्यक्रम चोक नहीं करेगा। यह एक खाली लाइन को आउटपुट करता है और इनायत से बाहर निकलता है।

Comments

यह छोटा लगता है अगर आप एक ही सूची में सब कुछ smoosh करते हैं। मुझे तर्क को थोड़ा बदलना पड़ा, लेकिन मुझे 162 मिले s=raw_input();r,l,g=range,len(s),'TGCA';print max([a for a in[s[i:j+1]for i in r(l)for j in r(i,l)]if[g[n]for n in[~g.find(c)for c in a]]==list(a)[::-1]],key=len)। इसके अलावा, तार के लिए, का उपयोग findअधिक index:)

— FryAmTheEggman