Raizekas

Untitled

Mar 2nd, 2021
722
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. import java.util.ArrayList;
  2. import java.util.Scanner;
  3.  
  4. /**
  5.  *
  6.  */
  7. public class Programa
  8. {
  9.     public static void main(String[] args)
  10.     {
  11.       /*  int x = 4;
  12.         pakeistiSkaiciu(x);
  13.         System.out.println(x);
  14.         x = pakeistiSkaiciu2();
  15.         System.out.println(x);*/
  16.  
  17.         //-------------------------------- KINTAMŲJŲ APRAŠYMAS --------------------------------------
  18.         ArrayList<Double> ivestiUgiai = new ArrayList<>();
  19.         ArrayList<Double> didesniUgiai = new ArrayList<>();             // ugiai, kurie yra didensi uz lyginamaji ugi
  20.         double ugiuSuma;
  21.         double ugiuVidurkis;
  22.         int auksciausioIndeksas;
  23.         int zemiausioIndeksas;
  24.  
  25.         double zemiausioUgis;
  26.         double auksciausioUgis;
  27.  
  28.         double lyginamasUgis;
  29.  
  30.         int kiekAukstesniu;
  31.         int kiekAukstesniuOverloadintoMetodo;
  32.  
  33.         int[] overloadintaSumosMasyvas = {3, 5, 7};
  34.         int overloadintaSuma;
  35.  
  36.  
  37.         //----------------------------------- ĮVEDIMO NUSKAITYMAS -------------------------------
  38.         nuskaitymas(ivestiUgiai);
  39.         System.out.println("Iveskite ugi, kuri tikrinsite su kitais ugiais (ar didesni, ar mazesni)");
  40.         lyginamasUgis = nuskaitytiVienaDouble();
  41.         System.out.println("lyginamas ugis: " + lyginamasUgis);
  42.  
  43.  
  44.         //--------------------------------- REIKŠMIŲ PRISKYRIMAS ------------------------------
  45.         ugiuSuma = arrayListSuma(ivestiUgiai);
  46.         ugiuVidurkis = arrayListVidurkis(ivestiUgiai);
  47.         auksciausioIndeksas = maxReiksmesIndeksas(ivestiUgiai);
  48.         zemiausioIndeksas = minReiksmesIndeksas(ivestiUgiai);
  49.  
  50.         zemiausioUgis = ivestiUgiai.get(zemiausioIndeksas);
  51.         auksciausioUgis = ivestiUgiai.get(auksciausioIndeksas);
  52.  
  53.         // Du kreipimaisi i overloadintus metodus
  54.         kiekAukstesniu = kiekDidesniu(ivestiUgiai, lyginamasUgis, didesniUgiai);
  55.         kiekAukstesniuOverloadintoMetodo = kiekDidesniu(ivestiUgiai, lyginamasUgis);
  56.  
  57.         // Overloadinta masyvo suma
  58.         overloadintaSuma = arrayListSuma(overloadintaSumosMasyvas);
  59.  
  60.  
  61.         //-------------------------------- REZULTATŲ IŠVEDIMAI---------------------------
  62.         System.out.println(ivestiUgiai.toString());
  63.         System.out.println("Visu ugiu suma: " + ugiuSuma);
  64.         System.out.println("Ugiu vidurkis: " + ugiuVidurkis);
  65.  
  66.         System.out.println("Auksciausias zmogus buvo " + (auksciausioIndeksas + 1) + "-asis zmogus");
  67.         System.out.println("Auksciausio zmogaus ugis: " + auksciausioUgis);
  68.  
  69.         System.out.println("Zemiausias zmogus buvo " + (zemiausioIndeksas + 1) + "-asis zmogus");
  70.         System.out.println("Zemiausio zmogaus ugis: " + zemiausioUgis);
  71.  
  72.         System.out.println("Yra tiek aukštesnių ūgių už lyginamąjį: " + kiekAukstesniu);
  73.         System.out.println("Šie ūgiai yra: " + didesniUgiai.toString());
  74.         System.out.println("-----------------");
  75.         System.out.println("O čia yra tiek aukštesnių iš overloadinto metodo: " + kiekAukstesniuOverloadintoMetodo);
  76.         System.out.println("Čia būtų overladinta suma: " + overloadintaSuma);
  77.  
  78.  
  79.     }
  80.  
  81.     // Pass by Reference
  82.     public static void nuskaitymas(ArrayList<Double> ivestiUgiai)
  83.     {
  84.         Scanner skaitytuvas = new Scanner(System.in);
  85.  
  86.         String ivestasUgisStr;
  87.         double ivestasUgis;
  88.  
  89.         ivestasUgisStr = skaitytuvas.next();
  90.         while (!ivestasUgisStr.equals("q"))
  91.         {
  92.             ivestasUgis = Double.parseDouble(ivestasUgisStr);
  93.             ivestiUgiai.add(ivestasUgis);
  94.             ivestasUgisStr = skaitytuvas.next();
  95.         }
  96.     }
  97.  
  98.  
  99.     public static double nuskaitytiVienaDouble()
  100.     {
  101.         Scanner skaitytuvas = new Scanner(System.in);
  102.  
  103.         double ugis;
  104.         ugis = skaitytuvas.nextDouble();
  105.         return ugis;
  106.     }
  107.  
  108.  
  109.     // Overloadinta masyvo suma - gauna double ARRAYLIST ir grazina double suma
  110.     public static double arrayListSuma(ArrayList<Double> masyvoList)
  111.     {
  112.         double suma = 0;
  113.         for (int i = 0; i < masyvoList.size(); i++)
  114.         {
  115.             suma += masyvoList.get(i);
  116.             //suma = suma + masyvoList.get(i);
  117.         }
  118.         return suma;
  119.     }
  120.  
  121.  
  122.     // Neina overloadinti metodu jeigu juose yra tik tai ArrayList, kadangi nors ir tarp < > tagu paduodame skirtingą tipą,
  123.     // Tačiau vis vien programa mato tik tiek, jog mes tiek viename, tiek kitame metode paduodame tik tai ArrayList tipo objektą
  124.     public static int arrayListSumaInt(ArrayList<Integer> masyvoList)
  125.     {
  126.         int suma = 0;
  127.         for (int i = 0; i < masyvoList.size(); i++)
  128.         {
  129.             suma += masyvoList.get(i);
  130.             //suma = suma + masyvoList.get(i);
  131.         }
  132.         return suma;
  133.     }
  134.  
  135.  
  136.     // Overloadinta masyvo suma - gauna integer MASYVA ir grazina integer suma
  137.     public static int arrayListSuma(int[] masyvoList)
  138.     {
  139.         int suma = 0;
  140.         for (int i = 0; i < masyvoList.length; i++)
  141.         {
  142.             suma += masyvoList[i];
  143.             //suma = suma + masyvoList.get(i);
  144.         }
  145.         return suma;
  146.     }
  147.  
  148.  
  149.     /**
  150.      * Metodas apskaičiuoja gaunamo ArrayList elementų vidurkį.
  151.      * @param masyvoList - gaunamas double ArrayList, kurio vidurkio ieškosime
  152.      * @return grąžinamas vidurkis double formatu
  153.      */
  154.     public static double arrayListVidurkis(ArrayList<Double> masyvoList)
  155.     {
  156.         double masyvoSuma = arrayListSuma(masyvoList);
  157.         int n = masyvoList.size();
  158.  
  159.         double vidurkis = masyvoSuma / n;
  160.         return vidurkis;
  161.     }
  162.  
  163.  
  164.     public static int maxReiksmesIndeksas(ArrayList<Double> masyvoList)
  165.     {
  166.         int maxIndeksas = 0;
  167.         for (int i = 1; i < masyvoList.size(); i++)
  168.         {
  169.             if (masyvoList.get(i) > masyvoList.get(maxIndeksas))
  170.             {
  171.                 maxIndeksas = i;
  172.             }
  173.         }
  174.         return maxIndeksas;
  175.     }
  176.  
  177.  
  178.     public static int minReiksmesIndeksas(ArrayList<Double> masyvoList)
  179.     {
  180.         int minIndeksas = 0;
  181.         for (int i = 1; i < masyvoList.size(); i++)
  182.         {
  183.             if (masyvoList.get(i) < masyvoList.get(minIndeksas))
  184.             {
  185.                 minIndeksas = i;
  186.             }
  187.         }
  188.         return minIndeksas;
  189.     }
  190.  
  191.     /**
  192.      * Overloadintas metodas, kuris grąžina kiek ir kokie yra didesni elementai už lyginamą elementą
  193.      * @param masyvoList - gaunamas double ArrayList, kurio elementus lyginsime
  194.      * @param lyginamasSk - reikšmė, su kuria lyginsime masyvo skaičius
  195.      * @param didesniElementai - gaunamas double ArrayList į kurį pridėtume tuos elementus, kurie yra didesni už lyginamą reikšmę
  196.      * @return - grąžina int reikšmę, kiek yra didesnių elementų už lyginamą
  197.      */
  198.     // Overlaodintas metodas - taip pat gauna dar ir papildoma arraylist, jame saugo didesnius elementus
  199.     public static int kiekDidesniu(ArrayList<Double> masyvoList, double lyginamasSk, ArrayList<Double> didesniElementai)
  200.     {
  201.         int kiekDaugiau = 0;
  202.         for (int i = 0; i < masyvoList.size(); i++)
  203.         {
  204.             if (masyvoList.get(i) > lyginamasSk)
  205.             {
  206.                 kiekDaugiau++;
  207.                 //kiekDaugiau = kiekDaugiau + 1;
  208.  
  209.                 didesniElementai.add(masyvoList.get(i));
  210.             }
  211.         }
  212.         return kiekDaugiau;
  213.     }
  214.  
  215.  
  216.     // Overloadintas metodas - jis tik tai grazina kiek didesniu, bet nesaugo arraylist
  217.     public static int kiekDidesniu(ArrayList<Double> masyvoList, double lyginamasSk)
  218.     {
  219.         int kiekDaugiau = 0;
  220.         for (int i = 0; i < masyvoList.size(); i++)
  221.         {
  222.             if (masyvoList.get(i) > lyginamasSk)
  223.             {
  224.                 kiekDaugiau++;
  225.                 //kiekDaugiau = kiekDaugiau + 1;
  226.             }
  227.         }
  228.         return kiekDaugiau;
  229.     }
  230.  
  231.  
  232.  
  233.  
  234.  
  235.  
  236.  
  237.  
  238.  
  239.  
  240.  
  241.  
  242.  
  243.  
  244.  
  245.  
  246.  
  247.  
  248.  
  249.  
  250.  
  251.     // Pass by Value
  252.     public static void pakeistiSkaiciu(int x)
  253.     {
  254.         x = 25;
  255.         System.out.println("Viduje metodo: " + x);
  256.     }
  257.  
  258.     // Norint pakeisti skaiciu
  259.     public static int pakeistiSkaiciu2()
  260.     {
  261.         return 25;
  262.     }
  263. }
  264.  
RAW Paste Data

Adblocker detected! Please consider disabling it...

We've detected AdBlock Plus or some other adblocking software preventing Pastebin.com from fully loading.

We don't have any obnoxious sound, or popup ads, we actively block these annoying types of ads!

Please add Pastebin.com to your ad blocker whitelist or disable your adblocking software.

×