C6

import java.util.Arrays;

public class Generator {
        /**
         * Pole, v ktorom generujeme postupnost
         */
        private int[] pole;
        private int minimalnyRozdiel;
        private int[] ktoMaCo;
        private int[] lup;

        /**
         * Spracuje hodnoty v postupnosti - vypise ich
         */
        private void vypis() {
                //System.out.println(Arrays.toString(pole));
                if(minimalnyRozdiel>pocitajRozdiel(pole)){
                        minimalnyRozdiel=pocitajRozdiel(pole);
                        System.arraycopy(pole, 0, ktoMaCo, 0, pole.length);
                }

        }

        /**
         * Generuje variacie s opakovanim v podpoli pocnuc indexom odIndexu
         */
        private void generuj(int odIndexu) {
                if (odIndexu == pole.length) {
                        vypis();
                        return;
                }

                for (int i = 0; i <= 1; i++) {
                        pole[odIndexu] = i;
                        generuj(odIndexu + 1);
                        // Eventualne mozeme vratit obsah pola do povodneho stavu - ale je
                        // to zbytocne...
                        // pole[odIndexu] = 0;
                }
        }

        /**
         * Nastartuje generovanie
         */
        public void generuj() {
                generuj(0);
                System.out.println(Arrays.toString(ktoMaCo));
        }

        public Generator(int[] lup) {
                minimalnyRozdiel=Integer.MAX_VALUE;
                pole = new int[lup.length];
                this.lup = lup;
                ktoMaCo=new int[lup.length];
        }

        private int pocitajRozdiel(int[] vygenerovane) {
                int prvyLup = 0;
                int druhyLup = 0;
                for (int i = 0; i < vygenerovane.length; i++) {
                        if (vygenerovane[i] == 0) {
                                prvyLup = prvyLup + lup[i];
                        }
                        if (vygenerovane[i] == 1) {
                                druhyLup = druhyLup + lup[i];
                        }
                        //System.out.println("0: "+prvyLup+" 1: "+druhyLup);
                }
                //System.out.println("0: "+prvyLup+" 1: "+druhyLup);
                return Math.abs(prvyLup - druhyLup);
        }

        public static void main(String[] args) {
                int[] lup = {90, 20, 30, 1, 1, 50};
                Generator g = new Generator(lup);
                g.generuj();
        }
}

import java.util.Arrays;

public class GeneratorBezOpakovania {
        //damy na sachovnici
        /**
         * Pole v ktorom generujeme variacie
         */
        private int[] pole;

        /**
         * Pole, v ktorom uchovavame, ci sa hodnota i (i=1..n) nachadza v poli pole.
         */
        private boolean[] uzBolo;

        /**
         * Urcuje velkost mnoziny, z ktorej vytvarame variacie bez opakovania ({1,
         * ..., n})
         */
        private int n;

        private void vypis() {

                for(int i=0;i<n;i++){
                        for(int j=i+1;j<n;j++){
                                if(Math.abs(pole[i]-pole[j])==Math.abs(i-j))
                                        return;
                        }
                }
                System.out.println(Arrays.toString(pole));
        }

        private void generuj(int odIndexu) {
                // Ak sme vygenerovali vsetky hodnoty v poli, tak pole vypiseme
                if (odIndexu == pole.length) {
                        vypis();
                        return;
                }

                for (int i = 1; i <= n; i++) {
                        // Cislo i ulozime do pola, iba ak sa este nenachadza na indexoch
                        // 0..(odIndexu-1)
                        if (!uzBolo[i]) {
                                // Poznacime si pridanie hodnoty i do pola
                                uzBolo[i] = true;
                                pole[odIndexu] = i;
                                // Generujeme variacie bez opakovania od indexu odIndexu+1
                                generuj(odIndexu + 1);
                                // pole[odIndexu] = 0;
                                // Poznacime si odobratie hodnoty i z pola
                                uzBolo[i] = false;
                        }
                }
        }

        public void generuj() {
                generuj(0);
        }

