Une petite leçon de génétique

Lorsque vous n'avez accès qu'aux traits visibles ou au phénotype d' une personne, un pedigree de ses antécédents familiaux est souvent utilisé pour déterminer les informations génétiques réelles ou le génotype de chaque membre de la famille.

Lorsque nous traiterons de la dominance simple comme nous le serons, un simple tableau généalogique suffira pour déterminer les allèles, ou la version des gènes qu'ils ont, de chaque personne. En simple domination, une personne avec un allèle dominant (indiqué par une majuscule) aura toujours le trait que cette version représente, quel que soit l'autre allèle. Il faut deux allèles récessifs (indiqués par une lettre minuscule) pour que cette version soit exprimée. En d'autres termes, l'allèle dominant masque toujours la version récessive de ce gène. Voici un exemple de tableau généalogique:

Ici, chaque rangée est une génération. Les cercles sont féminins, les carrés masculins, les lignes horizontales sont le mariage, les lignes verticales les enfants. Assez simple. Noir signifie phénotype récessif, blanc, dominant. En partant du haut, (supposons que les allèles sont Aet a), nous savons que la personne 2 a aa, récessive homozygote parce que c'est la seule option possible pour le phénotype récessif. Maintenant, même si la personne une peut être phénotype dominant Aaou AAêtre dominante, parce qu'elle a un enfant récessif, elle doit être Aaou hétérozygote. Vous pouvez le faire pour toutes les autres personnes. Dans le cas où vous ne disposez pas d'informations qui vous permet de comprendre le second allèle, il peut être fait comme ceci: A_.

Ta tâche

• Vous recevrez un tableau généalogique sous la forme d'une liste de générations comme [GenI, GenII, etc.]dans n'importe quel format sain.
• Chaque génération sera une liste de chaînes, chaque chaîne représentant une personne.
• Les personnes sont composées de trois parties - une pièce d'identité, leur phénotype et leurs «connexions».
• Leur ID est un seul caractère ascii imprimable qui est unique dans l'arborescence entière autre que Aou a. (Non, il n'y aura pas plus de 95 personnes dans le graphique).
• Leur phénotype est l'un des Aor a, Aétant l'allèle dominant et aétant récessif.
• Leurs connexions sont une séquence de pièces d'identité d'autres personnes avec lesquelles elles ont des connexions.
• Un lien dans la même génération est le mariage, dans différentes générations, l'enfant et le parent.
• Les liens se répètent des deux côtés (c'est-à-dire que le mari a dit qu'il était le mari de la femme et que la femme disait qu'elle était le mari de la femme).
• Vous devez déterminer autant que possible les génotypes de chacun.
• Renvoyez la même liste, sauf qu'au lieu de personnes, mettez leurs génotypes dans la même position.
• Le génotype doit être sorti dans l'ordre, donc Aaau lieu de aA.
• Une petite latitude sur le format d'entrée est très bien.
• C'est le code-golf, donc la réponse la plus courte en octets gagne.

Exemples

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

Prime

• -30 octets si vous traitez également avec incomplète et co-dominance . Lors de la détection de trois phénotypes au lieu de deux dans l'ensemble du graphique, appliquez une dominance incomplète / co à votre algorithme.

05AB1E , 39 octets

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

Port de ma réponse Java .

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

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

Essayez-le en ligne.

Explication générale:

1) Tout adeviendra toujoursaa

2a) Si un enfant Aa des parents aaet Acela deviendra Aa
2b) Si un enfant Aa des parents Aet Acela deviendra A_
2c) (Il n'est pas possible pour un enfant Ad'avoir des parents aaet aa)

3a) Si un parent Aa au moins un enfant a, il deviendra Aa
3b) Si un parent An'a que des enfants A, il deviendraA_

Explication du code:

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