Göreviniz girdi iki gen sekansı ve bir "çapraz geçiş noktaları" sekansı olarak kabul etmek ve belirtilen çapraz aşımlardan kaynaklanan gen sekansını döndürmektir.

Ne mi demek istiyorsunuz siz dizilerine sahip söylüyorlar [A, A, A, A, A, A, A]ve [Z, Z, Z, Z, Z, Z, Z]ve noktaları üzerinde çapraz 2ve 5. Ortaya çıkan dizi şöyle olacaktır [A, A, Z, Z, Z, A, A], çünkü:

Buraya Geç: VV
Endeksler: 0 1 2 3 4 5 6

Genes 1: AAAAAAA
Genler 2: ZZZZZZZ

Sonuç: AAZZZAA
              ^ ^

Burada netlik için harfleri kullanırken, asıl zorluğun genler için sayılar kullandığını unutmayın.

Sonuç, bir çapraz geçiş noktasıyla karşılaşılana kadar ilk sekanstır, daha sonra sonuç, ikinci bir sekanstan başka bir çapraz nokta ile karşılaşılana kadar alır, daha sonra sonuç, bir çapraz nokta ile karşılaşılana kadar ilk sekanstan alınır ...

Giriş:

• Girdi makul bir form olabilir. İki dizi, ikinci argüman olarak noktaları olan bir çift olabilir, üçü de ayrı argümanlar, tek bir üçlü, (genes 1, genes 2, cross-points)adlandırılmış tuşları olan bir harita olabilir ...

• Çapraz noktalar her zaman düzenli olacak ve her zaman gelen olacaktır. Yinelenen noktalar olmayacak, ancak geçiş noktalarının listesi boş olabilir.

• Gen dizileri her zaman aynı uzunlukta olacak ve boş olmayacaktır.

• Endeksler 0 veya 1 tabanlı olabilir.

• Genler daima 0-255 aralığında sayılar olacaktır.

• Hangi argümanın "gen 1" veya "gen 2" olduğu önemli değildir. Kesişme noktalarının olmaması durumunda, sonuç ya tamamen "genler 1" ya da "genler 2" olabilir.

Çıktı

• Çıktı, belirsiz olmayan herhangi bir makul form olabilir. Bir dizi / sayı listesi, bir dizi dize numarası, sınırlandırılmış bir sayı dizesi olabilir (sayısal olmayan bazı karakterler sayıları ayırmalıdır) ...

• İade edilebilir veya standart çıktıya yazdırılabilir.

Girişler tam program veya işlevlerle yapılabilir.

Test Durumları (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]

Bu Code Golf.

Jöle , 12 10 bayt

ṁ⁹L‘¤ḣ"ḷ"/

Çevrimiçi deneyin!

Bağımsız değişken 1: sıra 1, sıra
2 Bağımsız değişken 2: çapraz noktalar (0 dizinli)

Haskell, 58 53 51 45 bayt

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

İki gen dizisi bir çift liste olarak ve çapraz noktalar ikinci bir argüman olarak alınır.

Çevrimiçi deneyin!

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   

JavaScript (ES6), 47 45 bayt

@ETHproductions sayesinde 2 bayt tasarruf edildi

Girdiyi üçlü a [a, b, c] olarak alır ; burada a ve b , gen sekanslarıdır ve c , 0 ile indekslenmiş çapraz noktaların listesidir.

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

Çevrimiçi deneyin!

Yorumlananlar

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

APL (Dyalog 16.0) , 26 bayt

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

Çevrimiçi deneyin!

Giriş a , c , sonra b'dir . c olan1 endekslendi.

Nasıl?

a←⎕- get a .

0⍴⍨≢- 0uzunluğunda s dizisi oluşturun .

1@⎕⊢- take c ve değiştirmek 0için s 1endeksleri üzerinde s.

d← - atamak d' ata .

⊂≠\d- genişletmek d ile XOR (seçim dizisi oluşturmak için 0için bir ,1 için b ) ve içine alın.

(~,⊢) - al d al ve tersini al.

a⎕×- ve sırasıyla girilen b ile çarpın ve a .

+/- sonuçta, elemanların her biri çift Özetle bir s, 0s ve b ilgili 1s.

Python 2 , 43 bayt

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

Çevrimiçi deneyin!

Argümanı değiştirerek çıktılara . Bunun yerine bir program olarak:

50 bayt

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

Çevrimiçi deneyin!

Perl 5 -a , 45 40 bayt

STDIN'de ayrı satırlar olarak "kontrol", "ikinci sıra", "birinci sıra" sırasıyla giriş verin

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

Çevrimiçi deneyin!

J , 24 bayt

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

Çevrimiçi deneyin!

Saymıyorum f=:Karakterleri , çünkü anonim bir işlev olarak eşit derecede iyi çalışıyor (bir TIO örneğinde gösterildiği gibi)

Not: Boş geçiş noktalarının listesi için çalışmaz!

Açık bir oneliner, xsol argüman - çapraz noktaların listesi,y , sağ argüman, dizilerin iki satırlı bir tablosu.

Açıklama:

4 :' ... ' - ikili bir fiil

(...)}y - Her işlenen atomu (...) y öğelerinin karşılık gelen konumlarından bir atom seçer

#{.y - ilk sırayı alır ve uzunluğunu bulur

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

I. argüman uzunluğunda sıfırların bir listesini oluşturur

   I.6
0 0 0 0 0 0

1 x}rigth argümanı (sıfırlar xlistesi) öğelerini (noktalar üzerindeki korler listesi ) ile belirtilen endekslerde 1 olarak değiştirir

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

+/\ listenin toplamları

   +/\ 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

Birleştirilmiş:

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

R , 84 79 bayt

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}

Çevrimiçi deneyin!

Girdiyi 2 sütun ve a vector.

Python 3, 61 60 bayt

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

Çevrimiçi deneyin!

Jonathan Frech'ten -1 bayt

Açıklama:

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

Jöle , 13 bayt

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

Soldaki (1 dizinli) geçiş noktasını ve sağdaki sonuç listesini döndüren iki dizinin bir listesini kabul eden ikili bir bağlantı.

Çevrimiçi deneyin!

Nasıl?

ṬœṗЀż/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]

Kömür , 19 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Bir çift dize gen dizisi ve 0 indeksli bir geçiş noktası listesi olarak girdi alır. Açıklama:

Ａθ                  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

Alternatif olarak, sonucu bir dize olarak yazdırmak ⭆için Ｅdeğiştirilebilir. Çevrimiçi deneyin!

SWI-Prolog, 78 bayt

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.

Kullanım: "Genes1", "Genes2", "CrossoverPoints" köşeli parantez içine alınmış, virgülle ayrılmış listeler olduğunda "Genes1 / Genes2 / CrossoverPoints / X" çağırın.

C (clang) , 79 bayt

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

Çevrimiçi deneyin!

Girişler:
g[0]gen sekansı 1,
g[1]gen sekansı 2,
ckesişme noktalarıdır.
luzunluğudur g[0]ve g[1]
muzunluğu c
0 tabanlı dizin tamsayılar diziler olan tüm dizi girişleri.

Çıktılar:
Çıktıg[0]

altbilgideki makro a (), test senaryolarının ve sonucun güzel yazdırılmasını sağlar