Найдин

src/main/java/ru/urfu/Main.java

@@ -1,17 +1,9 @@
 package ru.urfu;
 
-//TIP To <b>Run</b> code, press <shortcut actionId="Run"/> or
-// click the <icon src="AllIcons.Actions.Execute"/> icon in the gutter.
+import ru.urfu.console.Communicator;
+
 public class Main {
     public static void main(String[] args) {
-        //TIP Press <shortcut actionId="ShowIntentionActions"/> with your caret at the highlighted text
-        // to see how GIGA IDE suggests fixing it.
-        System.out.printf("Hello and welcome!");
-
-        for (int i = 1; i <= 5; i++) {
-            //TIP Press <shortcut actionId="Debug"/> to start debugging your code. We have set one <icon src="AllIcons.Debugger.Db_set_breakpoint"/> breakpoint
-            // for you, but you can always add more by pressing <shortcut actionId="ToggleLineBreakpoint"/>.
-            System.out.println("i = " + i);
-        }
+        Communicator.runChampionship();
     }
 }

src/main/java/ru/urfu/console/Communicator.java

@@ -0,0 +1,33 @@
+package ru.urfu.console;
+
+import ru.urfu.parser.CsvParser;
+import ru.urfu.resolver.Resolver;
+
+import java.util.Scanner;
+
+public class Communicator {
+    public static void runChampionship() {
+        var scanner = new Scanner(System.in);
+        System.out.print("Введите файл для анализа: ");
+        String fileName = "D:\\java_git\\2\\src\\main\\resources\\fakePlayers.csv";
+        //String fileName = scanner.nextLine();
+        var players = CsvParser.parseCsvToList(fileName);
+        //System.out.println(players);
+
+        var resolver = new Resolver(players);
+
+        System.out.print("Количество игроков, интересы которых не представляет агентство: ");
+        System.out.println(resolver.getCountWithoutAgency());
+
+        System.out.print("Максимальное число голов, забитых защитником: ");
+        System.out.println(resolver.getMaxDefenderGoalsCount());
+
+        System.out.print("Русское название позиции самого дорогого немецкого игрока: ");
+        System.out.println(resolver.getTheExpensiveGermanPlayerPosition());
+
+        System.out.print("Команда с наибольшим средним числом красных карточек на одного игрока: ");
+        System.out.println(resolver.getTheRudestTeam());
+
+        resolver.renderGraphic();
+    }
+}

src/main/java/ru/urfu/graphics/Graphic.java

@@ -0,0 +1,40 @@
+package ru.urfu.graphics;
+
+import org.jfree.chart.ChartFactory;
+import org.jfree.chart.ChartPanel;
+import org.jfree.chart.JFreeChart;
+import org.jfree.chart.plot.PlotOrientation;
+import org.jfree.data.xy.XYSeries;
+import org.jfree.data.xy.XYSeriesCollection;
+import ru.urfu.model.Player;
+import ru.urfu.model.Position;
+
+import javax.swing.*;
+import java.util.List;
+
+public class Graphic {
+    static XYSeriesCollection createDataset(List<Player> players) {
+        XYSeries series = new XYSeries("Нападающие");
+        players.stream()
+                .filter(player -> player.position() == Position.FORWARD)
+                .forEach(p -> series.add(p.cost(), p.goals()));
+        return new XYSeriesCollection(series);
+    }
+
+    public static void showGraphic(List<Player> players) {
+        var dataset = createDataset(players);
+        JFreeChart chart = ChartFactory.createXYLineChart(
+                "Голы vs Стоимость (FORWARD)",
+                "Трансферная стоимость",
+                "Голы",
+                dataset,
+                PlotOrientation.VERTICAL,
+                true, true, false
+        );
+        JFrame frame = new JFrame("Диаграмма");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        frame.add(new ChartPanel(chart));
+        frame.pack();
+        frame.setVisible(true);
+    }
+}

src/main/java/ru/urfu/model/Player.java

@@ -0,0 +1,13 @@
+package ru.urfu.model;
+
+public record Player(
+        String name,
+        Position position,
+        String agency,
+        int goals,
+        String nation,
+        int cost,
+        String team,
+        int redCards
+) {
+}

src/main/java/ru/urfu/model/Position.java

@@ -0,0 +1,8 @@
+package ru.urfu.model;
+
+public enum Position{
+    GOALKEEPER,
+    DEFENDER,
+    MIDFIELD,
+    FORWARD
+}

