Pelajaran genetika kecil

Ketika Anda hanya memiliki akses ke sifat-sifat atau fenotip seseorang yang terlihat , silsilah sejarah keluarga mereka sering digunakan untuk mencari tahu informasi genetik aktual atau, genotipe dari setiap anggota keluarga.

Ketika berhadapan dengan dominasi sederhana seperti kita, bagan silsilah sederhana akan cukup untuk mengetahui alel, atau versi gen yang mereka miliki, dari setiap orang. Dalam dominasi sederhana seseorang dengan alel dominan (dilambangkan dengan huruf kapital) akan selalu memiliki sifat yang diwakili oleh versi itu, tidak peduli alel lainnya. Dibutuhkan dua alel resesif (dilambangkan dengan huruf kecil) untuk mengekspresikan versi itu. Dengan kata lain alel dominan selalu menutupi versi resesif gen itu. Berikut adalah contoh bagan silsilah:

Setiap baris di sini adalah satu generasi. Lingkaran adalah perempuan, kotak laki-laki, garis horizontal adalah pernikahan, garis vertikal anak-anak. Cukup mudah. Hitam berarti fenotip resesif, putih, dominan. Mulai dari atas, (anggap alel adalah Adan a), kita tahu orang 2 memiliki aa, resesif homozigot karena itu adalah satu-satunya pilihan yang mungkin untuk fenotipe resesif. Sekarang walaupun seseorang dapat menjadi fenotip dominan Aaatau AAdominan, karena ia memiliki anak resesif, ia harus Aa, atau heterozigot. Anda dapat melakukan ini untuk semua orang lain. Dalam hal Anda tidak memiliki informasi apapun yang memungkinkan Anda untuk mencari tahu alel kedua, hal itu dapat dilakukan seperti: A_.

Tugas Anda

• Anda akan menerima bagan silsilah dalam bentuk daftar generasi seperti [GenI, GenII, etc.]dalam format waras apa pun.
• Setiap generasi akan menjadi daftar string, masing-masing string mewakili seseorang.
• Orang-orang terdiri dari tiga bagian - ID, fenotip mereka, dan "koneksi" mereka.
• ID mereka adalah karakter ascii tunggal yang dapat dicetak yang unik di seluruh pohon selain Aatau a. (Tidak, tidak akan ada lebih dari 95 orang di grafik).
• Fenotip mereka adalah salah satu dari Aatau a, Amenjadi alel dominan, dan aresesif.
• Koneksi mereka adalah urutan ID dari orang lain yang memiliki koneksi dengan mereka.
• Koneksi dalam generasi yang sama adalah pernikahan, dalam generasi yang berbeda adalah anak dan orang tua.
• Koneksi diulangi di kedua sisi (yaitu suami mengatakan dia adalah suami istri, dan istri mengatakan dia adalah suami istri).
• Anda harus mengetahui genotipe setiap orang sebanyak mungkin.
• Kembalikan daftar yang sama, kecuali orang, menempatkan genotipe mereka di posisi yang sama.
• Genotipe harus di-output agar Aatidak aA.
• Sedikit kelonggaran pada format input baik-baik saja.
• Ini adalah kode-golf sehingga jawaban terpendek dalam byte menang.

Contohnya

[["0A1234", "1a0234"], ["2A01", "3a01", "4A015678",
"5a4678"], ["6a45", "7A45","8A45"]] (The one above)   ->

[["Aa", "aa"], ["Aa", "aa", "Aa", "aa"], ["aa", "Aa", "Aa"]]

[["0A12", "1A02"], ["2A301", "3a2"]]    ->

[["A_", "A_"], ["A_", "aa"]]

Bonus

• -30 byte jika Anda berurusan dengan tidak lengkap dan co-dominance juga. Pada deteksi tiga fenotipe alih-alih dua di seluruh bagan, terapkan dominasi tidak lengkap / ko untuk algoritma Anda.

05AB1E , 39 byte

εNUε'aåi„aaë¯.øX<X>‚è˜y2£lSδåPài„Aaë„A_

Port jawaban Java saya .

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

