daily pastebin goal
25%
SHARE
TWEET

Untitled

a guest Oct 21st, 2018 67 Never
Upgrade to PRO!
ENDING IN00days00hours00mins00secs
  1. public class MyClass {
  2.    
  3.     public static void main(String args[]) {
  4.        
  5.         // Sukuriame 10-ties teigiamų ir neigiamų skaičių masyvą.
  6.         int[] skaiciai = {1,-5,66,-7,-9,10000,1005,3,4,222};
  7.        
  8.         // suskaičiuojame nelyginių skaičių sumą (visus nelyginius sudedame)
  9.         int nelyginiuSuma = nelyginiuSuma(skaiciai);
  10.        
  11.         // suskaičiuojame kiek nelyginių skaičių (narių) turime deklaruotame masyve
  12.         int nelyginiuKiekis = nelyginiuKiekis(skaiciai);
  13.        
  14.         // padalinę nelyginių sumą iš kiekio gauname vidurkį
  15.         double vidurkis = skaiciuotiVidurki(nelyginiuSuma, nelyginiuKiekis);
  16.        
  17.         // išspausdiname suskaičiuotą vidurkį
  18.         System.out.println(vidurkis);
  19.        
  20.         // spausdiname masyvą prieš pakeitimus
  21.         spausdintiMasyva(skaiciai);
  22.        
  23.         // priskiriame 0 (nulį) vietoje mažiausio masyvo nario
  24.         skaiciai[iMin(skaiciai)] = 0;
  25.        
  26.         // priskiriame 0 (nulį) vietoje didžiausio masyvo nario
  27.         skaiciai[iMax(skaiciai)] = 0;
  28.        
  29.         // spausdiname masyvą po pakeitimų
  30.         spausdintiMasyva(skaiciai);
  31.     }
  32.    
  33.     /******************************/
  34.     /* VISOS PAGALBINĖS FUNKCIJOS */
  35.     /******************************/
  36.    
  37.     // funkcija vidurkiui suskaičiuoti
  38.     static double skaiciuotiVidurki(int suma, int kiekis){
  39.         double vidurkis = suma / kiekis;
  40.         return vidurkis;
  41.     }
  42.    
  43.     // funkcija sumai suskaičiuoti, funkcija priima skaičių masyvą
  44.     // ir pati patiktina ar skaičius yra nelyginis.
  45.     static int nelyginiuSuma(int[] skaiciai){
  46.        
  47.         // inicializuojame kintamąjį prie kurio
  48.         // vis pridėsime nelyginį skaičių
  49.         int nelyginiuSuma = 0;
  50.        
  51.         // suksime ciklą tol, kol pereisime visus narius
  52.         // skaiciai.length == 10, todėl naudojame "<", o ne "<="
  53.         for(int i = 0; i < skaiciai.length; ++i){
  54.             if(skaiciai[i] % 2 != 0){ // nelyginis
  55.                 nelyginiuSuma = nelyginiuSuma + skaiciai[i];
  56.             }
  57.         }
  58.        
  59.         return nelyginiuSuma;
  60.     }
  61.    
  62.     // funkcija kiekiui
  63.     static int nelyginiuKiekis(int[] skaiciai){
  64.        
  65.         int nelyginiuKiekis = 0;
  66.        
  67.         // suksime ciklą tol, kol pereisime visus narius
  68.         // skaiciai.length == 10, todėl naudojame "<", o ne "<="
  69.         for(int i = 0; i < skaiciai.length; ++i){
  70.             if(skaiciai[i] % 2 != 0){ // nelyginis
  71.                 nelyginiuKiekis++;
  72.             }
  73.         }
  74.        
  75.         return nelyginiuKiekis;
  76.     }
  77.    
  78.     // funkcija randanti kuris masyvo indeksas (narys)
  79.     // turi pačia mažiausią reikšmę - imin
  80.     static int iMin(int[] skaiciai){
  81.         // 1 | -5 | 66 | -7, -9, 10000, 1005, 3, 4, 222 <-- reikšmės
  82.         // 0 |  1 |  2 | ....                           <-- indeksai
  83.         // ^__ minimumoPozicija
  84.         int minimumoPozicija = 0;
  85.        
  86.         // 1-mas apsisukimas: i = 1, length = 10, 1 < 10 -- TRUE
  87.         // 2-as  apsisukimas: i = 2, length = 10, 2 < 10 -- TRUE
  88.         // 3-ias apsisukimas: i = 3, length = 10, 3 < 10 -- TRUE
  89.         for(int i = 1; i < skaiciai.length; ++i){
  90.             // 1-mas apsisukimas: if(skaiciai[1] < skaiciai[0]) --> if(-5 <  1) --> TRUE
  91.             // 2-as  apsisukimas: if(skaiciai[2] < skaiciai[1]) --> if(66 < -5) --> FALSE
  92.             // 3-ias apsisukimas: if(skaiciai[3] < skaiciai[1]) --> if(-7 < -5) --> TRUE
  93.             if(skaiciai[i] < skaiciai[minimumoPozicija]){
  94.                
  95.                 // 1-mas apsisukimas: minimumoPozicija taps 1
  96.                 // 1 | -5 | 66 | -7 | -9 | 10000, 1005, 3, 4, 222 <-- reikšmės
  97.                 // 0 |  1 |  2 |  3 |  4 |                        <-- indeksai
  98.                 //      ^__ minimumoPozicija
  99.                
  100.                 // 3-ias apsisukimas: minimumoPozicija taps 3
  101.                 // 1 | -5 | 66 | -7 | -9 | 10000, 1005, 3, 4, 222 <-- reikšmės
  102.                 // 0 |  1 |  2 |  3 |  4 |                        <-- indeksai
  103.                 //                ^__ minimumoPozicija
  104.                 minimumoPozicija = i; // įsimename naujojo minimo poziciją
  105.             }
  106.         }
  107.         return minimumoPozicija;
  108.     }
  109.    
  110.     // funkcija randanti kuris masyvo indeksas (narys)
  111.     // turi pačia didžiausią reikšmę - imax
  112.     static int iMax(int[] skaiciai){
  113.        
  114.         int maksimumoPozicija = 0;
  115.        
  116.         for(int i = 1; i < skaiciai.length; ++i){
  117.             if(skaiciai[i] > skaiciai[maksimumoPozicija]){
  118.                 maksimumoPozicija = i;
  119.             }
  120.         }
  121.         return maksimumoPozicija;
  122.     }
  123.    
  124.     // funkcija spausdinti masyvą.
  125.     // Ją panaudojame masyvo spausdinimui
  126.     // prieš ir po pakeitimų. Masyvo nariai
  127.     // atskiriami tarpu (" ").
  128.     static void spausdintiMasyva(int[] skaiciai){
  129.        
  130.         for(int i = 0; i < skaiciai.length; ++i){
  131.             System.out.print(skaiciai[i] + " ");
  132.         }
  133.        
  134.         System.out.println();
  135.     }
  136. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top