        public GeneratorBezOpakovania(int n) {
                // Ulozime si parameter n
                this.n = n;
                // Vytvorime pole, do ktoreho budeme generovat variacie
                pole = new int[n];
                // Vytvorime pole s indexami 0..n, v ktorom si pre cisla v rozsahu 1..n
                // budeme pamatat, ci sme ich pouzili
                uzBolo = new boolean[n + 1];
        }

        public static void main(String[] args) {
                GeneratorBezOpakovania g = new GeneratorBezOpakovania(8);
                g.generuj();
        }
}

import java.util.Arrays;

public class NepriatelseCisla {
        /**
         * Pole v ktorom generujeme variacie
         */
        private int[] pole;
        private int pocetZlych;
        private int pocetVsetkych;
        private int pocetCisel;

        /**
         * Pole, v ktorom uchovavame, ci sa hodnota i (i=1..n) nachadza v poli pole.
         */
        private boolean[] uzBolo;

        /**
         * Urcuje velkost mnoziny, z ktorej vytvarame variacie bez opakovania ({1,
         * ..., n})
         */
        private int n;

        private void vypis() {
                pocetVsetkych++;
                for (int i = 1; i < n - 1; i++) {
                        if ((pole[i] % pole[i + 1] == 0) || (pole[i + 1] % pole[i] == 0)) {
                                pocetZlych++;
                                return;
                        }
                }
                System.out.println(Arrays.toString(pole));
        }

        private boolean jeToOK(int i) {
                if (i > 1) {
                        if (((pole[i] % pole[i - 1] == 0) || (pole[i - 1] % pole[i] == 0)))
                                return false;
                        else
                                return true;
                } else
                        return true;
        }

        private void generuj(int odIndexu) {

                // Ak sme vygenerovali vsetky hodnoty v poli, tak pole vypiseme
                if (odIndexu == pole.length) {
                        vypis();
                        return;
                }

                for (int i = 1; i <= n; i++) {

                        // Cislo i ulozime do pola, iba ak sa este nenachadza na indexoch
                        // 0..(odIndexu-1)
                        if ((!uzBolo[i])) {

                                // Poznacime si pridanie hodnoty i do pola
                                uzBolo[i] = true;
                                pole[odIndexu] = i;
                                // Generujeme variacie bez opakovania od indexu odIndexu+1
                                if(jeToOK(odIndexu)){
                                generuj(odIndexu + 1);
                                pocetCisel++;
                                }
                                // pole[odIndexu] = 0;
                                // Poznacime si odobratie hodnoty i z pola
                                uzBolo[i] = false;
                        }
                }
        }

        public void generuj() {
                pocetVsetkych = 0;
                pocetZlych = 0;
                pocetCisel = 0;
                generuj(0);
                System.out.println("Pocet vsetkych vygenetovanych celych "+n+"-tic: "
                                + pocetVsetkych + "\npocet zlych "+n+"-tic: " + pocetZlych);
                System.out.println("Pocet vygenerovanych cisel: " + pocetCisel);
        }

        public NepriatelseCisla(int n) {
                // Ulozime si parameter n
                this.n = n;
                // Vytvorime pole, do ktoreho budeme generovat variacie
                pole = new int[n];
                // Vytvorime pole s indexami 0..n, v ktorom si pre cisla v rozsahu 1..n
                // budeme pamatat, ci sme ich pouzili
                uzBolo = new boolean[n + 1];
        }

        public static void main(String[] args) {
                NepriatelseCisla g = new NepriatelseCisla(5);
                g.generuj();
        }
}

import java.lang.reflect.Array;
import java.util.Arrays;

public class Generator {
        /**
         * Pole, v ktorom generujeme postupnost
         */
        private int[] pole;

        private int najmensiRozdiel = Integer.MAX_VALUE;
        private int[] najlepsiVyber = { 0, 0, 0, 0, 0, 0 };
        private int[] ceny = { 90, 20, 30, 1, 1, 50 };

        public int[] getPole() {
                return pole;
        }

        public void setPole(int[] pole) {
                this.pole = pole;
        }

        /**
         * Spracuje hodnoty v postupnosti - vypise ich
         */
        private void vypis() {
                System.out.println(Arrays.toString(pole));
        }

        /**
         * Generuje variacie s opakovanim v podpoli pocnuc indexom odIndexu
         */
        private void generuj(int odIndexu, int[] mnozina) {
                if (odIndexu == pole.length) {
                        spracuj(pole);
                        // vypis();
                        return;
                }

                for (int i = 0; i < mnozina.length; i++) {
                        pole[odIndexu] = mnozina[i];
                        generuj(odIndexu + 1, mnozina);
                        // Eventualne mozeme vratit obsah pola do povodneho stavu - ale je
                        // to zbytocne...
                        // pole[odIndexu] = 0;
                }
        }

        public int[] spracuj(int[] pole) {
                int prvy = 0;
                int druhy = 0;
                for (int i = 0; i < pole.length; i++) {
                        if (pole[i] == 1) {
                                prvy += ceny[i];
                        } else
                                druhy += ceny[i];
                }
                if (najmensiRozdiel > Math.abs(prvy - druhy)) {
                        najmensiRozdiel = Math.abs(prvy - druhy);
                        najlepsiVyber = pole.clone();
                }
                return najlepsiVyber;
        }

        /**
         * Nastartuje generovanie
         */
        public int[] generuj(int[] mnozina) {
                generuj(0, mnozina);
                return najlepsiVyber;
        }

        public Generator(int k) {
                pole = new int[k];
        }

        public static void main(String[] args) {
                Generator g = new Generator(6);
                int[] mnozina = { 1, 0 };

                System.out.println(Arrays.toString(g.generuj(mnozina)));
        }
}

import java.io.*;
import java.util.*;

public class Trezor {

    /**
     * Trieda uchovavajuca udaje o jednom predmete
     */
    public static class Predmet {
        int cena;
        int velkost;
    }

    /**
     * Zoznam predmetov v trezore
     */
    int[] predmety;

    /**
     * Najlepsi najdeny vyber
     */
    private int[] najVyber;
    /**
     * Cena najlepsieho najdeneho vyberu
     */
    private int najrozdiel=Integer.MAX_VALUE;

    /**
     * Kapacita batohu
     */
    private int kapacitaBatoha;

    /**
     * Pole, v ktorom generujeme 0 a 1 - vsetky moznosti vyberu
     */
    private int[] vyber;

    /**
     * Spracuje vyber
     */
    private void spracuj() {
        // Pre aktualny vyber spocitame celkovu velkost a celkovu cenu vyberu
        int celkovaVelkost = 0;
        int celkovaCena1 = 0;
        int celkovaCena2=0;
        for (int i = 0; i < vyber.length; i++) {
            if (vyber[i] == 1) {
                celkovaVelkost += predmety[i];
                celkovaCena1 += predmety[i];
            }else{
                celkovaCena2 += predmety[i];
            }
        }

        // Overime, ci sa vyber zmesti do batoha


        // Ak je aktualny vyber ako najlepsi, co sme doposial mali, tak si ho
        // ulozime
        if (Math.abs(celkovaCena1-celkovaCena2 )< najrozdiel) {
            najrozdiel = Math.abs(celkovaCena1-celkovaCena2 );
            najVyber = vyber.clone();
        }

    }

    /**
     * Generuje vsetky mozne vybery pocnuc odIdx-tym predmetom
     */
    private void generuj(int odIdx) {
        if (vyber.length == odIdx) {
            spracuj();
            return;
        }

        vyber[odIdx] = 0;
        generuj(odIdx + 1);

        vyber[odIdx] = 1;
        generuj(odIdx + 1);
    }

