Advertisement
Vladislav8653

laba_2_4_java

Nov 17th, 2022 (edited)
137
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 8.49 KB | None | 0 0
  1. import java.util.Scanner;
  2. import java.io.*;
  3. public class moveMatrix {
  4.     private static final Scanner scanner = new Scanner(System.in);
  5.     private static Scanner fileScanner;
  6.  
  7.     public static void main(String[] args) {
  8.         int n;
  9.         int[][] arr;
  10.         System.out.println("Enter 1 or 0. " + '\n' + "1 is console input, 0 is file input.");
  11.         int chose = choose();
  12.         if (chose == 1) {
  13.             System.out.println("Input matrix size: ");
  14.             n = inputArraySize();
  15.             System.out.println("Enter the numbers one by one: ");
  16.             arr = inputArray(n);
  17.         } else {
  18.             String str = inputFilePath();
  19.             n = inputSizeOfMatrixFromFile(str);
  20.             arr = inputMatrixFile(str,n);
  21.         }
  22.         int starti = 0;
  23.         int startj = starti;
  24.         int[] bufferFor1 = transferMatrixVector(n, arr, starti, startj);
  25.  
  26.         starti = 0;
  27.         startj = n / 2;
  28.         int[] bufferFor2 = transferMatrixVector(n, arr, starti, startj);
  29.  
  30.         starti = n / 2;
  31.         startj = 0;
  32.         int[] bufferFor3 = transferMatrixVector(n, arr, starti, startj);
  33.  
  34.         starti = n / 2;
  35.         startj = starti;
  36.         int[] bufferFor4 = transferMatrixVector(n, arr, starti, startj);
  37.  
  38.         int i;
  39.         int j;
  40.         int k = 0;
  41.         for (i = 0; i < n; i++) {
  42.             for (j = 0; j < n; j++) {
  43.                 if ((i < n / 2) && (j < n / 2))
  44.                     arr[i][j] = bufferFor4[k];
  45.                 k = 0;
  46.                 if ((i < n / 2) && (j > n / 2 - 1))
  47.                     arr[i][j] = bufferFor3[k];
  48.                 if ((i > n / 2 - 1) && (j < n / 2))
  49.                     arr[i][j] = bufferFor1[k];
  50.                 if ((i > n / 2 - 1) && (j > n / 2 - 1))
  51.                     arr[i][j] = bufferFor2[k];
  52.                 k++;
  53.             }
  54.         }
  55.         System.out.println("Enter 1 or 0.");
  56.         System.out.println("1 is console output, 0 is file output.");
  57.         chose = choose();
  58.         if (chose == 1)
  59.             outputArray(n, arr);
  60.         else {
  61.             String str = inputFilePath();
  62.             fileOutput(arr, n, str);
  63.         }
  64.         scanner.close();
  65.         fileScanner.close();
  66.     }
  67.  
  68.  
  69.     public static int choose() {
  70.         int chose = 0;
  71.         boolean isIncorrect;
  72.         do {
  73.             isIncorrect = false;
  74.             try {
  75.                 chose = Integer.parseInt(scanner.nextLine());
  76.             } catch (Exception e) {
  77.                 isIncorrect = true;
  78.                 System.out.println("Please, enter a positive integer number:");
  79.             }
  80.             if ((isIncorrect) || !((chose == 1) || (chose == 0))) {
  81.                 isIncorrect = true;
  82.                 System.out.println("Please, choose.");
  83.                 System.out.println("1 is console input/output, 0 is file input/output.");
  84.             }
  85.         } while (isIncorrect);
  86.         return chose;
  87.     }
  88.     // консольный ввод и вывод. Функции для них
  89.     public static int inputData() {
  90.         int n = 0;
  91.         boolean isIncorrect;
  92.         do {
  93.             isIncorrect = false;
  94.             try {
  95.                 n = Integer.parseInt(scanner.nextLine());
  96.             } catch (Exception e) {
  97.                 isIncorrect = true;
  98.                 System.out.println("Please, enter a positive integer number:");
  99.             }
  100.         } while (isIncorrect);
  101.         return n;
  102.     }
  103.  
  104.     public static int inputPositiveNumber () {
  105.         int npos;
  106.         final int MIN = 1;
  107.         boolean isIncorrect;
  108.         do {
  109.             npos = inputData();
  110.             isIncorrect = false;
  111.             if (npos < MIN) {
  112.                 System.out.println("Please, enter a positive number.");
  113.                 isIncorrect = true;
  114.             }
  115.         } while (isIncorrect);
  116.         return npos;
  117.     }
  118.  
  119.     public static int inputArraySize() {
  120.         boolean isIncorrect;
  121.         int num;
  122.         do {
  123.             num = inputPositiveNumber();
  124.             isIncorrect = false;
  125.             if (num % 2 != 0) {
  126.                 System.out.println("Please, enter an even number:");
  127.                 isIncorrect = true;
  128.             }
  129.         } while (isIncorrect);
  130.         return num;
  131.     }
  132.  
  133.     public static int[][] inputArray(int num) {
  134.         int i;
  135.         int j;
  136.         int[][] arr = new int[num][num];
  137.         for (i = 0; i < num; i++)
  138.             for (j = 0; j < num; j++)
  139.                 arr[i][j] = inputData();
  140.         return arr;
  141.     }
  142.  
  143.     public static int[] transferMatrixVector(int n, int[][] arr, int starti, int startj) {
  144.         final int min = 4;
  145.         int[] quarter = new int[(n * n) / min];
  146.         int k = 0;
  147.         int i;
  148.         int j;
  149.         int halfn = n / 2;
  150.         for (i = starti; i < starti + halfn; i++) {
  151.             for (j = startj; j < startj + halfn; j++) {
  152.                 quarter[k] = arr[i][j];
  153.                 k++;
  154.             }
  155.         }
  156.         return quarter;
  157.     }
  158.  
  159.  
  160.  
  161.  
  162.  
  163.     public static void outputArray(int num, int[][] arr) {
  164.         int i;
  165.         int j;
  166.         for (i = 0; i < num; i++) {
  167.             for (j = 0; j < num; j++)
  168.                 System.out.print(arr[i][j] + " ");
  169.             System.out.print('\n');
  170.         }
  171.     }
  172.     //functions for files:
  173.     public static String inputFilePath() {
  174.         String path;
  175.         boolean isIncorrect;
  176.         do {
  177.             isIncorrect = false;
  178.             System.out.println("Input file path:");
  179.             path = scanner.nextLine();
  180.             File file = new File(path);
  181.             if (!file.exists()) {
  182.                 System.out.println("Wrong way to file.");
  183.                 isIncorrect = true;
  184.             }
  185.             if (!file.canRead() && file.exists()) {
  186.                 System.out.println("Impossible to read a file.");
  187.                 isIncorrect = true;
  188.             }
  189.             if (!file.canWrite() && file.canRead()) {
  190.                 System.out.println("Impossible to write a file.");
  191.                 isIncorrect = true;
  192.             }
  193.         } while (isIncorrect);
  194.         return path;
  195.     }
  196.  
  197.     public static int inputSizeOfMatrixFromFile(String path) {
  198.         int n = 0;
  199.         boolean isIncorrect;
  200.         final int MIN = 1;
  201.         final int MAX = 10;
  202.         do {
  203.             isIncorrect = false;
  204.             try {
  205.                 fileScanner = new Scanner(new File(path));
  206.                 n = fileScanner.nextInt();
  207.             } catch (Exception q) {
  208.                 isIncorrect = true;
  209.                 System.out.println("Check file");
  210.                 path = inputFilePath();
  211.             }
  212.             if (!isIncorrect && (n < MIN || n > MAX)) {
  213.                 isIncorrect = true;
  214.                 System.out.println("Matrix size should be at least 2");
  215.             }
  216.         } while (isIncorrect);
  217.         return n;
  218.     }
  219.     public static int[][] inputMatrixFile(String path, int num) {
  220.         boolean isIncorrect;
  221.         int i, j;
  222.         int[][] arrFile = new int[num][num];
  223.         for (i = 0; i < num; i++)
  224.             arrFile[i] = new int[num];
  225.         do {
  226.             isIncorrect = false;
  227.             try {
  228.                 fileScanner = new Scanner(new File(path));
  229.                 fileScanner.nextLine();
  230.                 for (i = 0; (i < num); i++) {
  231.                     for (j = 0; (j < num); j++) {
  232.                         arrFile[i][j] = Integer.parseInt(fileScanner.next());
  233.                     }
  234.                 }
  235.             } catch (Exception q) {
  236.                 isIncorrect = true;
  237.                 System.out.println("Reading of matrix elements failed.");
  238.                 path = inputFilePath();
  239.             }
  240.         } while (isIncorrect);
  241.         return arrFile;
  242.     }
  243.     private static void fileOutput(int[][] arr, int num, String path) {
  244.         boolean isIncorrect;
  245.         do {
  246.             isIncorrect = false;
  247.             try {
  248.                 FileWriter writer = new FileWriter(path);
  249.                 for (int i = 0; i < num; i++){
  250.                     for (int j = 0; j < num; j++) {
  251.                         writer.write((arr[i][j]) + " ");
  252.                     }
  253.                     writer.write('\n');
  254.                 }
  255.                 writer.close();
  256.             } catch (IOException e) {
  257.                 isIncorrect = true;
  258.                 System.out.println("Mistake of output in file. Input path.");
  259.                 path = inputFilePath();
  260.             }
  261.         } while(isIncorrect);
  262.         System.out.println("Successful output in file.");
  263.     }
  264. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement