रनिंग जीन क्रॉसओवर एल्गोरिथम

Question

आपका कार्य इनपुट दो जीन अनुक्रमों के रूप में स्वीकार करना है, और "क्रॉस ओवर पॉइंट्स" का एक क्रम है, और संकेतित क्रॉस ओवरों के परिणामस्वरूप जीन अनुक्रम को वापस करना है।

क्या मैं इस से मतलब है, आप दृश्यों है कहना है [A, A, A, A, A, A, A]और [Z, Z, Z, Z, Z, Z, Z], और के अंक को पार 2और 5। परिणामी अनुक्रम होगा [A, A, Z, Z, Z, A, A], क्योंकि:

यहां क्रॉस करें: वी.वी.
संकेत: 0 1 2 3 4 5 6

जीन 1: AAAAAAA
जीन 2: ZZZZZZZ

परिणाम: AAZZZAA
              ^ ^

ध्यान दें कि जब मैं स्पष्टता के लिए यहां पत्र का उपयोग कर रहा हूं, वास्तविक चुनौती जीन के लिए संख्याओं का उपयोग करती है।

जब तक एक क्रॉस ओवर पॉइंट का सामना नहीं किया जाता है तब तक परिणाम पहला अनुक्रम होता है, फिर परिणाम दूसरे अनुक्रम से लेता है जब तक कि एक और क्रॉस ओवर प्वाइंट का सामना नहीं किया जाता है, तब परिणाम पहले अनुक्रम से लेता है जब तक कि एक क्रॉस ओवर पॉइंट का सामना नहीं किया जाता है ...

इनपुट:

• इनपुट कोई भी उचित रूप हो सकता है। दो अनुक्रम एक जोड़ी हो सकते हैं, दूसरे तर्क के रूप में अंक के साथ, तीनों अलग-अलग तर्क हो सकते हैं, एक एकल ट्रिपल (genes 1, genes 2, cross-points), नाम की चाबियाँ के साथ एक नक्शा ...

• क्रॉस पॉइंट हमेशा क्रम में होंगे, और हमेशा इनबाउंड होंगे। डुप्लिकेट अंक नहीं होंगे, लेकिन क्रॉस ओवर पॉइंट की सूची खाली हो सकती है।

• जीन अनुक्रम हमेशा एक ही लंबाई के होंगे, और गैर-खाली होंगे।

• संकेत 0 या 1 आधारित हो सकते हैं।

• जीन हमेशा 0-255 की रेंज में नंबर होंगे।

• इससे कोई फर्क नहीं पड़ता कि कौन सा तर्क "जीन 1" या "जीन 2" है। अंकों के पार नहीं होने की स्थिति में, परिणाम या तो पूरी तरह से "जीन 1" या "जीन 2" हो सकता है।

---

उत्पादन

• आउटपुट कोई भी उचित रूप हो सकता है जो अस्पष्ट नहीं है। यह संख्याओं की एक सरणी / सूची, स्ट्रिंग संख्याओं की एक सरणी, संख्याओं का एक सीमांकित स्ट्रिंग (कुछ गैर-संख्यात्मक वर्ण संख्याओं को अलग करना होगा) हो सकता है ...

• इसे वापस किया जा सकता है या एसटीडी-आउट के लिए मुद्रित किया जा सकता है।

---

प्रविष्टियाँ पूर्ण कार्यक्रमों या कार्यों द्वारा की जा सकती हैं।

---

परीक्षण के मामले (genes 1, genes 2, cross points) => result:

[0], [1], [0] => [1]
[0, 1], [9, 8], [1] => [0, 8]
[0, 2, 4, 6, 8, 0], [1, 3, 5, 7, 9, 1], [1, 3, 5] => [0, 3, 5, 6, 8, 1]
[1, 2, 3, 4], [5, 6, 7, 8], [] => [1, 2, 3, 4]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 2, 3, 6, 8] => [1, 1, 0, 1, 1, 1, 0, 0, 1, 1]

यह कोड गोल्फ है।

Comments

यदि आपका क्रॉसओवर इंडेक्स अनुक्रमों में भी तत्व नहीं थे तो आपका काम किया गया उदाहरण थोड़ा स्पष्ट होगा।

— झबरा

फिक्स्ड। इसे ए और जेड के रूप में बदल दिया। आशा है कि यह स्पष्ट है।

