Cvičení 10 a 11 z Javy. Jen se inspirovat, nekopírovat!

Cviceni10.java

/**
 * Created by IntelliJ IDEA.
 * User: Milan
 * Date: Nov 30, 2009
 * Time: 7:19:35 PM
 */

import java.util.*;
import static java.lang.Character.*;
import static java.lang.Math.*;
import static java.lang.System.*;
import static java.text.MessageFormat.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;

public class Cviceni10 {
    public static void main (String[] args) {
        Scanner sc = new Scanner(in);
        byte program;

        out.print("<i> Ktery program spustit?\n" +
                "<i> 1 - sekvencni vyhledavani\n" +
                "<i> 2 - binarni puleni\n" +
                "<i> 3 - nahrada nul\n" +
                "<i> 4 - presun vyhovujicich\n" +
                "<i> ");
        program = sc.nextByte();

        if (program == 1) {
            int n, x;
            int[] pole;

            out.print("<i> Delka pole: ");
            n = sc.nextInt();

            pole = GenerujPole(n, 1, 10, false);
            VytiskniPole(pole, "Vygenerovane pole");

            out.print("<i> Hledany prvek: ");
            x = sc.nextInt();

            if (HledejPrvekSekvencne(pole, x)) {
                out.println(format("^.^ Prvek {0} se v poli nachazi.", x));
            } else {
                out.println(format("^.^ Prvek {0} se v poli nenachazi.", x));
            }
        } else if (program == 2) {
            int n, x;
            int[] pole;

            out.print("<i> Delka pole: ");
            n = sc.nextInt();

            pole = GenerujPole(n, 1, 10, true);
            VytiskniPole(pole, "Vygenerovane pole");

            out.print("<i> Hledany prvek: ");
            x = sc.nextInt();

            if (HledejPrvekPulenim(pole, x)) {
                out.println(format("^.^ Prvek {0} se v poli nachazi.", x));
            } else {
                out.println(format("^.^ Prvek {0} se v poli nenachazi.", x));
            }
        } else if (program == 3) {
            int n;
            int[] pole;
            boolean poprve = true;

            do {
                if (!poprve) {
                    out.println(">.< Neplatna hodnota.");
                }

                out.print("<i> Delka pole: ");
                n = sc.nextInt();

                poprve = false;                
            } while (n <= 0);

            pole = GenerujPole(n, 0, 10, false);
            VytiskniPole(pole, "Puvodni pole");

            if (!HledejPrvekSekvencne(pole, 0)) {
                exit(0);
            } else {
                for (int i = 0; i < pole.length; i++) {
                    if (pole[i] == 0) {
                        pole[i] = -1;
                    }
                }
            }

            VytiskniPole(pole, "Modifikovane pole");
        } else if (program == 4) {
            int n, x;
            int[] pole;
            boolean poprve = true;
            char opakovat;
            String radek;
            List<Integer> vyhovujici = new ArrayList<Integer>();

            do {
                if (!poprve) {
                    out.println(">.< Neplatna hodnota.");
                }

                out.print("<i> Delka pole: ");
                n = sc.nextInt();

                poprve = false;
            } while (n <= 0);

            pole = GenerujPole(n, 0, 10, false);
            VytiskniPole(pole, "Vygenerovane pole");

            do {
                out.print("<i> Hledany prvek: ");
                x = sc.nextInt();

                for (int prvek : pole) {
                    if (prvek == x) {
                        vyhovujici.add(prvek);
                    }
                }

                sort(vyhovujici);
                VytiskniSeznam(vyhovujici, "Vyhovujici");

                out.print("<c> Opakovat? ");
                radek = sc.next();
                opakovat = radek.charAt(0);
            } while (toLowerCase(opakovat) == 'a');
        }
    }

