From 8c82217bb50db6cc3ebdfe1b6c1aa32543e60e88 Mon Sep 17 00:00:00 2001 From: Luis Romero Date: Tue, 13 Mar 2018 07:07:32 -0400 Subject: [PATCH 1/8] starting project, I did this problem before in JavaScript --- src/main/java/io/zipcoder/ParenChecker.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/main/java/io/zipcoder/ParenChecker.java b/src/main/java/io/zipcoder/ParenChecker.java index caee675..4a7c390 100644 --- a/src/main/java/io/zipcoder/ParenChecker.java +++ b/src/main/java/io/zipcoder/ParenChecker.java @@ -1,4 +1,11 @@ package io.zipcoder; public class ParenChecker { + + public ParenChecker() { + + } + + + } From 0c89c557cc0e3b3787d154f607a2df48430f8dec Mon Sep 17 00:00:00 2001 From: Luis Romero Date: Tue, 13 Mar 2018 17:45:58 -0400 Subject: [PATCH 2/8] works in simplified way only (assumes only brackets and no letters) - will modify --- src/main/java/io/zipcoder/ParenChecker.java | 145 +++++++++++++++++- .../java/io/zipcoder/ParenCheckerTest.java | 101 ++++++++++++ 2 files changed, 244 insertions(+), 2 deletions(-) diff --git a/src/main/java/io/zipcoder/ParenChecker.java b/src/main/java/io/zipcoder/ParenChecker.java index 4a7c390..2ecbf0c 100644 --- a/src/main/java/io/zipcoder/ParenChecker.java +++ b/src/main/java/io/zipcoder/ParenChecker.java @@ -1,11 +1,152 @@ package io.zipcoder; +import java.util.Arrays; +import java.util.Stack; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import java.util.regex.*; + public class ParenChecker { + private String inputExpression; + private Stack stack; + public ParenChecker() { + this.stack = new Stack(); + } + + public ParenChecker(String inputExpression) { + this.inputExpression = inputExpression; + this.stack = new Stack(); + } + + public Stack getStack() { + return stack; + } + public boolean isInputLengthEven(String input) { + boolean isInputLengthEven = true; + if (input.length() % 2 != 0) { + isInputLengthEven = false; + } + return isInputLengthEven; } - + public boolean isFirstCharCorrect(String input) { + boolean isFirstCharCorrect = true; + String incorrectFirstCharStringPattern = "^[)}\\]]"; + Pattern incorrectFirstCharPattern = Pattern.compile(incorrectFirstCharStringPattern); + Matcher firstCharMatcher = incorrectFirstCharPattern.matcher(input); + + if (firstCharMatcher.find()) { + isFirstCharCorrect = false; + } + return isFirstCharCorrect; + } + + public boolean isLastCharCorrect(String input) { + boolean isLastCharCorrect = true; + String incorrectLastCharStringPattern = "[({\\[]$"; + + Pattern incorrectLastCharPattern = Pattern.compile(incorrectLastCharStringPattern); + Matcher lastCharMatcher = incorrectLastCharPattern.matcher(input); + + if (lastCharMatcher.find()) { + isLastCharCorrect = false; + } + return isLastCharCorrect; + } -} + public boolean areAllParensPaired(String input) { + boolean areAllParensPaired = true; + + String[] inputStringArray = input.split(""); + this.stack.addAll(Arrays.asList(inputStringArray)); + + for (int i = 0; i < stack.size() - 1; i++) { + if (stack.get(i).equals("{")) { + if (stack.get(i + 1).equals("[") || stack.get(i + 1).equals("(")) { + continue; + } + if (stack.get(i + 1).equals("}")) { + stack.remove(i); + stack.remove(i); + if (i == 0) i--; + else i -= 2; + continue; + } + if (stack.get(i + 1).equals("]") || stack.get(i + 1).equals(")")) { + break; + } + // Removing any other characters doesn't work right now. +// else { +// stack.remove(i + 1); +// i--; +// continue; +// } + } + + if (stack.get(i).equals("[")) { + if (stack.get(i + 1).equals("{") || stack.get(i + 1).equals("(")) { + continue; + } + if (stack.get(i + 1).equals("]")) { + stack.remove(i); + stack.remove(i); + if (i == 0) i--; + else i -= 2; + continue; + } + if (stack.get(i + 1).equals("}") || stack.get(i + 1).equals(")")) { + break; + } + } + + if (stack.get(i).equals("(")) { + if (stack.get(i + 1).equals("{") || stack.get(i + 1).equals("[")) { + continue; + } + if (stack.get(i + 1).equals(")")) { + stack.remove(i); + stack.remove(i); + if (i == 0) i--; + else i -= 2; + continue; + } + if (stack.get(i + 1).equals("}") || stack.get(i + 1).equals("]")) { + break; + } + } + } + + if (stack.size() != 0) { + areAllParensPaired = false; + } + return areAllParensPaired; + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + for (String string : stack) { + sb.append(string); + } + return sb.toString(); + } + + public static void main(String[] args) { + ParenChecker parenChecker = new ParenChecker(); + + String inputExpression = "{}{}{}{{}}"; + System.out.println("isInputLengthEven: " + parenChecker.isInputLengthEven(inputExpression)); + System.out.println("isFirstCharCorrect: " + parenChecker.isFirstCharCorrect(inputExpression)); + System.out.println("isLastCharCorrect: " + parenChecker.isLastCharCorrect(inputExpression)); + System.out.println(); + System.out.printf("%25s", "areAllParensPaired: " + parenChecker.areAllParensPaired(inputExpression)); + System.out.println(); + System.out.printf("%20s", "original string: "); + System.out.println(inputExpression); + System.out.printf("%23s", "final string: " + parenChecker.toString()); + + } +} \ No newline at end of file diff --git a/src/test/java/io/zipcoder/ParenCheckerTest.java b/src/test/java/io/zipcoder/ParenCheckerTest.java index 76aa3b6..63c1ab8 100644 --- a/src/test/java/io/zipcoder/ParenCheckerTest.java +++ b/src/test/java/io/zipcoder/ParenCheckerTest.java @@ -3,6 +3,107 @@ import org.junit.Assert; import org.junit.Test; +import org.junit.Assert; +import org.junit.Test; + public class ParenCheckerTest { + private ParenChecker pc; + + @Test + public void isInputLengthEvenFalseTest() { + // Given + String oddLengthString = "(()"; + boolean expectedResponse = false; + // When + pc = new ParenChecker(); + boolean actualResponse = pc.isInputLengthEven(oddLengthString); + // Then + Assert.assertEquals(expectedResponse, actualResponse); + } + + @Test + public void isInputLengthEvenTrueTest() { + // Given + String evenLengthString = ")(()"; + boolean expectedResponse = true; + // When + pc = new ParenChecker(); + boolean actualResponse = pc.isInputLengthEven(evenLengthString); + // Then + Assert.assertEquals(expectedResponse, actualResponse); + } + + @Test + public void isFirstCharCorrectTrueTest() { + // Given + String input = "asdfasd(()"; + boolean expectedFirstCharTrueResponse = true; + // When + pc = new ParenChecker(); + boolean actualResponse = pc.isFirstCharCorrect(input); + // Then + Assert.assertEquals(expectedFirstCharTrueResponse, actualResponse); + } + + @Test + public void isFirstCharCorrectFalseTest() { + // Given + String input = "}(()"; + boolean expectedFirstCharFalseResponse = false; + // When + pc = new ParenChecker(); + boolean actualResponse = pc.isFirstCharCorrect(input); + // Then + Assert.assertEquals(expectedFirstCharFalseResponse, actualResponse); + } + + @Test + public void isLastCharCorrectTrueTest() { + // Given + String input = "(()}"; + boolean expectedLastCharTrueResponse = true; + // When + pc = new ParenChecker(); + boolean actualResponse = pc.isLastCharCorrect(input); + // Then + Assert.assertEquals(expectedLastCharTrueResponse, actualResponse); + } + + @Test + public void isLastCharCorrectFalseTest() { + // Given + String input = "}((){"; + boolean expectedLastCharFalseResponse = false; + // When + pc = new ParenChecker(); + boolean actualResponse = pc.isLastCharCorrect(input); + // Then + Assert.assertEquals(expectedLastCharFalseResponse, actualResponse); + } + + @Test + public void areAllParensPairedTrueTest() { + // Given + String input = "()()()"; + boolean expectedAreAllParensPairedTrue = true; + // When + pc = new ParenChecker(); + boolean actualAreAllParensPaired = pc.areAllParensPaired(input); + // Then + Assert.assertEquals(expectedAreAllParensPairedTrue, actualAreAllParensPaired); + } + + @Test + public void areAllParensPairedFalseTest() { + // Given + String input = "((("; + boolean expectedAreAllParensPairedFalse = false; + // When + pc = new ParenChecker(); + boolean actualAreAllParensPaired = pc.areAllParensPaired(input); + // Then + Assert.assertEquals(expectedAreAllParensPairedFalse, actualAreAllParensPaired); + } + } \ No newline at end of file From 82e86d674823df54f6009f279853d13bac42069d Mon Sep 17 00:00:00 2001 From: Luis Romero Date: Wed, 14 Mar 2018 07:47:55 -0400 Subject: [PATCH 3/8] bruteforcing this with if/else conditions inside a for loop, it does ignore anything that's not a parens string, using regex --- src/main/java/io/zipcoder/ParenChecker.java | 109 ++++++++++++++------ src/main/java/io/zipcoder/ParenStrings.java | 37 +++++++ 2 files changed, 117 insertions(+), 29 deletions(-) create mode 100644 src/main/java/io/zipcoder/ParenStrings.java diff --git a/src/main/java/io/zipcoder/ParenChecker.java b/src/main/java/io/zipcoder/ParenChecker.java index 2ecbf0c..3e757c5 100644 --- a/src/main/java/io/zipcoder/ParenChecker.java +++ b/src/main/java/io/zipcoder/ParenChecker.java @@ -1,6 +1,7 @@ package io.zipcoder; import java.util.Arrays; +import java.util.EnumSet; import java.util.Stack; import java.util.regex.Matcher; import java.util.regex.Pattern; @@ -10,14 +11,18 @@ public class ParenChecker { private String inputExpression; private Stack stack; + private EnumSet parenStrings; + public ParenChecker() { this.stack = new Stack(); + this.parenStrings = EnumSet.allOf(ParenStrings.class); } public ParenChecker(String inputExpression) { this.inputExpression = inputExpression; this.stack = new Stack(); + this.parenStrings = EnumSet.allOf(ParenStrings.class); } public Stack getStack() { @@ -57,17 +62,42 @@ public boolean isLastCharCorrect(String input) { return isLastCharCorrect; } + public void addOnlyParenStringsToStack(String input) { + String[] inputStringArray = input.split(""); + +// String correctStrings = "[(){}\\[\\]<>\"\']$"; + String correctStrings = "[(){}\\[\\]<>]$"; + Pattern correctStringsPattern = Pattern.compile(correctStrings); + System.out.println("String entering addOnlyParenStringsToStack: "); + System.out.println(input); + + for (String string : inputStringArray) { + Matcher correctStringsMatcher = correctStringsPattern.matcher(string); + if (correctStringsMatcher.find()) { + stack.add(string); + } + } + System.out.println("Stack leaving addOnlyParenStringsToStack: "); + System.out.println(this.toString()); + } + public boolean areAllParensPaired(String input) { boolean areAllParensPaired = true; +// if (! (this.isFirstCharCorrect(input) && this.isLastCharCorrect(input)) ) { +// areAllParensPaired = false; +// return areAllParensPaired; +// } + + this.addOnlyParenStringsToStack(input); - String[] inputStringArray = input.split(""); - this.stack.addAll(Arrays.asList(inputStringArray)); + + System.out.println("Stack inside areAllParensPaired: "); + System.out.println(this.toString()); for (int i = 0; i < stack.size() - 1; i++) { + + // SQUIGGLY CHECK if (stack.get(i).equals("{")) { - if (stack.get(i + 1).equals("[") || stack.get(i + 1).equals("(")) { - continue; - } if (stack.get(i + 1).equals("}")) { stack.remove(i); stack.remove(i); @@ -75,21 +105,17 @@ public boolean areAllParensPaired(String input) { else i -= 2; continue; } - if (stack.get(i + 1).equals("]") || stack.get(i + 1).equals(")")) { - break; - } - // Removing any other characters doesn't work right now. -// else { -// stack.remove(i + 1); -// i--; +// if (stack.get(i + 1).equals("[") || stack.get(i + 1).equals("(")) { // continue; // } + if ( stack.get(i + 1).equals("]") || stack.get(i + 1).equals(")") + || stack.get(i + 1).equals(">") ) { + break; + } } + // BRACKET CHECK if (stack.get(i).equals("[")) { - if (stack.get(i + 1).equals("{") || stack.get(i + 1).equals("(")) { - continue; - } if (stack.get(i + 1).equals("]")) { stack.remove(i); stack.remove(i); @@ -97,36 +123,63 @@ public boolean areAllParensPaired(String input) { else i -= 2; continue; } - if (stack.get(i + 1).equals("}") || stack.get(i + 1).equals(")")) { +// if (stack.get(i + 1).equals("{") || stack.get(i + 1).equals("(")) { +// continue; +// } + if ( stack.get(i + 1).equals("}") || stack.get(i + 1).equals(")") + || stack.get(i + 1).equals(">") ) { break; } } + // PARENTHESIS CHECK if (stack.get(i).equals("(")) { - if (stack.get(i + 1).equals("{") || stack.get(i + 1).equals("[")) { + if (stack.get(i + 1).equals(")")) { + stack.remove(i); + stack.remove(i); + if (i == 0) i--; + else i -= 2; continue; } - if (stack.get(i + 1).equals(")")) { +// if (stack.get(i + 1).equals("{") || stack.get(i + 1).equals("[")) { +// continue; +// } + if ( stack.get(i + 1).equals("}") || stack.get(i + 1).equals("]") + || stack.get(i + 1).equals(">") ) { + break; + } + } + + // DIAMONDS CHECK + if (stack.get(i).equals("<")) { + if (stack.get(i + 1).equals(">")) { stack.remove(i); stack.remove(i); if (i == 0) i--; else i -= 2; continue; } - if (stack.get(i + 1).equals("}") || stack.get(i + 1).equals("]")) { + if ( stack.get(i + 1).equals("}") || stack.get(i + 1).equals("]") + || stack.get(i + 1).equals(")") ) { break; } } - } + + } // end of for loop if (stack.size() != 0) { areAllParensPaired = false; } return areAllParensPaired; + + } + + public boolean checkStack() { + return false; } @Override - public String toString() { + public String toString () { StringBuilder sb = new StringBuilder(); for (String string : stack) { sb.append(string); @@ -134,19 +187,17 @@ public String toString() { return sb.toString(); } - public static void main(String[] args) { + public static void main(String[] args){ ParenChecker parenChecker = new ParenChecker(); - String inputExpression = "{}{}{}{{}}"; + String inputExpression = "{{}}{}{}{}{}"; System.out.println("isInputLengthEven: " + parenChecker.isInputLengthEven(inputExpression)); System.out.println("isFirstCharCorrect: " + parenChecker.isFirstCharCorrect(inputExpression)); System.out.println("isLastCharCorrect: " + parenChecker.isLastCharCorrect(inputExpression)); System.out.println(); - System.out.printf("%25s", "areAllParensPaired: " + parenChecker.areAllParensPaired(inputExpression)); - System.out.println(); - System.out.printf("%20s", "original string: "); - System.out.println(inputExpression); - System.out.printf("%23s", "final string: " + parenChecker.toString()); + System.out.println("areAllParensPaired: " + parenChecker.areAllParensPaired(inputExpression)); + System.out.println("original String: " + inputExpression); + System.out.println("final Stack: " + parenChecker.toString()); } -} \ No newline at end of file +} diff --git a/src/main/java/io/zipcoder/ParenStrings.java b/src/main/java/io/zipcoder/ParenStrings.java new file mode 100644 index 0000000..822e337 --- /dev/null +++ b/src/main/java/io/zipcoder/ParenStrings.java @@ -0,0 +1,37 @@ +package io.zipcoder; + +public enum ParenStrings { + + PARENTHESES("(", ")"), + BRACKETS("[", "]"), + SQUIGGLIES("{", "}"), + DIAMONDS("<", ">"), + DOUBLE_QUOTES("\"", "\""), + SINGLE_QUOTES("\'", "\'"); + + private final String openingString; + private final String closingString; + + ParenStrings(String openingString, String closingString) { + this.openingString = openingString; + this.closingString = closingString; + } + + public String getOpeningString() { + return openingString; + } + + public String getClosingString() { + return closingString; + } + + public String getOppositeString(String input) { + String oppositeString = ""; + if (input.equals(openingString)) { + oppositeString = closingString; + } else if (input.equals(closingString)) { + oppositeString = openingString; + } + return oppositeString; + } +} From 8d37d6e04794975994e9409783352002eb8a9ad3 Mon Sep 17 00:00:00 2001 From: Luis Romero Date: Wed, 14 Mar 2018 08:18:32 -0400 Subject: [PATCH 4/8] code working for detecting correct pairs, cleaning code now --- src/main/java/io/zipcoder/ParenChecker.java | 54 ++++++++++++++------- 1 file changed, 37 insertions(+), 17 deletions(-) diff --git a/src/main/java/io/zipcoder/ParenChecker.java b/src/main/java/io/zipcoder/ParenChecker.java index 3e757c5..8d76a4b 100644 --- a/src/main/java/io/zipcoder/ParenChecker.java +++ b/src/main/java/io/zipcoder/ParenChecker.java @@ -65,8 +65,7 @@ public boolean isLastCharCorrect(String input) { public void addOnlyParenStringsToStack(String input) { String[] inputStringArray = input.split(""); -// String correctStrings = "[(){}\\[\\]<>\"\']$"; - String correctStrings = "[(){}\\[\\]<>]$"; + String correctStrings = "[(){}\\[\\]<>\"\']$"; Pattern correctStringsPattern = Pattern.compile(correctStrings); System.out.println("String entering addOnlyParenStringsToStack: "); System.out.println(input); @@ -83,13 +82,13 @@ public void addOnlyParenStringsToStack(String input) { public boolean areAllParensPaired(String input) { boolean areAllParensPaired = true; -// if (! (this.isFirstCharCorrect(input) && this.isLastCharCorrect(input)) ) { -// areAllParensPaired = false; -// return areAllParensPaired; -// } this.addOnlyParenStringsToStack(input); - + String cleanedInput = this.toString(); + if (! (this.isFirstCharCorrect(cleanedInput) && this.isLastCharCorrect(cleanedInput)) ) { + areAllParensPaired = false; + return areAllParensPaired; + } System.out.println("Stack inside areAllParensPaired: "); System.out.println(this.toString()); @@ -105,9 +104,6 @@ public boolean areAllParensPaired(String input) { else i -= 2; continue; } -// if (stack.get(i + 1).equals("[") || stack.get(i + 1).equals("(")) { -// continue; -// } if ( stack.get(i + 1).equals("]") || stack.get(i + 1).equals(")") || stack.get(i + 1).equals(">") ) { break; @@ -123,9 +119,6 @@ public boolean areAllParensPaired(String input) { else i -= 2; continue; } -// if (stack.get(i + 1).equals("{") || stack.get(i + 1).equals("(")) { -// continue; -// } if ( stack.get(i + 1).equals("}") || stack.get(i + 1).equals(")") || stack.get(i + 1).equals(">") ) { break; @@ -141,9 +134,6 @@ public boolean areAllParensPaired(String input) { else i -= 2; continue; } -// if (stack.get(i + 1).equals("{") || stack.get(i + 1).equals("[")) { -// continue; -// } if ( stack.get(i + 1).equals("}") || stack.get(i + 1).equals("]") || stack.get(i + 1).equals(">") ) { break; @@ -165,6 +155,36 @@ public boolean areAllParensPaired(String input) { } } + // DOUBLE_QUOTE CHECK + if (stack.get(i).equals("\"")) { + if (stack.get(i + 1).equals("\"")) { + stack.remove(i); + stack.remove(i); + if (i == 0) i--; + else i -= 2; + continue; + } + if ( stack.get(i + 1).equals("}") || stack.get(i + 1).equals("]") + || stack.get(i + 1).equals(")") || stack.get(i + 1).equals(">") ) { + break; + } + } + + // SINGLE_QUOTE CHECK + if (stack.get(i).equals("\'")) { + if (stack.get(i + 1).equals("\'")) { + stack.remove(i); + stack.remove(i); + if (i == 0) i--; + else i -= 2; + continue; + } + if ( stack.get(i + 1).equals("}") || stack.get(i + 1).equals("]") + || stack.get(i + 1).equals(")") || stack.get(i + 1).equals(">") ) { + break; + } + } + } // end of for loop if (stack.size() != 0) { @@ -190,7 +210,7 @@ public String toString () { public static void main(String[] args){ ParenChecker parenChecker = new ParenChecker(); - String inputExpression = "{{}}{}{}{}{}"; + String inputExpression = "aaa{}[]()\"\"\'\'\'"; System.out.println("isInputLengthEven: " + parenChecker.isInputLengthEven(inputExpression)); System.out.println("isFirstCharCorrect: " + parenChecker.isFirstCharCorrect(inputExpression)); System.out.println("isLastCharCorrect: " + parenChecker.isLastCharCorrect(inputExpression)); From 76ec8aace32c321fdb60ddfde815e153123f7e1d Mon Sep 17 00:00:00 2001 From: Luis Romero Date: Wed, 14 Mar 2018 10:31:57 -0400 Subject: [PATCH 5/8] parts 1 and 2 finished, code works, but a brute force solution --- src/main/java/io/zipcoder/ParenChecker.java | 64 +++++++++++++-------- 1 file changed, 40 insertions(+), 24 deletions(-) diff --git a/src/main/java/io/zipcoder/ParenChecker.java b/src/main/java/io/zipcoder/ParenChecker.java index 8d76a4b..261548c 100644 --- a/src/main/java/io/zipcoder/ParenChecker.java +++ b/src/main/java/io/zipcoder/ParenChecker.java @@ -39,7 +39,7 @@ public boolean isInputLengthEven(String input) { public boolean isFirstCharCorrect(String input) { boolean isFirstCharCorrect = true; - String incorrectFirstCharStringPattern = "^[)}\\]]"; + String incorrectFirstCharStringPattern = "^[)}\\]>]"; Pattern incorrectFirstCharPattern = Pattern.compile(incorrectFirstCharStringPattern); Matcher firstCharMatcher = incorrectFirstCharPattern.matcher(input); @@ -51,7 +51,7 @@ public boolean isFirstCharCorrect(String input) { public boolean isLastCharCorrect(String input) { boolean isLastCharCorrect = true; - String incorrectLastCharStringPattern = "[({\\[]$"; + String incorrectLastCharStringPattern = "[({\\[<]$"; Pattern incorrectLastCharPattern = Pattern.compile(incorrectLastCharStringPattern); Matcher lastCharMatcher = incorrectLastCharPattern.matcher(input); @@ -67,8 +67,8 @@ public void addOnlyParenStringsToStack(String input) { String correctStrings = "[(){}\\[\\]<>\"\']$"; Pattern correctStringsPattern = Pattern.compile(correctStrings); - System.out.println("String entering addOnlyParenStringsToStack: "); - System.out.println(input); +// System.out.println("String entering addOnlyParenStringsToStack: "); +// System.out.println(input); for (String string : inputStringArray) { Matcher correctStringsMatcher = correctStringsPattern.matcher(string); @@ -76,22 +76,21 @@ public void addOnlyParenStringsToStack(String input) { stack.add(string); } } - System.out.println("Stack leaving addOnlyParenStringsToStack: "); - System.out.println(this.toString()); +// System.out.println("Stack leaving addOnlyParenStringsToStack: "); +// System.out.println(this.getStackElementsAsString()); } public boolean areAllParensPaired(String input) { boolean areAllParensPaired = true; this.addOnlyParenStringsToStack(input); - String cleanedInput = this.toString(); + String cleanedInput = this.getStackElementsAsString(); if (! (this.isFirstCharCorrect(cleanedInput) && this.isLastCharCorrect(cleanedInput)) ) { areAllParensPaired = false; return areAllParensPaired; } - - System.out.println("Stack inside areAllParensPaired: "); - System.out.println(this.toString()); +// System.out.println("Stack inside areAllParensPaired: "); +// System.out.println(this.getStackElementsAsString()); for (int i = 0; i < stack.size() - 1; i++) { @@ -191,15 +190,9 @@ public boolean areAllParensPaired(String input) { areAllParensPaired = false; } return areAllParensPaired; - - } - - public boolean checkStack() { - return false; } - @Override - public String toString () { + public String getStackElementsAsString() { StringBuilder sb = new StringBuilder(); for (String string : stack) { sb.append(string); @@ -207,17 +200,40 @@ public String toString () { return sb.toString(); } + public boolean isFinalStackSizeZero() { + boolean isFinalStackSizeZero = false; + if (stack.size() == 0) { + isFinalStackSizeZero = true; + } + return isFinalStackSizeZero; + } + + public void makeStackSizeZero() { + stack.clear(); + } + public static void main(String[] args){ ParenChecker parenChecker = new ParenChecker(); - String inputExpression = "aaa{}[]()\"\"\'\'\'"; - System.out.println("isInputLengthEven: " + parenChecker.isInputLengthEven(inputExpression)); - System.out.println("isFirstCharCorrect: " + parenChecker.isFirstCharCorrect(inputExpression)); - System.out.println("isLastCharCorrect: " + parenChecker.isLastCharCorrect(inputExpression)); + String inputExpression = "1918-203948-209{}"; + parenChecker.addOnlyParenStringsToStack(inputExpression); + String cleanedInput = parenChecker.getStackElementsAsString(); + parenChecker.makeStackSizeZero(); + + System.out.println("FINAL RESULT"); + System.out.println("Are parens paired?: " + parenChecker.areAllParensPaired(inputExpression)); + System.out.println("Original String: " + inputExpression); + System.out.println("Final Stack: " + parenChecker.getStackElementsAsString()); System.out.println(); - System.out.println("areAllParensPaired: " + parenChecker.areAllParensPaired(inputExpression)); - System.out.println("original String: " + inputExpression); - System.out.println("final Stack: " + parenChecker.toString()); + + System.out.println("REQUIREMENTS (should all be true)"); + System.out.println("Cleaned String: " + cleanedInput); + System.out.println("Is Cleaned String even?: " + parenChecker.isInputLengthEven(cleanedInput)); + System.out.println("Is first String correct?: " + parenChecker.isFirstCharCorrect(cleanedInput)); + System.out.println("Is last String correct?: " + parenChecker.isLastCharCorrect(cleanedInput)); + System.out.println("Is Final Stack size = 0?: " + parenChecker.isFinalStackSizeZero()); + System.out.println(); + } } From 146267ed8b2f3f5dd2b1c50494565708599f01e4 Mon Sep 17 00:00:00 2001 From: Luis Romero Date: Thu, 15 Mar 2018 16:16:43 -0400 Subject: [PATCH 6/8] working on Part 3 --- src/main/java/io/zipcoder/WC.java | 8 ++++++++ src/main/resources/someTextFile.txt | 7 +++++++ 2 files changed, 15 insertions(+) diff --git a/src/main/java/io/zipcoder/WC.java b/src/main/java/io/zipcoder/WC.java index babb68c..21dacc0 100644 --- a/src/main/java/io/zipcoder/WC.java +++ b/src/main/java/io/zipcoder/WC.java @@ -6,6 +6,7 @@ import java.util.Scanner; public class WC { + private Iterator si; public WC(String fileName) { @@ -20,4 +21,11 @@ public WC(String fileName) { public WC(Iterator si) { this.si = si; } + + public static void main(String[] args) { + + String inputExpression = "first second third fourth"; + + + } } diff --git a/src/main/resources/someTextFile.txt b/src/main/resources/someTextFile.txt index e69de29..5640ff2 100644 --- a/src/main/resources/someTextFile.txt +++ b/src/main/resources/someTextFile.txt @@ -0,0 +1,7 @@ +Then to his glance appeared the accurst swordbelt surmounting Turnus' shoulder, +shining with its familiar studs—the strap Young Pallas wore when Turnus wounded him +and left him dead upon the field; now Turnus bore that enemy token on his shoulder—enemy still. +For when the sight came home to him, Aeneas raged at the relic of his anguish worn by this man as trophy. +Blazing up and terrible in his anger, he called out: "You in your plunder, torn from one of mine, +shall I be robbed of you? This wound will come from Pallas: Pallas makes this offering, +and from your criminal blood exacts his due." He sank his blade in fury in Turnus' chest ... \ No newline at end of file From 565fb746ec81a190dd9bf4214643066145944ff3 Mon Sep 17 00:00:00 2001 From: Luis Romero Date: Fri, 16 Mar 2018 10:36:43 -0400 Subject: [PATCH 7/8] word counting is good, working on displaying by count --- src/main/java/io/zipcoder/WC.java | 34 +++++++++++++++++-- .../{someTextFile.txt => aeneid.txt} | 0 src/test/java/io/zipcoder/WCTest.java | 25 ++++++++++++++ 3 files changed, 56 insertions(+), 3 deletions(-) rename src/main/resources/{someTextFile.txt => aeneid.txt} (100%) diff --git a/src/main/java/io/zipcoder/WC.java b/src/main/java/io/zipcoder/WC.java index 21dacc0..ab6ed9f 100644 --- a/src/main/java/io/zipcoder/WC.java +++ b/src/main/java/io/zipcoder/WC.java @@ -2,12 +2,14 @@ import java.io.FileNotFoundException; import java.io.FileReader; -import java.util.Iterator; -import java.util.Scanner; +import java.util.*; +import java.util.Map.Entry; public class WC { private Iterator si; + private LinkedHashMap linkedHashMap; + private final String DELIMITER = "[^a-zA-Z0-9]+"; public WC(String fileName) { try { @@ -16,16 +18,42 @@ public WC(String fileName) { System.out.println(fileName + " Does Not Exist"); System.exit(-1); } + linkedHashMap = new LinkedHashMap(); } public WC(Iterator si) { this.si = si; + linkedHashMap = new LinkedHashMap(); + } + + public LinkedHashMap getLinkedHashMap() { + return linkedHashMap; + } + + public void addWordsToLinkedHashMap() { +// System.out.println("test"); + + while(si.hasNext()) { + String[] words = si.next().split(DELIMITER); + for (String word : words) { + if (linkedHashMap.get(word) == null) { + linkedHashMap.put(word, 1); + } else { + linkedHashMap.put(word, linkedHashMap.get(word) + 1); + } + } + } } public static void main(String[] args) { String inputExpression = "first second third fourth"; - + WC wc = new WC(WC.class.getResource("/aeneid.txt").getFile()); + wc.addWordsToLinkedHashMap(); + wc.getLinkedHashMap(); + for (Map.Entry entry : wc.getLinkedHashMap().entrySet()) { + System.out.println(entry.toString()); + } } } diff --git a/src/main/resources/someTextFile.txt b/src/main/resources/aeneid.txt similarity index 100% rename from src/main/resources/someTextFile.txt rename to src/main/resources/aeneid.txt diff --git a/src/test/java/io/zipcoder/WCTest.java b/src/test/java/io/zipcoder/WCTest.java index 895e831..ae33199 100644 --- a/src/test/java/io/zipcoder/WCTest.java +++ b/src/test/java/io/zipcoder/WCTest.java @@ -1,11 +1,36 @@ package io.zipcoder; import org.junit.Assert; +import org.junit.Before; import org.junit.Test; import java.util.ArrayList; import java.util.Arrays; +import java.util.Iterator; +import java.util.List; public class WCTest { + private WC wc; + + @Before + public void setupConstructorIteratorTest() { + // Given + String expectedFirstWord = "first"; + String wordsAsString = "first second third fourth"; + String[] wordsArray = wordsAsString.split("[a-zA-Z0-9]+"); + List wordsArrayList = new ArrayList(Arrays.asList(wordsArray)); + Iterator wordsArrayListIterator = wordsArrayList.iterator(); + wc = new WC(wordsArrayListIterator); + // When + String actualFirstWord = "hold"; + // Then + } + + @Test + public void createWordsArrayTest() { + + } + + } \ No newline at end of file From 3ebe3a3302503568f50425762b96fae1c11ca436 Mon Sep 17 00:00:00 2001 From: Luis Romero Date: Fri, 16 Mar 2018 15:33:35 -0400 Subject: [PATCH 8/8] finished labs --- pom.xml | 12 +++++++++++ src/main/java/io/zipcoder/WC.java | 35 ++++++++++++++++++++++++++----- 2 files changed, 42 insertions(+), 5 deletions(-) diff --git a/pom.xml b/pom.xml index e66b725..5c3991d 100644 --- a/pom.xml +++ b/pom.xml @@ -7,6 +7,18 @@ io.zipcoder collections 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 1.7 + 1.7 + + + + diff --git a/src/main/java/io/zipcoder/WC.java b/src/main/java/io/zipcoder/WC.java index ab6ed9f..3ad24db 100644 --- a/src/main/java/io/zipcoder/WC.java +++ b/src/main/java/io/zipcoder/WC.java @@ -2,6 +2,7 @@ import java.io.FileNotFoundException; import java.io.FileReader; +import java.lang.reflect.Array; import java.util.*; import java.util.Map.Entry; @@ -31,11 +32,10 @@ public LinkedHashMap getLinkedHashMap() { } public void addWordsToLinkedHashMap() { -// System.out.println("test"); - while(si.hasNext()) { String[] words = si.next().split(DELIMITER); for (String word : words) { + word = word.toLowerCase(); if (linkedHashMap.get(word) == null) { linkedHashMap.put(word, 1); } else { @@ -45,15 +45,40 @@ public void addWordsToLinkedHashMap() { } } + public String getWordCountInDescendingOrder() { + List> wordCount = new ArrayList<>(linkedHashMap.entrySet()); + StringBuilder sb = new StringBuilder(); + + Collections.sort(wordCount, new Comparator() { + public int compare(Entry e1, Entry e2) { + if ( (int)e2.getValue() == (int)e1.getValue() ) { + return 0; + } else if ( (int)e1.getValue() > (int)e2.getValue() ) { + return -1; + } else + return 1; + } + }); + + sb.append("Count = Word" + "\n"); + for (Entry entry : wordCount) { + sb.append(entry.getValue() + " = " + entry.getKey() + "\n"); + } + + return sb.toString(); + } + public static void main(String[] args) { String inputExpression = "first second third fourth"; WC wc = new WC(WC.class.getResource("/aeneid.txt").getFile()); wc.addWordsToLinkedHashMap(); wc.getLinkedHashMap(); - for (Map.Entry entry : wc.getLinkedHashMap().entrySet()) { - System.out.println(entry.toString()); - } +// for (Entry entry : wc.getLinkedHashMap().entrySet()) { +// System.out.println(entry.toString()); +// } + + System.out.println(wc.getWordCountInDescendingOrder()); } }