— २०:२२ पर मारक

Answer 1

जेली , 12 10 बाइट्स

ṁ⁹L‘¤ḣ"ḷ"/

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

तर्क 1: seq1, seq2
तर्क 2: क्रॉस अंक (0-अनुक्रमित)

Comments

एक कारण था ... यह एक परीक्षण के मामलों के लिए काम नहीं करता है !

— जोनाथन एलन

अन्य परिदृश्यों में भी विफल रहता है, उदाहरण के लिए

— जोनाथन एलन

ऐसा लगता है कि कुछ की ;⁹ZL‘¤Ṭ+\ịŒDḢआवश्यकता होगी :(

— जोनाथन एलन

@JonathanAllan मैं वास्तव में एक 12-बाइट संस्करण खोजने में कामयाब रहा जो आपने सुझाया था। :)

— Out पर आउटगॉल्फ

@JonathanAllan ... और फिर मैंने एक पूरी तरह से अलग-अलग 10-बाइट संस्करण की खोज की, जो आपके लिंक और दूसरे परीक्षण मामले (आराम करो, मुझे 0-आधारित अनुक्रमण में बदलने के लिए याद है) के साथ जाँच की। : D

— द एग्री द आउटग्राफर

Answer 2

हास्केल, 58 53 51 45 बाइट्स

(fst.).foldl(\(a,b)p->(take p a++drop p b,a))

दो जीन अनुक्रमों को सूचियों की एक जोड़ी के रूप में लिया जाता है और दूसरे तर्क के रूप में क्रॉस अंक।

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

foldl           -- fold the pair of genes into the list of
                -- cross points and on each step
    \(a,b) p -> -- let the pair of genes be (a,b) and the next cross point 'p'
      (take p a++drop p b,a)  
                -- let 'b' the new first element of the pair, but
                --   drop the first 'p' elements and 
                --   prepend the first 'p' elements of 'a'
                -- let 'a' the new second element 
fst             -- when finished, return the first gene   

Answer 3

जावास्क्रिप्ट (ईएस 6), 47 45 बाइट्स

सहेजे गए 2 बाइट्स @ETHproductions की बदौलत

एक ट्रिपलेट के रूप में इनपुट लेता है [ए, बी, सी] जहां ए और बी जीन अनुक्रम हैं और सी 0-अनुक्रमित क्रॉस-पॉइंट की सूची है।

x=>x[i=j=0].map(_=>x[(j+=x[2][j]==i)&1][i++])

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

टिप्पणी की गई

x =>                    // given x = [ geneSeqA, geneSeqB, crossPoints ]
  x[i = j = 0]          // initialize i = gene sequence pointer and j = cross point pointer
  .map(_ =>             // for each value in the first gene sequence:
    x[(                 //   access x[]
      j += x[2][j] == i //     increment j if i is equal to the next cross point
    ) & 1]              //   access either x[0] or x[1] according to the parity of j
    [i++]               //   read gene at x[0][i] or x[1][i]; increment i
  )                     // end of map()

Comments

मेरा मानना ​​है कि आप कुछ x[(j+=x[2][j]==i)%2][i++]बाइट्स को बचाने के लिए कुछ कर सकते हैं ।

— ETHproductions

@ETHproductions धन्यवाद! मैंने मूर्खता से x [2] में सूचक का ट्रैक रखने के लिए एक 3 चर जोड़ने की कोशिश की, लेकिन इस अनुकूलन को अनदेखा कर दिया।

— अरनुलद

Answer 4

एपीएल (डायलॉग 16.0) , 26 बाइट्स

+/a⎕×(~,⊢)⊂≠\d←1@⎕⊢0⍴⍨≢a←⎕

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

इनपुट ए , सी , बी है । c को 1अनुक्रमित किया गया है।

कैसे?

a←⎕- एक प्राप्त करें ।

0⍴⍨≢- 0इसकी लंबाई पर सरणी बनाएँ ।

1@⎕⊢- सी लें और सूचकांकों पर 0एस को बदल दें 1।

d← - को आवंटित d ।

⊂≠\d- विस्तार घ के साथ XOR चयन अनुक्रम (बनाने के लिए 0के लिए एक , 1के लिए ख ), और संलग्न करें।

(~,⊢)- d और इसका विलोम लें।