    /**
     * Vygeneruje nahodne prvky pole v intervalu <1; 10>
     * @param n pocet prvku vyhledneho pole
     * @param minimum nejmensi prvek
     * @param maximum maximalni prvek
     * @param seradit urcuje, zda ma byt pole pred predanim serazeno od nejmensiho prvku po nejvetsi
     * @return vysledne pole
     */
    private static int[] GenerujPole (int n, int minimum, int maximum, boolean seradit) {
        int[] pole = new int[n];

        for (int i = 0; i < pole.length; i++) {
            pole[i] = (int) (random() * maximum + minimum);
        }

        if (seradit) {
            sort(pole);
        }

        return pole;
    }

    /**
     * Vytiskne vsechny prvky pole
     * @param pole pole, jehoz prvky maji byt vytisteny
     * @param hlaska hlaska, co se u toho ma vypsat
     */
    private static void VytiskniPole (int[] pole, String hlaska) {
        out.print(format("^.^ {0}: [", hlaska));

        for (int i = 0; i < pole.length; i++) {
            out.print(format("{0}", pole[i]));
            if ((i + 1) != pole.length) {
                out.print(", ");
            }
        }
        
        out.println("].");
    }

    /**
     * Vytiskne vsechny prvky seznamu
     * @param seznam seznam, jehos prvky maji byt vytisteny
     * @param hlaska hlaska, co se u toho ma vypsat
     */
    private static void VytiskniSeznam (List<Integer> seznam, String hlaska) {
        out.println(format("^.^ {0}: {1}.", hlaska, seznam));
    }

    /**
     * Hleda hodnotu v poli metodou sekvencniho vyhledavani
     * @param pole pole, v nemz se ma hodnota vyhledat
     * @param x hledana hodnota
     * @return true = nalezeno, false = nenalezeno
     */
    private static boolean HledejPrvekSekvencne (int[] pole, int x) {
        // Vytvoreni zarazky
        int[] druhePole = new int[pole.length + 1];
        arraycopy(pole, 0, druhePole, 0, pole.length);
        druhePole[druhePole.length - 1] = x; 

        int i = 0;  // Inicializace predem = chceme hodnotu promenne i po probehnuti cyklu

        for (; i < druhePole.length; i++) {
            if (druhePole[i] == x) {
                break;
            }
        }

        return ((i + 1) != druhePole.length);
    }

    /**
     * Hleda hodnotu v poli metodou binarniho puleni
     * @param pole pole, v nemz se ma hodnota vyhledat
     * @param x hledana hodnota
     * @return true = nalezeno, false = nenalezeno
     */
    private static boolean HledejPrvekPulenim (int[] pole, int x) {
        int k, l = 0, r = pole.length - 1;

        do {
            k = (l + r) / 2;
            if (x > pole[k]) {
                l = k + 1;
            } else {
                r = k - 1;
            }
        } while ((pole[k] != x) && (l <= r));

        return (pole[k] == x);
    }
}

Cviceni11.java

/**
 * Created by IntelliJ IDEA.
 * User: Milan
 * Date: Dec 7, 2009
 * Time: 1:27:02 PM
 */

import java.util.*;
import static java.lang.Integer.*;
import static java.lang.Math.*;
import static java.lang.System.*;
import static java.text.MessageFormat.*;

