Una piccola lezione di genetica

Quando hai accesso solo ai tratti o al fenotipo visibili di qualcuno , un pedigree della loro storia familiare viene spesso usato per capire le informazioni genetiche effettive o il genotipo di ciascun membro della famiglia.

Quando avremo a che fare con il dominio semplice come saremo, sarà sufficiente una semplice tabella genealogica per capire gli alleli, o la versione dei geni che hanno, di ogni persona. In semplice dominio, una persona con un allele dominante (indicato con una lettera maiuscola) avrà sempre il tratto che quella versione rappresenta, indipendentemente dall'altro allele. Ci vogliono due alleli recessivi (indicati con una lettera minuscola) per esprimere quella versione. In altre parole, l'allele dominante maschera sempre la versione recessiva di quel gene. Ecco un esempio di un diagramma genealogico:

Ogni riga qui è una generazione. I cerchi sono femmine, i maschi quadrati, le linee orizzontali sono il matrimonio, le linee verticali i bambini. Abbastanza semplice. Il nero significa fenotipo recessivo, bianco, dominante. Partendo dall'alto, (supponiamo che gli alleli siano Ae a), sappiamo che la persona 2 ha aa, omozigote recessiva perché questa è l'unica opzione possibile per il fenotipo recessivo. Ora, anche se la persona uno potrebbe essere Aao AAessere fenotipo dominante, poiché ha un figlio recessivo, deve essere Aao eterozigote. Puoi farlo per tutte le altre persone. Nel caso in cui non si dispone di alcuna informazione che consente di capire il secondo allele, si può fare in questo modo: A_.

Il tuo compito

• Riceverai un diagramma genealogico sotto forma di un elenco di generazioni come [GenI, GenII, etc.]in qualsiasi formato sano.
• Ogni generazione sarà un elenco di stringhe, ogni stringa che rappresenta una persona.
• Le persone sono composte da tre parti: un ID, il loro fenotipo e le loro "connessioni".
• Il loro ID è un singolo carattere ASCII stampabile che è unico nell'intero albero diverso da Ao a. (No, non ci saranno più di 95 persone nel grafico).
• Il loro fenotipo è uno Ao a, Aessendo l'allele dominante, e arecessivo.
• Le loro connessioni sono una sequenza di ID di altre persone con cui hanno connessioni.
• Una connessione nella stessa generazione è il matrimonio, nelle diverse generazioni è figlio e genitore.
• Le connessioni si ripetono da entrambe le parti (cioè il marito ha detto che è un marito di moglie e la moglie dice che è marito di moglie).
• Devi capire il più possibile i genotipi di tutti.
• Restituisce la stessa lista, tranne che al posto delle persone, mettendo i loro genotipi nella stessa posizione.
• Il genotipo deve essere emesso in ordine in modo che Aainvece di aA.
• Un piccolo margine di manovra sul formato di input va bene.
• Questo è code-golf, quindi la risposta più breve in byte vince.

Esempi

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

indennità

• -30 byte se hai a che fare anche con il dominio incompleto . Sulla rilevazione di tre fenotipi anziché due nell'intero grafico, applica il dominio incompleto / co al tuo algoritmo.

05AB1E , 39 byte

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

Porta della mia risposta Java .

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Provalo online.

Spiegazione generale:

1) Qualsiasi adiventerà sempreaa

2a) Se un bambino Aha genitori aae Adiventerà Aa
2b) Se un bambino Aha genitori Ae Adiventerà A_
2c) (Non è possibile che un bambino Aabbia genitori aae aa)

3a) Se un genitore Aha almeno un figlio a, diventerà Aa
3b) Se un genitore Aha solo figli A, diventeràA_

Spiegazione del codice:

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