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

Dodaj komentarz

Twój adres email nie zostanie opublikowany. Pola, których wypełnienie jest wymagane, są oznaczone symbolem *