public class Cviceni11 {
    public static void main (String args[]) {
        Scanner sc = new Scanner(in);
        byte program;

        out.print("<i> Ktery program spustit?\n" +
                "<i> 1 -- Priklad 11x05\n" +
                "<i> 2 -- Priklad 11x06\n" +
                "<i> 3 -- Priklad 11x07\n" +
                "<i> 4 -- Priklad 11x08\n" +
                "<i> 5 -- Priklad 11x09\n" +
                "<i> 6 -- Priklad 11x10\n" +
                "<i> 7 -- Priklad 11x11\n" +
                "<i> ");
        program = sc.nextByte();

        if (program == 1) {
            int n;
            int[] pole;

            out.print("<i> Delka pole: ");
            n = sc.nextInt();

            pole = generujPole(n, 1, 10);
            vytiskniPole(pole);
            hledejNejvetsi(pole);
            hledejNejvetsiAPozici(pole);
            hledejNejvetsiAPocet(pole);
        } else if (program == 2) {
            int x;
            int[][] pole;

            out.print("<i> Hledana hodnota: ");
            x = sc.nextInt();

            pole = generujPole(3, 4, 1, 10);
            vytiskniPole(pole);
            out.println(format("^.^ Aritmeticky prumer vsech prvku pole je {0}.", spocitejPrumer(pole)));
            zjistiPocet(pole, x);
            hledejNejvetsi(pole);
        } else if (program == 3) {
            int m, n;
            int[][] pole;

            out.print("<i> Pocet radku: ");
            m = sc.nextInt();

            out.print("<i> Pocet sloupcu: ");
            n = sc.nextInt();

            pole = generujPole(m, n, 1, 10);
            vytiskniPole(pole);
            vytiskniRadek(pole, 2);
            vytiskniSloupec(pole, 3);
        } else if (program == 4) {
            int m, n;
            int[][] pole;

            out.print("<i> Pocet radku: ");
            m = sc.nextInt();

            out.print("<i> Pocet sloupcu: ");
            n = sc.nextInt();

            pole = generujPole(m, n, 0, 9);
            vytiskniPoleASecti(pole, true);
        } else if (program == 5) {
            int n, x;
            int[][] pole;

            out.print("<i> Velikost pole: ");
            n = sc.nextInt();

            out.print("<i> Nahradit hodnotou: ");
            x = sc.nextInt();

            pole = generujPole(n, n, 0, 9);
            vytiskniPole(pole);
            pole = nahradDiagonalu(pole, x);
            vytiskniPole(pole);
        } else if (program == 6) {
            int n;
            int[][] pole;

            out.print("<i> Velikost pole: ");
            n = sc.nextInt();

            pole = generujPole(n, n, 0, 9);
            vytiskniPole(pole);
            out.println(format("^.^ Soucet prvku pod hlavni diagonalou je {0}.", sectiPodNadDiagonalou(pole, true)));
            out.println(format("^.^ Soucet prvku nad hlavni diagonalou je {0}.", sectiPodNadDiagonalou(pole, false)));
        } else if (program == 7) {
            int m, n;
            int[][] pole;

            out.print("<i> Pocet radku: ");
            m = sc.nextInt();

            do {
                n = (int) (random() * 10 + 1);
            } while (m == n);

            pole = generujPole(m, n, 0, 9);
            vytiskniPoleASecti(pole, false);
        }
    }

    /**
     * Vygeneruje nahodne prvky pole v zadanem intervalu
     * @param n pocet prvku vyhledneho pole
     * @param minimum nejmensi prvek
     * @param maximum nejvetsi prvek
     * @return pole vysledne pole
     */
    private static int[] generujPole (int n, int minimum, int maximum) {
        int[] pole = new int[n];

        for (int i = 0; i < pole.length; i++) {
            pole[i] = (int) (random() * maximum + minimum);
        }

        return pole;
    }

    /**
     * Vygeneruje nahodne prvky dvourozmerneho pole v zadanem intervalu
     * @param m pocet radku
     * @param n pocet sloupcu
     * @param minimum nejmensi prvek
     * @param maximum nejvetsi prvek
     * @return pole vysledne pole
     */
    private static int[][] generujPole (int m, int n, int minimum, int maximum) {
        int[][] pole = new int[m][n];

        for (int i = 0; i < pole.length; i++) {
            for (int j = 0; j < pole[i].length; j++) {
                pole[i][j] = (int) (random() * maximum + minimum);
            }
        }

        return pole;
    }

    /**
     * Vytiskne vsechny prvky pole
     * @param pole pole, jehoz prvky maji byt vytisteny
     */
    private static void vytiskniPole (int[] pole) {
        out.print("^.^ Vygenerovane pole: [");

        for (int i = 0; i < pole.length; i++) {
            out.print(pole[i]);
            if ((i + 1) != pole.length) {
                out.print(", ");
            }
        }

        out.println("].");
    }

