Komelin Gleb Croc Java School

src/main/java/croc/education/ws2023spb/knightsmove/Application.java

@@ -11,8 +11,12 @@ public final class Application {
      * @param args
      *            аргументы
      */
-    public static void main(final String[] args) {
-        // TODO: реализовать логику исполнения программы.
-        System.out.print("Логика программы ещё не реализована");
+    public static void main(final String[] args){
+        try {
+            KnightsMoveCheckerFactory.get().check(args);
+            System.out.print("OK");
+        } catch (IllegalMoveException e) {
+            System.out.print(e.getMessage());
+        }
     }
 }

src/main/java/croc/education/ws2023spb/knightsmove/ChessPosition.java

@@ -7,6 +7,7 @@
  */
 public interface ChessPosition {
 
+
     /**
      * Возвращает позицию фигуры по горизонтали.
      * <p/>

src/main/java/croc/education/ws2023spb/knightsmove/ChessPositionImpl.java

@@ -0,0 +1,54 @@
+package croc.education.ws2023spb.knightsmove;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+public class ChessPositionImpl implements ChessPosition {
+    private final int x;
+    private final int y;
+    private static Map<Integer, String> chessColumns = new HashMap<>();
+
+    // По ощущениям заполнение этой мапы можно было сделать элегантнее, но выбрал самый банальный вариант
+    static {
+        chessColumns.put(0, "a");
+        chessColumns.put(1, "b");
+        chessColumns.put(2, "c");
+        chessColumns.put(3, "d");
+        chessColumns.put(4, "e");
+        chessColumns.put(5, "f");
+        chessColumns.put(6, "g");
+        chessColumns.put(7, "h");
+        chessColumns = Collections.unmodifiableMap(chessColumns);
+    }
+
+    public ChessPositionImpl(int x, int y) throws IllegalPositionException{
+        if (x < 0 || x > 7) {
+            throw new IllegalPositionException("Illegal value of argument x = %d. 'X' position value ".formatted(x) +
+                    "should belong [0, 7]");
+        }
+
+        if (y < 0 || y > 7) {
+            throw new IllegalPositionException("Illegal value of argument y = %d. 'Y' position value ".formatted(y) +
+                    "should belong [0, 7]");
+        }
+
+        this.x = x;
+        this.y = y;
+    }
+
+    @Override
+    public int x() {
+        return x;
+    }
+
+    @Override
+    public int y() {
+        return y;
+    }
+
+    @Override
+    public String toString() {
+        return ChessPositionImpl.chessColumns.get(x) + (y + 1);
+    }
+}

src/main/java/croc/education/ws2023spb/knightsmove/ChessPositionParser.java

@@ -1,13 +1,32 @@
 package croc.education.ws2023spb.knightsmove;
 
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
 /**
  * Класс, содержащий методы преобразования в объект расположения фигуры на шахматной доске из различных форматов.
  * 
  * @author Dmitry Malenok
  * @see ChessPosition
  */
 public final class ChessPositionParser {
+    private static Map<Character, Integer> chessColumns = new HashMap<>();
 
+    // По ощущениям заполнение этой мапы можно было сделать элегантнее, но выбрал самый банальный вариант
+    static {
+        chessColumns.put('a', 0);
+        chessColumns.put('b', 1);
+        chessColumns.put('c', 2);
+        chessColumns.put('d', 3);
+        chessColumns.put('e', 4);
+        chessColumns.put('f', 5);
+        chessColumns.put('g', 6);
+        chessColumns.put('h', 7);
+        chessColumns = Collections.unmodifiableMap(chessColumns);
+    }
     /**
      * Конструктор.
      */
@@ -24,8 +43,26 @@ private ChessPositionParser() {
      *            наименование клетки шахматной доски, на которой находится фигура
      * @return объект расположения фигуры на шахматной доске, соответствующий переданному наименованию клетки
      */
-    public static ChessPosition parse(final String position) {
-        // TODO: создать реализацию метода.
-        throw new UnsupportedOperationException("Вызван ещё не реализованный метод.");
+    public static ChessPosition parse(final String position) throws IllegalPositionException{
+        if (position.length() != 2) {
+            throw new IllegalPositionException("Unknown position : " + position);
+        }
+
+        if (chessColumns.get(position.charAt(0)) == null) {
+            throw new IllegalPositionException("Unknown position : " + position);
+        }
+
+        int x = chessColumns.get(position.charAt(0));
+
+        Pattern pattern = Pattern.compile("[1-8]");
+        Matcher matcher = pattern.matcher(position.substring(1, 2));
+
+        if (!matcher.matches()) {
+            throw new IllegalPositionException("Unknown position : " + position);
+        }
+
+        int y = Character.getNumericValue(position.charAt(1)) - 1;
+
+        return new ChessPositionImpl(x, y);
     }
 }

src/main/java/croc/education/ws2023spb/knightsmove/IllegalMoveException.java

@@ -7,5 +7,22 @@
  * @author Dmitry Malenok
  */
 public class IllegalMoveException extends Exception {
-    // TODO: наполнить класс.
+
+    private String message;
+
+    public IllegalMoveException() {
+    }
+
+    public IllegalMoveException(String message) {
+        this.message = message;
+    }
+
+    public IllegalMoveException(Throwable cause) {
+        super(cause);
+    }
+
+    @Override
+    public String getMessage() {
+        return message;
+    }
 }

src/main/java/croc/education/ws2023spb/knightsmove/IllegalPositionException.java

@@ -0,0 +1,19 @@
+package croc.education.ws2023spb.knightsmove;
+
+public class IllegalPositionException extends RuntimeException{
+
+    private String message;
+
+    public IllegalPositionException(String message) {
+        this.message = message;
+    }
+
+    public IllegalPositionException(Throwable cause) {
+        super(cause);
+    }
+
+    @Override
+    public String getMessage() {
+        return message;
+    }
+}

src/main/java/croc/education/ws2023spb/knightsmove/KnightsMoveCheckerFactory.java

@@ -22,7 +22,26 @@ private KnightsMoveCheckerFactory() {
      * @return обработчик, проверяющий, что последовательность клеток на шахматной доске может быть пройдена ходом коня
      */
     public static KnightsMoveChecker get() {
-        // TODO: создать реализацию метода.
-        throw new UnsupportedOperationException("Вызван ещё не реализованный метод.");
+        // Решил сделать через анонимный класс
+        return new KnightsMoveChecker() {
+            @Override
+            public void check(String[] positions) throws IllegalMoveException {
+                for (int i = 0; i < positions.length - 1; i++) {
+                    if (!moveCanBeMade(positions[i], positions[i + 1])) {
+                        throw new IllegalMoveException("конь так не ходит: " + positions[i] + " -> " + positions[i + 1]);
+                    }
+                }
+            }
+
+            private boolean moveCanBeMade(String start, String finish) {
+                ChessPosition chessPositionStart = ChessPositionParser.parse(start);
+                ChessPosition chessPositionFinish = ChessPositionParser.parse(finish);
+
+                int dx = Math.abs(chessPositionStart.x() - chessPositionFinish.x());
+                int dy = Math.abs(chessPositionStart.y() - chessPositionFinish.y());
+
+                return dx == 1 && dy == 2 || dx == 2 && dy == 1;
+            }
+        };
     }
 }