Merge pull request #26 from clormor/visitor

adding solution to visitor problem

Author: clormor

src/main/java/io/github/clormor/hackerrank/advanced/visitor/Color.java

@@ -0,0 +1,5 @@
+package io.github.clormor.hackerrank.advanced.visitor;
+
+enum Color {
+    RED, GREEN
+}

src/main/java/io/github/clormor/hackerrank/advanced/visitor/FancyVisitor.java

@@ -0,0 +1,23 @@
+package io.github.clormor.hackerrank.advanced.visitor;
+
+public class FancyVisitor extends TreeVis {
+
+    int greenLeafSum = 0;
+    int evenDepthNodeSum = 0;
+
+    public int getResult() {
+        return Math.abs(greenLeafSum - evenDepthNodeSum);
+    }
+
+    public void visitNode(TreeNode node) {
+        if (node.getDepth() % 2 == 0) {
+            evenDepthNodeSum += node.getValue();
+        }
+    }
+
+    public void visitLeaf(TreeLeaf leaf) {
+        if (leaf.getColor().equals(Color.GREEN)) {
+            greenLeafSum += leaf.getValue();
+        }
+    }
+}

src/main/java/io/github/clormor/hackerrank/advanced/visitor/ProductOfRedNodesVisitor.java

@@ -0,0 +1,28 @@
+package io.github.clormor.hackerrank.advanced.visitor;
+
+import java.math.BigInteger;
+
+public class ProductOfRedNodesVisitor extends TreeVis {
+
+    BigInteger result = new BigInteger("1");
+    static final BigInteger BIG_INT_MOD = new BigInteger(
+            Integer.toString((int) Math.pow(10, 9) + 7));
+
+    public int getResult() {
+        return result.mod(BIG_INT_MOD).intValue();
+    }
+
+    public void visitNode(TreeNode node) {
+        processIfRed(node);
+    }
+
+    public void visitLeaf(TreeLeaf leaf) {
+        processIfRed(leaf);
+    }
+
+    private void processIfRed(Tree t) {
+        if (t.getColor().equals(Color.RED)) {
+            result = result.multiply(new BigInteger(Integer.toString(t.getValue())));
+        }
+    }
+}

src/main/java/io/github/clormor/hackerrank/advanced/visitor/SumInLeavesVisitor.java

@@ -0,0 +1,21 @@
+package io.github.clormor.hackerrank.advanced.visitor;
+
+public class SumInLeavesVisitor extends TreeVis {
+
+    int result = 0;
+
+    @Override
+    public int getResult() {
+        return result;
+    }
+
+    @Override
+    public void visitNode(TreeNode node) {
+        // Only sum leaves, do nothing here.
+    }
+
+    @Override
+    public void visitLeaf(TreeLeaf leaf) {
+        result += leaf.getValue();
+    }
+}

src/main/java/io/github/clormor/hackerrank/advanced/visitor/Tree.java

