ProgalapZHfeladatok

```
package gyakorlas;

/**
 * @author Z T
 */
public class ZHFeladatok {
public static void main(String[] args) {
       //tömbök létrehozása és feltöltése véletlen egész szamokkal
       int []tomb1=new int[20];
       int []tomb2=new int[10];
       int []ujtomb;

       int i;

       for(i=0;i<tomb1.length;i++){
         //random számok képlete random*(B-A+1)+A pl. kétjegyű számok 10-99
         //random*(99-10+1)+10 = 10-99 azaz kétjegyű számok
            tomb1[i]=(int)(Math.random()*90+10);

       }

       for(i=0;i<tomb2.length;i++){
         //random számok negatív tartományban -99 - +99
         //random*(99+99+1)-99
            tomb2[i]=(int)(Math.random()*199-99);
       }
       sorbarendezes(tomb1);
       tombkiiratas(tomb1);
       primszamok(tomb1);
       ujtomb=ismetlodesekeltavolitasa(tomb1);
       System.out.print("Az új tömb ismétlődések nélkül:");
       tombkiiratas(ujtomb);

    }

    public static void tombkiiratas(int []tomb){
        System.out.println("");
        for (int i=0;i<tomb.length;i++){
            System.out.print(tomb[i]+", ");
        }
    }
    public static int[] sorbarendezes(int[] tomb){
        int i,j,csere;
        //Hogyan működik az alábbi rendezés?
        // vegyünk egy pédát: Van egy 4 elemű tömböm ami a küvetkező elemek tartalmazza sorrendben:
        // {4,4,2,1}
        // Szeretném ha ezek sorrenben lennének tehát ez legyen a végeredmény: {1,2,4,4}
        // a lenti kettős ciklus így fut le
        // A külső ciklus (i) veszi a 0. elemt ami 4

        // A belső ciklus (j)
        // Megnézi hogy a 0. elem nagyobb a 0. elemnél, értelemszerűen nem hiszen önmagával hasonlítja
        // lépteti ciklust: j++
        // Megnézi hogy a 0. elem nagyobb a 1. elemnél, 4=4 > nem igaz (nem történik semmi)
        // lépteti ciklust: j++
        // Megnézi hogy a 0. elem nagyobb a 2. elemnél, 4>2 > igaz
        // eltárolja 4 értéket egy ideiglenes <csere> nevű változóba
        // A tömb 0. elemének értékét kicseréli 2-re
        // majd a tömb 2. elemének visszaadja a letárolt értéket vagyis a 4-et
        // Így néz ki most a tömb: {2,4,4,1}
        // lépteti ciklust: j++
        // Megnézi hogy a 0. elem (ami mostmár a 2 értéket tartalmazza) nagyobb a 3. elemnél, 2>1 > igaz
        // eltárolja 2 értéket egy ideiglenes <csere> nevű változóba
        // A tömb 0. elemének értékét kicseréli 1-re
        // majd a tömb 2. elemének visszaadja a letárolt értéket vagyis a 2-et
        // Így néz ki most a tömb: {1,4,4,2}
        // véget ért a j ciklus lépteti az i cilust (i++)
        // és kezdi ujra a j ciklust, de a j kezdőértéke i-vel lesz egyenlő
        // Megnézi hogy a 1. elem nagyobb a 1. elemnél 4>4 -> hamis
        // lépteti ciklust: j++
        // Megnézi hogy a 1. elem nagyobb a 2. elemnél 4>4 -> hamis
        // lépteti ciklust: j++
        // Megnézi hogy a 1. elem nagyobb a 3. elemnél 4>2 -> igaz
        //eltárolja 4 értéket egy ideiglenes <csere> nevű változóba
        // A tömb 1. elemének értékét kicseréli 2-re
        // majd a tömb 3. elemének visszaadja a letárolt értéket vagyis a 4-et
        // Így néz ki most a tömb: {1,2,4,4}  (ami egyébként már jó, de ezt csak mi tudjuk, a ciklus végig fog futni :)
        // véget ért a j ciklus lépteti az i cilust (i++)
        // és kezdi ujra a j ciklust, de a j kezdőértéke i-vel lesz egyenlő
        // Megnézi hogy a 2. elem nagyobb a 2. elemnél 4>4 -> hamis
        // lépteti ciklust: j++
        // Megnézi hogy a 2. elem nagyobb a 3. elemnél 4>4 -> hamis
        // véget ért a j ciklus lépteti az i cilust (i++)
        // és kezdi ujra a j ciklust, de a j kezdőértéke i-vel lesz egyenlő
        // Megnézi hogy a 3. elem nagyobb a 3. elemnél 4>4 -> hamis
        // véget ért a j ciklus
        // véget ért a i ciklus
        // a végeredmény a rendezett tömb: {1,2,4,4}
        for (i=0;i<tomb.length;i++){
            for (j=i;j<tomb.length;j++){
                if (tomb[i]>tomb[j]){
                    csere=tomb[i];
                    tomb[i]=tomb[j];
                    tomb[j]=csere;
                }
            }
        }
    return tomb;
    }
    public static void primszamok(int[] tomb){
        int i,j,osztok=0;
        System.out.println("\nA tömbben a következő prímszámok találhatók: ");
        for (i=0;i<tomb.length;i++){ // Nézzük meg az összes elemet a tömbben
            for (j=2;j<tomb[i];j++){ // nézzük meg az osszes osztót<j> 2-től a szám-ig (a számmal már nem osztjuk)
              if (tomb[i]%j==0){     // Ha az osztás maradéka 0 akkor
                  osztok++;          // az <osztok> számát növeljük 1-el
              }
            }
            if (osztok==0){           // Ha az osztók száma 0 maradt akkor ez egy prímszám
                System.out.println("Elem sorszáma:"+i+", értéke:"+tomb[i]); // irassuk ki az értéket

            }
            osztok=0;               // ne felejtsük el visszaállítani az osztók számát 0-ra
        }                           // nézzük a következő elemét a tömbnek
    }
    public static int[] ismetlodesekeltavolitasa(int[] tomb){
        //az eljárás az visszatérési értéke egy tömb amiben az eredeti tömb elemi csak egyszer szerepelnek
        int i,j,szamlalo=0;
        boolean bennevan=false,nullamegvan=false;
        // Hozzunk létre egy tömböt(tomb2) amibe majd az egyedi értékeket töltjük
        // Ennek a mérete akkora kell legyen mint a kapott tomb mérete
        // hiszen lehet, hogy a kapott tömbben nincsenek többször előforduló értékek
        int[] tomb2=new int[tomb.length];  //Ezzel a deklarációval és inicializálással a tomb2 összes elemének értéke 0 lesz!
        // Ezt később le kell kezelnünk
        for (i=0;i<tomb.length;i++){    //Nézzük végig a tömb összes elemét
            for (j=0;j<tomb2.length;j++){ // Nézzük meg hogy a tomb i-edik elem benne van e már az új tömbünkben (tömb2)

                if (tomb[i]==tomb2[j]){
                    bennevan=true;  //Ha benne van állítsuk az erre a célra létrehozott változó értékét igazra
                 }
            }
            if (tomb[i]==0 && nullamegvan==false ){ // Ezzel kezeljük le a nulla érétéket, amikor a ciklus előszőr találkozik azzal hogy
                // az eredeti tömb i-edik elemének értéke nulla akkor végrehajtja az alábbiakat
                tomb2[szamlalo]=tomb[i]; //eltárolja a nullát az egyedi értékeket tartalmazó tömbbe
                szamlalo++; // lépteti a tömb eleminek számlálóját
                nullamegvan=true; // és átálítja az erre a célra deklarált változót, hogy többet ne foglalkozzon a nullával
            }
            if (!bennevan){
                tomb2[szamlalo]=tomb[i]; // ha j ciklusban nem találta meg a tömb2 ben az aktuális elemet akkor felveszi új értékként
                szamlalo++;

            }
            bennevan=false; // ne felejtsük el visszaállítani a változó értékét hamisra, különben nem vesz fel új elemet a ciklus a tömb2-be
        }
        // Megvan az új tömbünk amibe már nincsenek dupla értéke, de a tömb eleminek vége tele van nullákkal
        // mivel megvan még a <szamlalo> nevű változó ezért most már tudjuk, hogy mekkora elemszámú tömbbe kellene
        // letárolni az új értékeket
        int[] ujtomb=new int[szamlalo]; // deklaráljuk le
        for (i=0;i<ujtomb.length;i++){ // és töltsük fel az értékekkel
            ujtomb[i]=tomb2[i];
        }
    return ujtomb; // majd adjuk vissza annak aki meghívta
    }
}

```