ITI0011:harjutus 04

Üldine

Tähtaeg: 17. - 19. veebruar 2016
Kausta nimi gitis: EX04

Ülesanne

Marko ja Triin istuvad diivanil ja mõtlevad, et pole tükk aega üksteise võimeid proovile pannud. Nimelt on mõlemad head matemaatikud ja pole tükk aega üksteisega võistelnud. Niisiis pakkus Marko välja, et ta suudab suvalises N x M maatriksis leida keskmiselt 3 pakkumisega punkti (X₀, Y₀), millele Triin mõtleb, kui Triin ütleb ühe punkti (x, y) pakkumisel selle eukleidilise kauguse punktist (X₀, Y₀). Triinule idee meeldis ning otsustas kirjutada abistava programmi, et välja selgitada, kas Markol on õigus. Ta implementeeris järgnevad abistavad funktsioonid

char[][] createMatrix(int n, int m, int x, int y) - Teeb valmis n realise ja m tulbalise maatriksi, kus '.' tähistab tühja kohta ja 'x' Triinu mõeldud punkti. Võib eeldada, et sisendid on alati kontrollitud.

[['x', '.', '.'],
['.', '.', '.'],
['.', '.', '.']]

kui n = 3, m = 3, x = 0, y = 0

double guess(char[][] matrix, int x, int y) - Tagastab kauguse algselt valitud (X0,Y0) punkti ja proovitud punkti (x, y) vahel ja märgistab proovitud punkti sümboliga '*'. Kaugus (x,y) ja algse punkti (X0, Y0) vahel tuleb arvutada kasutades Pythagorase teoreemi (https://et.wikipedia.org/wiki/Pythagorase_teoreem). Korduval proovimisel käituda samamoodi nagu esmakordselgi. Võib eeldada, et sisendid on alati kontrollitud.

String getAsciiMatrix(char[][] matrix) - tagastab maatriksi sisu tekstikujul. Näiteks näide 1 puhul oleks tagastatav väärtus:

"...
...
..."

(Unix-style line endings \n)

Kui punkti on juba pakutud, siis peab see olema asendatud sümboliga '*' ehk pärast guess(matrix, 1, 1) väljakutsumist oleks näite 1 kaart:

"...
.*.
..."

(Unix-style line endings \n)

Ka mõeldud punkti näidatakse kaardil '.'.

Kasutades ülalolevaid funktsioone komplekteeris Triin programmi, mis küsib N, M, X0, Y0 väärtused ja lubab pakkuda suvalisi punkte kujul x,y öeldes selle kauguse ja printides välja praeguse kaardi. Kahjuks unustas ta git'i üles laadida abistavad funktsioonid createMatrix, guess, getAsciiMatrix, kas aitaksid tal need uuesti kirjutada?

Mall

Uuendatud mall on siin: ITI0011:harjutus 04 mall. Kui te pole ülesande lahendamist veel alustanud, kasutage uut malli. Vana mall (mis siin lehel kohe järgneb) töötab ka, kuigi selles osade muutujate sisu ei vasta tegelikule sisule.

Juhime tähelepanu, et antud ülesande puhul on väga suur hulk koodi teile ette antud. Etteantud koodi tegeleb sisendilugemise ja mänguloogikaga, seda ei tasu muuta. Teie peate realiseerima eelnevalt mainitud kolm meetodit.

<source lang="java"> import java.util.Scanner;

/**

* EX04.
*/

public class EX04 {

   /** Guess parameter array index for guess X value*/
   public static final int FIELD_X = 0;
   /** Guess parameter array index for guess Y value*/
   public static final int FIELD_Y = 1;
   /** Settings parameter array index for matrix height value*/
   public static final int FIELD_MATRIX_HEIGHT = 0;
   /** Settings parameter array index for matrix wdith value */
   public static final int FIELD_MATRIX_WIDTH = 1;
   /** Settings parameter array index for matrix target x value */
   public static final int FIELD_TARGET_X = 2;
   /** Settings parameter array index for matrix target y value*/
   public static final int FIELD_TARGET_Y = 3;
   /** The count of settings parameters */
   public static final int INITIAL_PARAMETER_ARRAY_LENGTH = 4;
   /** The count of guess parameters */
   public static final int GUESS_ARRAY_LENGTH = 2;
   /** Maximum matrix dimension value */
   public static final int MAX_DIMENSION = 10;
   /** Precision for double checking */
   public static final double ERROR_BOUND = 0.001;

   /**
    * Entry point.
    * @param args commandline arguments
    */
   public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);
       int[] matrixParameters = readInitialMatrixParameters(scanner);
       char[][] matrix = createMatrix(
               matrixParameters[FIELD_MATRIX_HEIGHT],
               matrixParameters[FIELD_MATRIX_WIDTH],
               matrixParameters[FIELD_TARGET_X],
               matrixParameters[FIELD_TARGET_Y]
       );

       int[] guessInput;
       int totalGuesses = 0;
       while (true) {
           System.out.println(getAsciiMatrix(matrix));
           guessInput = readGuessInput(scanner, matrixParameters);
           totalGuesses++;
           System.out.println("Katseid : " + totalGuesses);
           double distance = guess(matrix, guessInput[FIELD_X], guessInput[FIELD_Y]);
           if (distance < ERROR_BOUND) {
               System.out.println("Lahendus leitud " + totalGuesses + " katsega!");
               break;
           } else {
               System.out.printf("Kaugus mõeldud punktist %.2f\n", distance);
           }
       }
   }

   public static char[][] createMatrix(int n, int m, int y, int x) {
       // TODO: implement this function
       return null;
   }

   public static double guess(char[][] matrix, int y, int x) {
       // TODO: implement this function
       return 0.0;
   }

   public static String getAsciiMatrix(char[][] matrix) {
       // TODO: implement this function
       return "";
   }

   /**
    * Read user guess input from scanner.
    * Returned array structure:
    * X - x coordinate, Y - y coordinate
    * Index 0 - X, Index 1 - Y
    *
    * @param scanner          Input scanner
    * @param matrixParameters Array of user guess information
    * @return int[] array of guess input parameters
    */
   public static int[] readGuessInput(Scanner scanner, int[] matrixParameters) {
       int[] parameters;
       do {
           System.out.print("Sisestage mõeldav ruut (näiteks 0,0):");
           String parameterInput = scanner.nextLine();
           parameters = splitInputStructureToIntArray(parameterInput);
       } while (!validateGuessInput(parameters, matrixParameters));
       return parameters;
   }

   /**
    * Validate whether the guess input parameters are ok.
    * 1) Guessinput length must be 2 (x,y) coordinates
    * 2) (x,y) must be inside matrix that is specified by the matirxParameters
    *
    * @param guessInput       user guess input, consists of [0] - x [1] - y coordinates
    * @param matrixParameters game matrix parameters (look readInitialMatrixParameters for structure information)
    * @return whether the guess input is ok.
    */
   public static boolean validateGuessInput(int[] guessInput, int[] matrixParameters) {
       if (guessInput.length != GUESS_ARRAY_LENGTH) {
           return false;
       }
       for (int guessValue : guessInput) {
           if (guessValue < 0) {
               return false;
           }
       }
       return guessInput[FIELD_Y] < matrixParameters[FIELD_MATRIX_HEIGHT]
               && guessInput[FIELD_X] < matrixParameters[FIELD_MATRIX_WIDTH];
   }

   /**
    * Read matrix parameters from scanner.
    * returned array structure
    * N - Matrix height, M - matrix width
    * X - x value of target square, Y - y value of target square
    * index 0 - N value, index 1 - M value
    * index 2 - X value, index 3 - Y value
    *
    * @param scanner Input scanner
    * @return int[] - Array of user input parameters
    */
   public static int[] readInitialMatrixParameters(Scanner scanner) {
       int[] parameters;
       do {
           System.out.print("Sisestage N,M,X,Y (näiteks: 2,2,0,0):");
           String parameterInput = scanner.nextLine();
           parameters = splitInputStructureToIntArray(parameterInput);
       } while (!validateInitialParameters(parameters));

       return parameters;
   }

   /**
    * Converts input that is spearetd by commas to integer array.
    * If value is not convertable to int -1 is used.
    *
    * @param input input string to be parsed
    * @return int[] array of int values.
    */
   public static int[] splitInputStructureToIntArray(String input) {

       String[] splitParts = input.replaceAll(" ", "").split(",");
       int[] parameters = new int[splitParts.length];
       for (int i = 0; i < splitParts.length; i++) {
           try {
               parameters[i] = Integer.parseInt(splitParts[i]);
           } catch (NumberFormatException e) {
               parameters[i] = -1;
           }
       }
       return parameters;
   }

   /**
    * Check whether the input input parameters are ok.
    * We consider a parameter ok when its value is between 1 and 10(exlusive) and
    * X, Y are inside the matrix
    *
    * @param parameters Array of user matrix parameters.
    * @return boolean - whether the input parameters are ok.
    */
   public static boolean validateInitialParameters(int[] parameters) {
       if (parameters.length != INITIAL_PARAMETER_ARRAY_LENGTH) {
           return false;
       }
       for (int parameter : parameters) {
           if (parameter < 0 || parameter > MAX_DIMENSION) {
               return false;
           }
       }
       return parameters[FIELD_MATRIX_HEIGHT] > parameters[FIELD_TARGET_Y]
               && parameters[FIELD_MATRIX_WIDTH] > parameters[FIELD_TARGET_X];
   }

}

</source>