    public int[] najlepsiVyber() {
        // Inicializujeme hladanie najlepsieho vyberu

najVyber= new int[predmety.length];
        // Vytvorime pole, do ktoreho budeme generovat vysledok
        vyber = new int[predmety.length];
        // Spustime generovanie
        generuj(0);

        // Vyberieme zoznam predmetov v najlepsom najdenom vybere
        int[] vysledok1= new int[predmety.length];
        int[]  vysledok2 = new int[predmety.length];

        for (int i = 0; i < predmety.length; i++)
            if (najVyber[i] == 1) {
                vysledok1[i]=predmety[i];
            }else{
                vysledok2[i]=predmety[i];
            }


        return vysledok1;
    }



    public static void main(String[] args) {
        Trezor trezor = new Trezor();

        trezor.predmety=new int[]{90,20,30,1,1,50};
        int[] vyber= trezor.najlepsiVyber();
        System.out.println(trezor.najrozdiel);

    }
}

import java.util.Arrays;

public class KoneNaSachovnici {

        /**
         * Pole v ktorom generujeme variacie
         */
        private int[] pole;
        private int pocetRieseni = 0;
        private int pocetGenerovani = 0;
        private int prveRiesenie = 0;

        /**
         * Pole, v ktorom uchovavame, ci sa hodnota i (i=1..n) nachadza v poli pole.
         */
        private boolean[] uzBolo;

        /**
         * Urcuje velkost mnoziny, z ktorej vytvarame variacie bez opakovania ({1,
         * ..., n})
         */
        private int n;
        private int r;

        private void vypis() {
                // System.out.println(Arrays.toString(pole));

                for (int i = 0; i < pole.length - 1; i++) {
                        if (!(((Math.abs((pole[i] - 1) % r - (pole[i + 1] - 1) % r) == 2) && (Math
                                        .abs((pole[i] - 1) / r - (pole[i + 1] - 1) / r) == 1)) || ((Math
                                        .abs((pole[i] - 1) % r - (pole[i + 1] - 1) % r) == 1) && (Math
                                        .abs((pole[i] - 1) / r - (pole[i + 1] - 1) / r) == 2)))) {
                                // System.out.println("zle je");
                                return;
                        }
                }

                // System.out.println(Arrays.toString(pole));
                pocetRieseni++;
                if (prveRiesenie == 0) {
                        prveRiesenie = pocetGenerovani;
                        System.out.println("prveRiesenie: " + prveRiesenie);
                        for (int i = 0; i < pole.length; i++) {
                                System.out.print(pole[i] - 1 + " ");
                        }
                        System.out.println();
                }

        }

        public static boolean jeToOK(int i, int[] pole, int r) {
                if (i == 0)
                        return true;
                i = i - 1;

                if (!(((Math.abs((pole[i] - 1) % r - (pole[i + 1] - 1) % r) == 2) && (Math
                                .abs((pole[i] - 1) / r - (pole[i + 1] - 1) / r) == 1)) || ((Math
                                .abs((pole[i] - 1) % r - (pole[i + 1] - 1) % r) == 1) && (Math
                                .abs((pole[i] - 1) / r - (pole[i + 1] - 1) / r) == 2)))) {
                        // System.out.println("zle je");
                        return false;
                }

                return true;
        }

        public boolean jeToOK(int i) {
                if (i == 0)
                        return true;
                i = i - 1;
                if (!(((Math.abs((pole[i] - 1) % r - (pole[i + 1] - 1) % r) == 2) && (Math
                                .abs((pole[i] - 1) / r - (pole[i + 1] - 1) / r) == 1)) || ((Math
                                .abs((pole[i] - 1) % r - (pole[i + 1] - 1) % r) == 1) && (Math
                                .abs((pole[i] - 1) / r - (pole[i + 1] - 1) / r) == 2)))) {
                        // System.out.println("zle je");
                        return false;
                }

                return true;
        }