ε                     # Map over the rows of the (implicit) input-list:
 NU                   #  Store the outer-map index in variable `X`
   ε                  #  Map over the strings `y` of the current row:
    'aåi             '#   If the current string contains an "a":
        „aa           #    Push string "aa"
       ë              #   Else (it contains an "A" instead):
        ¯.ø           #    Surround the (implicit) input-list with two empty lists
                      #    (05AB1E has automatic wrap-around when indexing lists,
                      #     so this is to prevent that)
           X<X>‚      #    Push `X-1` and `X+1` and pair them together
                è     #    Index both into the list to get (potential) parent and child rows
                 ˜    #    Flatten it to a single list
        y             #    Push the current string we're mapping again
         2£           #    Only leave the first 2 characters (its id and the letter "A")
           l          #    Lowercase the "A" to "a"
            S         #    And convert it to a list of characters: [id, "A"]
             δå       #    Check in each string whether it contains the id and "A"
               P      #    Check for each whether it contained BOTH the id AND "A"
                ài    #    If a child/parent is found for which this is truthy:
                  „Aa #     Push string "Aa"
                 ë    #    Else:
                  „A_ #     Push string "A_"
                      # (after which the mapped result is output implicitly)

Java 10, 356 349 340 byte

a->{int i=0,j,k,f,z=a.length;var r=new String[z][];for(;i<z;i++)for(r[i]=new String[j=a[i].length];j-->0;)if(a[i][j].contains("a"))r[i][j]="aa";else{var t=".a.*"+a[i][j].charAt(0)+".*";for(f=k=0;i>0&&k<a[i-1].length;)f=a[i-1][k++].matches(t)?1:f;for(k=0;i+1<z&&k<a[i+1].length;)f=a[i+1][k++].matches(t)?1:f;r[i][j]=f>0?"Aa":"A_";}return r;}

Cobalah online.

Penjelasan umum:

1) Apa pun aakan selalu menjadiaa

2a) Jika seorang anak Amemiliki orang tua aadan A, itu akan menjadi Aa
2b) Jika seorang anak Amemiliki orang tua Adan A, itu akan menjadi A_
2c) (Tidak mungkin bagi seorang anak Auntuk memiliki orang tua aadan aa)

3a) Jika orang tua Amemiliki setidaknya satu anak a, itu akan menjadi Aa
3b) Jika orangtua Ahanya memiliki anak A, itu akan menjadiA_

Penjelasan kode:

a->{                     // Method with 2D String array as both parameter and return-type
  int i=0,j,k,           //  Index-integers
      f,                 //  Flag-integer
      z=a.length;        //  Length-integer
  var r=new String[z][]; //  Result 2D String array
  for(;i<z;i++)          //  Loop over the rows:
    for(r[i]=new String[j=a[i].length];
                         //   Create the inner String-array of the result
        j-->0;)          //   Loop over the columns:
      if(a[i][j].contains("a"))
                         //    If the current node contains "a":
        r[i][j]="aa";    //     Set the result at this node to "aa"
      else{              //    Else(-if the current node contains "A" instead):
        var t=".a.*"+a[i][j].charAt(0)+".*";
                         //     Set a temp String to a regex to check relations and "a"
        for(f=k=0;       //     Set the flag to 0
            i>0&&        //     If the current node has parents:
            k<a[i-1].length;)
                         //      Loop over the row above:
          f=a[i-1][k++].matches(t)?
                         //       If a parent with "a" is found:
            1:f;         //        Set the flag to 1 (else: leave it unchanged)
        for(k=0;i+1<z&&  //     If the current node has children:
            k<a[i+1].length;) 
                         //      Loop over the row below:
          f=a[i+1][k++].matches(t)?
                         //       If child with "a" is found:
            1:f;         //        Set the flag to 1 (else: leave it unchanged)
        r[i][j]=f>0?     //     If the flag is 1:
                 "Aa"    //      Current node changes from "A" to "Aa"
                :        //     Else (flag is still 0):
                 "A_";}  //      Current node changes from "A" to "A_"
  return r;}             //  Return the result