Characters encapsulated

pom.xml

@@ -8,6 +8,19 @@
     <artifactId>collections</artifactId>
     <version>1.0-SNAPSHOT</version>
 
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
     <dependencies>
         <dependency>
             <groupId>junit</groupId>

src/main/java/io/zipcoder/PairChecker.java

@@ -0,0 +1,78 @@
+package io.zipcoder;
+
+import java.util.*;
+
+public class PairChecker {
+
+    private Stack<Character> openers = new Stack<>();
+
+    private static final Map<Character, Character> pairs = createMap();
+
+    private static Map<Character, Character> createMap() {
+        Map<Character, Character> pairs = new HashMap<Character, Character>();
+        pairs.put(')', '(');
+        pairs.put('}', '{');
+        pairs.put(']', '[');
+        pairs.put('>', '<');
+        pairs.put('"', '"');
+        pairs.put('\'', '\'');
+        return pairs;
+    }
+
+    public boolean checkPairs(String textInput) {
+        char[] charArray = textInput.toCharArray();
+
+        // loop through characters in string
+        for (char character : charArray) {
+            // if opener is found
+            if (pairs.containsValue(character)) {
+                // push it onto the stack
+                openers.push(character);
+                // if closer is found
+            } else if (pairs.containsKey(character)) {
+                // && no opener is stored
+                if (openers.isEmpty() || openers.peek() != pairs.get(character)) {
+                    return false;
+                    // && opener if at top of stack
+                } else {
+                    // pop that opener off the stack
+                    openers.pop();
+                    // otherwise, closer is improperly nested
+                }
+            }
+        }
+        //        } else if (pairs.containsKey(character)) {
+        //            // && no opener is stored
+        //            if (pairs.isEmpty()) {
+        //                return false;
+        //                // && opener if at top of stack
+        //            } else if (openers.peek() == pairs.get(character)) {
+        //                // pop that opener off the stack
+        //                openers.pop();
+        //                // otherwise, closer is improperly nested
+        //            } else {
+        //                // so we return false
+        //                return false;
+        //            }
+        //        }
+
+        // parens checker
+//        for (char character : charArray) {
+//            if (character == '(') {
+//                this.openers.push(character);
+//            } else if (character == ')' && openers.empty() == true) {
+//                return false;
+//            } else if (character == ')' && openers.peek() == '(') {
+//                this.openers.pop();
+//            } else {
+//                continue;
+//            }
+//        }
+
+        if (openers.empty()) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}

src/main/java/io/zipcoder/ParenChecker.java

@@ -1,4 +1,26 @@
 package io.zipcoder;
 
+import java.util.Stack;
+
 public class ParenChecker {
+
+    Stack<Character> parens = new Stack<>();
+
+    public boolean checkParens(String textInput) {
+        char[] charArray = textInput.toCharArray();
+
+        for (char character : charArray) {
+            if (character == '(') {
+                this.parens.push(character);
+            } else if (character == ')' && parens.empty() == true) {
+                return false;
+            } else if (character == ')' && parens.peek() == '(') {
+                this.parens.pop();
+            } else {
+                continue;
+            }
+        }
+
+        if (parens.empty()) { return true; } else { return false; }
+    }
 }

src/main/java/io/zipcoder/WC.java

@@ -3,10 +3,15 @@ package io.zipcoder;
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.util.Iterator;
+import java.util.Map;
 import java.util.Scanner;
+import java.util.TreeMap;
+
+import static java.util.Map.Entry.comparingByValue;
 
 public class WC {
     private Iterator<String> si;
+    TreeMap<String, Integer> wordData = new TreeMap<String, Integer>();
 
     public WC(String fileName) {
         try {
@@ -20,4 +25,23 @@ public class WC {
     public WC(Iterator<String> si) {
         this.si = si;
     }
+
+    public void wordCounter() {
+        String word;
+
+        while (si.hasNext()) {
+            String rawWord = si.next().toLowerCase();
+            word = rawWord.replaceAll("[^a-z]", "");
+
+            if (wordData.containsKey(word)) {
+                wordData.put(word, wordData.get(word)+1);
+            } else {
+                wordData.put(word, 1);
+            }
+        }
+
+        wordData.entrySet().stream()
+                .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
+                .forEach(entry -> System.out.println(String.format("%15d    %s\n", entry.getValue(), entry.getKey())));
+    }
 }

src/main/java/io/zipcoder/test.java

@@ -0,0 +1,75 @@
+package io.zipcoder;// File: WordCounter.java
+// Program from Section 5.7 to illustrate the use of TreeMaps and Iterators.
+// The program opens and reads a file called words.txt. Each line in this
+// file should consist of one or more English words separated by spaces.
+// The end of each line must not have any extra spaces after the last word.
+// The program reads the file and then a table is printed of
+// all words and their counts.
+
+import java.util.*;  // Provides TreeMap, Iterator, Scanner
+import java.io.*;    // Provides FileReader, FileNotFoundException
+
+public class test
+{
+    public static void main(String[ ] args)
+    {
+        TreeMap<String, Integer> frequencyData = new TreeMap<String, Integer>( );
+
+        readWordFile(frequencyData);
+        printAllCounts(frequencyData);
+    }
+
+    public static int getCount
+            (String word, TreeMap<String, Integer> frequencyData)
+    {
+        if (frequencyData.containsKey(word))
+        {  // The word has occurred before, so get its count from the map
+            return frequencyData.get(word); // Auto-unboxed
+        }
+        else
+        {  // No occurrences of this word
+            return 0;
+        }
+    }
+
+    public static void printAllCounts(TreeMap<String, Integer> frequencyData)
+    {
+        System.out.println("-----------------------------------------------");
+        System.out.println("    Occurrences    Word");
+
+        for(String word : frequencyData.keySet( ))
+        {
+            System.out.printf("%15d    %s\n", frequencyData.get(word), word);
+        }
+
+        System.out.println("-----------------------------------------------");
+    }
+
+    public static void readWordFile(TreeMap<String, Integer> frequencyData)
+    {
+        Scanner wordFile;
+        String word;     // A word read from the file
+        Integer count;   // The number of occurrences of the word
+
+        try
+        {
+            wordFile = new Scanner(new FileReader("words.txt"));
+        }
+        catch (FileNotFoundException e)
+        {
+            System.err.println(e);
+            return;
+        }
+
+        while (wordFile.hasNext( ))
+        {
+            // Read the next word and get rid of the end-of-line marker if needed:
+            word = wordFile.next( );
+
+            // Get the current count of this word, add one, and then store the new count:
+            count = getCount(word, frequencyData) + 1;
+            frequencyData.put(word, count);
+        }
+    }
+
+}

src/test/java/io/zipcoder/PairCheckerTest.java

@@ -0,0 +1,78 @@
+package io.zipcoder;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class PairCheckerTest {
+
+    @Test public void singlePairCheckerTrue() {
+        PairChecker pairChecker = new PairChecker();
+
+        String textTest = "Testing (this jawn)";
+        boolean expected = true;
+        boolean actual = pairChecker.checkPairs(textTest);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test public void singlePairCheckerFalse() {
+        PairChecker pairChecker = new PairChecker();
+
+        String textTest = "Testing (((((({[[[[[{{{[[[{{{{(((({(this jawn";
+        boolean expected = false;
+        boolean actual = pairChecker.checkPairs(textTest);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test public void doublePairCheckerTrue() {
+        PairChecker pairChecker = new PairChecker();
+
+        String textTest = "{Testing [this] jawn}";
+        boolean expected = true;
+        boolean actual = pairChecker.checkPairs(textTest);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test public void doublePairCheckerFalse() {
+        PairChecker pairChecker = new PairChecker();
+
+        String textTest = "Testing (this (jawn)";
+        boolean expected = false;
+        boolean actual = pairChecker.checkPairs(textTest);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test public void wildPairCheckerTrue() {
+        PairChecker pairChecker = new PairChecker();
+
+        String textTest = "Testing (this (jawn)) And (((this))) jawn";
+        boolean expected = true;
+        boolean actual = pairChecker.checkPairs(textTest);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test public void wildPairCheckerFalse() {
+        PairChecker pairChecker = new PairChecker();
+
+        String textTest = "Testing (this (jawn)) And ((this))) jawn";
+        boolean expected = false;
+        boolean actual = pairChecker.checkPairs(textTest);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test public void lonePairCheckerFalse() {
+        PairChecker pairChecker = new PairChecker();
+
+        String textTest = ")";
+        boolean expected = false;
+        boolean actual = pairChecker.checkPairs(textTest);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+}

src/test/java/io/zipcoder/ParenCheckerTest.java

@@ -1,8 +1,70 @@
 package io.zipcoder;
 
 import org.junit.Assert;
+import org.junit.Before;
 import org.junit.Test;
 
 public class ParenCheckerTest {
 
+    @Test public void singlePairCheckerTrue() {
+        ParenChecker parenChecker = new ParenChecker();
+
+        String textTest = "\"Testin\" {[](this 'jawn')}";
+        boolean expected = true;
+        boolean actual = parenChecker.checkParens(textTest);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test public void singlePairCheckerFalse() {
+        ParenChecker parenChecker = new ParenChecker();
+
+        String textTest = "{Testing} (this [jawn]";
+        boolean expected = false;
+        boolean actual = parenChecker.checkParens(textTest);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test public void doublePairCheckerTrue() {
+        ParenChecker parenChecker = new ParenChecker();
+
+        String textTest = "Testing (this (jawn))";
+        boolean expected = true;
+        boolean actual = parenChecker.checkParens(textTest);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test public void doublePairCheckerFalse() {
+        ParenChecker parenChecker = new ParenChecker();
+
+        String textTest = "Testing (this (jawn)";
+        boolean expected = false;
+        boolean actual = parenChecker.checkParens(textTest);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test public void wildPairCheckerTrue() {
+        ParenChecker parenChecker = new ParenChecker();
+
+        String textTest = "Testing (this (jawn)) And (((this))) jawn";
+        boolean expected = true;
+        boolean actual = parenChecker.checkParens(textTest);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test public void wildPairCheckerFalse() {
+        ParenChecker parenChecker = new ParenChecker();
+
+        String textTest = "Testing (this (jawn)) And ((this))) jawn";
+        boolean expected = false;
+        boolean actual = parenChecker.checkParens(textTest);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+
 }

src/test/java/io/zipcoder/WCTest.java

@@ -8,4 +8,9 @@ import java.util.Arrays;
 
 public class WCTest {
 
+    @Test public void test() {
+        WC wc = new WC(WC.class.getResource("/28054-0.txt").getFile());
+        wc.wordCounter();
+    }
+
 }