        private void generuj(int odIndexu) {
                // Ak sme vygenerovali vsetky hodnoty v poli, tak pole vypiseme
                if (odIndexu == pole.length) {
                        vypis();
                        return;
                }

                for (int i = 1; i <= n; i++) {
                        // Cislo i ulozime do pola, iba ak sa este nenachadza na indexoch
                        // 0..(odIndexu-1)
                        if (!uzBolo[i]) {

                                // Poznacime si pridanie hodnoty i do pola
                                uzBolo[i] = true;
                                pole[odIndexu] = i;
                                // Generujeme variacie bez opakovania od indexu odIndexu+1
                                //if (jeToOK(odIndexu)) {
                                        generuj(odIndexu + 1);
                                        pocetGenerovani++;
                                //}
                                // pole[odIndexu] = 0;
                                // Poznacime si odobratie hodnoty i z pola
                                uzBolo[i] = false;
                        }
                }
        }

        public void generuj() {
                generuj(0);
                System.out.println(pocetRieseni);
                System.out.println(pocetGenerovani);
                System.out.println(prveRiesenie);
        }

        public KoneNaSachovnici(int n) {

                // Ulozime si parameter n
                this.n = n * n;

                // Vytvorime pole, do ktoreho budeme generovat variacie
                pole = new int[n * n];

                // Vytvorime pole s indexami 0..n, v ktorom si pre cisla v rozsahu 1..n
                // budeme pamatat, ci sme ich pouzili
                uzBolo = new boolean[n * n + 1];
                this.r = n;

        }

        public static void main(String[] args) {
                // int[] pole=new int[2];
                // pole[0]=12;
                // for (int i = 0; i < 25; i++) {
                // pole[1]=i;
                // System.out.println(jeToOK(1, pole, 5)+" "+i);
                // }
                KoneNaSachovnici g = new KoneNaSachovnici(5);
                g.generuj();
        }
}
 

import java.util.Arrays;

public class NepriatelseCisla {
        /**
         * Pole v ktorom generujeme variacie
         */
        private int[] pole;
        private int pocetZlych;
        private int pocetVsetkych;
        private int pocetCisel;

        /**
         * Pole, v ktorom uchovavame, ci sa hodnota i (i=1..n) nachadza v poli pole.
         */
        private boolean[] uzBolo;

        /**
         * Urcuje velkost mnoziny, z ktorej vytvarame variacie bez opakovania ({1,
         * ..., n})
         */
        private int n;

        private void vypis() {
                pocetVsetkych++;
                for (int i = 1; i < n - 1; i++) {
                        if ((pole[i] % pole[i + 1] == 0) || (pole[i + 1] % pole[i] == 0)) {
                                pocetZlych++;
                                return;
                        }
                }
                System.out.println(Arrays.toString(pole));
        }

        private boolean jeToOK(int i) {
                if (i > 1) {
                        if (((pole[i] % pole[i - 1] == 0) || (pole[i - 1] % pole[i] == 0)))
                                return false;
                        else
                                return true;
                } else
                        return true;
        }

        private void generuj(int odIndexu) {

                // Ak sme vygenerovali vsetky hodnoty v poli, tak pole vypiseme
                if (odIndexu == pole.length) {
                        vypis();
                        return;
                }

                for (int i = 1; i <= n; i++) {

                        // Cislo i ulozime do pola, iba ak sa este nenachadza na indexoch
                        // 0..(odIndexu-1)
                        if ((!uzBolo[i])) {

                                // Poznacime si pridanie hodnoty i do pola
                                uzBolo[i] = true;
                                pole[odIndexu] = i;
                                // Generujeme variacie bez opakovania od indexu odIndexu+1
                                if(jeToOK(odIndexu)){
                                generuj(odIndexu + 1);
                                pocetCisel++;
                                }
                                // pole[odIndexu] = 0;
                                // Poznacime si odobratie hodnoty i z pola
                                uzBolo[i] = false;
                        }
                }
        }

        public void generuj() {
                pocetVsetkych = 0;
                pocetZlych = 0;
                pocetCisel = 0;
                generuj(0);
                System.out.println("Pocet vsetkych vygenetovanych celych "+n+"-tic: "
                                + pocetVsetkych + "\npocet zlych "+n+"-tic: " + pocetZlych);
                System.out.println("Pocet vygenerovanych cisel: " + pocetCisel);
        }

