Nhiệm vụ của bạn là chấp nhận làm hai chuỗi gen đầu vào và một chuỗi "điểm chéo" và trả về chuỗi gen kết quả từ sự lai chéo được chỉ định.

Điều tôi muốn nói là, nói rằng bạn có các chuỗi [A, A, A, A, A, A, A]và [Z, Z, Z, Z, Z, Z, Z], và vượt qua các điểm của 2và 5. Trình tự kết quả sẽ là [A, A, Z, Z, Z, A, A], bởi vì:

Băng qua đây: VV
Chỉ số: 0 1 2 3 4 5 6

Gen 1: AAAAAAA
Gen 2:

Kết quả: AAZZZAA
              ^ ^

Lưu ý rằng trong khi tôi sử dụng các chữ cái ở đây để rõ ràng, thử thách thực tế sử dụng số cho gen.

Kết quả là chuỗi đầu tiên cho đến khi gặp điểm chéo, sau đó kết quả sẽ lấy từ chuỗi thứ hai cho đến khi gặp điểm chéo khác, sau đó kết quả sẽ lấy từ chuỗi đầu tiên cho đến khi gặp điểm chéo ...

Đầu vào:

• Đầu vào có thể là bất kỳ hình thức hợp lý. Hai chuỗi có thể là một cặp, với các điểm là đối số thứ hai, cả ba có thể là các đối số riêng biệt, một bộ ba duy nhất (genes 1, genes 2, cross-points), một bản đồ với các khóa được đặt tên ...

• Các điểm giao nhau sẽ luôn theo thứ tự, và sẽ luôn ở trong phạm vi. Sẽ không có điểm trùng lặp, nhưng danh sách các điểm giao nhau có thể trống.

• Trình tự gen sẽ luôn có cùng độ dài và sẽ không trống.

• Các chỉ số có thể là 0 hoặc 1 dựa.

• Các gen sẽ luôn là số trong phạm vi 0-255.

• Không quan trọng đối số nào là "gen 1" hay "gen 2". Trong trường hợp không có điểm chéo, kết quả có thể hoàn toàn là "gen 1" hoặc "gen 2".

Đầu ra

• Đầu ra có thể là bất kỳ hình thức hợp lý nào không mơ hồ. Nó có thể là một mảng / danh sách các số, một mảng các số chuỗi, một chuỗi số được phân tách (một số ký tự không phải là số phải tách các số) ...

• Nó có thể được trả lại hoặc in ra std-out.

Các mục có thể bằng các chương trình hoặc chức năng đầy đủ.

Các trường hợp thử nghiệm (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]

Đây là Code Golf.

Thạch , 12 10 byte

ṁ⁹L‘¤ḣ"ḷ"/

Hãy thử trực tuyến!

Đối số 1: seq1, seq2
Đối số 2: điểm chéo (được lập chỉ mục 0)

Haskell, 58 53 51 45 byte

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

Hai trình tự gen được lấy làm một cặp danh sách và các điểm chéo làm đối số thứ hai.

Hãy thử trực tuyến!

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 byte

Đã lưu 2 byte nhờ @ETHproductions

Lấy đầu vào là một bộ ba [a, b, c] trong đó a và b là các chuỗi gen và c là danh sách các điểm chéo được lập chỉ mục 0.

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

Hãy thử trực tuyến!

Đã bình luận

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 byte

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

Hãy thử trực tuyến!

Đầu vào là a , c , sau đó b . c được 1lập chỉ mục.

Làm sao?

a←⎕- nhận được một .

0⍴⍨≢- tạo mảng 0s ở độ dài của nó.

1@⎕⊢- lấy c và thay đổi 0s thành 1s trên các chỉ số.

d←- gán cho d .

⊂≠\d- mở rộng d với xor để tạo chuỗi lựa chọn ( 0cho a , 1cho b ) và kèm theo.

(~,⊢)- lấy d và nghịch đảo của nó.

a⎕×- và nhân tương ứng với b và a .

+/- tổng hợp từng cặp phần tử, thu được a s trên 0s và b s trên 1s.

Python 2 , 43 byte

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

Hãy thử trực tuyến!

Đầu ra bằng cách sửa đổi đối số a. Thay vào đó là một chương trình:

50 byte

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

Hãy thử trực tuyến!

Perl 5 -a , 45 40 byte

Đưa đầu vào theo thứ tự "điều khiển", "chuỗi thứ hai", "chuỗi thứ nhất" dưới dạng các dòng riêng biệt trên STDIN

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

Hãy thử trực tuyến!

J , 24 byte

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

Hãy thử trực tuyến!

Tôi không đếm các f=:ký tự, bởi vì nó hoạt động tốt như một hàm ẩn danh (như được minh họa trong mẫu TIO)

Lưu ý: Nó không hoạt động cho danh sách trống các điểm chéo!

Một oneliner rõ ràng, xlà đối số bên trái - danh sách các điểm giao nhau, ylà đối số bên phải, một bảng hai hàng của các chuỗi.

Giải trình:

4 :' ... ' - một động từ dyadic

(...)}y - Mỗi nguyên tử toán hạng (...) chọn một nguyên tử từ các vị trí tương ứng của các mục của y

#{.y - lấy chuỗi đầu tiên và tìm độ dài của nó

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

I. tạo một danh sách các số không có độ dài đối số

   I.6
0 0 0 0 0 0

1 x}thay đổi các mục của đối số độ cứng (danh sách các số 0) thành 1 tại các chỉ số được chỉ định bởi x(danh sách các điểm trên các điểm)

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

+/\ tổng hợp danh sách

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

Lắp ráp:

    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 byte

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}

Hãy thử trực tuyến!

Lấy đầu vào dưới dạng ma trận gồm 2 cột và a vector.

Python 3, 61 60 byte

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

Hãy thử trực tuyến!

-1 byte từ Jonathan Frech

Giải trình:

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

Thạch , 13 byte

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

Một liên kết dyadic chấp nhận các điểm giao nhau (1 chỉ mục) ở bên trái và một danh sách hai chuỗi bên phải trả về danh sách kết quả.

Hãy thử trực tuyến!

Làm sao?

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

Than , 19 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Đưa đầu vào thành một cặp chuỗi gen chuỗi và danh sách các điểm giao nhau được lập chỉ mục 0. Giải trình:

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

Ngoài ra, ⭆có thể được đăng ký Ｅđể in kết quả dưới dạng chuỗi. Hãy thử trực tuyến!

SWI-Prolog, 78 byte

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.

Cách sử dụng: Gọi "Genes1 / Genes2 / CrossoverPoints / X" trong đó "Genes1", "Genes2", "CrossoverPoints" là các danh sách được đóng dấu ngoặc, được phân tách bằng dấu phẩy.

C (tiếng kêu) , 79 byte

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

Hãy thử trực tuyến!

Đầu vào:
g[0]là trình tự gen 1,
g[1]là trình tự gen 2,
clà điểm giao nhau.
llà độ dài g[0]và g[1]
mlà độ dài của c
Tất cả các đầu vào mảng là các mảng số nguyên có chỉ số dựa trên 0.

Đầu ra:
Đầu ra được lưu trữ trongg[0]

macro a () ở chân trang thực hiện in đẹp các trường hợp thử nghiệm và kết quả