A6

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

public class Generator {
        /**
         * Pole, v ktorom generujeme postupnost
         */
        private int[] pole;
        private Set<Integer> mnozina;

        /**
         * 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) {
                if (odIndexu == pole.length) {
                        vypis();
                        return;
                }

                for (Integer cislo : mnozina) {
                        pole[odIndexu] = cislo;
                        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);
        }

        public Generator(int k, Set<Integer> mnozina) {
                pole = new int[k];
                this.mnozina = mnozina;
        }

        public static void main(String[] args) {
                Set<Integer> mnozina = new HashSet<>();
                mnozina.add(2);
                mnozina.add(3);
                mnozina.add(5);
                Generator g = new Generator(3, mnozina);
                g.generuj();
        }
}

import java.util.Arrays;

public class NaplnanieLietadla {
        /**
         * Pole, v ktorom generujeme postupnost
         */
        private int[] rozdelenie;
        private int[] ceny;
        private int pocetLietadiel;

        private int[] vyherneRozdelenie;
        private int minimalnyRozdiel = Integer.MAX_VALUE;

        private void porovnaj() {
                int[] aktualneCeny = new int[pocetLietadiel];
                for (int i = 0; i < rozdelenie.length; i++) {
                        aktualneCeny[rozdelenie[i]] += ceny[i];
                }
                int max = Integer.MIN_VALUE;
                int min = Integer.MAX_VALUE;
                for (int i = 0; i < aktualneCeny.length; i++) {
                        if (aktualneCeny[i] < min)
                                min = aktualneCeny[i];

                        if (aktualneCeny[i] > max)
                                max = aktualneCeny[i];
                }
                int rozdiel = max - min;
                if (rozdiel < minimalnyRozdiel) {
                        vyherneRozdelenie = rozdelenie.clone();
                        minimalnyRozdiel = rozdiel;
                }
        }

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

                for (int i = 0; i < pocetLietadiel; i++) {
                        rozdelenie[odIndexu] = i;
                        generuj(odIndexu + 1);
                }
        }

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

        public NaplnanieLietadla(int pocetLietadiel, int[] ceny) {
                this.pocetLietadiel = pocetLietadiel;
                this.ceny = ceny;
                this.rozdelenie = new int[ceny.length];
        }

        public static void main(String[] args) {
                NaplnanieLietadla z = new NaplnanieLietadla(9, new int[] { 2, 3, 19, 29, 53, 97, 113, 157,
                                211 });
                z.najdiRozdelenie();
        }

}

import java.util.Arrays;

public class NepriatelskeCisla {

        private int[] cisla;
        private int[] permutaciaIndexov;
        private boolean[] uzBolo;

        private void spracuj() {
                System.out.println(Arrays.toString(permutaciaIndexov));
                for (int i = 0; i < permutaciaIndexov.length; i++) {
                        System.out.print(cisla[permutaciaIndexov[i]] + ", ");
                }
                System.out.println();
        }

        private boolean nemajuSaRady(int c1, int c2) {
                return (c1 % c2 == 0) || (c2 % c1 == 0);
        }

        private void generuj(int odIdx) {
                if (odIdx == permutaciaIndexov.length) {
                        spracuj();
                        return;
                }

                for (int poziciaCisla = 0; poziciaCisla < permutaciaIndexov.length; poziciaCisla++) {
                        if (uzBolo[poziciaCisla] == false) {
                                if ((odIdx == 0)
                                                || (nemajuSaRady(cisla[poziciaCisla],
                                                                cisla[permutaciaIndexov[odIdx - 1]]) == false)) {
                                        permutaciaIndexov[odIdx] = poziciaCisla;
                                        uzBolo[poziciaCisla] = true;
                                        generuj(odIdx + 1);
                                        uzBolo[poziciaCisla] = false;
                                }
                        }
                }
        }

        public void najdiUsporiadanie() {
                permutaciaIndexov = new int[cisla.length];
                uzBolo = new boolean[permutaciaIndexov.length];
                generuj(0);
        }

        public NepriatelskeCisla(int[] cisla) {
                this.cisla = cisla;
        }

        public static void main(String[] args) {
                int[] cisla = { 4, 7, 10, 2, 5 };
                NepriatelskeCisla nc = new NepriatelskeCisla(cisla);
                nc.najdiUsporiadanie();
        }
}

import java.util.Arrays;

public class NepriatelskeCisla {

        private int[] cisla;
        private int[] permutacia;
        private boolean[] uzBolIndex;

        public NepriatelskeCisla(int[] cisla) {
                this.cisla = cisla;
        }

        private boolean mozuBytVedlaSeba(int c1, int c2) {
                return !((c1 % c2 == 0) || (c2 % c1 == 0));
        }

        private void spracuj() {
                System.out.println(Arrays.toString(permutacia));
        }

        private void generuj(int odIdx) {
                if (odIdx == permutacia.length) {
                        spracuj();
                        return;
                }

                for (int i = 0; i < cisla.length; i++)
                        if (uzBolIndex[i] == false)
                                if (odIdx == 0
                                                || mozuBytVedlaSeba(permutacia[odIdx - 1], cisla[i])) {
                                        uzBolIndex[i] = true;

                                        permutacia[odIdx] = cisla[i];
                                        generuj(odIdx + 1);

                                        uzBolIndex[i] = false;
                                }
        }

        private void najdiRiesenie() {
                permutacia = new int[cisla.length];
                uzBolIndex = new boolean[cisla.length];
                generuj(0);
        }

        /**
         * @param args
         */
        public static void main(String[] args) {
                int[] cisla = { 4, 4, 7, 5, 8, 11 };
                NepriatelskeCisla nc = new NepriatelskeCisla(cisla);
                nc.najdiRiesenie();
        }
}