        public NepriatelseCisla(int n) {
                // Ulozime si parameter n
                this.n = n;
                // Vytvorime pole, do ktoreho budeme generovat variacie
                pole = new int[n];
                // Vytvorime pole s indexami 0..n, v ktorom si pre cisla v rozsahu 1..n
                // budeme pamatat, ci sme ich pouzili
                uzBolo = new boolean[n + 1];
        }

        public static void main(String[] args) {
                NepriatelseCisla g = new NepriatelseCisla(5);
                g.generuj();
        }
}

import java.util.Arrays;

public class KoneNaSachovnici {

        /**
         * Pole v ktorom generujeme variacie
         */
        private int[] pole;
        private int pocetRieseni = 0;
        private int pocetGenerovani = 0;
        private int prveRiesenie = 0;

        /**
         * Pole, v ktorom uchovavame, ci sa hodnota i (i=1..n) nachadza v poli pole.
         */
        private boolean[] uzBolo;

        /**
         * Urcuje velkost mnoziny, z ktorej vytvarame variacie bez opakovania ({1,
         * ..., n})
         */
        private int n;
        private int r;

        private void vypis() {
                // System.out.println(Arrays.toString(pole));

                for (int i = 0; i < pole.length - 1; i++) {
                        if (!(((Math.abs((pole[i] - 1) % r - (pole[i + 1] - 1) % r) == 2) && (Math
                                        .abs((pole[i] - 1) / r - (pole[i + 1] - 1) / r) == 1)) || ((Math
                                        .abs((pole[i] - 1) % r - (pole[i + 1] - 1) % r) == 1) && (Math
                                        .abs((pole[i] - 1) / r - (pole[i + 1] - 1) / r) == 2)))) {
                                // System.out.println("zle je");
                                return;
                        }
                }

                // System.out.println(Arrays.toString(pole));
                pocetRieseni++;
                if (prveRiesenie == 0) {
                        prveRiesenie = pocetGenerovani;
                        System.out.println("prveRiesenie: " + prveRiesenie);
                        for (int i = 0; i < pole.length; i++) {
                                System.out.print(pole[i] - 1 + " ");
                        }
                        System.out.println();
                }

        }

        public static boolean jeToOK(int i, int[] pole, int r) {
                if (i == 0)
                        return true;
                i = i - 1;

                if (!(((Math.abs((pole[i] - 1) % r - (pole[i + 1] - 1) % r) == 2) && (Math
                                .abs((pole[i] - 1) / r - (pole[i + 1] - 1) / r) == 1)) || ((Math
                                .abs((pole[i] - 1) % r - (pole[i + 1] - 1) % r) == 1) && (Math
                                .abs((pole[i] - 1) / r - (pole[i + 1] - 1) / r) == 2)))) {
                        // System.out.println("zle je");
                        return false;
                }

                return true;
        }

        public boolean jeToOK(int i) {
                if (i == 0)
                        return true;
                i = i - 1;
                if (!(((Math.abs((pole[i] - 1) % r - (pole[i + 1] - 1) % r) == 2) && (Math
                                .abs((pole[i] - 1) / r - (pole[i + 1] - 1) / r) == 1)) || ((Math
                                .abs((pole[i] - 1) % r - (pole[i + 1] - 1) % r) == 1) && (Math
                                .abs((pole[i] - 1) / r - (pole[i + 1] - 1) / r) == 2)))) {
                        // System.out.println("zle je");
                        return false;
                }

                return true;
        }

