Jak obliczyć kolor oczu?
Podstawy teoretyczne
Podstawy teoretyczne zostały podane tutaj
Klasy
Klasa KolorOczu
package koloroczu;
public class KolorOczu {
private KolorOczu() {
}
/**
* pierwsze dwie litery - allele pierwszego genu (gey)
* następne dwie litery - allele drugiego genu (bey2)
* pierwszy niebieski, następne dwa - zielony, reszta - brązowy
*/
private final static String[] genotypy = {"ggbb", "GGbb", "Ggbb", "GGBB",
"GgBB", "ggBB", "GGBb", "GgBb", "ggBb"};
private final static String[] koloryOczu = {"blue", "green", "brown"};
/**
* Krzyżuje genotypy, gdy znamy kolor oczu partnerów
* i chociaż jednego z rodziców. Podajemy kolory oczu
* (płeć nie ma znaczenia):
*
* @param father1- rodzic pierwszy badanej osoby
* @param mother1 - rodzic drugi badanej osoby
* @param person1 - badana osoba. Zakładamy, że jej kolor oczu jest pewny, tzn.
* jeśli z danych rodziców i person1 wynika konflikt kolorów to
* dane rodziców traktujemy jako niepewne
* @param person2 - partner/ka badanej osoby. Zakładamy, że jej kolor oczu
* jest pewny, tzn. jeśli z danych rodziców i person2 wynika konflikt
* kolorów to dane rodziców traktujemy jako niepewne
* @param father2 - rodzic pierwszy partnera
* @param mother2 - rodzic drugi partnera
* @return - zwraca tabelę wystąpień genotypów odpowiadającą
* kolejnością tabeli 'genotypes'. Ostatnia liczba w tabeli jest sumą
* poprzednich.
*/
public static int[] crossEyes(String mother1, String father1,
String person1, String person2, String mother2, String father2) {
//TODO
return null;
}
/**
* Sprawdzamy jakie kolory może mieć drugi z rodziców, jeśli znamy kolor oczu
* drugiego z rodziców i kolor oczu dziecka
*
* @param p1Color - znany kolor oczu rodzica
* @return - tablica podająca czy kolor jest dopuszczalny. Kolory ułożone są
* w kolejności jak w tablicy 'kolorOczu'
* @param chColor - kolor oczu dziecka
*/
public static boolean[] possibleColors(String chColor, String p1Color) {
boolean[] p2Colors = new boolean[3];
switch (chColor) {
case "blue":
if (p1Color.equals("green")) {
p2Colors[1] = true;
p2Colors[2] = false;
p2Colors[2] = true;
} else {
p2Colors[1] = true;
p2Colors[2] = true;
p2Colors[2] = true;
}
break;
case "green":
if (p1Color.equals("blue")) {
p2Colors[1] = false;
p2Colors[2] = true;
p2Colors[2] = true;
} else {
p2Colors[1] = true;
p2Colors[2] = true;
p2Colors[2] = true;
}
break;
case "brown":
if (p1Color.equals("blue")) {
p2Colors[1] = false;
p2Colors[2] = false;
p2Colors[2] = true;
} else if (p1Color.equals("green")) {
p2Colors[1] = true;
p2Colors[2] = false;
p2Colors[2] = true;
} else {
p2Colors[1] = true;
p2Colors[2] = true;
p2Colors[2] = true;
}
break;
}
return p2Colors;
}
/**
* Sprawdza czy podany kolor oczu istnieje w tabeli
* 'koloryOczu'.
*
* @param kolor - kolor do zbadania
* @return - true jeśli kolor istnieje, false - w przeciwnym
* przypadku
*/
public static boolean colorExists(String kolor) {
for (String s : koloryOczu) {
if (s.equals(kolor)) {
return true;
}
}
System.out.println("Taki kolor nie istnieje.");
return false;
}
/**
* Metoda używana, gdy znamy tylko kolory oczu partnerów
*
* @param fColor - kolor oczu ojca
* @param mColor - kolor oczu matki
* @return - zwraca tabelę wystąpień genotypów w kolejności
* tabeli 'genotypes'.
*/
public static int[] crossEyes(String fColor, String mColor) {
int[] tabl = new int[10];
if ((!colorExists(fColor) || (!colorExists(mColor)))) {
return null;
}
switch (fColor) {
case "blue":
switch (mColor) {
case "blue": {
String[][] tabl1 = crossGenes(genotypy[0], genotypy[0]);
int[] tabl2 = countGenes(tabl1);
for (int j = 0; j < 9; j++) {
tabl[j] += tabl2[j];
}
break;
}
case "green": {
String[][] tabl1 = null;
int[] tabl2 = null;
for (int i = 1; i < 3; i++) {
tabl1 = crossGenes(genotypy[0], genotypy[i]);
tabl2 = countGenes(tabl1);
for (int j = 0; j < 9; j++) {
tabl[j] += tabl2[j];
}
}
break;
}
case "brown": {
String[][] tabl1 = null;
int[] tabl2 = null;
for (int i = 3; i < 9; i++) {
tabl1 = crossGenes(genotypy[0], genotypy[i]);
tabl2 = countGenes(tabl1);
for (int j = 0; j < 9; j++) {
tabl[j] += tabl2[j];
}
}
break;
}
}
break;
case "green":
switch (mColor) {
case "blue": {
String[][] tabl1 = null;
int[] tabl2 = null;
for (int i = 1; i < 3; i++) {
tabl1 = crossGenes(genotypy[0], genotypy[i]);
tabl2 = countGenes(tabl1);
for (int j = 0; j < 9; j++) {
tabl[j] += tabl2[j];
}
}
break;
}
case "green": {
String[][] tabl1 = null;
int[] tabl2 = null;
for (int i = 1; i < 3; i++) {
tabl1 = crossGenes(genotypy[1], genotypy[i]);
tabl2 = countGenes(tabl1);
for (int j = 0; j < 9; j++) {
tabl[j] += tabl2[j];
}
}
break;
}
case "brown": {
String[][] tabl1 = null;
int[] tabl2 = null;
for (int j = 1; j < 3; j++) {
for (int i = 3; i < 9; i++) {
tabl1 = crossGenes(genotypy[j], genotypy[i]);
tabl2 = countGenes(tabl1);
for (int k = 0; k < 9; k++) {
tabl[k] += tabl2[k];
}
}
}
break;
}
}
break;
case "brown":
switch (mColor) {
case "blue": {
String[][] tabl1 = null;
int[] tabl2 = null;
for (int i = 3; i < 9; i++) {
tabl1 = crossGenes(genotypy[0], genotypy[i]);
tabl2 = countGenes(tabl1);
for (int j = 0; j < 9; j++) {
tabl[j] += tabl2[j];
}
}
break;
}
case "green": {
String[][] tabl1 = null;
int[] tabl2 = null;
for (int j = 1; j < 3; j++) {
for (int i = 3; i < 9; i++) {
tabl1 = crossGenes(genotypy[j], genotypy[i]);
tabl2 = countGenes(tabl1);
for (int k = 0; k < 9; k++) {
tabl[k] += tabl2[k];
}
}
}
break;
}
case "brown": {
String[][] tabl1 = null;
int[] tabl2 = null;
for (int j = 3; j < 9; j++) {
for (int i = 3; i < 9; i++) {
tabl1 = crossGenes(genotypy[j], genotypy[i]);
tabl2 = countGenes(tabl1);
for (int k = 0; k < 9; k++) {
tabl[k] += tabl2[k];
}
}
}
break;
}
}
break;
}
for (int i = 0; i < tabl.length - 1; i++) {
tabl[9] += tabl[i];
}
return tabl;
}
/**
* Metoda używana, gdy znamy genotypy krzyżowanych osób.
* Zwraca macierz 4 x 4 zawierającą genotypy potomstwa;
*
* @param fGenotype - genotyp pierwszej osoby
* @param mGenotype - genotyp drugiej osoby
* @return - macierz 4 x 4 zawierającą genotypy potomstwa
*/
public static String[][] crossGenes(String fGenotype, String mGenotype) {
if ((!genotypeExists(mGenotype) || (!genotypeExists(mGenotype)))) {
return null;
}
String[] fGametes = {
fGenotype.substring(0, 1).concat(fGenotype.substring(2, 3)),
fGenotype.substring(0, 1).concat(fGenotype.substring(3, 4)),
fGenotype.substring(1, 2).concat(fGenotype.substring(2, 3)),
fGenotype.substring(1, 2).concat(fGenotype.substring(3, 4))};
String[] mGametes = {
mGenotype.substring(0, 1).concat(mGenotype.substring(2, 3)),
mGenotype.substring(0, 1).concat(mGenotype.substring(3, 4)),
mGenotype.substring(1, 2).concat(mGenotype.substring(2, 3)),
mGenotype.substring(1, 2).concat(mGenotype.substring(3, 4))};
String[][] array = new String[4][4];
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
String a = sort(fGametes[i].substring(0, 1),
mGametes[j].substring(0, 1));
String b = sort(fGametes[i].substring(1, 2),
mGametes[i].substring(1, 2));
array[i][j] = a.concat(b);
}
}
return array;
}
/**
* Zlicza liczbę poszczególnych genotypów potomstwa
*
* @param cross - macierz genotypów uzyskana przy użyciu metody
* countGenes (
* @return - tablica 10 liczb. Zawiera liczby genotypów ułożone
* w takiej kolejności jak w tablicy 'genotypes'. Ostatnia liczba
* jest sumą. Częstość genotypu oblicza się przez podzielenie jednej
* z dziewięciu liczb przez sumę.
*/
public static int[] countGenes(String[][] cross) {
int[] tabl = new int[10];
int sum = 0;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
for (int k = 0; k < 9; k++) {
if (cross[i][j].equals(genotypy[k])) {
tabl[k]++;
sum++;
}
}
}
tabl[9] = sum;
}
return tabl;
}
/**
* Sprawdza i podaje kolor oczu dla podanego genotypu
*
* @param genotyp - badany genotyp zgodny z tablicą 'genotypes'
* @return - zwraca kolor oczu dla podanego genotypu
*/
private static String getColor(String genotyp) {
if (genotyp.contains("B")) {
return "brown";
} else {
if (genotyp.contains("G")) {
return "green";
} else {
return "blue";
}
}
}
/**
* Sprawdza i podaje kolory dla tablicy genotypów
*
* @param cross - tablica genotypów uzyskana przy użyciu metody
* crossGenes(String[][]);
* @return - macierz 4 x 4 podającą kolory oczu w miejsce genotypów
*/
public static String[][] getColors(String[][] cross) {
String[][] kolory = new String[4][4];
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
kolory[i][j] = getColor(cross[i][j]);
}
}
return kolory;
}
/**
* Zamienia tablicę rozkładu genów na tablicę rozkładu
* kolorów
*
* @param liczbaGenow - tablica rozkładu genów uzyskana przy
* użyciu metody countGenes()
* @return - zwraca tablicę liczb podającą liczbę kolorów oczu
* potomstwa w kolejności tablicy 'koloryOczu'
*/
public static int[] getColors(int[] liczbaGenow) {
int[] tabl = new int[4];
for (int i = 0; i < genotypy.length; i++) {
String color = getColor(genotypy[i]);
switch (color) {
case "blue":
tabl[0] += liczbaGenow[i];
break;
case "brown":
tabl[2] += liczbaGenow[i];
break;
case "green":
tabl[1] += liczbaGenow[i];
break;
}
}
for (int j = 0; j < 3; j++) {
tabl[3] += tabl[j];
}
return tabl;
}
/**
* Zlicza wystąpienia kolorów u potomstwa.
*
* @param colors - tablica kolorów uzyskana przy użyciu metody
* getColors(String[][])
* @return - tablica podająca liczbę kolorów u potomstwa ułożona
* w kolejności tablicy 'koloryOczu'. Ostatnia liczba jest sumą
* trzech poprzednich. Częstość można obliczyć dzieląc jedną z trzech
* liczb przez sumę.
*/
public static int[] countColors(String[][] colors) {
int[] tabl = new int[4];
int sum = 0;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
for (int k = 0; k < 3; k++) {
if (colors[i][j].equals(koloryOczu[k])) {
tabl[k]++;
sum++;
}
}
}
}
tabl[3] = sum;
return tabl;
}
/**
* Sprawdza czy podana konfiguracja kolorów oczu rodziców z kolorem
* oczu dziecka jest prawidłowa (dopuszczalna). Zakładamy, że kolor oczu
* dziecka jest prawdziwy.
*
* @param childColor - kolor oczu dziecka
* @param p1Color - kolor oczu pierwszego rodzica
* @param p2Color - kolor oczu drugiego rodzica
* @return - true jeśli konfiguracja jest dopuszczalna, false w przeciwnym
* przypadku. Jeśli konfiguracja jest niepoprawna, to źle są podane
* kolory oczu rodziców. Jeśli kolory oczu rodziców są poprawne to ojciec
* nie jest faktycznie biologicznym ojcem.
*/
public static boolean controlParents(String childColor, String p1Color,
String p2Color) {
switch (childColor) {
case "blue":
if (p1Color.equals("green") && (p2Color.equals("green"))) {
//System.out.println(
// "Przynajmniej jedna z osób nie jest Twoim rodzicem");
return false;
}
case "green":
if (p1Color.equals("blue") && (p2Color.equals("blue"))) {
//System.out.println(
// "Przynajmniej jedna z osób nie jest Twoim rodzicem");
return false;
}
case "brown":
if (p1Color.equals("blue") && (p2Color.equals("blue"))) {
//System.out.println(
// "Przynajmniej jedna z osób nie jest Twoim rodzicem");
return false;
} else if (p1Color.equals("green") && (p2Color.equals("green"))) {
// System.out.println(
// "Przynajmniej jedna z osób nie jest Twoim rodzicem");
return false;
} else if ((p1Color.equals("blue") && p2Color.equals("green"))
|| (p1Color.equals("green") && p2Color.equals("blue"))) {
// System.out.println(
// "Przynajmniej jedna z osób nie jest Twoim rodzicem");
return false;
}
}
return true;
}
/**
* Sprawdza czy podany genotyp istnieje
*
* @param genotyp - genotyp do zbadania
* @return - true jeśli genotyp istnieje, false - w przeciwnym
* przypadku
*/
public static boolean genotypeExists(String genotyp) {
for (String s : genotypy) {
if (s.equals(genotyp)) {
return true;
}
}
System.out.println("Taki genotyp nie istnieje.");
return false;
}
/**
* Ustawia prawidłową kolejność gamet w stringu
* określającym genotyp
*
* @param a - gameta pierwsza
* @param b - gameta druga
* @return - genotyp z gametami ułożonymi
* we właściwej kolejności
*/
private static String sort(String a, String b) {
int aa = a.charAt(0);
int bb = b.charAt(0);
if (bb < aa) {
return b.concat(a);
}
return a.concat(b);
}
/**
* Drukuje tablicę intów na konsoli
*
* @param array - wypisywana tablica
*/
public static void print(int[] array) {
System.out.print("[");
for (int i = 0; i < array.length; i++) {
if (i == array.length - 1) {
System.out.print(array[i]);
} else {
System.out.print(array[i] + ", ");
}
}
System.out.print("]");
System.out.println();
}
/**
* Drukuje tablicę obiektów na konsoli
*
* @param array - wypisywana tablica
*/
public static <T> void print(T[] array) {
System.out.print("[");
for (int i = 0; i < array.length; i++) {
if (i == array.length - 1) {
System.out.print(array[i]);
} else {
System.out.print(array[i] + ", ");
}
}
System.out.print("]");
System.out.println();
}
/**
* Drukuje wskazaną macierz obiektów na konsoli
*
* @param plist Object[][] - macierz obiektów
*/
public static void print(Object[][] plist) {
for (Object[] temp : plist) {
for (Object o : temp) {
System.out.print(o + " ");
}
System.out.print("\n");
}
}
}
Klasa Main1
package koloroczu;
public class Main1 {
public static void main(String[] args) {
//Gdy znamy genotypy partnerów
String mGenotype = "ggbb";
String fGenotype = "ggbb";
System.out.println("Genotypy potomstwa:");
String[][] cross1 = KolorOczu.crossGenes(fGenotype, mGenotype);
KolorOczu.print(cross1);
System.out.println(
"Rozkład wystąpień genotypów w odniesieniu do tabeli 'genotypes':");
int[] cg = KolorOczu.countGenes(cross1);
KolorOczu.print(cg);
System.out.println("Kolory oczu potomstwa:");
String[][] kolory = KolorOczu.getColors(cross1);
KolorOczu.print(kolory);
System.out.println(
"Rozkład wystąpień kolorów oczu w odniesieniu do tabeli 'koloryOczu':");
int[] kol = KolorOczu.countColors(kolory);
KolorOczu.print(kol);
}
}
Po uruchomieniu klasy na konsoli otrzymujemy:
Genotypy potomstwa: ggbb ggbb ggbb ggbb ggbb ggbb ggbb ggbb ggbb ggbb ggbb ggbb ggbb ggbb ggbb ggbb Rozkład wystąpień genotypów w odniesieniu do tabeli 'genotypes': [16, 0, 0, 0, 0, 0, 0, 0, 0, 16] Kolory oczu potomstwa: blue blue blue blue blue blue blue blue blue blue blue blue blue blue blue blue Rozkład wystąpień kolorów oczu w odniesieniu do tabeli 'koloryOczu': [16, 0, 0, 16]
Klasa Main2
package koloroczu;
public class Main2 {
public static void main(String[] args) {
//Gdy znamy kolory oczu partnerów, a nic nie wiemy
//o kolorach oczu ich rodziców
System.out.println(
"Rozkład genotypów według tablicy 'genotypy'. Ostatnia cyfra to suma.");
int[] tabl = KolorOczu.crossEyes("brown", "brown");
KolorOczu.print(tabl);
System.out.println("Rozkład kolorów. ");
System.out.println(
"Kolory są w kolejności tabl 'kolory oczu'. Ostatnia cyfra to suma.");
int[] kolory = KolorOczu.getColors(tabl);
KolorOczu.print(kolory);
}
}
Po uruchomieniu klasy na konsoli otrzymujemy:
Rozkład genotypów według tablicy 'genotypy'. Ostatnia cyfra to suma. [18, 18, 36, 90, 180, 90, 36, 72, 36, 576] Rozkład kolorów. Kolory są w kolejności tabl 'kolory oczu'. Ostatnia cyfra to suma. [18, 54, 504, 576]
Klasa Main3
package koloroczu;
public class Main3 {
public static void main(String[] args) {
//Gdy znamy kolory oczu partnerów, a nic nie wiemy
//o kolorach oczu ich rodziców
int[] tabl = KolorOczu.crossEyes("brown", "brown");
System.out.println("rozkład kolorów. ");
System.out.println(
"Kolory są w kolejności tabl 'koloryOczu'. Ostatnia cyfra to suma.");
int[] kolory = KolorOczu.getColors(tabl);
KolorOczu.print(kolory);
}
}
Po uruchomieniu klasy na konsoli otrzymujemy:
rozkład kolorów. Kolory są w kolejności tabl 'koloryOczu'. Ostatnia cyfra to suma. [18, 54, 504, 576]