DN11

domace-naloge.iml

@@ -7,5 +7,26 @@
     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module-library">
+      <library>
+        <CLASSES>
+          <root url="jar://$USER_HOME$/Development/java/lib/stdlib.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES>
+          <root url="jar://$USER_HOME$/Development/java/lib/stdlib.jar!/" />
+        </SOURCES>
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="JUnit4">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/junit-4.13.1.jar!/" />
+          <root url="jar://$MODULE_DIR$/lib/hamcrest-core-1.3.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
   </component>
 </module>

konvolucija1.p2

@@ -0,0 +1,2 @@
+P2: 4 x 4
+0 64 128 255 255 128 64 0 0 0 1 1 255 255 37 5

slika.p2

@@ -0,0 +1,2 @@
+P2: 15 x 10
+0 0 128 128 128 164 164 164 164 164 128 128 128 0 0 0 255 255 255 0 0 255 255 255 255 255 255 255 255 0 128 255 255 0 255 255 0 255 255 255 16 255 16 255 128 128 255 0 255 255 255 255 0 255 255 255 16 255 255 128 164 255 0 255 255 255 255 0 255 255 16 255 16 255 164 164 255 255 0 255 255 0 255 255 244 255 255 244 255 164 128 255 255 255 0 0 255 255 255 255 244 244 255 255 128 128 255 144 255 255 255 255 144 255 255 244 244 255 255 128 0 255 255 255 255 255 255 255 255 244 255 255 244 255 0 0 0 128 128 128 164 164 164 164 164 128 128 128 0 0

slikaB.p2

@@ -0,0 +1,2 @@
+P2B: 4 x 3
+1072693248 1072693248 1073741823 672794241 1073741823 1047552 1047552 1073741823 0 1073741823 1023 1023

src/DN04.java

@@ -0,0 +1,8 @@
+public class DN04 {
+    public static void main(String[] args) {
+        for (int i = 0; i < args[0].length(); i += 8) {
+            System.out.print((char) Integer.parseInt(args[0].substring(i, i + 8), 2));
+        }
+        System.out.println();
+    }
+}

src/DN05.java

@@ -0,0 +1,524 @@
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Arrays;
+import java.util.Scanner;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+
+public class DN05 {
+
+    public static void main(String[] args) {
+        if (args[0].equals("barvna") || args[0].equals("sivinska")) {
+            int[][][] barvnaSlika = preberiBarvnoSliko(args[1]);
+            if (barvnaSlika == null) return;
+
+            switch (args[0]) {
+                case "barvna":
+                    izpisiBarvnoSliko(barvnaSlika);
+                    return;
+                case "sivinska":
+                    izpisiSliko(pretvoriVSivinsko(barvnaSlika));
+                    return;
+            }
+        }
+
+        int[][] slika = preberiSliko(args[1]);
+        if (slika == null) return;
+
+        switch (args[0]) {
+            case "izpisi":
+                izpisiSliko(slika);
+                break;
+            case "histogram":
+                izpisiHistogram(slika);
+                break;
+            case "svetlost":
+                System.out.printf("Srednja vrednost sivine na sliki %s je: %.2f\n", args[1], svetlostSlike(slika));
+                break;
+            case "zmanjsaj":
+                izpisiSliko(zmanjsajSliko(slika));
+                break;
+            case "rotiraj":
+                izpisiSliko(rotirajSliko(slika));
+                break;
+            case "zrcali":
+                izpisiSliko(zrcaliSliko(slika));
+                break;
+            case "vrstica":
+                System.out.printf("Max razlika svetlo - temno je v %d. vrstici.\n", poisciMaxVrstico(slika));
+                break;
+            case "uredi":
+                preberiVseInIzpisi(Arrays.stream(args).skip(1).toArray(String[]::new));
+                break;
+            case "jedro":
+                konvolucijaJedro(slika);
+                break;
+            case "glajenje":
+                konvolucijaGlajenje(slika);
+                break;
+            case "robovi":
+                konvolucijaRobovi(slika);
+                break;
+
+            default:
+                System.out.println("Napaka: Neveljaven argument.");
+        }
+    }
+
+    static int[][] preberiSliko(String ime) {
+        File file = new File(ime);
+
+        Scanner scanner;
+        try {
+            scanner = new Scanner(file);
+        } catch (FileNotFoundException e) {
+            System.out.printf("Napaka: datoteka %s ne obstaja.\n", ime);
+            return null;
+        }
+
+        if (!scanner.hasNextLine()) {
+            System.out.printf("Napaka: Datoteka %s je prazna.\n", ime);
+            return null;
+        }
+
+        String format = scanner.nextLine();
+
+        Pattern pattern = Pattern.compile("^P2: (.+) x (.+)$");
+        Matcher matcher = pattern.matcher(format);
+
+        if (!matcher.matches()) {
+            System.out.printf("Napaka: datoteka %s ni v formatu P2.\n", ime);
+            return null;
+        }
+
+        int width, height;
+        try {
+            width = Integer.parseInt(matcher.group(1));
+            height = Integer.parseInt(matcher.group(2));
+        } catch (NumberFormatException e) {
+            System.out.printf("Napaka: datoteka %s ni v formatu P2 (velikost slike ni pravilna).\n", ime);
+            return null;
+        }
+
+        if (width <= 0 || height <= 0) {
+            System.out.printf("Napaka: datoteka %s ni v formatu P2 (velikost slike je 0 ali negativna).\n", ime);
+            return null;
+        }
+
+        if (!scanner.hasNextLine()) {
+            System.out.printf("Napaka: datoteka %s vsebuje premalo podatkov.\n", ime);
+            return null;
+        }
+
+        String[] data = scanner.nextLine().split(" ");
+
+        if (data.length < width * height) {
+            System.out.printf("Napaka: datoteka %s vsebuje premalo podatkov.\n", ime);
+            return null;
+        }
+
+
+        int[][] image = new int[height][width];
+        for (int i = 0; i < height; i++) {
+            for (int j = 0; j < width; j++) {
+                int p = Integer.parseInt(data[i * width + j]);
+                if (p < 0 || p > 255) {
+                    System.out.printf("Napaka: datoteka %s vsebuje podatke izven obsega 0 do 255.\n", ime);
+                    return null;
+                }
+                image[i][j] = p;
+            }
+        }
+
+        return image;
+    }
+
+    static void izpisiSliko(int[][] slika) {
+        System.out.printf("velikost slike: %d x %d\n", slika[0].length, slika.length);
+
+        for (int[] row : slika) {
+            for (int p : row) {
+                System.out.printf("%3d ", p);
+            }
+            System.out.println();
+        }
+    }
+
+    static void izpisiHistogram(int[][] slika) {
+        int[] histogram = new int[256];
+
+        for (int[] row : slika) {
+            for (int p : row) {
+                histogram[p]++;
+            }
+        }
+
+        System.out.println("sivina : # pojavitev");
+        for (int i = 0; i < 256; i++) {
+            if (histogram[i] == 0) continue;
+            System.out.printf("  %3d  :   %d\n", i, histogram[i]);
+        }
+    }
+
+    static double svetlostSlike(int[][] slika) {
+        double sum = 0;
+        for (int[] row : slika) {
+            for (int p : row) {
+                sum += p;
+            }
+        }
+        return sum / (slika.length * slika[0].length);
+    }
+
+    static int[][] zmanjsajSliko(int[][] slika) {
+        int width = slika[0].length;
+        int height = slika.length;
+        if (width < 3 || height < 3) {
+            return slika;
+        }
+
+        int newWidth = width / 2;
+        int newHeight = height / 2;
+
+        int[][] newImage = new int[newHeight][newWidth];
+
+        for (int i = 0; i < newHeight; i++) {
+            for (int j = 0; j < newWidth; j++) {
+                newImage[i][j] = (slika[i * 2][j * 2] + slika[i * 2][j * 2 + 1] + slika[i * 2 + 1][j * 2] + slika[i * 2 + 1][j * 2 + 1]) / 4;
+            }
+        }
+
+        return newImage;
+    }
+
+    static int[][] rotirajSliko(int[][] slika) {
+        int width = slika[0].length;
+        int height = slika.length;
+
+        int[][] newImage = new int[width][height];
+
+        for (int i = 0; i < width; i++) {
+            for (int j = 0; j < height; j++) {
+                newImage[i][j] = slika[height - j - 1][i];
+            }
+        }
+
+        return newImage;
+    }
+
+    static int[][] zrcaliSliko(int[][] slika) {
+        int width = slika[0].length;
+        int height = slika.length;
+
+        int[][] newImage = new int[height][width];
+
+        for (int i = 0; i < height; i++) {
+            for (int j = 0; j < width; j++) {
+                newImage[i][j] = slika[i][width - j - 1];
+            }
+        }
+
+        return newImage;
+    }
+
+    static int poisciMaxVrstico(int[][] slika) {
+        int maxDiff = 0;
+        int maxDiffIndex = 0;
+
+        for (int i = 0; i < slika.length; i++) {
+            int min = slika[i][0];
+            int max = slika[i][0];
+
+            for (int j = 1; j < slika[i].length; j++) {
+                if (slika[i][j] < min) {
+                    min = slika[i][j];
+                }
+                if (slika[i][j] > max) {
+                    max = slika[i][j];
+                }
+            }
+
+            int diff = max - min;
+            if (diff > maxDiff) {
+                maxDiff = diff;
+                maxDiffIndex = i;
+            }
+        }
+
+        return maxDiffIndex + 1;
+    }
+
+    static int[][][] preberiBarvnoSliko(String ime) {
+        File file = new File(ime);
+
+        Scanner scanner;
+        try {
+            scanner = new Scanner(file);
+        } catch (FileNotFoundException e) {
+            System.out.printf("Napaka: datoteka %s ne obstaja.\n", ime);
+            return null;
+        }
+
+        if (!scanner.hasNextLine()) {
+            System.out.printf("Napaka: Datoteka %s je prazna.\n", ime);
+            return null;
+        }
+
+        String format = scanner.nextLine();
+
+        Pattern pattern = Pattern.compile("^P2B: (.+) x (.+)$");
+        Matcher matcher = pattern.matcher(format);
+
+        if (!matcher.matches()) {
+            System.out.printf("Napaka: datoteka %s ni v formatu P2B.\n", ime);
+            return null;
+        }
+
+        int width, height;
+        try {
+            width = Integer.parseInt(matcher.group(1));
+            height = Integer.parseInt(matcher.group(2));
+        } catch (NumberFormatException e) {
+            System.out.printf("Napaka: datoteka %s ni v formatu P2B (velikost slike ni pravilna).\n", ime);
+            return null;
+        }
+
+        if (width <= 0 || height <= 0) {
+            System.out.printf("Napaka: datoteka %s ni v formatu P2B (velikost slike je 0 ali negativna).\n", ime);
+            return null;
+        }
+
+        if (!scanner.hasNextLine()) {
+            System.out.printf("Napaka: datoteka %s vsebuje premalo podatkov.\n", ime);
+            return null;
+        }
+
+        String[] data = scanner.nextLine().split(" ");
+
+        if (data.length < width * height) {
+            System.out.printf("Napaka: datoteka %s vsebuje premalo podatkov.\n", ime);
+            return null;
+        }
+
+        int[][][] image = new int[height][width][3];
+        for (int i = 0; i < height; i++) {
+            for (int j = 0; j < width; j++) {
+                int p = Integer.parseInt(data[i * width + j]);
+                int mask = 0b1111111111;
+                image[i][j][2] = p & mask;
+                image[i][j][1] = (p >> 10) & mask;
+                image[i][j][0] = (p >> 20) & mask;
+            }
+        }
+
+        return image;
+    }
+
+    static void izpisiBarvnoSliko(int[][][] slika) {
+        System.out.println("velikost slike: " + slika[0].length + " x " + slika.length);
+
+        for (int[][] row : slika) {
+            for (int[] p : row) {
+                System.out.printf("(%4d, %4d, %4d) ", p[0], p[1], p[2]);
+            }
+            System.out.println();
+        }
+    }
+
+    static int[][] pretvoriVSivinsko(int[][][] slika) {
+        int width = slika[0].length;
+        int height = slika.length;
+
+        int[][] newImage = new int[height][width];
+
+        for (int i = 0; i < height; i++) {
+            for (int j = 0; j < width; j++) {
+                newImage[i][j] = (slika[i][j][0] + slika[i][j][1] + slika[i][j][2]) / 3 * 255 / 1023;
+            }
+        }
+
+        return newImage;
+    }
+
+    static void preberiVseInIzpisi(String[] imenaSlik) {
+        int[][] map = new int[imenaSlik.length][2];
+
+        for (int i = 0; i < imenaSlik.length; i++) {
+            int[][] slika = preberiSliko(imenaSlik[i]);
+            if (slika == null) continue;
+            int svetlost = (int) Math.round(svetlostSlike(slika));
+            map[i][0] = svetlost;
+            map[i][1] = i;
+        }
+
+        for (int i = 0; i < map.length; i++) {
+            for (int j = 0; j < map.length - i - 1; j++) {
+                if (map[j][0] < map[j + 1][0] || (map[j][0] == map[j + 1][0] && imenaSlik[map[j][1]].compareToIgnoreCase(imenaSlik[map[j + 1][1]]) > 0)) {
+                    int[] temp = map[j];
+                    map[j] = map[j + 1];
+                    map[j + 1] = temp;
+                }
+            }
+        }
+
+        for (int[] pair : map) {
+            System.out.printf("%s (%d)\n", imenaSlik[pair[1]], pair[0]);
+        }
+    }
+
+    static void konvolucijaJedro(int[][] slika) {
+        int[][] jedro = {
+                {1, 1, 1},
+                {1, 1, 1},
+                {1, 1, 1}
+        };
+
+        int width = slika[0].length;
+        int height = slika.length;
+
+        int[][] novaSlika = new int[height - 2][width - 2];
+
+        for (int i = 1; i < height - 1; i++) {
+            for (int j = 1; j < width - 1; j++) {
+                int sum = 0;
+                for (int k = -1; k <= 1; k++) {
+                    for (int l = -1; l <= 1; l++) {
+                        sum += slika[i + k][j + l] * jedro[k + 1][l + 1];
+                    }
+                }
+                novaSlika[i - 1][j - 1] = sum;
+            }
+        }
+
+        izpisiSliko(novaSlika);
+    }
+
+    static int[][] razsiriSliko(int[][] slika) {
+        int w = slika[0].length;
+        int h = slika.length;
+
+        int[][] razsirjena = new int[h + 2][w + 2];
+        for (int i = 0; i < razsirjena.length; i++) {
+            for (int j = 0; j < razsirjena[i].length; j++) {
+                if (i == 0 && j == 0) {
+                    razsirjena[i][j] = slika[0][0];
+                } else if (i == 0 && j == w + 1) {
+                    razsirjena[i][j] = slika[0][w - 1];
+                } else if (i == h + 1 && j == 0) {
+                    razsirjena[i][j] = slika[h - 1][0];
+                } else if (i == h + 1 && j == w + 1) {
+                    razsirjena[i][j] = slika[h - 1][w - 1];
+                } else if (i == 0) {
+                    razsirjena[i][j] = slika[0][j - 1];
+                } else if (i == h + 1) {
+                    razsirjena[i][j] = slika[h - 1][j - 1];
+                } else if (j == 0) {
+                    razsirjena[i][j] = slika[i - 1][0];
+                } else if (j == w + 1) {
+                    razsirjena[i][j] = slika[i - 1][w - 1];
+                } else {
+                    razsirjena[i][j] = slika[i - 1][j - 1];
+                }
+            }
+        }
+
+        return razsirjena;
+    }
+
+    static void konvolucijaGlajenje(int[][] slika) {
+        double[][] jedro = {
+                {16, 8, 16},
+                {8, 4, 8},
+                {16, 8, 16},
+        };
+
+        int width = slika[0].length;
+        int height = slika.length;
+
+        int[][] razsirjenaSlika = razsiriSliko(slika);
+
+        int[][] novaSlika = new int[height][width];
+
+        for (int i = 1; i <= height; i++) {
+            for (int j = 1; j <= width; j++) {
+                int sum = 0;
+                for (int k = -1; k <= 1; k++) {
+                    for (int l = -1; l <= 1; l++) {
+                        sum += (int) Math.round(razsirjenaSlika[i + k][j + l] / jedro[k + 1][l + 1]);
+                    }
+                }
+                novaSlika[i - 1][j - 1] = sum;
+            }
+        }
+
+        izpisiSliko(novaSlika);
+    }
+
+    static void konvolucijaRobovi(int[][] slika) {
+        int width = slika[0].length;
+        int height = slika.length;
+
+        int[][] razsirjenaSlika = razsiriSliko(slika);
+
+        int[][] navpicni = {
+                {1, 0, -1},
+                {2, 0, -2},
+                {1, 0, -1}
+        };
+        int[][] roboviNavpicno = new int[height][width];
+        for (int i = 1; i <= height; i++) {
+            for (int j = 1; j <= width; j++) {
+                int sum = 0;
+                for (int k = -1; k <= 1; k++) {
+                    for (int l = -1; l <= 1; l++) {
+                        sum += razsirjenaSlika[i + k][j + l] * navpicni[k + 1][l + 1];
+                    }
+                }
+                roboviNavpicno[i - 1][j - 1] = sum;
+            }
+        }
+
+        int[][] vodoravni = {
+                {1, 2, 1},
+                {0, 0, 0},
+                {-1, -2, -1}
+        };
+        int[][] roboviVodoravno = new int[height][width];
+        for (int i = 1; i <= height; i++) {
+            for (int j = 1; j <= width; j++) {
+                int sum = 0;
+                for (int k = -1; k <= 1; k++) {
+                    for (int l = -1; l <= 1; l++) {
+                        sum += razsirjenaSlika[i + k][j + l] * vodoravni[k + 1][l + 1];
+                    }
+                }
+                roboviVodoravno[i - 1][j - 1] = sum;
+            }
+        }
+
+        int[][] roboviSkupaj = new int[height][width];
+        for (int i = 0; i < height; i++) {
+            for (int j = 0; j < width; j++) {
+                roboviSkupaj[i][j] = (int) Math.round(Math.sqrt(roboviNavpicno[i][j] * roboviNavpicno[i][j] + roboviVodoravno[i][j] * roboviVodoravno[i][j]));
+            }
+        }
+
+        int max = 0;
+        for (int i = 0; i < height; i++) {
+            for (int j = 0; j < width; j++) {
+                max = Math.max(max, roboviSkupaj[i][j]);
+            }
+        }
+
+        int[][] roboviKoncni = new int[height][width];
+
+        for (int i = 0; i < height; i++) {
+            for (int j = 0; j < width; j++) {
+                roboviKoncni[i][j] = (int) Math.round(roboviSkupaj[i][j] * 255.0 / max);
+            }
+        }
+
+        izpisiSliko(roboviKoncni);
+    }
+}

src/DN06.java

@@ -0,0 +1,37 @@
+public class DN06 {
+    static double offset = 0.01;
+    static double size = (1 - 2 * offset) / 9;
+
+    public static void main(String[] args) {
+        String input = args[0];
+
+        StdDraw.setPenRadius(0.005);
+        StdDraw.square(0.5, 0.5, 0.5 - offset);
+
+        for (int i = 1; i < 9; i++) {
+            if (i % 3 == 0)
+                StdDraw.setPenRadius(0.005);
+            else
+                StdDraw.setPenRadius(0.001);
+
+            StdDraw.line(offset, offset + size * i, 1 - offset, offset + size * i);
+        }
+
+        for (int i = 1; i < 9; i++) {
+            if (i % 3 == 0)
+                StdDraw.setPenRadius(0.005);
+            else
+                StdDraw.setPenRadius(0.001);
+
+            StdDraw.line(offset + size * i, offset, offset + size * i, 1 - offset);
+        }
+
+        for (int y = 0; y < 9; y++) {
+            for (int x = 0; x < 9; x++) {
+                String number = String.valueOf(input.charAt(y * 9 + x));
+                if (number.equals("0")) continue;
+                StdDraw.text(offset + size / 2 + x * size, 1 - (offset + size / 2 + y * size + offset - 0.005), number);
+            }
+        }
+    }
+}

src/DN07.java