        private void generuj(int odIndexu) {
                // Ak sme vygenerovali vsetky hodnoty v poli, tak pole vypiseme
                if (odIndexu == pole.length) {
                        vypis();
                        return;
                }

                for (int i = 1; i <= n; i++) {
                        // Cislo i ulozime do pola, iba ak sa este nenachadza na indexoch
                        // 0..(odIndexu-1)
                        if (!uzBolo[i]) {

                                // Poznacime si pridanie hodnoty i do pola
                                uzBolo[i] = true;
                                pole[odIndexu] = i;
                                // Generujeme variacie bez opakovania od indexu odIndexu+1
                                if (jeToOK(odIndexu)) {
                                        generuj(odIndexu + 1);
                                        pocetGenerovani++;
                                }
                                // pole[odIndexu] = 0;
                                // Poznacime si odobratie hodnoty i z pola
                                uzBolo[i] = false;
                        }
                }
        }

        public void generuj() {
                generuj(0);
                System.out.println(pocetRieseni);
                System.out.println(pocetGenerovani);
                System.out.println(prveRiesenie);
        }

        public KoneNaSachovnici(int n) {

                // Ulozime si parameter n
                this.n = n * n;

                // Vytvorime pole, do ktoreho budeme generovat variacie
                pole = new int[n * n];

                // Vytvorime pole s indexami 0..n, v ktorom si pre cisla v rozsahu 1..n
                // budeme pamatat, ci sme ich pouzili
                uzBolo = new boolean[n * n + 1];
                this.r = n;

        }

        public static void main(String[] args) {
                // int[] pole=new int[2];
                // pole[0]=12;
                // for (int i = 0; i < 25; i++) {
                // pole[1]=i;
                // System.out.println(jeToOK(1, pole, 5)+" "+i);
                // }
                KoneNaSachovnici g = new KoneNaSachovnici(5);
                g.generuj();
        }
}

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public class PermutacieSlova {
        /**
         * Pole v ktorom generujeme variacie
         */
        private int[] pole;
        private String s;
        private Set<String> vsetkySlova;

        /**
         * Pole, v ktorom uchovavame, ci sa hodnota i (i=1..n) nachadza v poli pole.
         */
        private boolean[] uzBolo;

        /**
         * Urcuje velkost mnoziny, z ktorej vytvarame variacie bez opakovania ({1,
         * ..., n})
         */
        private int n;

        private void vypis() {
                System.out.println(Arrays.toString(pole));
                String vysledok="";
                for(int i=0;i<s.length();i++){
                        vysledok=vysledok+s.charAt(pole[i]-1);
                }
                System.out.println(vysledok);
                vsetkySlova.add(vysledok);
        }

        private void generuj(int odIndexu) {
                // Ak sme vygenerovali vsetky hodnoty v poli, tak pole vypiseme
                if (odIndexu == pole.length) {
                        vypis();
                        return;
                }

                for (int i = 1; i <= n; i++) {
                        // Cislo i ulozime do pola, iba ak sa este nenachadza na indexoch
                        // 0..(odIndexu-1)
                        if (!uzBolo[i]) {
                                // Poznacime si pridanie hodnoty i do pola
                                uzBolo[i] = true;
                                pole[odIndexu] = i;
                                // Generujeme variacie bez opakovania od indexu odIndexu+1
                                generuj(odIndexu + 1);
                                // pole[odIndexu] = 0;
                                // Poznacime si odobratie hodnoty i z pola
                                uzBolo[i] = false;
                        }
                }
        }

        public Set<String> generuj() {
                generuj(0);
                return vsetkySlova;
        }

        public PermutacieSlova(String s) {
                this.s = s;
                // Ulozime si parameter n
                this.n = s.length();
                // Vytvorime pole, do ktoreho budeme generovat variacie
                pole = new int[s.length()];
                // Vytvorime pole s indexami 0..n, v ktorom si pre cisla v rozsahu 1..n
                // budeme pamatat, ci sme ich pouzili
                uzBolo = new boolean[s.length() + 1];
                vsetkySlova=new HashSet<String>();
        }

        public static void main(String[] args) {
                PermutacieSlova g = new PermutacieSlova("PAA");
                Set<String> vsetkyPermutacie=g.generuj();
                System.out.println("uz vypisujem");
                for (String string : vsetkyPermutacie) {
                        System.out.println(string);
                }
        }
}