一点遗传学课

当您仅能访问某人的可见特征或表型时，通常会使用其家族史的血统书来找出每个家庭成员的实际遗传信息或基因型。

当我们将要处理简单的优势时，简单的血统图就足以弄清楚每个人的等位基因或它们拥有的基因的版本。在简单的优势地位下，具有等位基因优势的人（用大写字母表示）将始终具有该版本所代表的特征，而与其他等位基因无关。需要表达两个隐性等位基因（用小写字母表示）。换句话说，优势等位基因总是掩盖该基因的隐性形式。这是血统图的示例：

这里的每一行都是一个世代。圆圈是女性，男性是正方形，水平线是婚姻，垂直线是孩子。很简单 黑色表示隐性表型，白色表示显性。从顶部开始（假设等位基因为A和a），我们知道人2具有aa纯合隐性，因为这是隐性表型的唯一可能选择。现在虽然一个人可能是要么Aa或者AA是显性表型，因为他有一个隐性的孩子，他必须Aa，或杂。您可以为所有其他人执行此操作。如果您没有任何信息可以让您找出第二个等位基因，可以这样进行：A_。

你的任务

• 您将以世代列表的形式收到血统图，就像[GenI, GenII, etc.]任何理智的格式一样。
• 每一代都是一个字符串列表，每个字符串代表一个人。
• 人们由三部分组成-ID，表型和“连接”。
• 它们的ID是一个可打印的ascii字符，在整个树中，除了A或以外都是唯一的a。（不，图表中的人数不会超过95人）。
• 它们的表型是A或之一a，A是优势等位基因，并且a是隐性的。
• 他们的联系是与他们有联系的其他人的ID序列。
• 同代人之间的联系是婚姻，不同世代中的孩子是父母。
• 双方都重复了这种联系（即丈夫说他是妻子的丈夫，而妻子说她是妻子的丈夫）。
• 您必须尽可能弄清楚每个人的基因型。
• 返回相同的列表，除了人类以外，将他们的基因型放在相同的位置。
• 必须按顺序输出基因型，Aa而不是aA。
• 在输入格式上留一点余地就可以了。
• 这是代码高尔夫球，因此最短答案以字节为单位。

例子

[["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"]]

奖金

• -30个字节（如果您还要处理不完整和共支配）。在检测到三个表型而不是整个图表中的两个表型时，对您的算法应用不完全/共同优势。

05AB1E，39 个字节

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

我的Java回答的端口。

在线尝试或验证所有测试用例。

说明：

ε                     # 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)

爪哇10，356个 349 340字节

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

在线尝试。

一般说明：

1）任何a都会成为aa

图2a）如果一个孩子A有父母aa和A，将成为Aa
图2b）如果一个孩子A有父母A和A，它将成为A_
2C）（这是不可能的孩子A有父母aa和aa）

3a）如果父母A有至少一个孩子a，它将变成Aa
3b）如果父母A只有一个孩子A，它将变成A_

代码说明：

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