Minimax refactor (eugenp#2212)

pivovarit · web-flow · commit c99bb7fcedfb · 2017-07-06T12:01:49.000+02:00
diff --git a/algorithms/src/main/java/com/baeldung/algorithms/minimax/GameOfBones.java b/algorithms/src/main/java/com/baeldung/algorithms/minimax/GameOfBones.java
@@ -1,17 +1,14 @@
 package com.baeldung.algorithms.minimax;
 
-import java.util.ArrayList;
 import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 
-public class GameOfBones {
-    public static List<Integer> getPossibleStates(int noOfBonesInHeap) {
-        List<Integer> listOfPossibleHeaps = new ArrayList<>();
-        for (int i = 1; i <= 3; i++) {
-            int newHeapCount = noOfBonesInHeap - i;
-            if (newHeapCount >= 0) {
-                listOfPossibleHeaps.add(newHeapCount);
-            }
-        }
-        return listOfPossibleHeaps;
+class GameOfBones {
+    static List<Integer> getPossibleStates(int noOfBonesInHeap) {
+        return IntStream.rangeClosed(1, 3).boxed()
+          .map(i -> noOfBonesInHeap - i)
+          .filter(newHeapCount -> newHeapCount >= 0)
+          .collect(Collectors.toList());
     }
 }
diff --git a/algorithms/src/main/java/com/baeldung/algorithms/minimax/MiniMax.java b/algorithms/src/main/java/com/baeldung/algorithms/minimax/MiniMax.java
@@ -1,8 +1,8 @@
 package com.baeldung.algorithms.minimax;
 
-import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
+import java.util.NoSuchElementException;
 
 public class MiniMax {
     private Tree tree;
@@ -11,10 +11,6 @@ public Tree getTree() {
         return tree;
     }
 
-    public void setTree(Tree tree) {
-        this.tree = tree;
-    }
-
     public void constructTree(int noOfBones) {
         tree = new Tree();
         Node root = new Node(noOfBones, true);
@@ -37,19 +33,15 @@ private void constructTree(Node node) {
     public boolean checkWin() {
         Node root = tree.getRoot();
         checkWin(root);
-        return root.getScore() == 1 ? true : false;
+        return root.getScore() == 1;
     }
 
     private void checkWin(Node node) {
         List<Node> children = node.getChildren();
         boolean isMaxPlayer = node.isMaxPlayer();
         children.forEach(child -> {
             if (child.getNoOfBones() == 0) {
-                if (isMaxPlayer) {
-                    child.setScore(1);
-                } else {
-                    child.setScore(-1);
-                }
+                child.setScore(isMaxPlayer ? 1 : -1);
             } else {
                 checkWin(child);
             }
@@ -59,10 +51,10 @@ private void checkWin(Node node) {
     }
 
     private Node findBestChild(boolean isMaxPlayer, List<Node> children) {
-        if (isMaxPlayer) {
-            return Collections.max(children, Comparator.comparing(c -> c.getScore()));
-        } else {
-            return Collections.min(children, Comparator.comparing(c -> c.getScore()));
-        }
+        Comparator<Node> byScoreComparator = Comparator.comparing(Node::getScore);
+
+        return children.stream()
+          .max(isMaxPlayer ? byScoreComparator : byScoreComparator.reversed())
+          .orElseThrow(NoSuchElementException::new);
     }
 }
diff --git a/algorithms/src/main/java/com/baeldung/algorithms/minimax/Node.java b/algorithms/src/main/java/com/baeldung/algorithms/minimax/Node.java
@@ -15,39 +15,27 @@ public Node(int noOfBones, boolean isMaxPlayer) {
         children = new ArrayList<>();
     }
 
-    public int getNoOfBones() {
+    int getNoOfBones() {
         return noOfBones;
     }
 
-    public void setNoOfBones(int noOfBones) {
-        this.noOfBones = noOfBones;
-    }
-
-    public boolean isMaxPlayer() {
+    boolean isMaxPlayer() {
         return isMaxPlayer;
     }
 
-    public void setMaxPlayer(boolean maxPlayer) {
-        isMaxPlayer = maxPlayer;
-    }
-
-    public int getScore() {
+    int getScore() {
         return score;
     }
 
-    public void setScore(int score) {
+    void setScore(int score) {
         this.score = score;
     }
 
-    public List<Node> getChildren() {
+    List<Node> getChildren() {
         return children;
     }
 
-    public void setChildren(List<Node> children) {
-        this.children = children;
-    }
-
-    public void addChild(Node newNode) {
+    void addChild(Node newNode) {
         children.add(newNode);
     }
 
diff --git a/algorithms/src/main/java/com/baeldung/algorithms/minimax/Tree.java b/algorithms/src/main/java/com/baeldung/algorithms/minimax/Tree.java
@@ -3,18 +3,14 @@
 public class Tree {
     private Node root;
 
-    public Tree() {
+    Tree() {
     }
 
-    public Tree(Node root) {
-        this.root = root;
-    }
-
-    public Node getRoot() {
+    Node getRoot() {
         return root;
     }
 
-    public void setRoot(Node root) {
+    void setRoot(Node root) {
         this.root = root;
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -15,39 +15,27 @@ public Node(int noOfBones, boolean isMaxPlayer) {`
`15`	`15`	`children = new ArrayList<>();`
`16`	`16`	`}`
`17`	`17`
`18`		`- public int getNoOfBones() {`
	`18`	`+ int getNoOfBones() {`
`19`	`19`	`return noOfBones;`
`20`	`20`	`}`
`21`	`21`
`22`		`- public void setNoOfBones(int noOfBones) {`
`23`		`- this.noOfBones = noOfBones;`
`24`		`- }`
`25`		`-`
`26`		`- public boolean isMaxPlayer() {`
	`22`	`+ boolean isMaxPlayer() {`
`27`	`23`	`return isMaxPlayer;`
`28`	`24`	`}`
`29`	`25`
`30`		`- public void setMaxPlayer(boolean maxPlayer) {`
`31`		`- isMaxPlayer = maxPlayer;`
`32`		`- }`
`33`		`-`
`34`		`- public int getScore() {`
	`26`	`+ int getScore() {`
`35`	`27`	`return score;`
`36`	`28`	`}`
`37`	`29`
`38`		`- public void setScore(int score) {`
	`30`	`+ void setScore(int score) {`
`39`	`31`	`this.score = score;`
`40`	`32`	`}`
`41`	`33`
`42`		`- public List<Node> getChildren() {`
	`34`	`+ List<Node> getChildren() {`
`43`	`35`	`return children;`
`44`	`36`	`}`
`45`	`37`
`46`		`- public void setChildren(List<Node> children) {`
`47`		`- this.children = children;`
`48`		`- }`
`49`		`-`
`50`		`- public void addChild(Node newNode) {`
	`38`	`+ void addChild(Node newNode) {`
`51`	`39`	`children.add(newNode);`
`52`	`40`	`}`
`53`	`41`
Original file line number	Diff line number	Diff line change
`@@ -3,18 +3,14 @@`
`3`	`3`	`public class Tree {`
`4`	`4`	`private Node root;`
`5`	`5`
`6`		`- public Tree() {`
	`6`	`+ Tree() {`
`7`	`7`	`}`
`8`	`8`
`9`		`- public Tree(Node root) {`
`10`		`- this.root = root;`
`11`		`- }`
`12`		`-`
`13`		`- public Node getRoot() {`
	`9`	`+ Node getRoot() {`
`14`	`10`	`return root;`
`15`	`11`	`}`
`16`	`12`
`17`		`- public void setRoot(Node root) {`
	`13`	`+ void setRoot(Node root) {`
`18`	`14`	`this.root = root;`
`19`	`15`	`}`
`20`	`16`	`}`