src/main/java/ru/urfu/parser/CsvParser.java

@@ -0,0 +1,47 @@
+package ru.urfu.parser;
+
+import ru.urfu.model.Player;
+import ru.urfu.model.Position;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Scanner;
+
+public class CsvParser {
+
+    public static ArrayList<Player> parseCsvToList(String pathString) {
+        Path path = Paths.get(pathString);
+        Scanner scanner = getScanner(path);
+        var list = new ArrayList<Player>();
+        scanner.nextLine();
+        while (scanner.hasNextLine()) {
+            list.add(parsePlayerRow(scanner.nextLine()));
+        }
+
+        return list;
+    }
+
+    private static Player parsePlayerRow(String row) {
+        var cells = row.split(";");
+        return new Player(
+                cells[0],
+                Position.valueOf(cells[3]),
+                cells[5],
+                Integer.parseInt(cells[8]),
+                cells[4],
+                Integer.parseInt(cells[6]),
+                cells[1],
+                Integer.parseInt(cells[11])
+        );
+    }
+
+    private static Scanner getScanner(Path path) {
+        try {
+            return new Scanner(path);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/ru/urfu/resolver/IResolver.java

@@ -4,7 +4,7 @@ public interface IResolver {
     // Выведите количество игроков, интересы которых не представляет агентство.
     int getCountWithoutAgency();
 
-    // Выведите максимальное число голов, забитых защинтником.
+    // Выведите максимальное число голов, забитых защитником.
     int getMaxDefenderGoalsCount();
 
     // Выведите русское название позиции самого дорогого немецкого игрока.

src/main/java/ru/urfu/resolver/Resolver.java

@@ -0,0 +1,77 @@
+package ru.urfu.resolver;
+
+import ru.urfu.model.Player;
+import ru.urfu.model.Position;
+import ru.urfu.graphics.Graphic;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+
+public class Resolver implements IResolver {
+    private final List<Player> players;
+
+    public Resolver(List<Player> players) {
+        this.players = players;
+    }
+
+    @Override
+    public int getCountWithoutAgency() {
+
+        return (int)players.stream().filter(player -> player.agency().isEmpty()).
+                count();
+    }
+
+    @Override
+    public int getMaxDefenderGoalsCount() {
+        return players.stream()
+                .filter(player -> player.position() == Position.DEFENDER)
+                .mapToInt(Player::goals).max().orElse(0);
+    }
+
+    @Override
+    public String getTheExpensiveGermanPlayerPosition() {
+        int maxCost = players.stream()
+                .filter(player -> player.nation().equals("Germany"))
+                .mapToInt(Player::cost).max().orElse(0);
+        Position position = players.stream()
+                .filter(player -> player.nation().equals("Germany"))
+                .filter(player -> player.cost() == maxCost)
+                .findAny().get().position();
+        if (position ==  Position.DEFENDER) {
+            return "Защитник";
+        }
+        else if (position == Position.GOALKEEPER) {
+            return "Вратарь";
+        }
+        else if (position == Position.MIDFIELD) {
+            return "Полузащитник";
+        }
+        else {
+            return "Нападающий";
+        }
+    }
+
+    @Override
+    public String getTheRudestTeam() {
+        Map<String, List<Player>> grouped = players.stream()
+                .collect(Collectors.groupingBy(Player::team));
+
+        Map.Entry<String, List<Player>> maxEntry = grouped.entrySet().stream()
+                .max(Comparator.comparingDouble(entry ->
+                        entry.getValue().stream()
+                                .mapToInt(Player::redCards)
+                                .average()
+                                .orElse(0)
+                ))
+                .orElse(null);
+
+        return maxEntry != null ? maxEntry.getKey() : "";
+    }
+
+    public void renderGraphic() {
+        Graphic.showGraphic(players);
+    }
+}

test/java/ru/urfu/graphics/GraphicMapperTest.java

@@ -0,0 +1,57 @@
+package ru.urfu.graphics;
+
+import org.jfree.data.xy.XYSeriesCollection;
+import org.junit.jupiter.api.Test;
+import ru.urfu.model.Player;
+import ru.urfu.model.Position;
+import ru.urfu.graphics.Graphic;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class GraphicMapperTest {
+
+    @Test
+    void testCreateDatasetFiltersAndMapsCorrectly() {
+        List<Player> players = List.of(
+                new Player("Messi", Position.FORWARD, "Agent", 30, "Argentina", 100_000_000, "PSG", 0),
+                new Player("Neuer", Position.GOALKEEPER, "Agent", 0, "Germany", 50_000_000, "Bayern", 0)
+        );
+
+        XYSeriesCollection dataset = Graphic.createDataset(players);
+
+        assertEquals(1, dataset.getSeriesCount());
+        assertEquals(1, dataset.getSeries(0).getItemCount());
+        assertEquals(100_000_000, dataset.getSeries(0).getX(0).intValue());
+        assertEquals(30, dataset.getSeries(0).getY(0).intValue());
+    }
+    @Test
+    void testMultipleForwardsMappedCorrectly() {
+        List<Player> players = List.of(
+                new Player("Messi", Position.FORWARD, "Agent", 30, "Argentina", 100_000_000, "PSG", 0),
+                new Player("Mbappe", Position.FORWARD, "Agent", 40, "France", 180_000_000, "PSG", 1),
+                new Player("Neuer", Position.GOALKEEPER, "Agent", 0, "Germany", 50_000_000, "Bayern", 0)
+        );
+
+        XYSeriesCollection dataset = Graphic.createDataset(players);
+
+        assertEquals(1, dataset.getSeriesCount());
+        assertEquals(2, dataset.getSeries(0).getItemCount());
+
+        assertEquals(100_000_000, dataset.getSeries(0).getX(0).intValue());
+        assertEquals(30, dataset.getSeries(0).getY(0).intValue());
+
+        assertEquals(180_000_000, dataset.getSeries(0).getX(1).intValue());
+        assertEquals(40, dataset.getSeries(0).getY(1).intValue());
+    }
+
+    @Test
+    void testEmptyPlayerListReturnsEmptyDataset() {
+        List<Player> players = List.of();
+        XYSeriesCollection dataset = Graphic.createDataset(players);
+
+        assertEquals(1, dataset.getSeriesCount());
+        assertEquals(0, dataset.getSeries(0).getItemCount());
+    }
+
+}

test/java/ru/urfu/resolver/ResolverTest.java

@@ -0,0 +1,53 @@
+package ru.urfu.resolver;
+
+import org.junit.jupiter.api.Test;
+import ru.urfu.model.Player;
+import ru.urfu.model.Position;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class ResolverTest {
+
+    @Test
+    void testGetCountWithoutAgency() {
+        List<Player> players = List.of(
+                new Player("A", Position.FORWARD, "", 10, "Germany", 100_000_000, "TeamX", 1),
+                new Player("B", Position.DEFENDER, "AgentX", 5, "France", 50_000_000, "TeamY", 0)
+        );
+        Resolver resolver = new Resolver(players);
+        assertEquals(1, resolver.getCountWithoutAgency());
+    }
+
+    @Test
+    void testMaxDefenderGoals() {
+        List<Player> players = List.of(
+                new Player("A", Position.DEFENDER, "Agent", 3, "Spain", 10_000_000, "TeamA", 0),
+                new Player("B", Position.DEFENDER, "Agent", 7, "Spain", 20_000_000, "TeamA", 1)
+        );
+        Resolver resolver = new Resolver(players);
+        assertEquals(7, resolver.getMaxDefenderGoalsCount());
+    }
+
+    @Test
+    void testExpensiveGermanPosition() {
+        List<Player> players = List.of(
+                new Player("A", Position.MIDFIELD, "Agent", 10, "Germany", 90_000_000, "TeamA", 0),
+                new Player("B", Position.FORWARD, "Agent", 15, "Germany", 120_000_000, "TeamB", 1)
+        );
+        Resolver resolver = new Resolver(players);
+        assertEquals("Нападающий", resolver.getTheExpensiveGermanPlayerPosition());
+    }
+
+    @Test
+    void testRudestTeam() {
+        List<Player> players = List.of(
+                new Player("A", Position.FORWARD, "Agent", 10, "Germany", 90_000_000, "TeamA", 2),
+                new Player("B", Position.DEFENDER, "Agent", 5, "France", 50_000_000, "TeamB", 0),
+                new Player("C", Position.DEFENDER, "Agent", 5, "France", 50_000_000, "TeamB", 0)
+        );
+        Resolver resolver = new Resolver(players);
+        assertEquals("TeamA", resolver.getTheRudestTeam());
+    }
+}