a⎕×- और क्रमशः बी और ए के साथ गुणा करें ।

+/- तत्वों की प्रत्येक जोड़ी के योग, उपज एक पर रों 0रों और ख पर रों 1रों।

Comments

⊢0⍴⍨≢-> ≠⍨( टिप )

— ngn

@ भाषा मुझे काम करने के लिए नहीं मिल सकती है [tio ]

— Uriel

आपको ,इनपुट में 1-तत्व वैक्टर से पहले की आवश्यकता है

— ngn

Answer 5

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

def f(a,b,l):
 for p in l:a[p:],b=b[p:],a*1

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

तर्क को संशोधित करके आउटपुटa । कार्यक्रम के बजाय:

50 बाइट्स

a,b,l=input()
for p in l:a[p:],b=b[p:],a*1
print a

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

Answer 6

पर्ल 5 -a , 45 40 बाइट्स

इनपुट को "कंट्रोल", "सेकंड सीक्वेंस", "फर्स्ट सीक्वेंस" को STDIN पर अलग-अलग लाइनों के रूप में दें

#!/usr/bin/perl -alp
@{$.}=@F}for(map${$.^=$%~~@1}[$%++],@2){

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

Answer 7

जे , 24 बाइट्स

4 :'(2|+/\1 x}I.#{.y)}y'

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

मेरी गिनती नहीं है f=: वर्णों की , क्योंकि यह एक अनाम फ़ंक्शन के रूप में समान रूप से अच्छी तरह से काम करता है (जैसा कि एक TIO नमूने में दिखाया गया है)

नोट: यह क्रॉस ओवर पॉइंट की खाली सूची के लिए काम नहीं करता है!

एक स्पष्ट ऑनलाइनर, xबाएं तर्क है - क्रॉस ओवर पॉइंट की सूची,y सही तर्क है, अनुक्रमों की दो-पंक्ति तालिका।

स्पष्टीकरण:

4 :' ... ' - एक रंजक क्रिया

(...)}y - ऑपरेंड (...) का प्रत्येक परमाणु y की वस्तुओं के संगत पदों से एक परमाणु का चयन करता है

#{.y - पहला क्रम लेता है और इसकी लंबाई ज्ञात करता है

    #{. 0 2 4 6 8 0,: 1 3 5 7 9 1
6

I. तर्क लंबाई के साथ शून्य की एक सूची बनाता है

   I.6
0 0 0 0 0 0

1 x}संकेत दिए गए सूचकांकों पर x( 1 से अधिक cors की सूची) में कठोर तर्क (शून्य की एक सूची) की वस्तुओं को बदलता है

   1(1 3 5)}I.6
0 1 0 1 0 1

+/\ एक सूची के चल रहे रकम

   +/\ 0 1 0 1 0 1
0 1 1 2 2 3

2| modulo 2

   2|+/\ 0 1 0 1 0 1
0 1 1 0 0 1

इकट्ठे:

    0 1 1 0 0 1 } 0 2 4 6 8 0 ,: 1 3 5 7 9 1
0 3 5 6 8 1

Answer 8

आर , 84 79 बाइट्स

function(G,K){o=G[,1]
m=1:nrow(G)
for(i in K)o[m>=i]=G[m>=i,match(i,K)%%2+1]
o}

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

2 कॉलम और a के मैट्रिक्स के रूप में इनपुट लेता है vector।

Answer 9

पायथन 3, 61 60 बाइट्स

f=lambda a,b,c,d=0:c and a[d:c[0]]+f(b,a,c[1:],c[0])or a[d:]

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

जोनाथन फ्रेच से -1 बाइट

स्पष्टीकरण:

f=lambda a,b,c,d=0:c and a[d:c[0]]+f(b,a,c[1:],c[0])or a[d:]
f=lambda a,b,c,d=0:
 # recursive lambda: a and b are the two lists,
 # c is the crossovers, and d is where to start
                   c and
 # if there is at least one crossover left
 #  then
                         a[d:c[0]]
 #  return the items of the first list from the
 #  starting point up to the first crossover
                                  +f(b,a,c[1:],c[0])
 #  plus the result of the inverted lists with
 #  the remaining crossovers, starting where
 #  the first part left off
                                                    or
 # else
                                                       a[d:]
 #  the first list from the starting point to the end

