done

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

@@ -2,63 +2,120 @@ 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
+     * countYZ("day fez"); // Should return 2
+     * countYZ("day fyyyz"); // Should return 2
      */
-    public Integer countYZ(String input){
-        return null;
+    public Integer countYZ(String input) {
+
+        input.toLowerCase();
+        String[] inputArray = input.split(" ");
+
+        int count = 0;
+
+        for (String eachElementInInputArray : inputArray)
+
+            if (eachElementInInputArray.charAt(eachElementInInputArray.length() - 1) == 'y' || (eachElementInInputArray.charAt(eachElementInInputArray.length() - 1) == 'z')) {
+                count += 1;
+            }
+        return count;
+
     }
 
+
     /**
      * 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".
-     *
+     * <p>
      * 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"
+     * 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;
+    public String withoutString(String base, String remove) {
+
+        remove.toLowerCase();
+        String str = base.replaceAll(remove, "");
+        return str;
     }
 
     /**
      * 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)
-     *
+     * <p>
      * example : equalIsNot("This is not")  // Should return false
-     *           equalIsNot("This is notnot") // Should return true
-     *           equalIsNot("noisxxnotyynotxisi") // Should return true
+     * equalIsNot("This is notnot") // Should return true
+     * equalIsNot("noisxxnotyynotxisi") // Should return true
      */
-    public Boolean equalIsNot(String input){
-        return null;
+
+
+    public Boolean equalIsNot(String input) {
+
+
+        int isCount = 0;
+        int notCount = 0;
+
+
+        for (int i = 0; i < input.length() - 1; i++) {
+            if ((input.charAt(i) == 'i') && (input.charAt(i + 1) == 's')) {
+                isCount += 1;
+            }
+        }
+
+        for (int i = 0; i < input.length() - 2; i++) {
+            if ((input.charAt(i) == 'n') && (input.charAt(i + 1) == 'o') && (input.charAt(i + 2) == 't')) {
+                notCount += 1;
+            }
+        }
+
+        if (isCount == notCount)
+            return true;
+        else
+            return false;
+
     }
 
     /**
      * 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
+     * gHappy("xxgxx") // Should return  false
+     * gHappy("xxggyygxx") // Should return  false
      */
-    public Boolean gIsHappy(String input){
-        return null;
-    }
+    public Boolean gIsHappy(String input) {
+
+        boolean flag = true;
 
+        for (int i = 0; i < input.length(); i++) {
+            if (input.charAt(i) == 'g') {
+                if ((input.charAt(i - 1) != 'g') && (input.charAt(i + 1) != 'g')) {
+                    flag = false;
+                }
+            }
+        }
+
+        return flag;
+    }
 
     /**
      * 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
+     * countTriple("xxxabyyyycd") // Should return 3
+     * countTriple("a") // Should return 0
      */
-    public Integer countTriple(String input){
-        return null;
+    public Integer countTriple(String input) {
+        int count = 0;
+        for (int i = 0; i < input.length() - 2; i++) {
+            if ((input.charAt(i + 1) == input.charAt(i)) && input.charAt(i + 2) == input.charAt(i))
+                count += 1;
+        }
+        return count;
+
     }
-}
+}

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

@@ -92,7 +92,7 @@ public class StringsAndThingsTest {
     @Test
     public void gIsHappyTest3(){
         Boolean actual = stringsAndThings.gIsHappy("xxggyygxx");
-        Assert.assertTrue(actual);
+        Assert.assertFalse(actual);
     }
 
     @Test