@@ -0,0 +1,59 @@
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Scanner;
+
+public class DN07 {
+    public static void main(String[] args) {
+        Planet[] planeti;
+        try {
+            planeti = preberiPlanete(args[0]);
+        } catch (FileNotFoundException e) {
+            System.out.println("Datoteka ne obstaja");
+            return;
+        }
+
+        String[] imena = args[1].toLowerCase().split("\\+");
+
+        double sum = 0;
+        for (String ime : imena) {
+            for (Planet planet :planeti) {
+                if (planet.ime.equals(ime)) {
+                    sum += planet.povrsina();
+                }
+            }
+        }
+
+        System.out.printf("Povrsina planetov \"%s\" je %d milijonov km2\n", args[1], Math.round(sum / 1000000));
+    }
+
+    static Planet[] preberiPlanete(String datoteka) throws FileNotFoundException {
+        File file = new File(datoteka);
+        Scanner scanner = new Scanner(file);
+
+        Planet[] planeti = new Planet[8];
+        for (int i = 0; i < 8; i++) {
+            if (!scanner.hasNextLine()) break;
+
+            String line = scanner.nextLine();
+            String[] parts = line.split(":");
+
+            planeti[i] = new Planet(parts[0].toLowerCase(), Integer.parseInt(parts[1]));
+        }
+
+        return planeti;
+    }
+}
+
+class Planet {
+    String ime;
+    int radij;
+
+    public Planet(String ime, int radij) {
+        this.ime = ime;
+        this.radij = radij;
+    }
+
+    public double povrsina() {
+        return 4*Math.PI*radij*radij;
+    }
+}

src/DN08.java

@@ -0,0 +1,82 @@
+public class DN08 {
+    static Lik[] liki;
+
+    public static void main(String[] args) {
+        liki = new Lik[args.length];
+        for (int i = 0; i < args.length; i++) {
+            String[] p = args[i].split(":");
+            switch (p[0]) {
+                case "kvadrat":
+                    liki[i] = new Kvadrat(Double.parseDouble(p[1]));
+                    break;
+                case "pravokotnik":
+                    liki[i] = new Pravokotnik(
+                            Double.parseDouble(p[1]),
+                            Double.parseDouble(p[2])
+                    );
+                    break;
+                case "nkotnik":
+                    liki[i] = new NKotnik(
+                            Integer.parseInt(p[1]),
+                            Double.parseDouble(p[2])
+                    );
+                    break;
+            }
+        }
+        System.out.println((int) skupniObseg());
+    }
+
+    static double skupniObseg() {
+        double obseg = 0;
+        for (Lik lik : liki) {
+            obseg += lik.obseg();
+        }
+        return obseg;
+    }
+}
+
+abstract class Lik {
+    abstract public double obseg();
+}
+
+class Pravokotnik extends Lik {
+    double visina, sirina;
+
+    Pravokotnik(double visina, double sirina) {
+        this.visina = visina;
+        this.sirina = sirina;
+    }
+
+    @Override
+    public double obseg() {
+        return 2 * visina + 2 * sirina;
+    }
+}
+
+class Kvadrat extends Lik {
+    double sirina;
+
+    Kvadrat(double sirina) {
+        this.sirina = sirina;
+    }
+
+    @Override
+    public double obseg() {
+        return 4 * sirina;
+    }
+}
+
+class NKotnik extends Lik {
+    int koti;
+    double dolzinaStranice;
+
+    NKotnik(int koti, double dolzinaStranice) {
+        this.koti = koti;
+        this.dolzinaStranice = dolzinaStranice;
+    }
+
+    @Override
+    public double obseg() {
+        return koti * dolzinaStranice;
+    }
+}

src/DN09.java

@@ -0,0 +1,442 @@
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class DN09 {
+    public static void main(String[] args) {
+        if (args.length == 0) {
+            System.out.println("Ukaz manjka");
+            return;
+        }
+
+        if (args[0].equals("pobratene")) {
+            ZgodovinaTekmovanj zgodovinaTekmovanj = ZgodovinaTekmovanj.izDatotek(args[1], args[2]);
+            assert zgodovinaTekmovanj != null;
+
+            zgodovinaTekmovanj.izpisiPobrateneDrzave(Integer.parseInt(args[3]));
+
+            return;
+        }
+
+        Tekmovanje tekmovanje = Tekmovanje.izDatotek(args[1], args[2]);
+        assert tekmovanje != null;
+
+        switch (args[0]) {
+            case "izpisiTekmovanje":
+                tekmovanje.izpisiTekmovalce();
+                System.out.println();
+                tekmovanje.izpisiGlasove();
+                break;
+
+            case "izpisiTocke":
+                tekmovanje.izpisiTocke();
+                break;
+
+            case "najboljse":
+                tekmovanje.izpisiRezultateUrejeno(Integer.parseInt(args[3]));
+                break;
+
+            case "utezeno":
+                tekmovanje.setKriterij(new UtezeniKriterij(Float.parseFloat(args[4]), Float.parseFloat(args[5])));
+                tekmovanje.izpisiRezultateUrejeno(Integer.parseInt(args[3]));
+                break;
+
+            default:
+                System.out.println("Neznan ukaz " + args[0]);
+        }
+    }
+}
+
+class Tekmovalec {
+    private String drzava, izvajalec, naslovPesmi;
+
+    Tekmovalec(String drzava, String izvajalec, String naslovPesmi) {
+        this.drzava = drzava;
+        this.izvajalec = izvajalec;
+        this.naslovPesmi = naslovPesmi;
+    }
+
+    String getDrzava() {
+        return drzava;
+    }
+
+    String getIzvajalec() {
+        return izvajalec;
+    }
+
+    String getNaslovPesmi() {
+        return naslovPesmi;
+    }
+
+    @Override
+    public String toString() {
+        return String.format("(%s) %s - %s", drzava, izvajalec, naslovPesmi);
+    }
+}
+
+class Glas {
+    private String odDrzave, zaDrzavo;
+    private int stTock;
+
+    Glas(String odDrzave, String zaDrzavo, int stTock) {
+        this.odDrzave = odDrzave;
+        this.zaDrzavo = zaDrzavo;
+        this.stTock = stTock;
+    }
+
+    public String getOdDrzave() {
+        return odDrzave;
+    }
+
+    public String getZaDrzavo() {
+        return zaDrzavo;
+    }
+
+    public int getStTock() {
+        return stTock;
+    }
+
+    @Override
+    public String toString() {
+        return String.format("%s --%dt-> %s", odDrzave, stTock, zaDrzavo);
+    }
+}
+
+class Tekmovanje {
+    private ArrayList<Tekmovalec> seznamTekmovalcev;
+    private ArrayList<Glas> seznamGlasov;
+    private Kriterij kriterij;
+    private boolean urejeno = false;
+
+    Tekmovanje(ArrayList<Tekmovalec> seznamTekmovalcev, ArrayList<Glas> seznamGlasov) {
+        this.seznamTekmovalcev = seznamTekmovalcev;
+        this.seznamGlasov = seznamGlasov;
+        this.kriterij = new OsnovniKriterij();
+    }
+
+    static Tekmovanje izDatotek(String datotekaTekmovalci, String datotekaGlasovi) {
+        Scanner scannerTekmovalci, scannerGlasovi;
+
+        try {
+            scannerTekmovalci = new Scanner(new File(datotekaTekmovalci));
+            scannerGlasovi = new Scanner(new File(datotekaGlasovi));
+        } catch (FileNotFoundException e) {
+            return null;
+        }
+
+        scannerTekmovalci.nextLine();
+        scannerGlasovi.nextLine();
+
+        ArrayList<Tekmovalec> seznamTekmovalcev = new ArrayList<>();
+        while (scannerTekmovalci.hasNextLine()) {
+            String[] fields = scannerTekmovalci.nextLine().split(";");
+            seznamTekmovalcev.add(new Tekmovalec(fields[1], fields[2], fields[3]));
+        }
+
+        ArrayList<Glas> seznamGlasov = new ArrayList<>();
+        while (scannerGlasovi.hasNextLine()) {
+            String[] fields = scannerGlasovi.nextLine().split(";");
+            switch (fields.length) {
+                case 5:
+                    seznamGlasov.add(new Glas(fields[2], fields[3], Integer.parseInt(fields[4])));
+                    break;
+                case 6:
+                    seznamGlasov.add(new LocenGlas(fields[2], fields[3], Integer.parseInt(fields[4]),
+                            Integer.parseInt(fields[5]), 0));
+                    break;
+                case 7:
+                    seznamGlasov.add(new LocenGlas(fields[2], fields[3], Integer.parseInt(fields[4]),
+                            Integer.parseInt(fields[5]), Integer.parseInt(fields[6])));
+                    break;
+            }
+        }
+
+        return new Tekmovanje(seznamTekmovalcev, seznamGlasov);
+    }
+
+    public ArrayList<Tekmovalec> getSeznamTekmovalcev() {
+        return seznamTekmovalcev;
+    }
+
+    public ArrayList<Glas> getSeznamGlasov() {
+        return seznamGlasov;
+    }
+
+    public void setKriterij(Kriterij kriterij) {
+        this.kriterij = kriterij;
+        urejeno = false;
+    }
+
+    void izpisiTekmovalce() {
+        if (seznamTekmovalcev.isEmpty()) {
+            System.out.println("Seznam tekmovalcev je prazen.");
+            return;
+        }
+        System.out.println("Seznam tekmovalcev:");
+        for (Tekmovalec tekmovalec : seznamTekmovalcev) {
+            System.out.println(tekmovalec);
+        }
+    }
+
+    void izpisiGlasove() {
+        if (seznamGlasov.isEmpty()) {
+            System.out.println("Seznam glasov je prazen.");
+            return;
+        }
+        System.out.println("Seznam glasov:");
+        for (Glas glas : seznamGlasov) {
+            System.out.println(glas);
+        }
+    }
+
+    int steviloTock(String drzava) {
+        return kriterij.steviloTock(this, drzava);
+    }
+
+    void izpisiTocke() {
+        if (seznamTekmovalcev.isEmpty()) {
+            System.out.println("Seznam tekmovalcev je prazen.");
+            return;
+        }
+
+        System.out.println("Seznam tekmovalcev in njihovih tock:");
+        for (Tekmovalec tekmovalec : seznamTekmovalcev) {
+            System.out.printf("%s: %dt\n", tekmovalec, steviloTock(tekmovalec.getDrzava()));
+        }
+    }
+
+    Tekmovalec getZmagovalec() {
+        int maxTocke = 0;
+        Tekmovalec maxTekmovalec = null;
+        for (Tekmovalec tekmovalec : seznamTekmovalcev) {
+            int tocke = steviloTock(tekmovalec.getDrzava());
+            if (tocke > maxTocke) {
+                maxTekmovalec = tekmovalec;
+                maxTocke = tocke;
+            }
+        }
+        return maxTekmovalec;
+    }
+
+    void urediPoTockah() {
+        seznamTekmovalcev.sort((Tekmovalec a, Tekmovalec b) ->
+                steviloTock(b.getDrzava()) - steviloTock(a.getDrzava())
+        );
+        urejeno = true;
+    }
+
+    int getMesto(String drzava) {
+        if (!urejeno) {
+            urediPoTockah();
+        }
+
+        for (Tekmovalec tekmovalec : seznamTekmovalcev) {
+            if (tekmovalec.getDrzava().equals(drzava)) {
+                return seznamTekmovalcev.indexOf(tekmovalec) + 1;
+            }
+        }
+
+        return -1;
+    }
+
+    void izpisiRezultateUrejeno(int n) {
+        if (!urejeno) {
+            urediPoTockah();
+        }
+
+        System.out.println("Najboljse uvrsceni tekmovalci:");
+        int i = 1;
+        for (Tekmovalec tekmovalec : seznamTekmovalcev) {
+            if (i > n) break;
+            System.out.printf("%d. %s: %dt\n", i, tekmovalec, steviloTock(tekmovalec.getDrzava()));
+            i++;
+        }
+    }
+}
+
+interface Kriterij {
+    int steviloTock(Tekmovanje tekmovanje, String drzava);
+}
+
+class OsnovniKriterij implements Kriterij {
+    @Override
+    public int steviloTock(Tekmovanje tekmovanje, String drzava) {
+        int tocke = 0;
+        for (Glas glas : tekmovanje.getSeznamGlasov()) {
+            if (glas.getZaDrzavo().equals(drzava)) {
+                tocke += glas.getStTock();
+            }
+        }
+        return tocke;
+    }
+}
+
+class LocenGlas extends Glas {
+    private int stTockGlasovi, stTockZirija;
+
+    public LocenGlas(String odDrzave, String zaDrzavo, int stTock, int stTockGlasovi, int stTockZirija) {
+        super(odDrzave, zaDrzavo, stTock);
+        this.stTockGlasovi = stTockGlasovi;
+        this.stTockZirija = stTockZirija;
+    }
+
+    public int getStTockGlasovi() {
+        return stTockGlasovi;
+    }
+
+    public int getStTockZirija() {
+        return stTockZirija;
+    }
+}
+
+class UtezeniKriterij implements Kriterij {
+    private float utezGlasovanja, utezZirija;
+
+    UtezeniKriterij(float utezGlasovanja, float utezZirije) {
+        this.utezGlasovanja = utezGlasovanja;
+        this.utezZirija = utezZirije;
+    }
+
+    @Override
+    public int steviloTock(Tekmovanje tekmovanje, String drzava) {
+        float tocke = 0;
+        for (Glas glas : tekmovanje.getSeznamGlasov()) {
+            if (glas.getZaDrzavo().equals(drzava)) {
+                if (glas instanceof LocenGlas locenGlas) {
+                    tocke += locenGlas.getStTockZirija() * utezZirija
+                            + locenGlas.getStTockGlasovi() * utezGlasovanja;
+                } else {
+                    tocke += glas.getStTock() * utezZirija;
+                }
+            }
+        }
+        return Math.round(tocke);
+    }
+}
+
+class Leto {
+    ArrayList<Tekmovalec> tekmovalci = new ArrayList<>();
+    HashMap<String, ArrayList<Glas>> glasovi = new LinkedHashMap<>();
+}
+
+class ZgodovinaTekmovanj {
+    ArrayList<Tekmovanje> seznamTekmovanj;
+
+
+    ZgodovinaTekmovanj(ArrayList<Tekmovanje> seznamTekmovanj) {
+        this.seznamTekmovanj = seznamTekmovanj;
+    }
+
+    public static ZgodovinaTekmovanj izDatotek(String datotekaTekmovalci, String datotekaGlasovi) {
+        Scanner scannerTekmovalci, scannerGlasovi;
+
+        try {
+            scannerTekmovalci = new Scanner(new File(datotekaTekmovalci));
+            scannerGlasovi = new Scanner(new File(datotekaGlasovi));
+        } catch (FileNotFoundException e) {
+            return null;
+        }
+
+        scannerTekmovalci.nextLine();
+        scannerGlasovi.nextLine();
+
+        Map<String, Leto> leta = new LinkedHashMap<>();
+
+        while (scannerGlasovi.hasNextLine()) {
+            String[] fields = scannerGlasovi.nextLine().split(";");
+            Glas glas = switch (fields.length) {
+                case 7 -> new LocenGlas(fields[2], fields[3], Integer.parseInt(fields[4]),
+                        Integer.parseInt(fields[5]), Integer.parseInt(fields[6]));
+                case 6 -> new LocenGlas(fields[2], fields[3], Integer.parseInt(fields[4]),
+                        Integer.parseInt(fields[5]), 0);
+                default -> new Glas(fields[2], fields[3], Integer.parseInt(fields[4]));
+            };
+
+            if (!leta.containsKey(fields[0])) {
+                leta.put(fields[0], new Leto());
+            }
+            Map<String, ArrayList<Glas>> glasovi = leta.get(fields[0]).glasovi;
+
+            if (!glasovi.containsKey(fields[1])) {
+                glasovi.put(fields[1], new ArrayList<>());
+            }
+            glasovi.get(fields[1]).add(glas);
+        }
+
+        while (scannerTekmovalci.hasNextLine()) {
+            String[] fields = scannerTekmovalci.nextLine().split(";");
+            Tekmovalec tekmovalec = new Tekmovalec(fields[1], fields[2], fields[3]);
+
+            leta.get(fields[0]).tekmovalci.add(tekmovalec);
+        }
+
+        ArrayList<Tekmovanje> tekmovanja = new ArrayList<>();
+
+        for (String leto : leta.keySet()) {
+            for (String krog : leta.get(leto).glasovi.keySet()) {
+                tekmovanja.add(new Tekmovanje(leta.get(leto).tekmovalci, leta.get(leto).glasovi.get(krog)));
+            }
+        }
+
+        return new ZgodovinaTekmovanj(tekmovanja);
+    }
+
+
+    public int getSkupnoSteviloTock(String drzava) {
+        int tocke = 0;
+        for (Tekmovanje tekmovanje : seznamTekmovanj) {
+            tocke += tekmovanje.steviloTock(drzava);
+        }
+        return tocke;
+    }
+
+    public float povprecnaUvrstitev(String drzava) {
+        int sum = 0, count = 0;
+        for (Tekmovanje tekmovanje : seznamTekmovanj) {
+            int mesto = tekmovanje.getMesto(drzava);
+            if (mesto == -1) continue;
+            sum += tekmovanje.getMesto(drzava);
+
+            count++;
+        }
+        return (float) sum / count;
+    }
+
+    public int najboljsaUvrstitev(String drzava) {
+        int min = Integer.MAX_VALUE;
+        for (Tekmovanje tekmovanje : seznamTekmovanj) {
+            int mesto = tekmovanje.getMesto(drzava);
+            if (mesto == -1) continue;
+            if (mesto < min) {
+                min = mesto;
+            }
+        }
+        return min;
+    }
+
+    public void izpisiPobrateneDrzave(int topN) {
+        Map<String, Integer> tocke = new HashMap<>();
+        for (Tekmovanje tekmovanje : seznamTekmovanj) {
+            for (Glas glas : tekmovanje.getSeznamGlasov()) {
+                String key = Stream.of(glas.getOdDrzave(), glas.getZaDrzavo()).sorted().collect(Collectors.joining("@"));
+                tocke.put(key, tocke.getOrDefault(key, 0) + glas.getStTock());
+            }
+        }
+
+        Map<String, Integer> sortirane = tocke.entrySet().stream()
+                .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
+                .limit(Math.min(topN, tocke.size()))
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (v1, v2) -> v1, LinkedHashMap::new));
+
+        System.out.println("Drzave z najvec medsebojnih glasov:");
+        int n = 1;
+        for (String key : sortirane.keySet()) {
+            int t = sortirane.get(key);
+            String[] drzave = key.split("@");
+            System.out.printf("%d. %s <-(%dt)-> %s\n", n, drzave[0], t, drzave[1]);
+            n++;
+        }
+    }
+}

src/DN09Test01.java