Comments

60 बाइट्स संभव ; यह मानते हुए कि a[d:c[0]]+f(b,a,c[1:],c[0])कभी भी गलत नहीं होगा।

— जोनाथन फ्रीच

Answer 10

जेली , 13 बाइट्स

ṬœṗЀż/JḂị"ƊF

(1-अनुक्रमित) क्रॉसओवर को बाईं ओर एक डाइएडिक लिंक और दाईं ओर दो अनुक्रमों की एक सूची को स्वीकार करता है जो परिणामी सूची देता है।

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

कैसे?

ṬœṗЀż/JḂị"ƊF - Link: list, C; list, S     e.g. [2,4,6]; [[0,2,4,6,8,0],[1,3,5,7,9,1]]
Ṭ             - untruth C                       [0,1,0,1,0,1]
   Ѐ         - map across S with:
 œṗ           -   partition at truthy indices   [[0],[2,4],[6,8],[0]]  /  [[1],[3,5],[7,9],[1]]
      /       - reduce with:
     ż        -   zip                           [[[0],[1]],[[2,4],[3,5]],[[6,8],[7,9]],[[0],[1]]]
           Ɗ  - last three links as a monad:
       J      -   range of length               [1,2,3,4]
        Ḃ     -   bit (modulo by 2)             [1,0,1,0]
          "   -   zip with:
         ị    -     index into                  [[0],[3,5],[6,8],[1]]
            F - flatten                         [0,3,5,6,8,1]

Comments

@Carcigenicate - धन्यवाद मैं सिर्फ पूछने के बाद देखा: डी

— जोनाथन एलन

Ḃ: 2-तत्व सूची में अनुक्रमण के लिए क्या बेकार बात है। ż/: कैसे एक जटिलता के बेकार, यह क्रूरता से दूर एक बड़े ट्रक द्वारा चपटा है!

— आउटगॉल्फ

Answer 11

चारकोल , 19 बाइट्स

ＡθＡηＥ§θ⁰§§θＬΦ⊕κ№ηλκ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्ट्रिंग जीन अनुक्रमों की एक जोड़ी के रूप में इनपुट लेता है और क्रॉसिंग बिंदुओं की एक 0-अनुक्रमित सूची है। स्पष्टीकरण:

Ａθ                  Input the pair of gene sequences into `q`
  Ａη                Input the list of crossing points into `h`
    Ｅ§θ⁰            Loop over one of the gene sequences
              κ     Current index
             ⊕      Incremented
            Φ  №ηλ  Intersect implicit range with crossing points
           Ｌ        Take the length
         §θ         Cyclically index into the pair of gene sequences
        §         κ Take the appropriate element of that sequence
                    Implicitly output on separate lines

वैकल्पिक रूप से, परिणाम को स्ट्रिंग के रूप में प्रिंट करने के ⭆लिए सब्सक्राइब किया जा सकता है Ｅ। इसे ऑनलाइन आज़माएं!

Answer 12

एसडब्ल्यूआई-प्रोलॉग, 78 बाइट्स

A/B/[0|C]/D:-B/A/C/D. [H|A]/[_|B]/C/[H|D]:-maplist(succ,E,C),A/B/E/D. A/_/_/A.

उपयोग: कॉल "Genes1 / Genes2 / CrossoverPoints / X" जहां "Genes1", "Genes2", "CrossoverPoints" ब्रैकेट-संलग्न, अल्पविराम से अलग की गई सूचियाँ हैं।

Answer 13

सी (क्लैंग) , 79 बाइट्स

*g[2],*c,l,m;f(i,j,k){for(i=j=k=0;i<l;g[0][i++]=g[k][i])m&&c[j]==i?k=!k,j++:0;}

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

इनपुट्स:
g[0]जीन-अनुक्रम 1 है,
g[1]जीन-अनुक्रम 2 है,
cक्रॉस-ओवर अंक है।
lकी लंबाई है g[0]और सभी ऐरे इनपुट्स g[1]
mकी लंबाई है c
0-आधारित इंडेक्स के साथ पूर्णांकों की सरणियाँ।

आउटपुट:
आउटपुट को स्टोर किया जाता हैg[0]

मैक्रो a () फुटर में टेस्ट-केस और रिजल्ट की सुंदर प्रिंटिंग करता है