Cosmetic adjustment of solution of several recursion tasks

Author: andrei-punko

src/main/java/by/andd3dfx/recursion/EightQueens.java

@@ -15,6 +15,7 @@ public class EightQueens {
     @Data
     @AllArgsConstructor
     public static class Solution {
+
         private boolean isFound;
         private boolean[][] cellsTaken;
 
@@ -32,16 +33,16 @@ public int[][] prettyPrint() {
 
     public Solution solve(int boardSize) {
         boolean[][] cellsTaken = new boolean[boardSize][boardSize];
-        boolean isFound = checkSolution(boardSize, cellsTaken, 0);
+        boolean isSolutionFound = checkSolution(boardSize, cellsTaken, 0);
 
-        return new Solution(isFound, cellsTaken);
+        return new Solution(isSolutionFound, cellsTaken);
     }
 
-    private boolean checkSolution(int size, boolean[][] cellsTaken, int queensPositioned) {
+    private boolean checkSolution(int size, boolean[][] cellsTaken, int positionedQueensAmount) {
         if (!isLegal(size, cellsTaken)) {
             return false;
         }
-        if (queensPositioned == size) {
+        if (positionedQueensAmount == size) {
             return true;
         }
 
@@ -50,7 +51,7 @@ private boolean checkSolution(int size, boolean[][] cellsTaken, int queensPositi
                 if (!cellsTaken[row][col]) {
                     cellsTaken[row][col] = true;
 
-                    if (checkSolution(size, cellsTaken, queensPositioned + 1)) {
+                    if (checkSolution(size, cellsTaken, positionedQueensAmount + 1)) {
                         return true;
                     } else {
                         cellsTaken[row][col] = false;

src/main/java/by/andd3dfx/recursion/HanoiTowers.java

@@ -16,13 +16,13 @@ public class HanoiTowers {
     public static class Column {
         private final String name;
         @Getter
-        private Deque<Integer> stack = new ArrayDeque<>();
+        private final Deque<Integer> stack = new ArrayDeque<>();
     }
 
     private final int height;
-    private Column left;
-    private Column middle;
-    private Column right;
+    private final Column left;
+    private final Column middle;
+    private final Column right;
 
     public HanoiTowers(int height) {
         this.height = height;

src/main/java/by/andd3dfx/recursion/HorseWalk.java

@@ -28,14 +28,14 @@ public String convertToCheckMateCoordinateSystem() {
     @Data
     @AllArgsConstructor
     public static class Solution {
-        private final boolean isFound;
+        private final boolean isSolutionFound;
         private final boolean[][] cellsTaken;
         private final Deque<Cell> log;
 
         public String logToString() {
             var size = cellsTaken.length;
-            if (!isFound || log.size() != size * size) {
-                throw new IllegalStateException("Solution still not found!");
+            if (!isSolutionFound || log.size() != size * size) {
+                throw new IllegalStateException("The solution is still not found!");
             }
 
             int[][] board = new int[size][size];
@@ -45,15 +45,14 @@ public String logToString() {
                 board[cell.x][cell.y] = positionNumber;
             }
 
-            var result = "";
+            StringBuilder sb = new StringBuilder();
             for (var x = 0; x < size; x++) {
-                var line = "";
                 for (var y = 0; y < size; y++) {
-                    line += board[x][y] + "\t";
+                    sb.append(board[x][y]).append("\t");
                 }
-                result += line.trim() + "\n";
+                sb.append("\n");
             }
-            return result;
+            return sb.toString();
         }
     }
 
@@ -64,13 +63,13 @@ public Solution solve(int boardSize) {
         Deque<Cell> log = new ArrayDeque<>();
         log.push(new Cell(0, 0));
 
-        boolean isFound = checkSolution(boardSize, cellsTaken, 1, 0, 0, log);
+        boolean isSolutionFound = checkSolution(boardSize, cellsTaken, 1, 0, 0, log);
 
-        return new Solution(isFound, cellsTaken, log);
+        return new Solution(isSolutionFound, cellsTaken, log);
     }
 
-    public boolean checkSolution(int size, boolean[][] cellsTaken, int cellsVisited, int currX, int currY, Deque<Cell> log) {
-        if (cellsVisited == size * size) {
+    public boolean checkSolution(int size, boolean[][] cellsTaken, int visitedCellsAmount, int currX, int currY, Deque<Cell> log) {
+        if (visitedCellsAmount == size * size) {
             return true;
         }
 
@@ -88,7 +87,8 @@ public boolean checkSolution(int size, boolean[][] cellsTaken, int cellsVisited,
 
             cellsTaken[nextX][nextY] = true;
             log.push(new Cell(nextX, nextY));
-            if (checkSolution(size, cellsTaken, cellsVisited + 1, nextX, nextY, log)) {
+
+            if (checkSolution(size, cellsTaken, visitedCellsAmount + 1, nextX, nextY, log)) {
                 return true;
             } else {
                 log.pop();

src/test/java/by/andd3dfx/recursion/HorseWalkTest.java

@@ -88,8 +88,8 @@ public void cell() {
     private void commonSolve(int boardSize, boolean solutionExpected) {
         HorseWalk.Solution solution = horseWalk.solve(boardSize);
 
-        assertThat(solution.isFound()).isEqualTo(solutionExpected);
-        if (solution.isFound()) {
+        assertThat(solution.isSolutionFound()).isEqualTo(solutionExpected);
+        if (solution.isSolutionFound()) {
             checkAreAllCellsVisited(boardSize, solution);
             System.out.println(solution.logToString());
         }