@@ -0,0 +1,109 @@
+import org.junit.*;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class DN09Test01 {
+
+    Tekmovanje tekmovanje;
+    Tekmovanje miniTekmovanje;
+    Tekmovanje praznoTekmovanje;
+
+    @Before
+    public void init() {
+        tekmovanje = Tekmovanje.izDatotek("viri/tekmovalci_2023.csv", "viri/glasovi_2023.csv");
+
+        ArrayList<Tekmovalec> seznamTekmovalcev = new ArrayList<>(Arrays.asList(
+                new Tekmovalec("Češka", "Vesna", "My Sister's Crown"),
+                new Tekmovalec("Armenija", "Brunette", "Future Lover"),
+                new Tekmovalec("Islandija", "Diljá", "Power")
+        ));
+
+        ArrayList<Glas> seznamGlasov = new ArrayList<>(Arrays.asList(
+                new Glas("Češka", "Islandija", 6),
+                new Glas("Armenija", "Islandija", 6),
+                new Glas("Armenija", "Češka", 4),
+                new Glas("Islandija", "Češka", 0)
+        ));
+
+        // Tekmovanje mora imeti ustrezen konstruktor
+        miniTekmovanje = new Tekmovanje(seznamTekmovalcev, seznamGlasov);
+
+        // Prazno tekmovanje
+        praznoTekmovanje = new Tekmovanje(new ArrayList<>(), new ArrayList<>());
+    }
+
+    @Test
+    public void testBranje() {
+        // Manjkajoca datoteka mora vracati null
+        Assert.assertNull(Tekmovanje.izDatotek("manjkajocaDatoteka.csv", "manjkajocaDatoteka.csv"));
+        // Preveri stevilo prebranih tekmovalcev in glasov
+        Assert.assertNotNull(tekmovanje);
+        Assert.assertEquals(tekmovanje.getSeznamTekmovalcev().size(), 37);
+        Assert.assertEquals(tekmovanje.getSeznamGlasov().size(), 554);
+
+        Tekmovalec t = tekmovanje.getSeznamTekmovalcev().get(0);
+        Assert.assertEquals(t.getDrzava(), "Albanija");
+    }
+
+    @Test
+    public void testToString() {
+        Tekmovalec t = new Tekmovalec("Izrael", "Noa Kirel", "Unicorn");
+        Assert.assertEquals(t.toString(), "(Izrael) Noa Kirel - Unicorn");
+
+        Glas g = new Glas("Slovenija", "Hrvaška", 10);
+        Assert.assertEquals(g.toString(), "Slovenija --10t-> Hrvaška");
+    }
+
+    @Test
+    public void testIzpis() {
+        // Testira `izpisiTekmovalce()` in `izpisiGlasove()`
+        PrintStream orig = System.out;
+        final ByteArrayOutputStream myOut = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(myOut));
+
+        miniTekmovanje.izpisiTekmovalce();
+        miniTekmovanje.izpisiGlasove();
+
+        final String stdOut = myOut.toString();
+        System.setOut(orig);
+
+        String expected = "Seznam tekmovalcev:\n" +
+                "(Češka) Vesna - My Sister's Crown\n" +
+                "(Armenija) Brunette - Future Lover\n" +
+                "(Islandija) Diljá - Power\n" +
+                "Seznam glasov:\n" +
+                "Češka --6t-> Islandija\n" +
+                "Armenija --6t-> Islandija\n" +
+                "Armenija --4t-> Češka\n" +
+                "Islandija --0t-> Češka\n";
+
+        Assert.assertEquals(stdOut.trim().replace("\r", ""), expected.trim().replace("\r", ""));
+
+        System.out.println(expected);
+    }
+
+    @Test
+    public void testIzpisPrazna() {
+        // Testira `izpisiTekmovalce()` in `izpisiGlasove()` v primeru prazenga tekmovanja
+        PrintStream orig = System.out;
+        final ByteArrayOutputStream myOut = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(myOut));
+
+        praznoTekmovanje.izpisiTekmovalce();
+        praznoTekmovanje.izpisiGlasove();
+
+        final String stdOut = myOut.toString();
+        System.setOut(orig);
+
+        String expected = "Seznam tekmovalcev je prazen.\n" +
+                "Seznam glasov je prazen.\n";
+
+        Assert.assertEquals(stdOut.trim().replace("\r", ""), expected.trim().replace("\r", ""));
+
+        System.out.println(expected);
+    }
+
+}

src/DN09Test02.java

@@ -0,0 +1,114 @@
+import org.junit.*;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class DN09Test02 {
+
+    Tekmovanje miniTekmovanje;
+    Tekmovanje praznoTekmovanje;
+
+    @Before
+    public void init(){
+        ArrayList<Tekmovalec> seznamTekmovalcev = new ArrayList<>(Arrays.asList(
+                new Tekmovalec("Češka", "Vesna", "My Sister's Crown"),
+                new Tekmovalec("Armenija", "Brunette", "Future Lover"),
+                new Tekmovalec("Islandija", "Diljá", "Power")
+        ));
+
+        ArrayList<Glas> seznamGlasov = new ArrayList<>(Arrays.asList(
+                new Glas("Češka", "Islandija", 6),
+                new Glas("Armenija", "Islandija", 6),
+                new Glas("Armenija", "Češka", 4),
+                new Glas("Islandija", "Češka", 0)
+        ));
+
+        miniTekmovanje = new Tekmovanje(seznamTekmovalcev, seznamGlasov);
+
+        // Prazno tekmovanje
+        praznoTekmovanje = new Tekmovanje(new ArrayList<>(), new ArrayList<>());
+    }
+
+    @Test
+    public void testOsnovniKriterij() {
+        Tekmovanje tekmovanje = Tekmovanje.izDatotek("viri/tekmovalci_2023.csv", "viri/glasovi_2023.csv");
+
+        OsnovniKriterij k = new OsnovniKriterij();
+        Assert.assertEquals(k.steviloTock(tekmovanje, "Slovenija"), 78);
+        Assert.assertEquals(k.steviloTock(tekmovanje, "Švedska"), 583);
+        Assert.assertEquals(k.steviloTock(tekmovanje, "Irska"), 0);
+
+        Assert.assertEquals(k.steviloTock(miniTekmovanje, "Armenija"), 0);
+        Assert.assertEquals(k.steviloTock(miniTekmovanje, "Islandija"), 12);
+        Assert.assertEquals(k.steviloTock(miniTekmovanje, "Češka"), 4);
+    }
+
+    @Test
+    public void testStTock(){
+        Tekmovanje tekmovanje = Tekmovanje.izDatotek("viri/tekmovalci_2023.csv", "viri/glasovi_2023.csv");
+
+        Assert.assertEquals(tekmovanje.steviloTock("Slovenija"), 78);
+        Assert.assertEquals(tekmovanje.steviloTock("Švedska"), 583);
+        Assert.assertEquals(tekmovanje.steviloTock("Irska"), 0);
+
+        Assert.assertEquals(miniTekmovanje.steviloTock("Armenija"), 0);
+        Assert.assertEquals(miniTekmovanje.steviloTock("Islandija"), 12);
+        Assert.assertEquals(miniTekmovanje.steviloTock("Češka"), 4);
+
+        // Testni kriterij, ki vraca toliko tock, kot je crk v imenu drzave
+        Kriterij mojKriterij = new Kriterij() {
+            @Override
+            public int steviloTock(Tekmovanje tekmovanje, String drzava) {
+                return drzava.length();
+            }
+        };
+
+        // Testiranje nastavljanja kriterija
+        tekmovanje.setKriterij(mojKriterij);
+        Assert.assertEquals(tekmovanje.steviloTock("Slovenija"), 9);
+        Assert.assertEquals(tekmovanje.steviloTock("Švedska"), 7);
+        Assert.assertEquals(tekmovanje.steviloTock("Irska"), 5);
+    }
+
+    @Test
+    public void testIzpis(){
+        PrintStream orig = System.out;
+        final ByteArrayOutputStream myOut = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(myOut));
+
+        miniTekmovanje.izpisiTocke();
+
+        final String stdOut = myOut.toString();
+        System.setOut(orig);
+
+        String expected = "Seznam tekmovalcev in njihovih tock:\n" +
+                "(Češka) Vesna - My Sister's Crown: 4t\n" +
+                "(Armenija) Brunette - Future Lover: 0t\n" +
+                "(Islandija) Diljá - Power: 12t\n";
+
+        Assert.assertEquals(stdOut.trim().replace("\r", ""), expected.trim().replace("\r", ""));
+        System.out.println(expected);
+    }
+
+    @Test
+    public void testIzpisPrazna(){
+        // Testira `izpisiTekmovalce()` in `izpisiGlasove()` v primeru prazenga tekmovanja
+        PrintStream orig = System.out;
+        final ByteArrayOutputStream myOut = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(myOut));
+
+        praznoTekmovanje.izpisiTocke();
+
+        final String stdOut = myOut.toString();
+        System.setOut(orig);
+
+        String expected = "Seznam tekmovalcev je prazen.\n";
+
+        Assert.assertEquals(stdOut.trim().replace("\r", ""), expected.trim().replace("\r", ""));
+
+        System.out.println(expected);
+    }
+
+}

src/DN09Test03.java

@@ -0,0 +1,130 @@
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class DN09Test03 {
+
+    Tekmovanje miniTekmovanje;
+    Tekmovanje praznoTekmovanje;
+
+
+    @Before
+    public void init() {
+        ArrayList<Tekmovalec> seznamTekmovalcev = new ArrayList<>(Arrays.asList(
+                new Tekmovalec("Češka", "Vesna", "My Sister's Crown"),
+                new Tekmovalec("Armenija", "Brunette", "Future Lover"),
+                new Tekmovalec("Islandija", "Diljá", "Power")
+        ));
+
+        ArrayList<Glas> seznamGlasov = new ArrayList<>(Arrays.asList(
+                new Glas("Češka", "Islandija", 6),
+                new Glas("Armenija", "Islandija", 6),
+                new Glas("Armenija", "Češka", 4),
+                new Glas("Islandija", "Češka", 0)
+        ));
+
+        miniTekmovanje = new Tekmovanje(seznamTekmovalcev, seznamGlasov);
+
+        // Prazno tekmovanje
+        praznoTekmovanje = new Tekmovanje(new ArrayList<>(), new ArrayList<>());
+    }
+
+    @Test
+    public void testIzpisZmagovalca() {
+        // Testira izpis zmagovalca
+        Tekmovanje tekmovanje = Tekmovanje.izDatotek("viri/tekmovalci_2023.csv", "viri/glasovi_2023.csv");
+        OsnovniKriterij k = new OsnovniKriterij();
+
+        tekmovanje.setKriterij(k);
+
+        Tekmovalec zmagovalec = tekmovanje.getZmagovalec();
+        Assert.assertEquals(zmagovalec.getDrzava(), "Švedska");
+
+        Assert.assertEquals(miniTekmovanje.getZmagovalec().getDrzava(), "Islandija");
+    }
+
+    @Test
+    public void testMestoDrzave() {
+        // Testira mesto države
+        Tekmovanje tekmovanje = Tekmovanje.izDatotek("viri/tekmovalci_2023.csv", "viri/glasovi_2023.csv");
+        OsnovniKriterij k = new OsnovniKriterij();
+
+        tekmovanje.setKriterij(k);
+
+        int mesto = tekmovanje.getMesto("Nizozemska");
+
+        Assert.assertEquals(mesto, 32);
+
+        // Za manjkajoce drzave metoda vrne -1
+        int mesto2 = tekmovanje.getMesto("Slovenijaaaa");
+
+        Assert.assertEquals(mesto2, -1);
+
+        int mesto3 = tekmovanje.getMesto("Slovenija");
+
+        Assert.assertEquals(mesto3, 21);
+    }
+
+    @Test
+    public void testIzpisNajboljsihDrzav() {
+        // Testira izpis najboljših držav
+        PrintStream orig = System.out;
+        final ByteArrayOutputStream myOut = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(myOut));
+
+        Tekmovanje tekmovanje = Tekmovanje.izDatotek("viri/tekmovalci_2023.csv", "viri/glasovi_2023.csv");
+        OsnovniKriterij k = new OsnovniKriterij();
+
+        tekmovanje.setKriterij(k);
+
+        tekmovanje.izpisiRezultateUrejeno(5);
+
+        final String stdOut = myOut.toString();
+        System.setOut(orig);
+
+        String expected = "Najboljse uvrsceni tekmovalci:\n" +
+                "1. (Švedska) Loreen - Tattoo: 583t\n" +
+                "2. (Finska) Käärijä - Cha Cha Cha: 526t\n" +
+                "3. (Izrael) Noa Kirel - Unicorn: 362t\n" +
+                "4. (Italija) Marco Mengoni - Due vite: 350t\n" +
+                "5. (Norveška) Alessandra - Queen of Kings: 268t\n";
+
+        Assert.assertEquals(stdOut.trim().replace("\r", ""), expected.trim().replace("\r", ""));
+
+
+    }
+
+    @Test
+    public void testIzpisNajboljsihDrzav2() {
+        // Testira izpis, ce je držav vec kot argument funkcije
+        PrintStream orig = System.out;
+        final ByteArrayOutputStream myOut = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(myOut));
+
+
+        OsnovniKriterij k = new OsnovniKriterij();
+
+        miniTekmovanje.setKriterij(k);
+
+        miniTekmovanje.izpisiRezultateUrejeno(5);
+
+        final String stdOut = myOut.toString();
+        System.setOut(orig);
+
+        String expected = "Najboljse uvrsceni tekmovalci:\n" +
+                "1. (Islandija) Diljá - Power: 12t\n" +
+                "2. (Češka) Vesna - My Sister's Crown: 4t\n" +
+                "3. (Armenija) Brunette - Future Lover: 0t\n";
+
+        Assert.assertEquals(stdOut.trim().replace("\r", ""), expected.trim().replace("\r", ""));
+
+
+    }
+
+
+}

src/DN09Test04.java

@@ -0,0 +1,91 @@
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class DN09Test04 {
+
+    Tekmovanje miniTekmovanje;
+    Tekmovanje praznoTekmovanje;
+
+
+    @Before
+    public void init() {
+        ArrayList<Tekmovalec> seznamTekmovalcev = new ArrayList<>(Arrays.asList(
+                new Tekmovalec("Češka", "Vesna", "My Sister's Crown"),
+                new Tekmovalec("Armenija", "Brunette", "Future Lover"),
+                new Tekmovalec("Islandija", "Diljá", "Power")
+        ));
+
+        ArrayList<Glas> seznamGlasov = new ArrayList<>(Arrays.asList(
+                new Glas("Češka", "Islandija", 6),
+                new Glas("Armenija", "Islandija", 6),
+                new Glas("Armenija", "Češka", 4),
+                new Glas("Islandija", "Češka", 0)
+        ));
+
+        miniTekmovanje = new Tekmovanje(seznamTekmovalcev, seznamGlasov);
+
+        // Prazno tekmovanje
+        praznoTekmovanje = new Tekmovanje(new ArrayList<>(), new ArrayList<>());
+    }
+
+    @Test
+    public void testLocenGlas() {
+        // Testira locenGlas
+        // Konstruktor mora slediti navodilom
+        LocenGlas locenGlas = new LocenGlas("Islandija", "Češka", 10, 8, 2);
+        Assert.assertNotNull(locenGlas);
+    }
+
+    @Test
+    public void testUtezeniKriterij() {
+        // Testira delovanje uteženega kriterija
+        Tekmovanje tekmovanje = Tekmovanje.izDatotek("viri/tekmovalci_2023.csv", "viri/glasovi_2023.csv");
+
+        UtezeniKriterij k = new UtezeniKriterij(0.1f, 5.3f);
+        Assert.assertEquals(k.steviloTock(tekmovanje, "Slovenija"), 179);
+        Assert.assertEquals(k.steviloTock(tekmovanje, "Švedska"), 1826);
+        Assert.assertEquals(k.steviloTock(tekmovanje, "Irska"), 0);
+
+        Assert.assertEquals(k.steviloTock(miniTekmovanje, "Armenija"), 0);
+        Assert.assertEquals(k.steviloTock(miniTekmovanje, "Islandija"), 64);
+        Assert.assertEquals(k.steviloTock(miniTekmovanje, "Češka"), 21);
+
+    }
+
+    @Test
+    public void preveriIzpisDrzav() {
+        // Testira izpis držav z uteženim kriterijem
+        PrintStream orig = System.out;
+        final ByteArrayOutputStream myOut = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(myOut));
+
+        Tekmovanje tekmovanje = Tekmovanje.izDatotek("viri/tekmovalci_2023.csv", "viri/glasovi_2023.csv");
+        UtezeniKriterij k = new UtezeniKriterij(0.2f, 12f);
+
+        tekmovanje.setKriterij(k);
+
+        tekmovanje.izpisiRezultateUrejeno(5);
+
+        final String stdOut = myOut.toString();
+        System.setOut(orig);
+
+        String expected = "Najboljse uvrsceni tekmovalci:\n" +
+                "1. (Švedska) Loreen - Tattoo: 4129t\n" +
+                "2. (Izrael) Noa Kirel - Unicorn: 2161t\n" +
+                "3. (Italija) Marco Mengoni - Due vite: 2147t\n" +
+                "4. (Finska) Käärijä - Cha Cha Cha: 1875t\n" +
+                "5. (Estonija) Alika - Bridges: 1756t\n";
+
+        Assert.assertEquals(stdOut.trim().replace("\r", ""), expected.trim().replace("\r", ""));
+
+
+    }
+
+
+}

src/DN09Test05.java

@@ -0,0 +1,123 @@
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class DN09Test05 {
+
+    Tekmovanje miniTekmovanje;
+    Tekmovanje praznoTekmovanje;
+
+    ZgodovinaTekmovanj miniZgodovinaTekmovanj;
+
+
+    @Before
+    public void init() {
+        ArrayList<Tekmovalec> seznamTekmovalcev = new ArrayList<>(Arrays.asList(
+                new Tekmovalec("Češka", "Vesna", "My Sister's Crown"),
+                new Tekmovalec("Armenija", "Brunette", "Future Lover"),
+                new Tekmovalec("Islandija", "Diljá", "Power")
+        ));
+
+        ArrayList<Glas> seznamGlasov = new ArrayList<>(Arrays.asList(
+                new Glas("Češka", "Islandija", 6),
+                new Glas("Armenija", "Islandija", 6),
+                new Glas("Armenija", "Češka", 4),
+                new Glas("Islandija", "Češka", 0)
+        ));
+
+        miniTekmovanje = new Tekmovanje(seznamTekmovalcev, seznamGlasov);
+
+        // Prazno tekmovanje
+        praznoTekmovanje = new Tekmovanje(new ArrayList<>(), new ArrayList<>());
+
+
+    }
+
+    @Test
+    public void testConstructor() {
+        //Testira razred zgodovinaTekmovanj
+        // Konstruktor mora ustrezno nastaviti zgodovino tekmovanj
+        miniZgodovinaTekmovanj = new ZgodovinaTekmovanj(new ArrayList<>(Arrays.asList(miniTekmovanje, miniTekmovanje)));
+        Assert.assertNotNull(miniZgodovinaTekmovanj);
+    }
+
+    @Test
+    public void testBranjePodatkov() {
+        // Testira branje podatkov
+        // Metoda izDatotek mora ustrezno delovati
+        ZgodovinaTekmovanj zgodovinaTekmovanj = ZgodovinaTekmovanj.izDatotek("viri/tekmovalci_sample.csv", "viri/glasovi_sample.csv");
+        Assert.assertEquals(zgodovinaTekmovanj.seznamTekmovanj.get(0).getSeznamTekmovalcev().get(0).getDrzava(), "Švedska");
+        Assert.assertEquals(zgodovinaTekmovanj.seznamTekmovanj.get(2).getSeznamTekmovalcev().get(5).getDrzava(), "Ukrajina");
+    }
+
+    @Test
+    public void testSkupnoSteviloTock() {
+        // Testira skupno število točk
+        miniZgodovinaTekmovanj = new ZgodovinaTekmovanj(new ArrayList<>(Arrays.asList(miniTekmovanje, miniTekmovanje)));
+        Assert.assertEquals(miniZgodovinaTekmovanj.getSkupnoSteviloTock("Islandija"), 24);
+        Assert.assertEquals(miniZgodovinaTekmovanj.getSkupnoSteviloTock("Armenija"), 0);
+
+        ZgodovinaTekmovanj zgodovinaTekmovanj = ZgodovinaTekmovanj.izDatotek("viri/tekmovalci_sample.csv", "viri/glasovi_sample.csv");
+        Assert.assertEquals(zgodovinaTekmovanj.getSkupnoSteviloTock("Islandija"), 146);
+        Assert.assertEquals(zgodovinaTekmovanj.getSkupnoSteviloTock("Armenija"), 156);
+    }
+
+    @Test
+    public void testPovprecnaUvrstitev() {
+        // Testira povprečno uvrstitev
+        miniZgodovinaTekmovanj = new ZgodovinaTekmovanj(new ArrayList<>(Arrays.asList(miniTekmovanje, miniTekmovanje)));
+        Assert.assertEquals(miniZgodovinaTekmovanj.povprecnaUvrstitev("Islandija"), 1, 0.01);
+        Assert.assertEquals(miniZgodovinaTekmovanj.povprecnaUvrstitev("Armenija"), 3, 0.01);
+        Assert.assertEquals(miniZgodovinaTekmovanj.povprecnaUvrstitev("Češka"), 2, 0.01);
+
+        ZgodovinaTekmovanj zgodovinaTekmovanj = ZgodovinaTekmovanj.izDatotek("viri/tekmovalci_sample.csv", "viri/glasovi_sample.csv");
+        Assert.assertEquals(zgodovinaTekmovanj.povprecnaUvrstitev("Islandija"), 22, 0.01);
+        Assert.assertEquals(zgodovinaTekmovanj.povprecnaUvrstitev("Armenija"), 15, 0.01);
+        Assert.assertEquals(zgodovinaTekmovanj.povprecnaUvrstitev("Češka"), 22, 0.01);
+    }
+
+    @Test
+    public void testNajboljsaUvrstitev() {
+        // Testira najboljšo uvrstitev
+        miniZgodovinaTekmovanj = new ZgodovinaTekmovanj(new ArrayList<>(Arrays.asList(miniTekmovanje, miniTekmovanje)));
+        Assert.assertEquals(miniZgodovinaTekmovanj.najboljsaUvrstitev("Islandija"), 1);
+        Assert.assertEquals(miniZgodovinaTekmovanj.najboljsaUvrstitev("Armenija"), 3);
+        Assert.assertEquals(miniZgodovinaTekmovanj.najboljsaUvrstitev("Češka"), 2);
+
+        ZgodovinaTekmovanj zgodovinaTekmovanj = ZgodovinaTekmovanj.izDatotek("viri/tekmovalci_sample.csv", "viri/glasovi_sample.csv");
+        Assert.assertEquals(zgodovinaTekmovanj.najboljsaUvrstitev("Islandija"), 2);
+        Assert.assertEquals(zgodovinaTekmovanj.najboljsaUvrstitev("Armenija"), 14);
+        Assert.assertEquals(zgodovinaTekmovanj.najboljsaUvrstitev("Češka"), 10);
+    }
+
+
+    @Test
+    public void testPobrateneDrzave() {
+        // Testira pobratene države
+        PrintStream orig = System.out;
+        final ByteArrayOutputStream myOut = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(myOut));
+
+        ZgodovinaTekmovanj zgodovinaTekmovanj = ZgodovinaTekmovanj.izDatotek("viri/tekmovalci_sample.csv", "viri/glasovi_sample.csv");
+
+        zgodovinaTekmovanj.izpisiPobrateneDrzave(5);
+
+        final String stdOut = myOut.toString();
+        System.setOut(orig);
+
+        String expected = "Drzave z najvec medsebojnih glasov:\n" +
+                "1. Norveška <-(74t)-> Švedska\n" +
+                "2. Estonija <-(59t)-> Švedska\n" +
+                "3. Belgija <-(54t)-> Švedska\n" +
+                "4. Hrvaška <-(53t)-> Slovenija\n" +
+                "5. Islandija <-(51t)-> Švedska\n";
+
+        Assert.assertEquals(stdOut.trim().replace("\r", ""), expected.trim().replace("\r", ""));
+    }
+
+}