@@ -0,0 +1,29 @@
+package io.github.clormor.hackerrank.advanced.visitor;
+
+abstract class Tree {
+
+    private int value;
+    private Color color;
+    private int depth;
+
+    public Tree(int value, Color color, int depth) {
+        this.value = value;
+        this.color = color;
+        this.depth = depth;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    public Color getColor() {
+        return color;
+    }
+
+    public int getDepth() {
+        return depth;
+    }
+
+    public abstract void accept(TreeVis visitor);
+
+}

src/main/java/io/github/clormor/hackerrank/advanced/visitor/TreeLeaf.java

@@ -0,0 +1,12 @@
+package io.github.clormor.hackerrank.advanced.visitor;
+
+class TreeLeaf extends Tree {
+
+    public TreeLeaf(int value, Color color, int depth) {
+        super(value, color, depth);
+    }
+
+    public void accept(TreeVis visitor) {
+        visitor.visitLeaf(this);
+    }
+}

src/main/java/io/github/clormor/hackerrank/advanced/visitor/TreeNode.java

@@ -0,0 +1,24 @@
+package io.github.clormor.hackerrank.advanced.visitor;
+
+import java.util.ArrayList;
+
+class TreeNode extends Tree {
+
+    private ArrayList<Tree> children = new ArrayList<>();
+
+    public TreeNode(int value, Color color, int depth) {
+        super(value, color, depth);
+    }
+
+    public void accept(TreeVis visitor) {
+        visitor.visitNode(this);
+
+        for (Tree child : children) {
+            child.accept(visitor);
+        }
+    }
+
+    public void addChild(Tree child) {
+        children.add(child);
+    }
+}

src/main/java/io/github/clormor/hackerrank/advanced/visitor/TreeParser.java

@@ -0,0 +1,95 @@
+package io.github.clormor.hackerrank.advanced.visitor;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+public class TreeParser {
+
+    Map<Integer, Integer> values;
+    Map<Integer, Color> colours;
+    Map<Integer, Integer> depths;
+    Map<Integer, Integer> edges;
+    Map<Integer, Tree> trees;
+
+    public Tree solve(int n, String[] args) {
+        // map the values and colours in helper methods
+        mapValues(n, args[0]);
+        mapColours(n, args[1]);
+
+        // keep track of max depth - determines if a tree is node or leaf
+        int maxDepth = mapDepthsAndEdges(n, Arrays.copyOfRange(args, 2, n + 1));
+
+        // Create the tree objects
+        createTrees(n, maxDepth);
+
+        // Create edges between trees
+        createEdges(n);
+
+        // return the tree root
+        return trees.get(0);
+    }
+
+    private void mapValues(int n, String valuesLine) {
+        values = new HashMap<>(n);
+        String[] valuesString = valuesLine.split(" ");
+        for (int i = 0; i < n; i++) {
+            values.put(i, Integer.parseInt(valuesString[i]));
+        }
+    }
+
+    private void mapColours(int n, String coloursLine) {
+        colours = new HashMap<>(n);
+        String[] coloursString = coloursLine.split(" ");
+        for (int i = 0; i < n; i++) {
+            colours.put(i, (coloursString[i].equals("0")) ? Color.RED : Color.GREEN);
+        }
+    }
+
+    private int mapDepthsAndEdges(int n, String[] edgeLines) {
+        int maxDepth = 0;
+        depths = new HashMap<>(n);
+        edges = new HashMap<>(n);
+
+        // Determine the depth of each node, and its edges
+        depths.put(0, 0);
+        for (int i = 0; i < n - 1; i++) {
+            String[] edgeString = edgeLines[i].split(" ");
+            int parent = Integer.parseInt(edgeString[0]) - 1;
+            int child = Integer.parseInt(edgeString[1]) - 1;
+
+            int parentDepth = depths.get(parent);
+            maxDepth = Math.max(maxDepth, parentDepth + 1);
+            depths.put(child, parentDepth + 1);
+            edges.put(child, parent);
+        }
+
+        return maxDepth;
+    }
+
+    private void createTrees(int n, int maxDepth) {
+        trees = new HashMap<>(n);
+
+        for (int i = 0; i < n; i++) {
+            // determine if node or leaf
+            int depth = depths.get(i);
+            if (depths.get(i) == maxDepth) {
+                trees.put(i, new TreeLeaf(values.get(i), colours.get(i), depth));
+            } else {
+                trees.put(i, new TreeNode(values.get(i), colours.get(i), depth));
+            }
+        }
+    }
+
+    private void createEdges(int n) {
+        for (int i = 0; i < n; i++) {
+            // find edges, add this tree to its parent
+            int parent = edges.getOrDefault(i, -1);
+            if (parent != -1) {
+                TreeNode parentNode = (TreeNode) trees.get(parent);
+                Tree child = trees.get(i);
+                parentNode.addChild(child);
+            }
+        }
+    }
+}

src/main/java/io/github/clormor/hackerrank/advanced/visitor/TreeVis.java

@@ -0,0 +1,11 @@
+package io.github.clormor.hackerrank.advanced.visitor;
+
+public abstract class TreeVis {
+
+    public abstract int getResult();
+
+    public abstract void visitNode(TreeNode node);
+
+    public abstract void visitLeaf(TreeLeaf leaf);
+
+}

src/test/java/io/github/clormor/hackerrank/advanced/visitor/SimpleCountTreeVisitor.java

@@ -0,0 +1,23 @@
+package io.github.clormor.hackerrank.advanced.visitor;
+
+/**
+ * For testing - Sums all node values to check we've visited the ones we expected to.
+ */
+public class SimpleCountTreeVisitor extends TreeVis {
+    int result = 0;
+
+    @Override
+    public int getResult() {
+        return result;
+    }
+
+    @Override
+    public void visitNode(TreeNode node) {
+        result += node.getValue();
+    }
+
+    @Override
+    public void visitLeaf(TreeLeaf leaf) {
+        result += leaf.getValue();
+    }
+}