    /**
     * Vytiskne vsechny prvky dvourozmerneho pole
     * @param pole pole, jehoz prvky maji byt vytisteny
     */
    private static void vytiskniPole (int[][] pole) {
        out.print("^.^ Vygenerovane pole: ");

        for (int i = 0; i < pole.length; i++) {
            if (i != 0) {
                out.print("^.^");
                for (int x = 0; x < 20; x++) {
                    out.print(" ");
                }
            }
            
            out.print("[");

            for (int j = 0; j < pole[i].length; j++) {
                out.print(pole[i][j]);
                if ((j + 1) != pole[i].length) {
                    out.print(", ");
                }
            }
            if ((i + 1) != pole.length) {
                out.println("]");
            } else {
                out.println("].");
            }
        }
    }

    /**
     * Vytiskne vsechny prvky dvourozmerneho pole a vypise soucty radku a sloupcu
     * @param pole pole, jehoz prvky maji byt vytisteny
     * @param sloupce vypsat i soucet sloupcu?
     */
    private static void vytiskniPoleASecti (int[][] pole, boolean sloupce) {
        int soucetRadku;
        int[] soucetSloupcu = new int[pole[0].length];
        String hlaska = "^.^";
        String[] sipka = {"|", "|", "v"};

        for (int x = 0; x < 20; x++) {
            hlaska += " ";
        }

        out.print("^.^ Vygenerovane pole: ");

        for (int i = 0; i < pole.length; i++) {
            soucetRadku = 0;
            
            if (i != 0) {
                out.print(hlaska);
            }

            out.print("[");

            for (int j = 0; j < pole[i].length; j++) {
                soucetRadku += pole[i][j];
                soucetSloupcu[j] += pole[i][j];
                out.print(pole[i][j]);
                if ((j + 1) != pole[i].length) {
                    out.print(", ");
                }
            }

            out.println(format("] --> {0}", soucetRadku));
        }

        if (sloupce) {
            for (String znak : sipka) {
                out.print(hlaska + " ");
                for (int i = 0; i < pole[0].length; i++) {
                    out.print(znak + "  ");
                }
                out.println();
            }

            out.print(hlaska + " ");

            for (int i = 0; i < pole[0].length; i++) {
                out.print(soucetSloupcu[i]);

                if (soucetSloupcu[i] >= 10) {
                    out.print(" ");
                } else {
                    out.print("  ");
                }
            }
        }
    }

    /**
     * Vypise n-ty radek pole
     * @param pole pole, jehoz radek bude vypsan
     * @param radek radek, jenz bude vypsan
     */
    private static void vytiskniRadek (int[][] pole, int radek) {
        out.print(format("^.^ {0}. radek pole: [", radek));

        radek--;

        for (int i = 0; i < pole[radek].length; i++) {
            out.print(pole[radek][i]);
            if ((i + 1) != pole[radek].length) {
                out.print(", ");
            }
        }

        out.println("].");
    }

    /**
     * Vypise n-ty sloupec pole
     * @param pole pole, jehoz sloupec bude vypsan
     * @param sloupec sloupec, jenz bude vypsan
     */
    private static void vytiskniSloupec (int[][] pole, int sloupec) {
        out.print(format("^.^ {0}. sloupec pole: [", sloupec));

        sloupec--;

        for (int i = 0; i < pole.length; i++) {
            out.print(pole[i][sloupec]);
            if ((i + 1) != pole.length) {
                out.print(", ");
            }
        }

        out.println("].");
    }

    /**
     * Vyhleda nejvetsi cele cislo v zadanem poli
     * @param pole pole, ktere se ma prohledat
     */
    private static void hledejNejvetsi (int[] pole) {
        int nejvetsi = MIN_VALUE;

        for (int prvek : pole) {
            if (prvek > nejvetsi) {
                nejvetsi = prvek;
            }
        }

        out.println(format("^.^ Nejvetsi prvek bylo cislo {0}.", nejvetsi));
    }