src/DN10.java

@@ -0,0 +1,38 @@
+import java.io.DataInputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+
+class Chunk {
+    int length;
+    String type;
+    byte[] data;
+
+    Chunk(int length, String type, byte[] data) {
+        this.length = length;
+        this.type = type;
+        this.data = data;
+    }
+
+    static Chunk read(DataInputStream dis) throws IOException {
+        int length = dis.readInt();
+        String type = new String(dis.readNBytes(4));
+        byte[] data = dis.readNBytes(length);
+        dis.skipBytes(4);
+        return new Chunk(length, type, data);
+    }
+}
+
+public class DN10 {
+    public static void main(String[] args) throws IOException {
+        FileInputStream fis = new FileInputStream(args[0]);
+        DataInputStream dis = new DataInputStream(fis);
+
+        dis.skipBytes(8); // header
+
+        Chunk chunk;
+        do {
+            chunk = Chunk.read(dis);
+            System.out.printf("Chunk: %s, length: %d\n", chunk.type, chunk.length);
+        } while (!chunk.type.equals("IEND"));
+    }
+}

src/DN11.java

@@ -0,0 +1,56 @@
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+public class DN11 {
+    public static void main(String[] args) {
+        var frame = new JFrame();
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        frame.setTitle("VELIKE ČRKE");
+        frame.setSize(600, 400);
+        frame.setLocationRelativeTo(null);
+        frame.setLayout(new GridBagLayout());
+
+        var textArea1 = new JTextArea();
+
+        var gbc = new GridBagConstraints();
+        gbc.gridx = 1;
+        gbc.gridy = 0;
+        gbc.weightx = 1;
+        gbc.weighty = 1;
+        gbc.fill = GridBagConstraints.BOTH;
+        gbc.insets = new Insets(10, 10, 10, 10);
+        frame.add(new JScrollPane(textArea1), gbc);
+
+        var button = new JButton("--> pretvori");
+
+        gbc = new GridBagConstraints();
+        gbc.gridx = 2;
+        gbc.gridy = 0;
+        gbc.weightx = 0;
+        gbc.weighty = 0;
+        gbc.fill = GridBagConstraints.NONE;
+        frame.add(button, gbc);
+
+        var textArea2 = new JTextArea();
+
+        gbc = new GridBagConstraints();
+        gbc.gridx = 3;
+        gbc.gridy = 0;
+        gbc.weightx = 1;
+        gbc.weighty = 1;
+        gbc.fill = GridBagConstraints.BOTH;
+        gbc.insets = new Insets(10, 10, 10, 10);
+        frame.add(new JScrollPane(textArea2), gbc);
+
+        button.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                textArea2.setText(textArea1.getText().toUpperCase());
+            }
+        });
+
+        frame.setVisible(true);
+    }
+}

src/Kviz2.java

@@ -0,0 +1,244 @@
+public class Kviz2 {
+
+    static int vsotaStevk(String str) {
+        int sum = 0;
+        for (char c : str.toCharArray()) {
+            if (Character.isDigit(c)) {
+                sum += Character.getNumericValue(c);
+            }
+        }
+        return sum;
+    }
+
+    static boolean preveriRep(String a, String b) {
+        return a.toLowerCase().endsWith(b.toLowerCase()) ||
+                b.toLowerCase().endsWith(a.toLowerCase());
+    }
+
+    static int[] range(int a, int b, int c) {
+        int[] range = new int[(b - a) / c];
+        for (int i = 0; i < range.length; i++) {
+            range[i] = a + i * c;
+        }
+        return range;
+    }
+
+    static void rotiraj(int[] tabela, int k) {
+        int n = (k / tabela.length) * tabela.length + tabela.length;
+        int[] copy = new int[tabela.length];
+        for (int i = 0; i < tabela.length; i++) {
+            copy[(n + i - k) % tabela.length] = tabela[i];
+        }
+        System.arraycopy(copy, 0, tabela, 0, tabela.length);
+    }
+
+    static int[] duplikati(int[] tabela) {
+        int[] copy = new int[tabela.length];
+        int n = 0;
+        for (int i = 0; i < tabela.length; i++) {
+            boolean found = false;
+            for (int j = 0; j < n; j++) {
+                if (copy[j] == tabela[i]) {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                copy[n++] = tabela[i];
+            }
+        }
+        int[] result = new int[n];
+        System.arraycopy(copy, 0, result, 0, n);
+        return result;
+    }
+
+    static double koren(int x, int d) {
+        double prev = 0d;
+        double c = 0;
+        for (int i = 0; i <= d; i++) {
+            for (c = prev; ; c += 1 / Math.pow(10, i)) {
+                if ((c + 1 / Math.pow(10, i)) * (c + 1 / Math.pow(10, i)) > x) {
+                    prev = c;
+                    break;
+                }
+            }
+        }
+        return c;
+    }
+
+    static String binarnoSestej(String s, String b) {
+        int carry = 0;
+        StringBuilder result = new StringBuilder();
+        for (int i = s.length() - 1, j = b.length() - 1; i >= 0 || j >= 0; i--, j--) {
+            int sum = carry;
+            if (i >= 0) {
+                sum += s.charAt(i) - '0';
+            }
+            if (j >= 0) {
+                sum += b.charAt(j) - '0';
+            }
+            result.append(sum % 2);
+            carry = sum / 2;
+        }
+        if (carry != 0) {
+            result.append(carry);
+        }
+        return result.reverse().toString();
+    }
+
+    static int vsotaSkupnihCifer(int a, int b) {
+        int[] digits = new int[10];
+        while (a > 0) {
+            digits[a % 10]++;
+            a /= 10;
+        }
+        int sum = 0;
+        while (b > 0) {
+            if (digits[b % 10] > 0) {
+                sum += b % 10;
+                digits[b % 10] = 0;
+            }
+            b /= 10;
+        }
+        return sum;
+    }
+
+    static boolean jePapajscina(String niz) {
+        niz = niz.toLowerCase();
+        for (int i = 0; i < niz.length(); i++) {
+            if (((niz.charAt(Math.max(0, i - 1)) != 'p' &&
+                    niz.charAt(i) == 'a') ||
+                    niz.charAt(i) == 'e' ||
+                    niz.charAt(i) == 'i' ||
+                    niz.charAt(i) == 'o' ||
+                    niz.charAt(i) == 'u') &&
+                    (niz.charAt(Math.min(niz.length() - 1, i + 1)) != 'p' ||
+                            niz.charAt(Math.min(niz.length() - 1, i + 2)) != 'a'))
+                return false;
+        }
+        return true;
+    }
+
+    static String prevod(String niz) {
+        String out = "";
+        if (jePapajscina(niz)) {
+            for (int i = 0; i < niz.length(); i++) {
+                out += niz.charAt(i);
+                if (niz.charAt(i) == 'a' ||
+                        niz.charAt(i) == 'e' ||
+                        niz.charAt(i) == 'i' ||
+                        niz.charAt(i) == 'o') {
+                    i += 2;
+                }
+            }
+        } else {
+            for (int i = 0; i < niz.length(); i++) {
+                out += niz.charAt(i);
+                if (niz.charAt(i) == 'a' ||
+                        niz.charAt(i) == 'e' ||
+                        niz.charAt(i) == 'i' ||
+                        niz.charAt(i) == 'o') {
+                    out += "pa";
+                }
+
+            }
+        }
+        return out;
+    }
+
+    static String prepleti(String niz1, String niz2) {
+        StringBuilder output = new StringBuilder();
+        for (int i = 0; i < Math.max(niz1.length(), niz2.length()); i++) {
+            output.append(niz1.length() > i ? niz1.charAt(i) : " ");
+            output.append(niz2.length() > i ? niz2.charAt(i) : " ");
+        }
+        return output.toString();
+    }
+
+    static void odpleti(String niz) {
+        StringBuilder niz1 = new StringBuilder();
+        StringBuilder niz2 = new StringBuilder();
+        for (int i = 0; i < niz.length(); i += 2) {
+            niz1.append(niz.charAt(i));
+            niz2.append(i + 1 < niz.length() ? niz.charAt(i + 1) : "");
+        }
+        System.out.println(niz1);
+        System.out.println(niz2);
+    }
+
+    static String vMorse(String niz) {
+        String[] abeceda = {".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--.." };
+        String[] stevilke = {"-----", ".----", "..---", "...--", "....-", ".....", "-....", "--...", "---..", "----." };
+        niz = niz.toUpperCase();
+        StringBuilder output = new StringBuilder();
+        for (int i = 0; i < niz.length(); i++) {
+            switch (niz.charAt(i)) {
+                case ' ':
+                    output.append(" ");
+                    break;
+                case '.':
+                    output.append(".-.-.- ");
+                    break;
+                case ',':
+                    output.append("--..-- ");
+                    break;
+                case '!':
+                    output.append("-.-.-- ");
+                    break;
+                case ':':
+                    output.append("---... ");
+                    break;
+                case ';':
+                    output.append("-.-.-. ");
+                    break;
+                case '?':
+                    output.append("..--.. ");
+                    break;
+                default:
+                    if (Character.isDigit(niz.charAt(i))) {
+                        output.append(stevilke[niz.charAt(i) - '0']).append(" ");
+                    } else {
+                        output.append(abeceda[niz.charAt(i) - 'A']).append(" ");
+                    }
+            }
+        }
+        return output.toString().trim();
+    }
+
+    static int fibo(int n) {
+        int[][] arr = new int[n][n];
+        int prev = 1;
+        int curr = 1;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                arr[i][j] = prev;
+                int tmp = curr;
+                curr += prev;
+                prev = tmp;
+            }
+        }
+        int sum = 0;
+
+        for (int i = 0; i < n; i++) {
+            sum += arr[i][i] + arr[i][n - i - 1];
+        }
+        return sum;
+    }
+
+    static int binomi(int n, int k) {
+        if ((n == k) || (k == 0))
+            return 1;
+        else
+            return binomi(n - 1, k) + binomi(n - 1, k - 1);
+    }
+
+    int[] pascal(int n) {
+        int[] vrstica = new int[n];
+
+        for (int r = 0; r < n; r++) {
+            vrstica[r] = binomi(n - 1, r);
+        }
+        return vrstica;
+    }
+
+}

src/Kviz4.java

