import java.util.Scanner;
import java.io.*;
public class Main {
    static Scanner scan = new Scanner(System.in);

    public static void main(String[] args) {
        int res = 0;
        String path = "";

        writeTask();
        outPuth(res, path);

        scan.close();
    }

    public static void writeTask() {
        System.out.println("В данной матрице подсчитать количество столбцов, у которых элементы расставлены в порядке возрастания.");
    }
    public static int chooseOutputMethod() {
        boolean isNotCorrect;
        int choice = 0;
        do {
            isNotCorrect = false;
            try {
                choice = Integer.parseInt(scan.nextLine());
            } catch (NumberFormatException e) {
                System.out.println("Число введено некорректно. Повторите попытку...");
                isNotCorrect = true;
            }
            if ((!isNotCorrect) && (choice != 1) && (choice != 2)) {
                System.out.println("Введите либо 1, либо 2. Ваш выбор: ");
                isNotCorrect = true;
            }
        } while (isNotCorrect);
        return choice;
    }
    public static String fileInputPath(boolean isFileForRead) {
        boolean isNotCorrect;
        String path;
        if (isFileForRead) {
            System.out.println("Введите путь к файлу для чтения: ");
        } else {
            System.out.println("Введите путь к файлу для записи: ");
        }
        do {
            isNotCorrect = false;
            path = scan.nextLine();
            File file = new File(path);
            if (!file.exists()) {
                isNotCorrect = true;
                System.out.println("Файл не найден. Повторите попытку...");
            }
        } while (isNotCorrect);
        return path;
    }
    public static int inputRowsFromFile(String path) {
        int size;
        boolean isIncorrect;

        System.out.println("Считывание размера строк......");
        size = 0;

        isIncorrect = false;
        try (BufferedReader reader = new BufferedReader(new FileReader(path))) {
            try {
                size = Integer.parseInt(reader.readLine());
            } catch(NumberFormatException exception) {
                isIncorrect = true;
            }
            if ((size < 2) || (isIncorrect)) {
                isIncorrect = true;
                System.out.println("Неверный ввод данных! Впишите данные с клавиатуры.");
                size = inputRowsFromConsole();
            }
        } catch (IOException ioException) {
            isIncorrect = true;
        }

        return size;

    }
    public static int inputColsFromFile(String path) {
        int size;
        boolean isIncorrect;

        System.out.println("Считывание размера столбцов......");
        size = 0;

        isIncorrect = false;
        try (BufferedReader reader = new BufferedReader(new FileReader(path))) {
            reader.readLine();
            try {
                size = Integer.parseInt(reader.readLine());
            } catch(NumberFormatException exception) {
                isIncorrect = true;
            }
            if ((size < 2) || (isIncorrect)) {
                isIncorrect = true;
                System.out.println("Неверный ввод данных! Впишите данные с клавиатуры.");
                size = inputColsFromConsole();
            }
        } catch (IOException ioException) {
            isIncorrect = true;
        }

        return size;

    }
    public static int exceptionRead(int i, int j) {
        boolean isIncorrect;
        int number;

        number = 0;
        do {
            isIncorrect = false;
            System.out.print("Введите " + (i+1) + "," + (j+1) + " элемент матрицы: ");
            try {
                number = Integer.parseInt(scan.nextLine());
            } catch (NumberFormatException exception) {
                System.err.println("Неверный ввод данных!");
                isIncorrect = true;
            }
        } while (isIncorrect);

        return number;
    }
    public static int[][] inputMatrixFromFile(String path, int sizeI, int sizeJ, int[][] matrix) {
        boolean isIncorrect;

        System.out.println("Считывание матрицы...");

        isIncorrect = false;
        try (BufferedReader reader = new BufferedReader(new FileReader(path))) {
            reader.readLine();
            reader.readLine();
            for (int i = 0; i < sizeI; i++) {
                String[] elements = reader.readLine().split(" ");
                for (int j = 0; j < sizeJ; j++) {
                    try {
                        matrix[i][j] = Integer.parseInt(elements[j]);
                    } catch(NumberFormatException exception) {
                        System.out.println("Неверный ввод данных! Запишите данные с клавиатуры.");
                        matrix[i][j] = exceptionRead(i, j);
                    }
                }
                System.out.println();
            }
        } catch (IOException ioException) {
            isIncorrect = true;
            System.err.println("Неверный ввод данных! Измените входные данные и перезапустите программу.");
        }


        return matrix;
    }
    public static int[][] fileInputMatrix(String path) {
        boolean isNotCorrect;
        int rows = 0;
        int cols = 0;
        int[][] matrix;
        int i;
        int j;

        rows = inputRowsFromFile(path);
        cols = inputColsFromFile(path);
        matrix = new int[rows][cols];

        matrix = inputMatrixFromFile(path, rows, cols, matrix);


        return matrix;
    }
    public static int inputRowsFromConsole() {
        final int MIN_VALUE = 2;
        boolean isNotCorrect;
        int number;

        number = 0;
        do {
            isNotCorrect = false;
            System.out.println("Введите количество строк в матрице: ");
            try {
                number = Integer.parseInt(scan.nextLine());
            } catch(NumberFormatException exception) {
                isNotCorrect = true;
            }
            if ((isNotCorrect) || (number < MIN_VALUE)) {
                isNotCorrect = true;
                System.out.println("Ошибка ввода! Проверьте, входит ли ваше\nзначение порядка в диапазон, и повторите попытку");
            }
        } while (isNotCorrect);

        return number;
    }
    public static int inputColsFromConsole() {
        final int MIN_VALUE = 2;
        boolean isNotCorrect;
        int number;

        number = 0;
        do {
            isNotCorrect = false;
            System.out.println("Введите количество столбцов в матрице: ");
            try {
                number = Integer.parseInt(scan.nextLine());
            } catch(NumberFormatException exception) {
                isNotCorrect = true;
            }
            if ((isNotCorrect) || (number < MIN_VALUE)) {
                isNotCorrect = true;
                System.out.println("Ошибка ввода! Проверьте, входит ли ваше\nзначение порядка в диапазон, и повторите попытку");
            }
        } while (isNotCorrect);

        return number;
    }
    public static int[][] consoleInputMatrix() {
        boolean isNotCorrect;
        int[][] matrix;
        int rows = 0;
        int cols = 0;

        rows = inputRowsFromConsole();
        cols = inputColsFromConsole();

        matrix = new int[rows][cols];
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                do {
                    System.out.println("Введите " + (j + 1) + " элемент " + (i + 1) + " строки");
                    isNotCorrect = false;
                    try {
                        matrix[i][j] = Integer.parseInt(scan.nextLine());
                    } catch (NumberFormatException e) {
                        System.out.println("Ошибка ввода! Повторите попытку...");
                        isNotCorrect = true;
                    }
                } while (isNotCorrect);
            }
        }
        return matrix;
    }
    public static void consoleMatrixOutput(int[][] matrix) {
        System.out.println("Исходная матрица:");
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
    }
    public static int[][] fileChoice() {
        boolean isFileForRead = true;
        String path = fileInputPath(isFileForRead);
        int[][] matrix = fileInputMatrix(path);
        consoleMatrixOutput(matrix);
        return matrix;
    }
    public static int[][] consoleChoice() {
        int[][] matrix = consoleInputMatrix();
        consoleMatrixOutput(matrix);
        return matrix;
    }
    public static int[][] Choice() {
        int[][] matrix;
        System.out.println("Введите число, чтобы выбрать способ решения задания:\n1 - через консоль, 2 - с помощью файлов");
        int choice = chooseOutputMethod();
        if (choice == 1) {
            matrix = consoleChoice();
        } else {
            matrix = fileChoice();
        }
        return matrix;
    }
    public static int solutionTask() {
        int i, j, count, res;
        int[][] matrix;
        matrix = Choice();
        res = 0;
        for (j = 0; j < matrix[0].length; j++) {
            count = 0;
            for (i = 1; i < matrix.length; i++) {
                if (matrix[i][j] > matrix[i - 1][j]) {
                    count++;
                }
            }
            if (count == matrix.length) {
                res++;
            }
        }
        return res;
    }
    public static void outPuth(int res, String path) {
        boolean isNotCorrect;
        res = solutionTask();
        System.out.println("Введите число, чтобы выбрать способ вывода решения задания: 1 - через консоль, 2 - через файл");
        int choice = chooseOutputMethod();
        if (choice == 1) {
            if (res > 0) {
                System.out.println("Количество таких столбцов:" + res);
            } else {
                System.out.println("Таких столбцов не найдено.");
            }
        } else {
            boolean isFileForRead = false;
            do {
                isNotCorrect = false;
                path = fileInputPath(isFileForRead);
                try (FileWriter fileWriter = new FileWriter(new File(path))) {
                    if (res > 0) {
                        fileWriter.write("Количество столбцов: " + res);
                    } else {
                        fileWriter.write("Таких столбцов нету.");
                    }
                } catch (IOException e) {
                    System.out.println("Не удалось открыть файл. Повторите попытку...");
                    isNotCorrect = true;
                }
            } while (isNotCorrect);
            System.out.println("Ответ записан в файл");
        }
    }
}