public class MyClass {

    public static void main(String args[]) {

        // Sukuriame 10-ties teigiamų ir neigiamų skaičių masyvą.
        int[] skaiciai = {1,-5,66,-7,-9,10000,1005,3,4,222};

        // suskaičiuojame nelyginių skaičių sumą (visus nelyginius sudedame)
        int nelyginiuSuma = nelyginiuSuma(skaiciai);

        // suskaičiuojame kiek nelyginių skaičių (narių) turime deklaruotame masyve
        int nelyginiuKiekis = nelyginiuKiekis(skaiciai);

        // padalinę nelyginių sumą iš kiekio gauname vidurkį
        double vidurkis = skaiciuotiVidurki(nelyginiuSuma, nelyginiuKiekis);

        // išspausdiname suskaičiuotą vidurkį
        System.out.println(vidurkis);

        // spausdiname masyvą prieš pakeitimus
        spausdintiMasyva(skaiciai);

        // priskiriame 0 (nulį) vietoje mažiausio masyvo nario
        skaiciai[iMin(skaiciai)] = 0;

        // priskiriame 0 (nulį) vietoje didžiausio masyvo nario
        skaiciai[iMax(skaiciai)] = 0;

        // spausdiname masyvą po pakeitimų
        spausdintiMasyva(skaiciai);
    }

    /******************************/
    /* VISOS PAGALBINĖS FUNKCIJOS */
    /******************************/

    // funkcija vidurkiui suskaičiuoti
    static double skaiciuotiVidurki(int suma, int kiekis){
        double vidurkis = suma / kiekis;
        return vidurkis;
    }

    // funkcija sumai suskaičiuoti, funkcija priima skaičių masyvą
    // ir pati patiktina ar skaičius yra nelyginis.
    static int nelyginiuSuma(int[] skaiciai){

        // inicializuojame kintamąjį prie kurio
        // vis pridėsime nelyginį skaičių
        int nelyginiuSuma = 0;

        // suksime ciklą tol, kol pereisime visus narius
        // skaiciai.length == 10, todėl naudojame "<", o ne "<="
        for(int i = 0; i < skaiciai.length; ++i){
            if(skaiciai[i] % 2 != 0){ // nelyginis
                nelyginiuSuma = nelyginiuSuma + skaiciai[i];
            }
        }

        return nelyginiuSuma;
    }

    // funkcija kiekiui
    static int nelyginiuKiekis(int[] skaiciai){

        int nelyginiuKiekis = 0;

        // suksime ciklą tol, kol pereisime visus narius
        // skaiciai.length == 10, todėl naudojame "<", o ne "<="
        for(int i = 0; i < skaiciai.length; ++i){
            if(skaiciai[i] % 2 != 0){ // nelyginis
                nelyginiuKiekis++;
            }
        }

        return nelyginiuKiekis;
    }

    // funkcija randanti kuris masyvo indeksas (narys)
    // turi pačia mažiausią reikšmę - imin
    static int iMin(int[] skaiciai){
        // 1 | -5 | 66 | -7, -9, 10000, 1005, 3, 4, 222 <-- reikšmės
        // 0 |  1 |  2 | ....                           <-- indeksai
        // ^__ minimumoPozicija
        int minimumoPozicija = 0;

        // 1-mas apsisukimas: i = 1, length = 10, 1 < 10 -- TRUE
        // 2-as  apsisukimas: i = 2, length = 10, 2 < 10 -- TRUE
        // 3-ias apsisukimas: i = 3, length = 10, 3 < 10 -- TRUE
        for(int i = 1; i < skaiciai.length; ++i){
            // 1-mas apsisukimas: if(skaiciai[1] < skaiciai[0]) --> if(-5 <  1) --> TRUE
            // 2-as  apsisukimas: if(skaiciai[2] < skaiciai[1]) --> if(66 < -5) --> FALSE
            // 3-ias apsisukimas: if(skaiciai[3] < skaiciai[1]) --> if(-7 < -5) --> TRUE
            if(skaiciai[i] < skaiciai[minimumoPozicija]){

                // 1-mas apsisukimas: minimumoPozicija taps 1
                // 1 | -5 | 66 | -7 | -9 | 10000, 1005, 3, 4, 222 <-- reikšmės
                // 0 |  1 |  2 |  3 |  4 |                        <-- indeksai
                //      ^__ minimumoPozicija

                // 3-ias apsisukimas: minimumoPozicija taps 3
                // 1 | -5 | 66 | -7 | -9 | 10000, 1005, 3, 4, 222 <-- reikšmės
                // 0 |  1 |  2 |  3 |  4 |                        <-- indeksai
                //                ^__ minimumoPozicija
                minimumoPozicija = i; // įsimename naujojo minimo poziciją
            }
        }
        return minimumoPozicija;
    }

    // funkcija randanti kuris masyvo indeksas (narys)
    // turi pačia didžiausią reikšmę - imax
    static int iMax(int[] skaiciai){

        int maksimumoPozicija = 0;

        for(int i = 1; i < skaiciai.length; ++i){
            if(skaiciai[i] > skaiciai[maksimumoPozicija]){
                maksimumoPozicija = i;
            }
        }
        return maksimumoPozicija;
    }

    // funkcija spausdinti masyvą.
    // Ją panaudojame masyvo spausdinimui
    // prieš ir po pakeitimų. Masyvo nariai
    // atskiriami tarpu (" ").
    static void spausdintiMasyva(int[] skaiciai){

        for(int i = 0; i < skaiciai.length; ++i){
            System.out.print(skaiciai[i] + " ");
        }

        System.out.println();
    }
}