    /**
     * Vyhleda nejvetsi cele cislo v zadanem dvojrozmernem poli
     * @param pole pole, ktere se ma prohledat
     */
    private static void hledejNejvetsi (int[][] pole) {
        int nejvetsi = MIN_VALUE;

        for (int[] radek : pole) {
            for (int prvek : radek) {
                if (prvek > nejvetsi) {
                    nejvetsi = prvek;
                }
            }
        }

        out.println(format("^.^ Nejvetsi prvek bylo cislo {0}.", nejvetsi));
    }

    /**
     * Vyhleda nejvetsi cele cislo v zadanem poli a poradi jeho prvniho vyskytu
     * @param pole pole, ktere se ma prohledat
     */
    private static void hledejNejvetsiAPozici (int[] pole) {
        int nejvetsi = MIN_VALUE, pozice = 0;

        for (int i = 0; i < pole.length; i++) {
            if (pole[i] > nejvetsi) {
                nejvetsi = pole[i];
                pozice = i + 1;
            }
        }

        out.println(format("^.^ Nejvetsi prvek bylo cislo {0}.", nejvetsi));
        out.println(format("^.^ Prvek se poprve vyskytl na pozici {0}.", pozice));
    }

    /**
     * Vyhleda nejvetsi cele cislo v zadanem poli a celkovy pocet jeho vyskytu
     * @param pole pole, ktere se ma prohledat
     */
    private static void hledejNejvetsiAPocet (int[] pole) {
        int nejvetsi = MIN_VALUE, pocet = 0;

        for (int prvek : pole) {
            if (prvek > nejvetsi) {
                nejvetsi = prvek;
                pocet = 0;
            }
            if (prvek == nejvetsi) {
                pocet++;
            }
        }

        out.println(format("^.^ Nejvetsi prvek bylo cislo {0}.", nejvetsi));
        out.println(format("^.^ V poli se vyskytlo {0}krat.", pocet));
    }

    /**
     * Spocita aritmeticky prumer hodnot zadaneho dvourozmerneho pole
     * @param pole pole, s jehoz prvky se ma pracovat
     * @return prumer aritmeticky prumer
     */
    private static float spocitejPrumer (int[][] pole) {
        int pocet = 0, soucet = 0;
        float prumer;

        for (int[] radek : pole) {
            for (int prvek : radek) {
                soucet += prvek;
                pocet++;
            }
        }

        prumer = (float) soucet / (float) pocet;

        return prumer;
    }

    /**
     * Zjisti, kolikrat se cislo vyskytuje v zadanem dvourozmernem poli
     * @param pole pole, jenz se bude prohledavat
     * @param x hodnota, jez se bude hledat
     */
    private static void zjistiPocet (int[][] pole, int x) {
        int pocet = 0;

        for (int[] radek : pole) {
            for (int prvek : radek) {
                if (prvek == x) {
                    pocet++;
                }
            }
        }

        out.println(format("^.^ Hodnota {0} se v poli nachazi {1}krat.", x, pocet));
    }

    /**
     * Nahradi prvky lezici na hlavni diagonale jinym cislem
     * @param pole pole, s nimz budeme pracovat
     * @param x prvek, na jehoz hodnotu bude nastavena hlavni diagonala
     * @return pole modifikovane pole
     */
    private static int[][] nahradDiagonalu (int[][] pole, int x) {
        for (int i = 0; i < pole.length; i++) {
            for (int j = 0; j < pole[i].length; j++) {
                if (i == j) {
                    pole[i][j] = x;
                }
            }
        }

        return pole;
    }

    /**
     * Secte vsechny prvky nad nebo pod hlavni diagonalou
     * @param pole pole, s nimz se pracuje
     * @param pod true = pod diagonalou, false = nad diagonalou
     * @return soucet soucet prvku
     */
    private static int sectiPodNadDiagonalou(int[][] pole, boolean pod) {
        int soucet = 0;

        for (int i = 0; i < pole.length; i++) {
            for (int j = 0; j < pole[i].length; j++) {
                if ((pod) && (i > j)) {
                    soucet += pole[i][j];
                } else if (!(pod) && (j > i)) {
                    soucet += pole[i][j];
                }
            }
        }

        return soucet;
    }
}