OneNumberGame.java

package arpad.kosa;

import java.io.*;
import java.util.*;
import java.util.regex.Pattern;
import java.util.stream.Collectors;


public class OneNumberGame {
    List<Player> players = new ArrayList<>();

    public static void main(String[] args) throws IOException {

        try(final BufferedReader reader = new BufferedReader(new FileReader("egyszamjatek.txt"));
            final BufferedWriter writer = new BufferedWriter(new FileWriter("nyertes.txt"))){
            new OneNumberGame().play(reader, writer, System.in, System.out);
        }
    }

    public void play(final BufferedReader reader,
                     final BufferedWriter writer,
                     final InputStream in,
                     final PrintStream out) throws IOException {
        readInputFromFile(reader);
        assertTournamentNumbersAreTheSame();
        printSizes(out);
        printFirstTournamentHadOneOrNot(out);
        printLargestTip(out);
        final int tournament = inputTournament(in, out);


        Optional<Integer> winnerTip = calculateWinnerTip(tournament);
        printWinner(out, winnerTip);

        if (winnerTip.isPresent()) {
            final String winnerName = findWinnerName(tournament, winnerTip);
            printWinnerName(out, winnerName);
            writeOutput(writer, tournament, winnerTip, winnerName);
        } else {
            printNoWinner(out);
        }
    }

    private void printNoWinner(PrintStream out) {
        out.println("A 8. feladat: a megadott forduloban nem volt nyertes. ");
    }

    private void writeOutput(BufferedWriter writer, int tournament, Optional<Integer> winnerTip, String winnerName) throws IOException {
        writer.write("Fordulo sorszama: " + tournament);
        writer.newLine();
        writer.write("Nyertes tipp: " + winnerTip.get());
        writer.newLine();
        writer.write("Nyertes players: " + winnerName);
        writer.newLine();
    }

    private void printWinnerName(PrintStream out, String winnerName) {
        out.println("8. feladat: A megadott fordulo nyertese: " + winnerName);
    }

    private String findWinnerName(int tournament, Optional<Integer> winnerTip) {
        return players.stream()
                        .filter(player -> player.tips.get(tournament - 1) == winnerTip.get())
                        .findFirst()
                        .map(player -> player.name).get();
    }

    private void printWinner(PrintStream out, Optional<Integer> winnerTip) {
        if (winnerTip.isPresent()) {
            out.println("7. feladat: A nyertes tipp a megadott forduloban: " + winnerTip.get());
        } else {
            out.println("7. feladat: A megadott forduloban nem volt nyertes. ");
        }
    }

    private Optional<Integer> calculateWinnerTip(int tournament) {
        final TreeMap<Integer, Integer> tipCounter = new TreeMap<>();
        players.stream().map(player -> player.tips.get(tournament - 1)).forEach(tip -> tipCounter.put(tip,
                Optional.ofNullable(tipCounter.get(tip)).orElse(0) + 1));
        return tipCounter.entrySet().stream()
                .filter(entry -> entry.getValue() == 1)
                .map(Map.Entry::getKey)
                .findFirst();
    }

    private int inputTournament(InputStream in, PrintStream out) {
        Scanner keyboard = new Scanner(in);
        out.print("7. feladat: Kerem a fordulo sorszamat: [1-" + players.get(0).tips.size() + "]");
        return keyboard.nextInt();
    }

    private void printLargestTip(PrintStream out) {
        out.println("6. feladat: a legnagyobb tipp: " + players
                .stream()
                .flatMap(player -> player.tips.stream())
                .max(Comparator.naturalOrder()).get());
    }

    private void printFirstTournamentHadOneOrNot(final PrintStream out) {
        if (players.stream().map(player -> player.tips.get(0)).anyMatch(tip -> tip == 1)) {
            out.println("5. feladat: az elso forduloban volt egyes");
        } else {
            out.println("5. feladat: az elso forduloban NEM volt egyes");
        }
    }

    private void printSizes(final PrintStream out) {
        out.println("3. feladat: a jatekosok szama: " + players.size());
        out.println("4. feladat: a fordulok szama: " + players.get(0).tips.size());
    }

    private void assertTournamentNumbersAreTheSame() {
        final int numberOfTournaments = players.get(0).tips.size();
        if (players.stream().anyMatch(player -> player.tips.size() != numberOfTournaments)) {
            throw new IllegalArgumentException("Different players played different number of tournaments");
        }
    }

    private void readInputFromFile(final BufferedReader reader) throws IOException {
        String line;
        while ((line = reader.readLine()) != null) {
            final int nameStartPosition = line.lastIndexOf(' ') + 1;
            final String name = line.substring(nameStartPosition);
            final String tipString = line.substring(0, nameStartPosition - 1);
            final Player player = new Player(Pattern.compile("\\s+")
                    .splitAsStream(tipString)
                    .map(Integer::parseInt)
                    .collect(Collectors.toList()), name);
            players.add(player);
        }
        reader.close();
    }

    static class Player {
        final List<Integer> tips;
        final String name;

        Player(List<Integer> tips, String name) {
            this.tips = tips;
            this.name = name;
        }
    }
}