@@ -0,0 +1,189 @@
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+public class Kviz4 {
+    public static void main(String[] args) {
+        System.out.println(Arrays.toString(getVrstica(20)));
+    }
+
+    static java.util.Map<Integer, int[]> cache = new java.util.HashMap<>();
+    
+    public static int[] getVrstica(int n) {
+        if (n == 1) {
+            return new int[]{1};
+        }
+        if (cache.containsKey(n)) {
+            return cache.get(n);
+        }
+
+        int[] vrstica = new int[n];
+        vrstica[0] = n % 10;
+
+        for (int i = 1; i < n; i++) {
+            vrstica[i] = (vrstica[i - 1] + getVrstica(n - 1)[i - 1]) % 10;
+        }
+
+        cache.put(n, vrstica);
+        return vrstica;
+    }
+
+    public static void statistikaStavkov(String imeDatoteke) {
+        class IzjemaManjkajocegaLocila extends Exception {
+            public IzjemaManjkajocegaLocila(String message) {
+                super(message);
+            }
+        }
+
+        try (java.io.BufferedReader br = new java.io.BufferedReader(new java.io.FileReader(imeDatoteke))) {
+            java.util.Map<Integer, Integer> dolzinaStavkov = new java.util.HashMap<>();
+            String line;
+            int stevec = 1; // Za sledenje vrsticam
+            while ((line = br.readLine()) != null) {
+                String[] stavki = line.split("[.!?]");
+                for (String stavek : stavki) {
+                    stavek = stavek.trim();
+                    if (!stavek.isEmpty()) {
+                        if (!stavek.endsWith(".") && !stavek.endsWith("!") && !stavek.endsWith("?")) {
+                            throw new IzjemaManjkajocegaLocila("Stavek na vrstici " + stevec + " se ne konča z ustrezno ločilo.");
+                        }
+                        int dolzina = stavek.split("\\s+").length;
+                        dolzinaStavkov.put(dolzina, dolzinaStavkov.getOrDefault(dolzina, 0) + 1);
+                    }
+                    stevec++;
+                }
+            }
+            // Izpis rezultatov
+            for (java.util.Map.Entry<Integer, Integer> entry : dolzinaStavkov.entrySet()) {
+                System.out.println("Stavki dolzine " + entry.getKey() + " se pojavijo: " + entry.getValue() + "x.");
+            }
+        } catch (java.io.IOException e) {
+            System.out.println("Napaka pri branju datoteke.");
+        } catch (IzjemaManjkajocegaLocila e) {
+            System.out.println(e.getMessage());
+        }
+    }
+
+    public static void poisciInIzpisiBarve(String imeDatoteke) {
+        try (java.io.BufferedReader br = new java.io.BufferedReader(new java.io.FileReader(imeDatoteke))) {
+            String line;
+            java.util.regex.Pattern pattern = java.util.regex.Pattern.compile("(^|[^\\-])color: #([0-9a-fA-F]{6})");
+
+            while ((line = br.readLine()) != null) {
+                java.util.regex.Matcher matcher = pattern.matcher(line);
+                while (matcher.find()) {
+                    String hexColor = matcher.group(2);
+                    int r = Integer.parseInt(hexColor.substring(0, 2), 16);
+                    int g = Integer.parseInt(hexColor.substring(2, 4), 16);
+                    int b = Integer.parseInt(hexColor.substring(4, 6), 16);
+
+                    // Convert RGB to HSL
+                    float[] hsl = rgbToHsl(r, g, b);
+
+                    System.out.printf("#%s -> rgb(%d, %d, %d) -> hsl(%d, %d, %d)%n",
+                            hexColor, r, g, b, Math.round(hsl[0]), Math.round(hsl[1]), Math.round(hsl[2]));
+                }
+            }
+        } catch (java.io.IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static float[] rgbToHsl(int r, int g, int b) {
+        float rNorm = r / 255.0f;
+        float gNorm = g / 255.0f;
+        float bNorm = b / 255.0f;
+
+        float max = Math.max(rNorm, Math.max(gNorm, bNorm));
+        float min = Math.min(rNorm, Math.min(gNorm, bNorm));
+        float delta = max - min;
+
+        float h = 0;
+        if (delta != 0) {
+            if (max == rNorm) {
+                h = ((gNorm - bNorm) / delta) % 6;
+            } else if (max == gNorm) {
+                h = ((bNorm - rNorm) / delta) + 2;
+            } else {
+                h = ((rNorm - gNorm) / delta) + 4;
+            }
+            h *= 60;
+            if (h < 0) {
+                h += 360;
+            }
+        }
+
+        float l = (max + min) / 2;
+
+        float s = 0;
+        if (delta != 0) {
+            s = delta / (1 - Math.abs(2 * l - 1));
+        }
+
+        return new float[]{h, s * 100, l * 100};
+    }
+
+    public static void izpisi(String imeDatoteke) {
+        try (java.io.FileInputStream fis = new java.io.FileInputStream(imeDatoteke);
+             java.nio.channels.FileChannel channel = fis.getChannel()) {
+
+            java.nio.ByteBuffer buffer = java.nio.ByteBuffer.allocate(3);
+
+            while (channel.read(buffer) != -1) {
+                buffer.flip();
+                int number = buffer.getInt();
+                System.out.println(formatTelefonskeStevilke(number));
+                buffer.clear();
+            }
+
+        } catch (java.io.IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void preveri(String stevilka, String imeDatoteke) {
+        int iskanaStevilka = parseTelefonskaStevilka(stevilka);
+
+        try (java.io.FileInputStream fis = new java.io.FileInputStream(imeDatoteke);
+             java.nio.channels.FileChannel channel = fis.getChannel()) {
+
+            java.nio.ByteBuffer buffer = java.nio.ByteBuffer.allocate(3);
+
+            while (channel.read(buffer) != -1) {
+                buffer.flip();
+                byte[] bytes = new byte[3];
+                buffer.get(bytes);
+
+                int number = ((bytes[1] << 28)) >>> 12 | (bytes[1]) | bytes[2];
+                System.out.println(number);
+                if (number == iskanaStevilka) {
+                    System.out.println("Številka " + stevilka + " je v datoteki.");
+                    return;
+                }
+                buffer.clear();
+            }
+
+            System.out.println("Številke " + stevilka + " ni v datoteki.");
+
+        } catch (java.io.IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static String formatTelefonskeStevilke(int number) {
+        int podrocnaKoda = number / 1000000;
+        int preostanek = number % 1000000;
+        int prvaTrojka = preostanek / 1000;
+        int drugaTrojka = preostanek % 1000;
+        return String.format("%d / %03d %03d", podrocnaKoda, prvaTrojka, drugaTrojka);
+    }
+
+    private static int parseTelefonskaStevilka(String stevilka) {
+        String[] parts = stevilka.split("/");
+        int podrocnaKoda = Integer.parseInt(parts[0].trim());
+        parts = parts[1].trim().split(" ");
+        int prvaTrojka = Integer.parseInt(parts[0].trim());
+        int drugaTrojka = Integer.parseInt(parts[1].trim());
+        return (podrocnaKoda * 1000000) + (prvaTrojka * 1000) + drugaTrojka;
+    }
+}

src/Vaja03PikcastiZnaki.java

@@ -0,0 +1,194 @@
+public class Vaja03PikcastiZnaki {
+    private static final char crnaPika = '⬛'; // črn kvadratek
+    private static final char belaPika = '⬜'; // prazen (bel) kvadratek
+
+    private static final char[] abeceda = {
+            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+            'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ' ', ',', '.'};
+
+    private static final short[] kodeZnakov16bit = {
+            (short) 0b1111100111111001, // A
+            (short) 0b1100101011011010, // B
+            (short) 0b1111100010001111, // C
+            (short) 0b1110100110011110, // D
+            (short) 0b1111111010001111, // E
+            (short) 0b1111100011101000, // F
+            (short) 0b1111100010111111, // G
+            (short) 0b1001100111111001, // H
+            (short) 0b1111010001001111, // I
+            (short) 0b1111000110011111, // J
+            (short) 0b1011110010101001, // K
+            (short) 0b1000100010001111, // L
+            (short) 0b1111101110011001, // M
+            (short) 0b1101101110011001, // N
+            (short) 0b1111100110011111, // O
+            (short) 0b1111100111111000, // P
+            (short) 0b1111100110111111, // Q
+            (short) 0b1111100111111010, // R
+            (short) 0b1111100011110111, // S
+            (short) 0b1111010001000100, // T
+            (short) 0b1001100110011111, // U
+            (short) 0b1001100110010110, // V
+            (short) 0b1001100110111111, // W
+            (short) 0b1001011001101001, // X
+            (short) 0b1001100111110100, // Y
+            (short) 0b1111001001001111, // Z
+            (short) 0b0110100110010110, // 0
+            (short) 0b0110001000101111, // 1
+            (short) 0b1110001001001111, // 2
+            (short) 0b1111011100011111, // 3
+            (short) 0b1000100111110001, // 4
+            (short) 0b1111100011110111, // 5
+            (short) 0b1000111110011111, // 6
+            (short) 0b1111000100010001, // 7
+            (short) 0b1110101111010111, // 8
+            (short) 0b1111100111110001, // 9
+            0                           // presledek
+    };
+
+    private static final long[] kodeZnakov64bit = {
+            0b0001100000100100010000100100001001111110010000100100001011100111L,
+            0b1111110001000010010001000111111001000001010000010100000111111110L,
+            0b0011110001000010100000011000000010000000100000010100001000111100L,
+            0b1111110001000010010000010100000101000001010000010100001011111100L,
+            0b1111111101000001010000000111110001000000010000000100000111111111L,
+            0b1111111101000001010000010100100001111000010010000100000011100000L,
+            0b0011111101000001100000001001111110010001100000010100000100111110L,
+            0b1110011101000010010000100111111001000010010000100100001011100111L,
+            0b1111111100010000000100000001000000010000000100000001000011111111L,
+            0b0011111100000100000001000000010011000100100001001000010001111000L,
+            0b1110111101000100010010000111000001001000010001000100001011100111L,
+            0b1110000001000000010000000100000001000000010000010100000111111111L,
+            0b1100011101101010010100100101001001000010010000100100001011100111L,
+            0b1100011101100010010100100100101001000110010000100100001011100111L,
+            0b0011110001000010100000011000000110000001100000010100001000111100L,
+            0b1111111001000001010000010100000101111110010000000100000011100000L,
+            0b0111111010000001100000011000000110000001100010010111111000001000L,
+            0b1111111001000001010000010100000101111110010001000100001011100111L,
+            0b0111110110000011100000010111110000000010100000011100000110111110L,
+            0b1111111110001001000010000000100000001000000010000000100000011100L,
+            0b1110011110000001100000011000000110000001100000011000000101111110L,
+            0b1110011101000010010000100100001000100010001001000001010000001000L,
+            0b1110011101000010010000100100001001010010010100100101001000101100L,
+            0b1110011101000010001001000001100000100100001001000100001011100111L,
+            0b1110011101000010001001000001010000001000000010000000100000011100L,
+            0b1111111110000010100001000000100000010000001000010100000111111111L,
+            0b0011110001000010100001011000100110010001101000010100001000111100L,
+            0b0011000001010000000100000001000000010000000100000001000011111111L,
+            0b0111111010000001000000010000011000011000011000011000000111111111L,
+            0b0111111010000001100000010000111000000001100000011000000101111110L,
+            0b0000011000001010000100100010001001000010111111110000001000000111L,
+            0b1111111110000001100000001111111000000001100000011000000101111110L,
+            0b0111111010000001100000001111111010000001100000011000000101111110L,
+            0b1111111110000001000000100000010000001000000100000001000000111000L,
+            0b0111111010000001100000010111111010000001100000011000000101111110L,
+            0b0111111010000001100000011000000101111111000000011000000101111110L,
+            0,
+            0b0000000000000000000000000000000000000000000000000000001100000001L, // vejica
+            0b0000000000000000000000000000000000000000000000000000001100000011L, // pika
+            0b0001100000011000000110000001100000011000000000000001100000011000L, // klicaj
+    };
+
+    public static void main(String[] args) {
+        izpisi64bit("P2 je super");
+    }
+
+    static void izpisi16bit(short kodaZnaka) {
+        int maska = 1 << 15;
+
+        for (int i = 0; i < 16; i++) {
+            if ((kodaZnaka & maska) != 0) {
+                System.out.print(crnaPika);
+            } else {
+                System.out.print(belaPika);
+            }
+            if ((i + 1) % 4 == 0) {
+                System.out.println();
+            }
+
+            maska >>= 1;
+        }
+    }
+
+    static void izpisiBit(short znak, int bit) {
+        int maska = 1 << bit;
+        if ((znak & maska) != 0) {
+            System.out.print(crnaPika);
+        } else {
+            System.out.print(belaPika);
+        }
+    }
+
+
+    static void izpisi16bit(short[] nizZnakov) {
+        for (int vrst = 0; vrst < 4; vrst++) {
+            for (short znak : nizZnakov) {
+                for (int st = 0; st < 4; st++) {
+                    izpisiBit(znak, 15 - (4 * vrst) - st);
+                }
+                System.out.print(belaPika);
+            }
+            System.out.println();
+        }
+    }
+
+    static int crkaIndex(char crka) {
+        for (int i = 0; i < abeceda.length; i++) {
+            if (crka == abeceda[i]) {
+                return i;
+            }
+        }
+        return 36;
+    }
+
+    static void izpisi16bit(String niz) {
+        niz = niz.toUpperCase();
+        short[] znaki = new short[niz.length()];
+        for (int i = 0; i < niz.length(); i++) {
+            znaki[i] = kodeZnakov16bit[crkaIndex(niz.charAt(i))];
+        }
+
+        izpisi16bit(znaki);
+    }
+
+    static void izpisiBit(long znak, int bit) {
+        long maska = 1L << bit;
+        if ((znak & maska) != 0) {
+            System.out.print(crnaPika);
+        } else {
+            System.out.print(belaPika);
+        }
+    }
+
+    static void izpisi64bit(long kodaZnaka) {
+        for (int i = 63; i >= 0; i--) {
+            izpisiBit(kodaZnaka, i);
+            if (i % 8 == 0) {
+                System.out.println();
+            }
+        }
+    }
+
+    static void izpisi64bit(long[] nizZnakov) {
+        for (int vrst = 0; vrst < 8; vrst++) {
+            for (long znak : nizZnakov) {
+                for (int st = 0; st < 8; st++) {
+                    izpisiBit(znak, 63 - (8 * vrst) - st);
+                }
+                System.out.print(belaPika);
+            }
+            System.out.println();
+        }
+    }
+
+    static void izpisi64bit(String niz) {
+        niz = niz.toUpperCase();
+        long[] znaki = new long[niz.length()];
+        for (int i = 0; i < niz.length(); i++) {
+            znaki[i] = kodeZnakov64bit[crkaIndex(niz.charAt(i))];
+        }
+
+        izpisi64bit(znaki);
+    }
+}

src/Vaja04Besedle.java

@@ -0,0 +1,251 @@
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Arrays;
+import java.util.Random;
+import java.util.Scanner;
+
+public class Vaja04Besedle {
+
+    // Konstante barv
+    static final int BELA = 0;
+    static final int CRNA = 1;
+    static final int RUMENA = 2;
+    static final int ZELENA = 3;
+
+    // ANSI ukazi (za barvni izpis)
+    static final String ANSI_RESET = "\u001B[0m";
+    static final String ANSI_GREEN_BG = "\u001b[42m";
+    static final String ANSI_YELLOW_BG = "\u001b[43m";
+    static final String ANSI_WHITE_BG = "\u001b[47;1m";
+    static final String ANSI_BLACK_BG = "\u001b[40m";
+    static final String ANSI_WHITE = "\u001b[37m";
+    static final String ANSI_BLACK = "\u001b[30m";
+
+    static final String abeceda = "ABCČDEFGHIJKLMNOPRSŠTUVZŽ"; // Veljavne črke
+    static final int MAX_POSKUSOV = 6; // Število poskusov
+
+    static String[] seznamBesed; // Seznam vseh možnih besed
+    static String iskanaBeseda; // Iskana beseda trenutne igre
+    static int[] barveAbecede; // Barve črk pri izpisu abecede
+    static String[] slovar;
+
+    static Scanner sc = new Scanner(System.in);
+
+    // Izpiše znak v izbrani barvi
+    static void izpisiZBarvo(char znak, int barva) {
+        String slog;
+        if (barva == ZELENA) {
+            slog = ANSI_BLACK + ANSI_GREEN_BG;
+        } else if (barva == RUMENA) {
+            slog = ANSI_BLACK + ANSI_YELLOW_BG;
+        } else if (barva == BELA) {
+            slog = ANSI_BLACK + ANSI_WHITE_BG;
+        } else {
+            slog = ANSI_WHITE + ANSI_BLACK_BG;
+        }
+        System.out.print(slog + " " + znak + " " + ANSI_RESET);
+    }
+
+    // Prebere seznam besed iz datoteke
+    static void preberiBesede(String datoteka) throws FileNotFoundException {
+        File file = new File(datoteka);
+        Scanner scanner = new Scanner(file);
+
+        int n = Integer.parseInt(scanner.nextLine());
+        seznamBesed = new String[n];
+
+        for (int i = 0; i < n; i++) {
+            seznamBesed[i] = scanner.nextLine().toUpperCase();
+        }
+    }
+
+    static void preberiSlovar(String datoteka) throws FileNotFoundException {
+        File file = new File(datoteka);
+        Scanner scanner = new Scanner(file);
+
+        int n = Integer.parseInt(scanner.nextLine());
+        slovar = new String[n];
+
+        for (int i = 0; i < n; i++) {
+            slovar[i] = scanner.nextLine().toUpperCase();
+        }
+    }
+
+    // Pripravi vse za novo igro
+    static void novaIgra() {
+        Random rnd = new Random();
+        // iskanaBeseda = seznamBesed[rnd.nextInt(seznamBesed.length)];
+        iskanaBeseda = "DREVO";
+
+        barveAbecede = new int[abeceda.length()];
+        Arrays.fill(barveAbecede, BELA);
+    }
+
+    // Izpiše abecedo
+    static void izpisiAbecedo() {
+        for (int i = 0; i < abeceda.length(); i++) {
+            izpisiZBarvo(abeceda.charAt(i), barveAbecede[i]);
+        }
+        System.out.println();
+    }
+
+    static boolean vSlovarju(String beseda) {
+        for (int i = 0; i < slovar.length; i++) {
+            if (slovar[i].equals(beseda)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    // Ali je beseda veljavna?
+    static boolean veljavnaBeseda(String beseda) {
+        if (beseda.length() != 5) {
+            System.out.println("Nepravilna dolžina besede!");
+            return false;
+        }
+
+        for (int i = 0; i < beseda.length(); i++) {
+            if (!veljavna(beseda.charAt(i))) {
+                System.out.println("V besedi so neveljavni znaki!");
+                return false;
+            }
+        }
+
+        if (!vSlovarju(beseda)) {
+            System.out.println("Besede ni v slovarju!");
+            return false;
+        }
+
+        return true;
+    }
+
+    static boolean veljavna(char c) {
+        for (int i = 0; i < abeceda.length(); i++) {
+            if (c == abeceda.charAt(i)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    static int abecedaIndex(char c) {
+        for (int i = 0; i < abeceda.length(); i++) {
+            if (c == abeceda.charAt(i)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    // Določi barve črk v ugibani besedi
+    static int[] pobarvajBesedo(String ugibanaBeseda) {
+        int[] barve = new int[5];
+        for (int i = 0; i < 5; i++) {
+            char c = ugibanaBeseda.charAt(i);
+            if (iskanaBeseda.charAt(i) == c) {
+                barve[i] = ZELENA;
+                barveAbecede[abecedaIndex(c)] = ZELENA;
+            } else if (iskanaBeseda.contains(Character.toString(c))) {
+                barve[i] = RUMENA;
+                barveAbecede[abecedaIndex(c)] = RUMENA;
+            }
+        }
+
+        return barve;
+    }
+
+    static int[] pravilnoPobarvajBesedo(String ugibanaBeseda) {
+        int[] barve = new int[5];
+        int[] steviloCrk = new int[abeceda.length()];
+        Arrays.fill(steviloCrk, 0);
+
+        for (int i = 0; i < iskanaBeseda.length(); i++) {
+            steviloCrk[abecedaIndex(iskanaBeseda.charAt(i))]++;
+        }
+
+        for (int i = 0; i < 5; i++) {
+            char c = ugibanaBeseda.charAt(i);
+            if (iskanaBeseda.charAt(i) == c) {
+                barve[i] = ZELENA;
+                barveAbecede[abecedaIndex(c)] = ZELENA;
+                steviloCrk[abecedaIndex(c)]--;
+            }
+        }
+
+        for (int i = 0; i < 5; i++) {
+            char c = ugibanaBeseda.charAt(i);
+            if (steviloCrk[abecedaIndex(c)] <= 0) {
+                continue;
+            }
+            if (iskanaBeseda.contains(Character.toString(c))) {
+                barve[i] = RUMENA;
+                barveAbecede[abecedaIndex(c)] = RUMENA;
+                steviloCrk[abecedaIndex(c)]--;
+            }
+        }
+
+        return barve;
+    }
+
+    // Izpiši besedo
+    static void izpisiBesedo(String ugibanaBeseda, int[] barve) {
+        for (int i = 0; i < ugibanaBeseda.length(); i++) {
+            izpisiZBarvo(ugibanaBeseda.charAt(i), barve[i]);
+        }
+        System.out.println();
+    }
+
+
+    // Izvede eno igro
+    static void igra() {
+        novaIgra();
+
+        System.out.println(iskanaBeseda);
+
+        int poskus = 1;
+        boolean uganil = false;
+        while (poskus <= MAX_POSKUSOV) {
+            izpisiAbecedo();
+            System.out.printf("Poskus %d/%d: ", poskus, MAX_POSKUSOV);
+            String ugibanaBeseda = sc.nextLine().toUpperCase();
+
+            // Preveri veljavnost
+            if (!veljavnaBeseda(ugibanaBeseda))
+                continue;
+
+            // Pobarvaj crke v besedi (namigi)
+            // int[] barve = pobarvajBesedo(ugibanaBeseda);
+            int[] barve = pravilnoPobarvajBesedo(ugibanaBeseda);
+
+            // Izpiši pobarvano besedo
+            izpisiBesedo(ugibanaBeseda, barve);
+
+            if (ugibanaBeseda.equals(iskanaBeseda)) {
+                uganil = true;
+                break;
+            }
+            poskus++;
+        }
+
+        if (uganil) {
+            System.out.printf("Bravo! Besedo si uganil/a v %d poskusih.\n", poskus);
+        } else {
+            System.out.printf("Žal ti ni uspelo. Pravilna beseda: %s\n", iskanaBeseda);
+        }
+    }
+
+    public static void main(String[] args) throws FileNotFoundException {
+        preberiBesede("besede.txt");
+        preberiSlovar("slovar.txt");
+
+        while (true) {
+            igra();
+            System.out.print("Nova igra? (d/n): ");
+            String odg = sc.nextLine();
+            if (odg.toLowerCase().charAt(0) != 'd') {
+                break;
+            }
+        }
+    }
+}

src/vaja05/igra/Igra2048.java

@@ -0,0 +1,44 @@
+package vaja05.igra;
+
+import javax.swing.*;
+import java.awt.*;
+
+/**
+ * Glavni razred igre, vključuje metodo main (z njim poženemo program).
+ * Ustvari novo okno, v katerem je igralno polje (privzeto mreža 4 x 4),
+ * in okno prikaže.
+ */
+public class Igra2048 extends JFrame {
+
+    public Igra2048() {
+        ustvariGUI();
+    }
+
+    // ustvarjanje uporabniškega vmesnika
+    private void ustvariGUI() {
+        // ustvarimo objekt razreda IgralnoPolje (panel, kjer poteka igra)
+        IgralnoPolje polje = new IgralnoPolje();
+        // ustvarimo novo okno z naslovom "2048"
+        setTitle("2048");
+        // če okno zapremo (klik na x), se program konča
+        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        // onemogoči spreminjanje velikosti okna
+        setResizable(false);
+        // v okno postavimo objekt polje, in sicer v središče (uporabimo robno razvrščanje)
+        setLayout(new BorderLayout());
+        getContentPane().add(polje, BorderLayout.CENTER);
+        // poskrbimo za preračun ustrezne velikosti okna glede na njegove komponente
+        pack();
+    }
+
+    public static void main(String[] args) {
+        // v ustrezni niti ustvarimo novo okno in ga prikažemo
+        SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                new Igra2048().setVisible(true);
+            }
+        });
+    }
+
+}

src/vaja05/igra/IgralnoPolje.java

@@ -0,0 +1,181 @@
+package vaja05.igra;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.KeyAdapter;
+import java.awt.event.KeyEvent;
+
+/**
+ * Razred predstavlja igralno polje, tj. mrežo kvadratkov,
+ * na katere postavimo ploščice s številkami. Poskrbi za
+ * grafični prikaz uporabniškega vmesnika ter za interakcijož
+ * z igralcem.
+ * Igralec lahko pritisne smerne tipke za premikanje ploščic
+ * po igralnem polju. Tipka ESC zaključi igro, tipka ENTER pa
+ * začne novo igro.
+ * Za logiko igre poskrbi razred Logika, katerega metode kličemo
+ * pri grafičnem prikazu igre (ob odzivu na pritisnjene tipke in
+ * ob izrisu spremenjenega igralnega polja).
+ * Ko igralec doseže ciljno ploščico (privzeto 2048), se pod točkami
+ * izpiše, da je zmagal, in igra se nadaljuje.
+ */
+public class IgralnoPolje extends JPanel {
+
+    private final static int STEVILO_POLJ = 4;     // velikost mreže, privzeto je 4 x 4
+    private final static int VELIKOST_GLAVE = 100; // višina dela za sporočila, kjer se izpisujejo točke (v pikslih)
+    private final static int VELIKOST_POLJA = 80;  // velikost enega polja (v pikslih)
+    private final static int ROB = 10;             // širina roba in razmik med dvemi polji (v pikslih)
+    private final static int LOK = 10;             // zaokroženost kvadratka
+
+    private final static int SIRINA = STEVILO_POLJ * (VELIKOST_POLJA + ROB) + ROB;                  // širina igralne površine (v pikslih)
+    private final static int VISINA = STEVILO_POLJ * (VELIKOST_POLJA + ROB) + ROB + VELIKOST_GLAVE; // višina igralne površine (v pikslih)
+
+    private final static Color BARVA_GLAVE = new Color(0xFA, 0xF8, 0xEF);
+    private final static Color BARVA_OZADJA = new Color(0xBB, 0xAD, 0xA0);
+    private final static Color BARVA_KONEC = new Color(0xBFFAA22E, true);
+
+    private final static int[] VELIKOST_PISAVE = {20, 45, 45, 35, 30};
+
+    private final String SPOROCILO = "KONEC IGRE!";                     // sporočilo ob koncu igre
+    private final String SPOROCILO2 = "Pritisni <Enter> za novo igro."; // sporočilo ob koncu igre, druga vrstica
+    private final String IZPIS_TOCKE = "Dosežene točke:";               // sporočilo pri izpisu točk
+    private final String ZMAGA = "BRAVO! Doseženo število 2048 :-)";    // sporočilo ob zmagi (sestavljena številka 2048)
+
+    // vrni barvo številke v kvadratku
+    private Color vrniBarvoPisave(int vrednost) {
+        return vrednost < 16 ? new Color(0x776e65) : new Color(0xf9f6f2);
+    }
+
+    // vrni barvo kvadratka za posamezno številko
+    private Color vrniBarvoKvadratka(int vrednost) {
+        switch (vrednost) {
+            case 2:
+                return new Color(0xeee4da);
+            case 4:
+                return new Color(0xede0c8);
+            case 8:
+                return new Color(0xf2b179);
+            case 16:
+                return new Color(0xf59563);
+            case 32:
+                return new Color(0xf67c5f);
+            case 64:
+                return new Color(0xf65e3b);
+            case 128:
+                return new Color(0xedcf72);
+            case 256:
+                return new Color(0xedcc61);
+            case 512:
+                return new Color(0xedc850);
+            case 1024:
+                return new Color(0xedc53f);
+            case 2048:
+                return new Color(0xedc22e);
+        }
+        return new Color(0xcdc1b4);
+    }
+
+    public IgralnoPolje() {
+        // nastavimo privzeto velikost panela oz. naše igralne površine
+        setPreferredSize(new Dimension(SIRINA, VISINA));
+        // dodamo poslišalca za dogodke s tipkovnice (pritiske tipk)
+        addKeyListener(new KeyAdapter() {
+            @Override
+            public void keyPressed(KeyEvent e) {
+                // pogledamo, katero tipko je pritisnil uporabnik in ustrezno ukrepamo
+                // zanimajo nas puščice levo, desno, gor in dol ter ENTER (nova igra) in ESC (konec)
+                int key = e.getKeyCode();
+                if (key == KeyEvent.VK_LEFT && !Logika.jeKonec()) {
+                    // ustrezno reagiraj na tipko levo
+                    //System.out.println("levo");
+                    Logika.naslednjaPoteza(0);
+                }
+                if (key == KeyEvent.VK_RIGHT && !Logika.jeKonec()) {
+                    // ustrezno reagiraj na tipko desno
+                    //System.out.println("desno");
+                    Logika.naslednjaPoteza(1);
+                }
+                if (key == KeyEvent.VK_UP && !Logika.jeKonec()) {
+                    // ustrezno reagiraj na tipko gor
+                    //System.out.println("gor");
+                    Logika.naslednjaPoteza(2);
+                }
+                if (key == KeyEvent.VK_DOWN && !Logika.jeKonec()) {
+                    // ustrezno reagiraj na tipko dol
+                    //System.out.println("dol");
+                    Logika.naslednjaPoteza(3);
+                }
+                if (key == KeyEvent.VK_ENTER && Logika.jeKonec()) {
+                    // tipka ENTER
+                    //System.out.println("ENTER: nova igra");
+                    Logika.zacniNovoIgro(STEVILO_POLJ); // začni novo igro, če je igre že konec
+                }
+                if (key == KeyEvent.VK_ESCAPE) {
+                    // tipka ESC
+                    //System.out.printf("ESC: konec = %b\n", Logika.jeKonec());
+                    Logika.koncajIgro();
+                }
+                repaint();
+            }
+        });
+        // barva v oknu igre
+        setBackground(BARVA_OZADJA);
+        // igralna površina je lahko v fokusu
+        setFocusable(true);
+        // začnemo novo igro
+        Logika.zacniNovoIgro(STEVILO_POLJ);
+        repaint();
+    }
+
+    @Override
+    public void paintComponent(Graphics g) {
+        // izriši igralno površino in točke
+        // če je igre konec, izpiši končno sporočilo na sredino igralne površine
+        super.paintComponent(g);
+
+        // nariši zgorni del - glavo, kjer se izpisujejo točke
+        g.setColor(BARVA_GLAVE);
+        g.fillRect(0, 0, SIRINA, VELIKOST_GLAVE);
+
+        // izpiši točke
+        String izpis = String.format("%s %6d", IZPIS_TOCKE, Logika.vrniTocke());
+        Font pisava = new Font("Arial", Font.BOLD, VELIKOST_PISAVE[0]);
+        g.setFont(pisava);
+        g.setColor(vrniBarvoPisave(0));
+        g.drawString(izpis, 2 * ROB, VELIKOST_GLAVE / 2 + ROB);
+        if (Logika.jeZmagal()) // če je igralec že dosegel 2048, izpiši sporočilo; igra se nadaljuje
+            g.drawString(ZMAGA, 2 * ROB, VELIKOST_GLAVE / 2 + 2 * ROB + VELIKOST_PISAVE[0]);
+
+        // nariši polje STEVILO_POLJ x STEVILO_POLJ (privzeto 4 x 4) z vpisanimi številkami
+        for (int i = 0; i < STEVILO_POLJ; i++) {
+            for (int j = 0; j < STEVILO_POLJ; j++) {
+                int ploscica = Logika.vrniPloscico(i, j);
+                g.setColor(vrniBarvoKvadratka(ploscica));
+                g.fillRoundRect(ROB + j * (VELIKOST_POLJA + ROB), VELIKOST_GLAVE + ROB + i * (VELIKOST_POLJA + ROB), VELIKOST_POLJA, VELIKOST_POLJA, LOK, LOK);
+                if (ploscica > 0) {
+                    String stevilka = Integer.toString(ploscica);
+                    int ind = stevilka.length();
+                    pisava = new Font("Arial", Font.BOLD, VELIKOST_PISAVE[ind]);
+                    int dolzina = this.getFontMetrics(pisava).stringWidth(stevilka);
+                    g.setFont(pisava);
+                    g.setColor(vrniBarvoPisave(ploscica));
+                    g.drawString(stevilka, ROB + j * (VELIKOST_POLJA + ROB) + (VELIKOST_POLJA - dolzina) / 2, VELIKOST_GLAVE + ROB + i * (VELIKOST_POLJA + ROB) + VELIKOST_PISAVE[ind] + (VELIKOST_POLJA - VELIKOST_PISAVE[ind] - ROB) / 2);
+                }
+            }
+        }
+
+        // če je igra končana, izpiši sporočilo ob koncu igre na sredino igralne površine
+        if (Logika.jeKonec()) {
+            g.setColor(BARVA_KONEC);
+            g.fillRoundRect(ROB, VELIKOST_GLAVE + ROB, SIRINA - 2 * ROB, VISINA - VELIKOST_GLAVE - 2 * ROB, LOK, LOK);
+            pisava = new Font("Arial", Font.BOLD, VELIKOST_PISAVE[0]);
+            g.setFont(pisava);
+            g.setColor(vrniBarvoPisave(0));
+            int dolzina = this.getFontMetrics(pisava).stringWidth(SPOROCILO);
+            g.drawString(SPOROCILO, (this.getWidth() - dolzina) / 2, this.getHeight() / 2);
+            dolzina = this.getFontMetrics(pisava).stringWidth(SPOROCILO2);
+            g.drawString(SPOROCILO2, (this.getWidth() - dolzina) / 2, this.getHeight() / 2 + VELIKOST_PISAVE[0] + ROB);
+        }
+    }
+
+}

src/vaja05/igra/Logika.java

@@ -0,0 +1,125 @@
+package vaja05.igra;
+
+import java.util.Random;
+
+public class Logika {
+    static int[][] polja;
+    static int tocke;
+    static boolean konec;
+
+    public static void zacniNovoIgro(int velikost) {
+        polja = new int[velikost][velikost];
+        tocke = 0;
+        konec = false;
+
+        dodajPloscico();
+    }
+
+    public static void koncajIgro() {
+        if (konec) {
+            System.exit(0);
+        }
+        konec = true;
+    }
+
+    public static int vrniPloscico(int i, int j) {
+        return polja[i][j];
+    }
+
+    public static int vrniTocke() {
+        return tocke;
+    }
+
+    public static boolean jeZmagal() {
+        return false;
+    }
+
+    public static boolean jeKonec() {
+        return konec;
+    }
+
+    public static void naslednjaPoteza(int smer) {
+        switch (smer) {
+            case 0:
+                premikVLevo2();
+        }
+
+        dodajPloscico();
+    }
+
+    static void premikVLevo2() {
+        for (int[] vrstica : polja) {
+            int dest = 0;
+            for (int curr = 1; curr < vrstica.length; curr++) {
+                if (vrstica[dest] == 0) {
+                    vrstica[dest] = vrstica[curr];
+                } else if (vrstica[dest] == vrstica[curr]) {
+                    vrstica[dest] *= 2;
+                    dest++;
+                } else {
+                    vrstica[dest + 1] = vrstica[curr];
+                    dest++;
+                }
+                vrstica[curr] = 0;
+            }
+        }
+    }
+
+    static void premikVLevo() {
+        for (int[] vrstica : polja) {
+            int prej = -1;
+            for (int i = 0; i < vrstica.length; i++) {
+                if (vrstica[i] == 0) continue;
+                if (prej != -1 && vrstica[i] == vrstica[prej]) {
+                    vrstica[prej] *= 2;
+                    vrstica[i] = 0;
+                } else {
+                    prej = i;
+                }
+            }
+
+            prej = 0;
+            for (int i = 0; i < vrstica.length; i++) {
+                if (prej == -1 && vrstica[i] == 0) {
+                    prej = i;
+                    continue;
+                }
+                if (prej != -1) {
+                    vrstica[prej] = vrstica[i];
+                    vrstica[i] = 0;
+                    prej = -1;
+                }
+            }
+        }
+    }
+
+    static void dodajPloscico() {
+        Random random = new Random();
+
+        boolean prosto = false;
+        for (int[] vrstica : polja) {
+            for (int polje : vrstica) {
+                if (polje == 0) {
+                    prosto = true;
+                    break;
+                }
+            }
+        }
+
+        if (!prosto) {
+            return;
+        }
+
+        int x, y;
+        do {
+            y = random.nextInt(polja.length);
+            x = random.nextInt(polja[0].length);
+        } while (polja[y][x] != 0);
+
+        if (random.nextInt(10) == 9) {
+            polja[y][x] = 4;
+        } else {
+            polja[y][x] = 2;
+        }
+    }
+}

viri/besedilo1.txt

@@ -0,0 +1 @@
+V tekstovni datoteki imamo shranjeno besedilo, sestavljeno iz stavkov, ki so lahko poljubno dolgi (vsebujejo poljubno mnogo besed). Vaša naloga je, da napišete program, ki bo odprl tekstovno datoteko, podano kot parameter ukazne vrstice, prebral celotno vsebino in za podano datoteko izpisal vse najdene dolžine stavkov in število pojavitev stavkov te dolžine (kot ločila med besedami upoštevajte presledke, kot znak za konec stavka pa upoštevajte piko, klicaj  oziroma vprašaj.  V primeru, da se stavek ne konča s piko, klicajem oziroma vprašajem, pa sprožite izjemo IzjemaManjkajocegaLocila. Definirajte tudi ta razred in ustrezno obravnavajte to izjemo.

viri/glasovi_2023.csv

@@ -0,0 +1,555 @@
+leto;krog;od_drzave;za_drzavo;skupaj_tocke;glasovanje_tocke;zirija_tocke
+2023;finale;Albanija;Švedska;22;10;12
+2023;finale;Albanija;Finska;6;6;0
+2023;finale;Albanija;Izrael;11;5;6
+2023;finale;Albanija;Italija;14;12;2
+2023;finale;Albanija;Norveška;4;4;0
+2023;finale;Albanija;Belgija;5;0;5
+2023;finale;Albanija;Estonija;8;0;8
+2023;finale;Albanija;Avstralija;3;0;3
+2023;finale;Albanija;Ciper;11;7;4
+2023;finale;Albanija;Hrvaška;8;8;0
+2023;finale;Albanija;Armenija;10;0;10
+2023;finale;Albanija;Francija;3;3;0
+2023;finale;Albanija;Španija;1;0;1
+2023;finale;Albanija;Poljska;1;1;0
+2023;finale;Albanija;Švica;7;0;7
+2023;finale;Albanija;Slovenija;2;2;0
+2023;finale;Armenija;Švedska;17;7;10
+2023;finale;Armenija;Finska;14;6;8
+2023;finale;Armenija;Izrael;24;12;12
+2023;finale;Armenija;Italija;3;3;0
+2023;finale;Armenija;Norveška;8;4;4
+2023;finale;Armenija;Ukrajina;4;1;3
+2023;finale;Armenija;Ciper;13;8;5
+2023;finale;Armenija;Avstrija;2;0;2
+2023;finale;Armenija;Francija;17;10;7
+2023;finale;Armenija;Španija;6;0;6
+2023;finale;Armenija;Poljska;6;5;1
+2023;finale;Armenija;Švica;2;2;0
+2023;finale;Avstralija;Švedska;17;10;7
+2023;finale;Avstralija;Finska;17;12;5
+2023;finale;Avstralija;Izrael;5;5;0
+2023;finale;Avstralija;Italija;1;0;1
+2023;finale;Avstralija;Norveška;6;6;0
+2023;finale;Avstralija;Belgija;15;3;12
+2023;finale;Avstralija;Estonija;8;0;8
+2023;finale;Avstralija;Litva;10;0;10
+2023;finale;Avstralija;Ciper;11;8;3
+2023;finale;Avstralija;Hrvaška;4;4;0
+2023;finale;Avstralija;Avstrija;13;7;6
+2023;finale;Avstralija;Francija;2;2;0
+2023;finale;Avstralija;Španija;4;0;4
+2023;finale;Avstralija;Slovenija;1;1;0
+2023;finale;Avstralija;Portugalska;2;0;2
+2023;finale;Avstrija;Švedska;14;4;10
+2023;finale;Avstrija;Finska;20;12;8
+2023;finale;Avstrija;Izrael;1;1;0
+2023;finale;Avstrija;Italija;20;8;12
+2023;finale;Avstrija;Norveška;7;7;0
+2023;finale;Avstrija;Ukrajina;5;5;0
+2023;finale;Avstrija;Belgija;3;0;3
+2023;finale;Avstrija;Češka;5;0;5
+2023;finale;Avstrija;Litva;7;0;7
+2023;finale;Avstrija;Ciper;2;0;2
+2023;finale;Avstrija;Hrvaška;10;10;0
+2023;finale;Avstrija;Armenija;1;0;1
+2023;finale;Avstrija;Švica;6;2;4
+2023;finale;Avstrija;Slovenija;6;0;6
+2023;finale;Avstrija;Albanija;3;3;0
+2023;finale;Avstrija;Nemčija;6;6;0
+2023;finale;Azerbajdžan;Švedska;20;10;10
+2023;finale;Azerbajdžan;Finska;11;8;3
+2023;finale;Azerbajdžan;Izrael;24;12;12
+2023;finale;Azerbajdžan;Italija;10;4;6
+2023;finale;Azerbajdžan;Norveška;2;2;0
+2023;finale;Azerbajdžan;Ukrajina;9;7;2
+2023;finale;Azerbajdžan;Estonija;1;0;1
+2023;finale;Azerbajdžan;Avstralija;5;0;5
+2023;finale;Azerbajdžan;Češka;3;3;0
+2023;finale;Azerbajdžan;Ciper;6;6;0
+2023;finale;Azerbajdžan;Španija;7;0;7
+2023;finale;Azerbajdžan;Švica;5;1;4
+2023;finale;Azerbajdžan;Slovenija;5;5;0
+2023;finale;Azerbajdžan;Albanija;8;0;8
+2023;finale;Belgija;Švedska;18;10;8
+2023;finale;Belgija;Finska;17;12;5
+2023;finale;Belgija;Izrael;15;5;10
+2023;finale;Belgija;Italija;14;7;7
+2023;finale;Belgija;Norveška;8;8;0
+2023;finale;Belgija;Ukrajina;1;1;0
+2023;finale;Belgija;Avstralija;4;0;4
+2023;finale;Belgija;Češka;3;0;3
+2023;finale;Belgija;Armenija;6;6;0
+2023;finale;Belgija;Avstrija;12;0;12
+2023;finale;Belgija;Francija;3;2;1
+2023;finale;Belgija;Španija;6;0;6
+2023;finale;Belgija;Poljska;6;4;2
+2023;finale;Belgija;Albanija;3;3;0
+2023;finale;Hrvaška;Švedska;12;2;10
+2023;finale;Hrvaška;Finska;17;10;7
+2023;finale;Hrvaška;Izrael;12;4;8
+2023;finale;Hrvaška;Italija;20;8;12
+2023;finale;Hrvaška;Norveška;5;5;0
+2023;finale;Hrvaška;Estonija;3;0;3
+2023;finale;Hrvaška;Češka;3;3;0
+2023;finale;Hrvaška;Španija;6;0;6
+2023;finale;Hrvaška;Moldavija;3;1;2
+2023;finale;Hrvaška;Slovenija;17;12;5
+2023;finale;Hrvaška;Albanija;6;6;0
+2023;finale;Hrvaška;Portugalska;1;0;1
+2023;finale;Hrvaška;Srbija;11;7;4
+2023;finale;Ciper;Švedska;20;8;12
+2023;finale;Ciper;Finska;10;7;3
+2023;finale;Ciper;Izrael;19;12;7
+2023;finale;Ciper;Italija;11;6;5
+2023;finale;Ciper;Norveška;5;5;0
+2023;finale;Ciper;Ukrajina;10;10;0
+2023;finale;Ciper;Avstralija;8;0;8
+2023;finale;Ciper;Češka;1;0;1
+2023;finale;Ciper;Armenija;8;4;4
+2023;finale;Ciper;Avstrija;10;0;10
+2023;finale;Ciper;Francija;3;3;0
+2023;finale;Ciper;Španija;6;0;6
+2023;finale;Ciper;Moldavija;1;1;0
+2023;finale;Ciper;Poljska;2;2;0
+2023;finale;Ciper;Švica;2;0;2
+2023;finale;Češka;Švedska;16;6;10
+2023;finale;Češka;Finska;15;10;5
+2023;finale;Češka;Izrael;8;8;0
+2023;finale;Češka;Italija;5;1;4
+2023;finale;Češka;Norveška;7;7;0
+2023;finale;Češka;Ukrajina;24;12;12
+2023;finale;Češka;Estonija;2;0;2
+2023;finale;Češka;Avstralija;7;0;7
+2023;finale;Češka;Hrvaška;4;4;0
+2023;finale;Češka;Armenija;10;2;8
+2023;finale;Češka;Španija;3;0;3
+2023;finale;Češka;Moldavija;5;5;0
+2023;finale;Češka;Slovenija;9;3;6
+2023;finale;Češka;Nemčija;1;0;1
+2023;finale;Danska;Švedska;20;8;12
+2023;finale;Danska;Finska;20;12;8
+2023;finale;Danska;Italija;3;3;0
+2023;finale;Danska;Norveška;20;10;10
+2023;finale;Danska;Ukrajina;7;7;0
+2023;finale;Danska;Belgija;9;6;3
+2023;finale;Danska;Avstralija;2;0;2
+2023;finale;Danska;Litva;4;0;4
+2023;finale;Danska;Ciper;7;2;5
+2023;finale;Danska;Avstrija;7;0;7
+2023;finale;Danska;Francija;6;0;6
+2023;finale;Danska;Moldavija;1;1;0
+2023;finale;Danska;Poljska;5;5;0
+2023;finale;Danska;Švica;4;4;0
+2023;finale;Danska;Velika Britanija;1;0;1
+2023;finale;Estonija;Švedska;22;10;12
+2023;finale;Estonija;Finska;22;12;10
+2023;finale;Estonija;Izrael;4;0;4
+2023;finale;Estonija;Italija;7;2;5
+2023;finale;Estonija;Norveška;7;7;0
+2023;finale;Estonija;Ukrajina;15;8;7
+2023;finale;Estonija;Belgija;6;0;6
+2023;finale;Estonija;Avstralija;14;6;8
+2023;finale;Estonija;Litva;6;5;1
+2023;finale;Estonija;Armenija;3;0;3
+2023;finale;Estonija;Španija;2;0;2
+2023;finale;Estonija;Poljska;3;3;0
+2023;finale;Estonija;Švica;4;4;0
+2023;finale;Estonija;Slovenija;1;1;0
+2023;finale;Finska;Švedska;12;0;12
+2023;finale;Finska;Italija;6;0;6
+2023;finale;Finska;Norveška;12;12;0
+2023;finale;Finska;Belgija;5;0;5
+2023;finale;Finska;Estonija;6;6;0
+2023;finale;Finska;Avstralija;8;8;0
+2023;finale;Finska;Češka;18;10;8
+2023;finale;Finska;Ciper;1;0;1
+2023;finale;Finska;Hrvaška;4;4;0
+2023;finale;Finska;Avstrija;4;2;2
+2023;finale;Finska;Francija;7;0;7
+2023;finale;Finska;Moldavija;3;3;0
+2023;finale;Finska;Švica;11;1;10
+2023;finale;Finska;Slovenija;7;7;0
+2023;finale;Finska;Portugalska;3;0;3
+2023;finale;Finska;Velika Britanija;4;0;4
+2023;finale;Finska;Nemčija;5;5;0
+2023;finale;Francija;Švedska;9;3;6
+2023;finale;Francija;Finska;14;6;8
+2023;finale;Francija;Izrael;22;10;12
+2023;finale;Francija;Italija;9;7;2
+2023;finale;Francija;Norveška;1;1;0
+2023;finale;Francija;Ukrajina;5;4;1
+2023;finale;Francija;Belgija;2;2;0
+2023;finale;Francija;Češka;4;0;4
+2023;finale;Francija;Armenija;19;12;7
+2023;finale;Francija;Avstrija;10;0;10
+2023;finale;Francija;Moldavija;8;8;0
+2023;finale;Francija;Švica;3;0;3
+2023;finale;Francija;Portugalska;10;5;5
+2023;finale;Gruzija;Švedska;11;7;4
+2023;finale;Gruzija;Finska;9;8;1
+2023;finale;Gruzija;Izrael;13;6;7
+2023;finale;Gruzija;Italija;13;5;8
+2023;finale;Gruzija;Norveška;2;2;0
+2023;finale;Gruzija;Ukrajina;10;10;0
+2023;finale;Gruzija;Belgija;12;0;12
+2023;finale;Gruzija;Estonija;5;0;5
+2023;finale;Gruzija;Avstralija;2;0;2
+2023;finale;Gruzija;Litva;10;4;6
+2023;finale;Gruzija;Ciper;3;0;3
+2023;finale;Gruzija;Hrvaška;1;1;0
+2023;finale;Gruzija;Armenija;22;12;10
+2023;finale;Gruzija;Moldavija;3;3;0
+2023;finale;Nemčija;Švedska;13;1;12
+2023;finale;Nemčija;Finska;12;12;0
+2023;finale;Nemčija;Italija;14;10;4
+2023;finale;Nemčija;Norveška;11;5;6
+2023;finale;Nemčija;Ukrajina;7;7;0
+2023;finale;Nemčija;Belgija;2;2;0
+2023;finale;Nemčija;Estonija;10;0;10
+2023;finale;Nemčija;Avstralija;8;0;8
+2023;finale;Nemčija;Češka;5;0;5
+2023;finale;Nemčija;Litva;1;0;1
+2023;finale;Nemčija;Hrvaška;6;6;0
+2023;finale;Nemčija;Avstrija;2;0;2
+2023;finale;Nemčija;Španija;7;0;7
+2023;finale;Nemčija;Poljska;4;4;0
+2023;finale;Nemčija;Švica;3;3;0
+2023;finale;Nemčija;Albanija;8;8;0
+2023;finale;Nemčija;Srbija;3;0;3
+2023;finale;Grčija;Švedska;14;8;6
+2023;finale;Grčija;Finska;10;10;0
+2023;finale;Grčija;Izrael;15;7;8
+2023;finale;Grčija;Italija;5;5;0
+2023;finale;Grčija;Norveška;6;6;0
+2023;finale;Grčija;Belgija;12;0;12
+2023;finale;Grčija;Avstralija;5;0;5
+2023;finale;Grčija;Češka;1;1;0
+2023;finale;Grčija;Ciper;16;12;4
+2023;finale;Grčija;Armenija;2;2;0
+2023;finale;Grčija;Avstrija;7;0;7
+2023;finale;Grčija;Francija;3;3;0
+2023;finale;Grčija;Švica;2;0;2
+2023;finale;Grčija;Albanija;7;4;3
+2023;finale;Grčija;Portugalska;10;0;10
+2023;finale;Grčija;Srbija;1;0;1
+2023;finale;Islandija;Švedska;17;10;7
+2023;finale;Islandija;Finska;22;12;10
+2023;finale;Islandija;Italija;1;1;0
+2023;finale;Islandija;Norveška;12;8;4
+2023;finale;Islandija;Ukrajina;2;2;0
+2023;finale;Islandija;Belgija;11;6;5
+2023;finale;Islandija;Avstralija;15;3;12
+2023;finale;Islandija;Češka;6;0;6
+2023;finale;Islandija;Hrvaška;5;5;0
+2023;finale;Islandija;Avstrija;8;0;8
+2023;finale;Islandija;Francija;4;4;0
+2023;finale;Islandija;Španija;3;0;3
+2023;finale;Islandija;Poljska;7;7;0
+2023;finale;Islandija;Srbija;1;0;1
+2023;finale;Islandija;Nemčija;2;0;2
+2023;finale;Irska;Švedska;18;6;12
+2023;finale;Irska;Finska;20;12;8
+2023;finale;Irska;Izrael;8;1;7
+2023;finale;Irska;Norveška;5;5;0
+2023;finale;Irska;Ukrajina;7;7;0
+2023;finale;Irska;Belgija;13;3;10
+2023;finale;Irska;Avstralija;4;0;4
+2023;finale;Irska;Češka;3;0;3
+2023;finale;Irska;Litva;11;10;1
+2023;finale;Irska;Hrvaška;2;2;0
+2023;finale;Irska;Armenija;6;0;6
+2023;finale;Irska;Francija;5;0;5
+2023;finale;Irska;Moldavija;4;4;0
+2023;finale;Irska;Poljska;8;8;0
+2023;finale;Irska;Velika Britanija;2;0;2
+2023;finale;Izrael;Švedska;16;4;12
+2023;finale;Izrael;Finska;20;12;8
+2023;finale;Izrael;Italija;7;7;0
+2023;finale;Izrael;Norveška;20;10;10
+2023;finale;Izrael;Ukrajina;15;8;7
+2023;finale;Izrael;Belgija;3;0;3
+2023;finale;Izrael;Estonija;5;0;5
+2023;finale;Izrael;Češka;6;2;4
+2023;finale;Izrael;Ciper;1;0;1
+2023;finale;Izrael;Hrvaška;6;6;0
+2023;finale;Izrael;Armenija;3;3;0
+2023;finale;Izrael;Avstrija;6;0;6
+2023;finale;Izrael;Francija;1;1;0
+2023;finale;Izrael;Moldavija;5;5;0
+2023;finale;Izrael;Poljska;2;0;2
+2023;finale;Italija;Švedska;11;3;8
+2023;finale;Italija;Finska;6;6;0
+2023;finale;Italija;Izrael;17;5;12
+2023;finale;Italija;Norveška;10;10;0
+2023;finale;Italija;Ukrajina;18;8;10
+2023;finale;Italija;Belgija;2;0;2
+2023;finale;Italija;Estonija;6;0;6
+2023;finale;Italija;Češka;9;2;7
+2023;finale;Italija;Litva;3;0;3
+2023;finale;Italija;Hrvaška;4;4;0
+2023;finale;Italija;Armenija;5;0;5
+2023;finale;Italija;Moldavija;12;12;0
+2023;finale;Italija;Švica;5;1;4
+2023;finale;Italija;Albanija;7;7;0
+2023;finale;Italija;Srbija;1;0;1
+2023;finale;Latvija;Švedska;18;8;10
+2023;finale;Latvija;Finska;12;12;0
+2023;finale;Latvija;Izrael;10;5;5
+2023;finale;Latvija;Italija;3;0;3
+2023;finale;Latvija;Norveška;3;3;0
+2023;finale;Latvija;Ukrajina;11;7;4
+2023;finale;Latvija;Belgija;2;0;2
+2023;finale;Latvija;Estonija;18;6;12
+2023;finale;Latvija;Češka;1;1;0
+2023;finale;Latvija;Litva;17;10;7
+2023;finale;Latvija;Ciper;6;0;6
+2023;finale;Latvija;Hrvaška;4;4;0
+2023;finale;Latvija;Armenija;1;0;1
+2023;finale;Latvija;Španija;8;0;8
+2023;finale;Latvija;Slovenija;2;2;0
+2023;finale;Litva;Švedska;19;7;12
+2023;finale;Litva;Finska;15;12;3
+2023;finale;Litva;Izrael;13;3;10
+2023;finale;Litva;Italija;6;6;0
+2023;finale;Litva;Ukrajina;12;10;2
+2023;finale;Litva;Belgija;7;0;7
+2023;finale;Litva;Estonija;10;5;5
+2023;finale;Litva;Avstralija;4;0;4
+2023;finale;Litva;Ciper;1;0;1
+2023;finale;Litva;Hrvaška;4;4;0
+2023;finale;Litva;Avstrija;8;0;8
+2023;finale;Litva;Francija;7;1;6
+2023;finale;Litva;Moldavija;2;2;0
+2023;finale;Litva;Poljska;8;8;0
+2023;finale;Malta;Švedska;22;10;12
+2023;finale;Malta;Finska;16;8;8
+2023;finale;Malta;Izrael;13;6;7
+2023;finale;Malta;Italija;22;12;10
+2023;finale;Malta;Norveška;9;7;2
+2023;finale;Malta;Ukrajina;5;5;0
+2023;finale;Malta;Litva;4;0;4
+2023;finale;Malta;Ciper;5;0;5
+2023;finale;Malta;Avstrija;1;0;1
+2023;finale;Malta;Francija;1;1;0
+2023;finale;Malta;Švica;6;0;6
+2023;finale;Malta;Albanija;3;3;0
+2023;finale;Malta;Portugalska;3;0;3
+2023;finale;Malta;Srbija;2;2;0
+2023;finale;Malta;Velika Britanija;4;4;0
+2023;finale;Moldavija;Švedska;20;8;12
+2023;finale;Moldavija;Finska;7;7;0
+2023;finale;Moldavija;Izrael;10;10;0
+2023;finale;Moldavija;Italija;15;5;10
+2023;finale;Moldavija;Norveška;6;6;0
+2023;finale;Moldavija;Ukrajina;18;12;6
+2023;finale;Moldavija;Estonija;7;0;7
+2023;finale;Moldavija;Avstralija;5;0;5
+2023;finale;Moldavija;Češka;1;1;0
+2023;finale;Moldavija;Ciper;7;3;4
+2023;finale;Moldavija;Armenija;4;2;2
+2023;finale;Moldavija;Španija;3;0;3
+2023;finale;Moldavija;Poljska;4;4;0
+2023;finale;Moldavija;Albanija;1;0;1
+2023;finale;Moldavija;Portugalska;8;0;8
+2023;finale;Nizozemska;Švedska;20;8;12
+2023;finale;Nizozemska;Finska;22;12;10
+2023;finale;Nizozemska;Izrael;8;6;2
+2023;finale;Nizozemska;Italija;3;3;0
+2023;finale;Nizozemska;Norveška;7;7;0
+2023;finale;Nizozemska;Belgija;14;10;4
+2023;finale;Nizozemska;Estonija;5;5;0
+2023;finale;Nizozemska;Avstralija;1;1;0
+2023;finale;Nizozemska;Češka;8;0;8
+2023;finale;Nizozemska;Avstrija;5;4;1
+2023;finale;Nizozemska;Francija;3;0;3
+2023;finale;Nizozemska;Španija;7;0;7
+2023;finale;Nizozemska;Poljska;2;2;0
+2023;finale;Nizozemska;Švica;6;0;6
+2023;finale;Nizozemska;Portugalska;5;0;5
+2023;finale;Norveška;Švedska;20;10;10
+2023;finale;Norveška;Finska;24;12;12
+2023;finale;Norveška;Izrael;6;3;3
+2023;finale;Norveška;Italija;13;7;6
+2023;finale;Norveška;Ukrajina;1;1;0
+2023;finale;Norveška;Belgija;4;4;0
+2023;finale;Norveška;Avstralija;5;0;5
+2023;finale;Norveška;Češka;4;0;4
+2023;finale;Norveška;Ciper;9;2;7
+2023;finale;Norveška;Francija;8;8;0
+2023;finale;Norveška;Španija;1;0;1
+2023;finale;Norveška;Moldavija;8;0;8
+2023;finale;Norveška;Poljska;6;6;0
+2023;finale;Norveška;Švica;7;5;2
+2023;finale;Poljska;Švedska;14;7;7
+2023;finale;Poljska;Finska;10;10;0
+2023;finale;Poljska;Izrael;17;5;12
+2023;finale;Poljska;Italija;6;0;6
+2023;finale;Poljska;Norveška;8;8;0
+2023;finale;Poljska;Ukrajina;12;12;0
+2023;finale;Poljska;Belgija;5;0;5
+2023;finale;Poljska;Estonija;8;0;8
+2023;finale;Poljska;Avstralija;4;0;4
+2023;finale;Poljska;Češka;3;3;0
+2023;finale;Poljska;Litva;4;1;3
+2023;finale;Poljska;Ciper;14;4;10
+2023;finale;Poljska;Hrvaška;6;6;0
+2023;finale;Poljska;Armenija;1;0;1
+2023;finale;Poljska;Švica;2;0;2
+2023;finale;Poljska;Slovenija;2;2;0
+2023;finale;Portugalska;Švedska;12;7;5
+2023;finale;Portugalska;Finska;10;10;0
+2023;finale;Portugalska;Izrael;5;5;0
+2023;finale;Portugalska;Italija;6;6;0
+2023;finale;Portugalska;Norveška;5;4;1
+2023;finale;Portugalska;Ukrajina;12;12;0
+2023;finale;Portugalska;Belgija;7;1;6
+2023;finale;Portugalska;Estonija;8;0;8
+2023;finale;Portugalska;Avstralija;12;0;12
+2023;finale;Portugalska;Češka;7;0;7
+2023;finale;Portugalska;Hrvaška;3;0;3
+2023;finale;Portugalska;Francija;2;2;0
+2023;finale;Portugalska;Španija;13;3;10
+2023;finale;Portugalska;Moldavija;8;8;0
+2023;finale;Portugalska;Švica;2;0;2
+2023;finale;Portugalska;Srbija;4;0;4
+2023;finale;Romunija;Švedska;18;8;10
+2023;finale;Romunija;Finska;10;10;0
+2023;finale;Romunija;Izrael;10;6;4
+2023;finale;Romunija;Italija;19;7;12
+2023;finale;Romunija;Norveška;5;5;0
+2023;finale;Romunija;Ukrajina;4;4;0
+2023;finale;Romunija;Belgija;2;0;2
+2023;finale;Romunija;Estonija;8;0;8
+2023;finale;Romunija;Avstralija;3;0;3
+2023;finale;Romunija;Ciper;7;1;6
+2023;finale;Romunija;Francija;3;3;0
+2023;finale;Romunija;Moldavija;19;12;7
+2023;finale;Romunija;Poljska;1;0;1
+2023;finale;Romunija;Slovenija;2;2;0
+2023;finale;Romunija;Albanija;5;0;5
+2023;finale;San Marino;Švedska;12;8;4
+2023;finale;San Marino;Finska;12;12;0
+2023;finale;San Marino;Izrael;10;10;0
+2023;finale;San Marino;Italija;19;7;12
+2023;finale;San Marino;Norveška;5;4;1
+2023;finale;San Marino;Ukrajina;6;6;0
+2023;finale;San Marino;Belgija;7;0;7
+2023;finale;San Marino;Estonija;10;0;10
+2023;finale;San Marino;Avstralija;5;0;5
+2023;finale;San Marino;Litva;10;2;8
+2023;finale;San Marino;Ciper;5;5;0
+2023;finale;San Marino;Avstrija;6;0;6
+2023;finale;San Marino;Španija;2;0;2
+2023;finale;San Marino;Moldavija;6;3;3
+2023;finale;San Marino;Poljska;1;1;0
+2023;finale;Srbija;Švedska;11;6;5
+2023;finale;Srbija;Finska;19;12;7
+2023;finale;Srbija;Izrael;17;7;10
+2023;finale;Srbija;Italija;4;2;2
+2023;finale;Srbija;Norveška;5;5;0
+2023;finale;Srbija;Češka;5;4;1
+2023;finale;Srbija;Hrvaška;18;10;8
+2023;finale;Srbija;Avstrija;9;3;6
+2023;finale;Srbija;Francija;5;1;4
+2023;finale;Srbija;Španija;3;0;3
+2023;finale;Srbija;Slovenija;20;8;12
+2023;finale;Slovenija;Švedska;11;4;7
+2023;finale;Slovenija;Finska;10;10;0
+2023;finale;Slovenija;Italija;20;8;12
+2023;finale;Slovenija;Norveška;5;5;0
+2023;finale;Slovenija;Belgija;7;2;5
+2023;finale;Slovenija;Estonija;10;0;10
+2023;finale;Slovenija;Avstralija;4;0;4
+2023;finale;Slovenija;Češka;6;0;6
+2023;finale;Slovenija;Litva;8;0;8
+2023;finale;Slovenija;Hrvaška;12;12;0
+2023;finale;Slovenija;Avstrija;3;0;3
+2023;finale;Slovenija;Francija;3;3;0
+2023;finale;Slovenija;Španija;2;0;2
+2023;finale;Slovenija;Poljska;1;1;0
+2023;finale;Slovenija;Švica;1;0;1
+2023;finale;Slovenija;Albanija;7;7;0
+2023;finale;Slovenija;Srbija;6;6;0
+2023;finale;Španija;Švedska;17;5;12
+2023;finale;Španija;Finska;13;12;1
+2023;finale;Španija;Izrael;15;7;8
+2023;finale;Španija;Italija;16;6;10
+2023;finale;Španija;Norveška;10;8;2
+2023;finale;Španija;Ukrajina;10;10;0
+2023;finale;Španija;Belgija;7;3;4
+2023;finale;Španija;Estonija;7;0;7
+2023;finale;Španija;Armenija;5;2;3
+2023;finale;Španija;Francija;5;0;5
+2023;finale;Španija;Moldavija;1;1;0
+2023;finale;Španija;Portugalska;10;4;6
+2023;finale;Švedska;Finska;24;12;12
+2023;finale;Švedska;Izrael;5;0;5
+2023;finale;Švedska;Italija;13;6;7
+2023;finale;Švedska;Norveška;18;10;8
+2023;finale;Švedska;Ukrajina;4;4;0
+2023;finale;Švedska;Belgija;7;7;0
+2023;finale;Švedska;Estonija;2;0;2
+2023;finale;Švedska;Avstralija;1;1;0
+2023;finale;Švedska;Češka;6;3;3
+2023;finale;Švedska;Ciper;1;0;1
+2023;finale;Švedska;Hrvaška;5;5;0
+2023;finale;Švedska;Francija;12;2;10
+2023;finale;Švedska;Švica;14;8;6
+2023;finale;Švedska;Velika Britanija;4;0;4
+2023;finale;Švica;Švedska;11;5;6
+2023;finale;Švica;Finska;8;8;0
+2023;finale;Švica;Izrael;4;3;1
+2023;finale;Švica;Italija;18;10;8
+2023;finale;Švica;Norveška;6;2;4
+2023;finale;Švica;Estonija;10;0;10
+2023;finale;Švica;Avstralija;2;0;2
+2023;finale;Švica;Češka;12;0;12
+2023;finale;Švica;Hrvaška;6;6;0
+2023;finale;Švica;Armenija;5;0;5
+2023;finale;Švica;Avstrija;7;0;7
+2023;finale;Švica;Španija;3;0;3
+2023;finale;Švica;Albanija;12;12;0
+2023;finale;Švica;Portugalska;7;7;0
+2023;finale;Švica;Srbija;1;1;0
+2023;finale;Švica;Nemčija;4;4;0
+2023;finale;Ukrajina;Švedska;15;3;12
+2023;finale;Ukrajina;Finska;10;10;0
+2023;finale;Ukrajina;Izrael;2;1;1
+2023;finale;Ukrajina;Italija;2;0;2
+2023;finale;Ukrajina;Norveška;7;7;0
+2023;finale;Ukrajina;Estonija;5;0;5
+2023;finale;Ukrajina;Avstralija;8;0;8
+2023;finale;Ukrajina;Češka;9;2;7
+2023;finale;Ukrajina;Litva;14;4;10
+2023;finale;Ukrajina;Hrvaška;8;8;0
+2023;finale;Ukrajina;Moldavija;6;6;0
+2023;finale;Ukrajina;Poljska;18;12;6
+2023;finale;Ukrajina;Slovenija;3;0;3
+2023;finale;Ukrajina;Velika Britanija;9;5;4
+2023;finale;Velika Britanija;Švedska;17;5;12
+2023;finale;Velika Britanija;Finska;12;12;0
+2023;finale;Velika Britanija;Izrael;7;3;4
+2023;finale;Velika Britanija;Italija;2;0;2
+2023;finale;Velika Britanija;Norveška;7;7;0
+2023;finale;Velika Britanija;Ukrajina;4;4;0
+2023;finale;Velika Britanija;Belgija;13;6;7
+2023;finale;Velika Britanija;Estonija;6;0;6
+2023;finale;Velika Britanija;Avstralija;12;2;10
+2023;finale;Velika Britanija;Litva;18;10;8
+2023;finale;Velika Britanija;Armenija;3;0;3
+2023;finale;Velika Britanija;Španija;5;0;5
+2023;finale;Velika Britanija;Moldavija;1;1;0
+2023;finale;Velika Britanija;Poljska;8;8;0
+2023;finale;Velika Britanija;Slovenija;1;0;1
+2023;finale;Svet;Švedska;7;7;
+2023;finale;Svet;Finska;10;10;
+2023;finale;Svet;Izrael;12;12;
+2023;finale;Svet;Norveška;4;4;
+2023;finale;Svet;Ukrajina;5;5;
+2023;finale;Svet;Hrvaška;3;3;
+2023;finale;Svet;Armenija;8;8;
+2023;finale;Svet;Francija;1;1;
+2023;finale;Svet;Španija;2;2;
+2023;finale;Svet;Albanija;6;6;

viri/skrito.dat

@@ -0,0 +1 @@
+<<3C><><13>)Q<>':<3A>D<>o+v<>8f<v<s!<21><>t<EFBFBD>Bbz<62>

viri/style.css

@@ -0,0 +1,93 @@
+html, body {
+    color: #242729;
+    font-family: "Lucida Grande", "Lucida Sans Unicode", "Lucida Sans", Tahoma, sans-serif;
+    font-size: 13px;
+    line-height: 1.30769231
+}
+body {
+    box-sizing: border-box;
+    min-height: 100%;
+    background: #fafafa
+}
+body *, body *: before, body *: after {
+    box-sizing: inherit
+}
+.s-btn {
+    position: relative;
+    padding: .8em;
+    border: 1px solid transparent;
+    border-radius: 0;
+    background-color: transparent;
+    outline: none;
+    font-family: inherit;
+    font-size: inherit;
+    font-weight: 400;
+    line-height: 1.15384615;
+    text-decoration: none;
+    cursor: pointer;
+    border-color: rgba(150, 18, 18, 0);
+    box-shadow: 0 0 0 0 rgba(0, 149, 255, 0);
+    color: #C31818
+}
+.s-btn: hover {
+    border-color: rgba(150, 18, 18, 0)
+}
+.s-btn: active {
+    border-color: rgba(104, 13, 13, 0)
+}
+.s-btn.is-selected {
+    border-color: rgba(59, 7, 7, 0)
+}
+.s-btn[disabled] {
+    border-color: rgba(113, 106, 106, 0.1)
+}
+.s-btn: hover {
+    box-shadow: 0 0 0 0 rgba(0, 149, 255, 0)
+}
+.s-btn: focus {
+    box-shadow: 0 0 0 1px rgba(255, 255, 255, 0.5), 0 0 0 4px rgba(0, 149, 255, 0.1)
+}
+.s-btn[disabled] {
+    box-shadow: none
+}
+.s-btn, .s-btn: focus {
+    background-color: rgba(195, 24, 24, 0)
+}
+.s-btn: hover {
+    background-color: rgba(200, 19, 19, 0.05)
+}
+.s-btn: active {
+    background-color: rgba(211, 8, 8, 0.15)
+}
+.s-btn.is-selected {
+    background-color: rgba(217, 2, 2, 0.25)
+}
+.s-btn[disabled] {
+    background-color: rgba(110, 110, 110, 0.2)
+}
+.s-btn, .s-btn: hover, .s-btn: focus, .s-btn.is-selected, .s-btn[disabled] {
+    background-image: none
+}
+.s-btn.s-btn__dropdown: after {
+    border-color: currentColor transparent
+}
+.s-btn: hover, .s-btn: active {
+    color: #961212
+}
+.s-btn: focus, .s-btn.is-selected {
+    color: #680d0d
+}
+.s-btn[disabled] {
+    color: rgba(110, 110, 110, 0.8)
+}
+.s-btn: hover, .s-btn: focus {
+    text-decoration: none
+}
+.s-btn: focus {
+    outline: none
+}
+.s-btn[disabled] {
+    opacity: 1;
+    cursor: default;
+    pointer-events: none
+}

viri/tekmovalci_2023.csv

@@ -0,0 +1,38 @@
+leto;drzava;tekmovalec;pesem
+2023;Albanija;Albina & Familja Kelmendi;Duje
+2023;Izrael;Noa Kirel;Unicorn
+2023;Avstrija;Teya & Salena;Who The Hell Is Edgar?
+2023;Srbija;Luke Black;Samo mi se spava
+2023;Italija;Marco Mengoni;Due vite
+2023;Češka;Vesna;My Sister's Crown
+2023;Ciper;Andrew Lambrou;Break a Broken Heart
+2023;Armenija;Brunette;Future Lover
+2023;Malta;The Busker;Dance (Our Own Party)
+2023;Latvija;Sudden Lights;Aijā
+2023;Gruzija;Iru;Echo
+2023;Moldavija;Pasha Parfeni;Soarele și Luna
+2023;Hrvaška;Let 3;Mama ŠČ!
+2023;San Marino;Piqued Jacks;Like An Animal
+2023;Belgija;Gustaph;Because of You
+2023;Azerbajdžan;TuralTuranX;Tell Me More
+2023;Francija;La Zarra;Évidemment
+2023;Španija;Blanca Paloma;Eaea
+2023;Estonija;Alika;Bridges
+2023;Litva;Monika Linkytė;Stay
+2023;Avstralija;Voyager;Promise
+2023;Norveška;Alessandra;Queen of Kings
+2023;Nizozemska;Mia Nicolai & Dion Cooper;Burning Daylight
+2023;Poljska;Blanka;Solo
+2023;Švedska;Loreen;Tattoo
+2023;Romunija;Theodor Andrei;D.G.T. (Off and On)
+2023;Islandija;Diljá;Power
+2023;Finska;Käärijä;Cha Cha Cha
+2023;Velika Britanija;Mae Muller;I Wrote A Song
+2023;Irska;Wild Youth;We Are One
+2023;Nemčija;Lord Of The Lost;Blood & Glitter
+2023;Ukrajina;Tvorchi;Heart of Steel
+2023;Slovenija;Joker Out;Carpe Diem
+2023;Danska;Reiley;Breaking My Heart
+2023;Portugalska;Mimicat;Ai Coração
+2023;Grčija;Victor Vernicos;What They Say
+2023;Švica;Remo Forrer;Watergun

viri/tekmovalci_sample.csv

@@ -0,0 +1,101 @@
+leto;drzava;tekmovalec;pesem
+1999;Švedska;Charlotte Nilsson;Take Me To Your Heaven
+1999;Islandija;Selma Björnsdóttir;All Out Of Luck
+1999;Nemčija;Sürpriz;Reise Nach Jerusalem - Kudüs'e Seyahat
+1999;Hrvaška;Doris Dragović;Marija Magdalena
+1999;Izrael;Eden;Yom Huledeth
+1999;Estonija;Evelin Samuel and Camille;Diamond Of Night
+1999;Bosna in Hercegovina;Dino and Beatrice;Putnici
+1999;Danska;Trine Jepsen & Michael Teschl;This Time (i Mean It)
+1999;Nizozemska;Marlayne;One Good Reason
+1999;Avstrija;Bobbie Singer;Reflection
+1999;Slovenija;Darja Svajger;For A Thousand Years
+1999;Belgija;Venessa Chinitor;Like The Wind
+1999;Velika Britanija;Precious;Say It Again
+1999;Norveška;Stig André Van Eijk;Living My Life Without You
+1999;Malta;Times 3;Believe 'n Peace
+1999;Turčija;Tuba Önal & Grup Mystik;Dön Artik
+1999;Irska;The Mullan's;When You Need Me
+1999;Poljska;Mietek Szczesniak;Przytul Mnie Mocno
+1999;Francija;Nayah;Je Veux Donner Ma Voix
+1999;Litva;Aiste Smilgeviciute;Strazdas
+1999;Portugalska;Rui Bandeira;Como Tudo Começou
+1999;Ciper;Marlain Angelidou;Tha'nai Erotas
+1999;Španija;Lydia;No Quiero Escuchar
+2015;Švedska;Måns Zelmerlöw;Heroes
+2015;Rusija;Polina Gagarina;A Million Voices
+2015;Italija;Il Volo;Grande Amore
+2015;Belgija;Loïc Nottet;Rhythm Inside
+2015;Avstralija;Guy Sebastian;Tonight Again
+2015;Latvija;Aminata Savadogo;Love Injected
+2015;Estonija;Elina Born & Stig Rästa;Goodbye to Yesterday
+2015;Norveška;Mørland & Debrah Scarlett;A Monster Like Me
+2015;Izrael;Nadav Guedj;Golden Boy
+2015;Srbija;Bojana Stamenov;Beauty Never Lies
+2015;Gruzija;Nina Sublatti;Warrior
+2015;Azerbajdžan;Elnur Hüseynov;Hour Of The Wolf
+2015;Črna gora;Knez;Adio
+2015;Slovenija;Maraaya;Here for You
+2015;Romunija;Voltaj;De La Capăt / All Over Again
+2015;Armenija;Genealogy;Face The Shadow
+2015;Albanija;Elhaida Dani;I'm Alive
+2015;Litva;Monika & Vaidas;This Time
+2015;Grčija;Maria Elena Kyriakou;One Last Breath
+2015;Madžarska;Boggie;Wars For Nothing
+2015;Španija;Edurne;Amanecer
+2015;Ciper;John Karayiannis;One Thing I Should Have Done
+2015;Poljska;Monika Kuszyńska;In The Name Of Love
+2015;Velika Britanija;Electro Velvet;Still in Love with You
+2015;Francija;Lisa Angell;N’oubliez pas
+2015;Avstrija;The Makemakes;I Am Yours
+2015;Nemčija;Ann Sophie;Black Smoke
+2015;Moldavija;Eduard Romanyuta;I Want Your Love
+2015;Malta;Amber;Warrior
+2015;Belorusija;Uzari & Maimuna;Time
+2015;Irska;Molly Sterling;Playing With Numbers
+2015;Danska;Anti Social Media;The Way You Are
+2015;Nizozemska;Trijntje Oosterhuis;Walk Along
+2015;Češka;Marta Jandová & Václav Noid Bárta;Hope Never Dies
+2015;Severna Makedonija;Daniel Kajmakoski;Autumn Leaves
+2015;Portugalska;Leonor Andrade;Há um mar que nos Separa
+2015;Islandija;María Ólafsdóttir;Unbroken
+2015;Finska;Pertti Kurikan Nimipäivät;Aina Mun Pitää
+2015;San Marino;Michele Perniola & Anita Simoncini;Chain Of Lights
+2015;Švica;Mélanie René;Time To Shine
+2023;Švedska;Loreen;Tattoo
+2023;Finska;Käärijä;Cha Cha Cha
+2023;Izrael;Noa Kirel;Unicorn
+2023;Italija;Marco Mengoni;Due vite
+2023;Norveška;Alessandra;Queen of Kings
+2023;Ukrajina;Tvorchi;Heart of Steel
+2023;Belgija;Gustaph;Because of You
+2023;Estonija;Alika;Bridges
+2023;Avstralija;Voyager;Promise
+2023;Češka;Vesna;My Sister's Crown
+2023;Litva;Monika Linkytė;Stay
+2023;Ciper;Andrew Lambrou;Break a Broken Heart
+2023;Hrvaška;Let 3;Mama ŠČ!
+2023;Armenija;Brunette;Future Lover
+2023;Avstrija;Teya & Salena;Who The Hell Is Edgar?
+2023;Francija;La Zarra;Évidemment
+2023;Španija;Blanca Paloma;Eaea
+2023;Moldavija;Pasha Parfeni;Soarele și Luna
+2023;Poljska;Blanka;Solo
+2023;Švica;Remo Forrer;Watergun
+2023;Slovenija;Joker Out;Carpe Diem
+2023;Albanija;Albina & Familja Kelmendi;Duje
+2023;Portugalska;Mimicat;Ai Coração
+2023;Srbija;Luke Black;Samo mi se spava
+2023;Velika Britanija;Mae Muller;I Wrote A Song
+2023;Nemčija;Lord Of The Lost;Blood & Glitter
+2023;Islandija;Diljá;Power
+2023;Latvija;Sudden Lights;Aijā
+2023;Gruzija;Iru;Echo
+2023;Grčija;Victor Vernicos;What They Say
+2023;Irska;Wild Youth;We Are One
+2023;Nizozemska;Mia Nicolai & Dion Cooper;Burning Daylight
+2023;Danska;Reiley;Breaking My Heart
+2023;Azerbajdžan;TuralTuranX;Tell Me More
+2023;Malta;The Busker;Dance (Our Own Party)
+2023;Romunija;Theodor Andrei;D.G.T. (Off and On)
+2023;San Marino;Piqued Jacks;Like An Animal

viri/tekmovalci_sample_cl.csv

@@ -0,0 +1,101 @@
+leto;drzava;tekmovalec;pesem
+1999;Svedska;Charlotte Nilsson;Take Me To Your Heaven
+1999;Islandija;Selma Bjornsdottir;All Out Of Luck
+1999;Nemcija;Surpriz;Reise Nach Jerusalem - Kudus'e Seyahat
+1999;Hrvaska;Doris Dragovic;Marija Magdalena
+1999;Izrael;Eden;Yom Huledeth
+1999;Estonija;Evelin Samuel and Camille;Diamond Of Night
+1999;Bosna in Hercegovina;Dino and Beatrice;Putnici
+1999;Danska;Trine Jepsen & Michael Teschl;This Time (i Mean It)
+1999;Nizozemska;Marlayne;One Good Reason
+1999;Avstrija;Bobbie Singer;Reflection
+1999;Slovenija;Darja Svajger;For A Thousand Years
+1999;Belgija;Venessa Chinitor;Like The Wind
+1999;Velika Britanija;Precious;Say It Again
+1999;Norveska;Stig Andre Van Eijk;Living My Life Without You
+1999;Malta;Times 3;Believe 'n Peace
+1999;Turcija;Tuba Onal & Grup Mystik;Don Artik
+1999;Irska;The Mullan's;When You Need Me
+1999;Poljska;Mietek Szczesniak;Przytul Mnie Mocno
+1999;Francija;Nayah;Je Veux Donner Ma Voix
+1999;Litva;Aiste Smilgeviciute;Strazdas
+1999;Portugalska;Rui Bandeira;Como Tudo Comecou
+1999;Ciper;Marlain Angelidou;Tha'nai Erotas
+1999;Spanija;Lydia;No Quiero Escuchar
+2015;Svedska;Mans Zelmerlow;Heroes
+2015;Rusija;Polina Gagarina;A Million Voices
+2015;Italija;Il Volo;Grande Amore
+2015;Belgija;Loic Nottet;Rhythm Inside
+2015;Avstralija;Guy Sebastian;Tonight Again
+2015;Latvija;Aminata Savadogo;Love Injected
+2015;Estonija;Elina Born & Stig Rasta;Goodbye to Yesterday
+2015;Norveska;Mørland & Debrah Scarlett;A Monster Like Me
+2015;Izrael;Nadav Guedj;Golden Boy
+2015;Srbija;Bojana Stamenov;Beauty Never Lies
+2015;Gruzija;Nina Sublatti;Warrior
+2015;Azerbajdzan;Elnur Huseynov;Hour Of The Wolf
+2015;Crna gora;Knez;Adio
+2015;Slovenija;Maraaya;Here for You
+2015;Romunija;Voltaj;De La Capat / All Over Again
+2015;Armenija;Genealogy;Face The Shadow
+2015;Albanija;Elhaida Dani;I'm Alive
+2015;Litva;Monika & Vaidas;This Time
+2015;Grcija;Maria Elena Kyriakou;One Last Breath
+2015;Madzarska;Boggie;Wars For Nothing
+2015;Spanija;Edurne;Amanecer
+2015;Ciper;John Karayiannis;One Thing I Should Have Done
+2015;Poljska;Monika Kuszynska;In The Name Of Love
+2015;Velika Britanija;Electro Velvet;Still in Love with You
+2015;Francija;Lisa Angell;N’oubliez pas
+2015;Avstrija;The Makemakes;I Am Yours
+2015;Nemcija;Ann Sophie;Black Smoke
+2015;Moldavija;Eduard Romanyuta;I Want Your Love
+2015;Malta;Amber;Warrior
+2015;Belorusija;Uzari & Maimuna;Time
+2015;Irska;Molly Sterling;Playing With Numbers
+2015;Danska;Anti Social Media;The Way You Are
+2015;Nizozemska;Trijntje Oosterhuis;Walk Along
+2015;Ceska;Marta Jandova & Vaclav Noid Barta;Hope Never Dies
+2015;Severna Makedonija;Daniel Kajmakoski;Autumn Leaves
+2015;Portugalska;Leonor Andrade;Ha um mar que nos Separa
+2015;Islandija;Maria Olafsdottir;Unbroken
+2015;Finska;Pertti Kurikan Nimipaivat;Aina Mun Pitaa
+2015;San Marino;Michele Perniola & Anita Simoncini;Chain Of Lights
+2015;Svica;Melanie Rene;Time To Shine
+2023;Svedska;Loreen;Tattoo
+2023;Finska;Kaarija;Cha Cha Cha
+2023;Izrael;Noa Kirel;Unicorn
+2023;Italija;Marco Mengoni;Due vite
+2023;Norveska;Alessandra;Queen of Kings
+2023;Ukrajina;Tvorchi;Heart of Steel
+2023;Belgija;Gustaph;Because of You
+2023;Estonija;Alika;Bridges
+2023;Avstralija;Voyager;Promise
+2023;Ceska;Vesna;My Sister's Crown
+2023;Litva;Monika Linkyte;Stay
+2023;Ciper;Andrew Lambrou;Break a Broken Heart
+2023;Hrvaska;Let 3;Mama SC!
+2023;Armenija;Brunette;Future Lover
+2023;Avstrija;Teya & Salena;Who The Hell Is Edgar?
+2023;Francija;La Zarra;Evidemment
+2023;Spanija;Blanca Paloma;Eaea
+2023;Moldavija;Pasha Parfeni;Soarele si Luna
+2023;Poljska;Blanka;Solo
+2023;Svica;Remo Forrer;Watergun
+2023;Slovenija;Joker Out;Carpe Diem
+2023;Albanija;Albina & Familja Kelmendi;Duje
+2023;Portugalska;Mimicat;Ai Coracao
+2023;Srbija;Luke Black;Samo mi se spava
+2023;Velika Britanija;Mae Muller;I Wrote A Song
+2023;Nemcija;Lord Of The Lost;Blood & Glitter
+2023;Islandija;Dilja;Power
+2023;Latvija;Sudden Lights;Aija
+2023;Gruzija;Iru;Echo
+2023;Grcija;Victor Vernicos;What They Say
+2023;Irska;Wild Youth;We Are One
+2023;Nizozemska;Mia Nicolai & Dion Cooper;Burning Daylight
+2023;Danska;Reiley;Breaking My Heart
+2023;Azerbajdzan;TuralTuranX;Tell Me More
+2023;Malta;The Busker;Dance (Our Own Party)
+2023;Romunija;Theodor Andrei;D.G.T. (Off and On)
+2023;San Marino;Piqued Jacks;Like An Animal