first commit

.gitignore

@@ -0,0 +1,53 @@
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff:
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/dictionaries
+
+# Sensitive or high-churn files:
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+
+# Gradle:
+.idea/**/gradle.xml
+.idea/**/libraries
+
+.idea/**
+
+*.iml
+
+# CMake
+cmake-build-debug/
+cmake-build-release/
+
+# Mongo Explorer plugin:
+.idea/**/mongoSettings.xml
+
+## File-based project format:
+*.iws
+
+## Plugin-specific files:
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

pom.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>io.zipcoder</groupId>
+    <artifactId>FundamentalDrillsPart2</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+</project>

src/main/java/io/zipcoder/StringsAndThings.java

@@ -0,0 +1,64 @@
+package io.zipcoder;
+
+public class StringsAndThings {
+
+    /**
+     * Given a string, count the number of words ending in 'y' or 'z' -- so the 'y' in "heavy" and the 'z' in "fez" count,
+     * but not the 'y' in "yellow" (not case sensitive). We'll say that a y or z is at the end of a word if there is not an alphabetic
+     * letter immediately following it. (Note: Character.isLetter(char) tests if a char is an alphabetic letter.)
+     * example : countYZ("fez day"); // Should return 2
+     *           countYZ("day fez"); // Should return 2
+     *           countYZ("day fyyyz"); // Should return 2
+     */
+    public Integer countYZ(String input){
+        return null;
+    }
+
+    /**
+     * Given two strings, base and remove, return a version of the base string where all instances of the remove string have
+     * been removed (not case sensitive). You may assume that the remove string is length 1 or more.
+     * Remove only non-overlapping instances, so with "xxx" removing "xx" leaves "x".
+     *
+     * example : withoutString("Hello there", "llo") // Should return "He there"
+     *           withoutString("Hello there", "e") //  Should return "Hllo thr"
+     *           withoutString("Hello there", "x") // Should return "Hello there"
+     */
+    public String withoutString(String base, String remove){
+        return null;
+    }
+
+    /**
+     * Given a string, return true if the number of appearances of "is" anywhere in the string is equal
+     * to the number of appearances of "not" anywhere in the string (case sensitive)
+     *
+     * example : equalIsNot("This is not")  // Should return false
+     *           equalIsNot("This is notnot") // Should return true
+     *           equalIsNot("noisxxnotyynotxisi") // Should return true
+     */
+    public Boolean equalIsNot(String input){
+        return null;
+    }
+
+    /**
+     * We'll say that a lowercase 'g' in a string is "happy" if there is another 'g' immediately to its left or right.
+     * Return true if all the g's in the given string are happy.
+     * example : gHappy("xxggxx") // Should return  true
+     *           gHappy("xxgxx") // Should return  false
+     *           gHappy("xxggyygxx") // Should return  false
+     */
+    public Boolean gIsHappy(String input){
+        return null;
+    }
+
+
+    /**
+     * We'll say that a "triple" in a string is a char appearing three times in a row.
+     * Return the number of triples in the given string. The triples may overlap.
+     * example :  countTriple("abcXXXabc") // Should return 1
+     *            countTriple("xxxabyyyycd") // Should return 3
+     *            countTriple("a") // Should return 0
+     */
+    public Integer countTriple(String input){
+        return null;
+    }
+}

src/test/java/io/zipcoder/StringsAndThingsTest.java

@@ -0,0 +1,120 @@
+package io.zipcoder;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class StringsAndThingsTest {
+
+    private StringsAndThings stringsAndThings;
+
+    @Before
+    public void setup(){
+        stringsAndThings = new StringsAndThings();
+    }
+
+    @Test
+    public void countYZTest1(){
+        String input = "fez day";
+        Integer expected = 2;
+        Integer actual = stringsAndThings.countYZ(input);
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void countYZTest2(){
+        String input = "day fez";
+        Integer expected = 2;
+        Integer actual = stringsAndThings.countYZ(input);
+        Assert.assertEquals(expected, actual);
+    }
+
+
+    @Test
+    public void countYZTest3 (){
+        String input = "day fyyyz";
+        Integer expected = 2;
+        Integer actual = stringsAndThings.countYZ(input);
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void withoutStringTest1(){
+        String expected = "He there";
+        String actual = stringsAndThings.withoutString("Hello there", "llo");
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void withoutStringTest2(){
+        String expected = "Hllo thr";
+        String actual = stringsAndThings.withoutString("Hello there", "e");
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void withoutStringTest3(){
+        String expected = "Hello there";
+        String actual = stringsAndThings.withoutString("Hello there", "x");
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void equalIsNotTest1(){
+        Boolean actual = stringsAndThings.equalIsNot("This is not");
+        Assert.assertFalse(actual);
+    }
+
+    @Test
+    public void equalIsNotTest2(){
+        Boolean actual = stringsAndThings.equalIsNot("This is notnot");
+        Assert.assertTrue(actual);
+    }
+
+    @Test
+    public void equalIsNotTest3(){
+        Boolean actual = stringsAndThings.equalIsNot("noisxxnotyynotxisi");
+        Assert.assertTrue(actual);
+    }
+
+    @Test
+    public void gIsHappyTest1(){
+        Boolean actual = stringsAndThings.gIsHappy("xxggxx");
+        Assert.assertTrue(actual);
+    }
+
+    @Test
+    public void gIsHappyTest2(){
+        Boolean actual = stringsAndThings.gIsHappy("xxgxx");
+        Assert.assertFalse(actual);
+    }
+
+    @Test
+    public void gIsHappyTest3(){
+        Boolean actual = stringsAndThings.gIsHappy("xxggyygxx");
+        Assert.assertTrue(actual);
+    }
+
+    @Test
+    public void countTripleTest1(){
+        Integer expected = 1;
+        Integer actual = stringsAndThings.countTriple("abcXXXabc");
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void countTripleTest2(){
+        Integer expected = 3;
+        Integer actual = stringsAndThings.countTriple("xxxabyyyycd");
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void countTripleTest3(){
+        Integer expected = 0;
+        Integer actual = stringsAndThings.countTriple("a");
+        Assert.assertEquals(expected, actual);
+    }
+
+
+}