update

Author: Cocoolanu

CodingBat/Warmup-2/altPairs.java

@@ -0,0 +1,19 @@
+/*
+Given a string, return a string made of the chars at indexes 0,1, 4,5, 8,9 ... so "kittens" yields "kien".
+eg:
+altPairs("kitten") → "kien"
+altPairs("Chocolate") → "Chole"
+altPairs("CodingHorror") → "Congrr"
+*/
+
+public String altPairs(String str) {
+  String result = "";
+  for(int i=0; i<str.length(); i+=4){
+    int end = i + 2; 
+    if (end > str.length()){
+      end = str.length(); 
+    }
+    result += str.substring(i,end); 
+  }
+  return result; 
+}

CodingBat/Warmup-2/array123.java

@@ -0,0 +1,17 @@
+/*
+
+Given an array of ints, return true if the sequence of numbers 1, 2, 3 appears in the array somewhere.
+eg:
+array123([1, 1, 2, 3, 1]) → true
+array123([1, 1, 2, 4, 1]) → false
+array123([1, 1, 2, 1, 2, 3]) → true
+*/
+
+public boolean array123(int[] nums) {
+  for(int i=0; i<nums.length-2; i++){
+    if(nums[i]==1 && nums[i+1]==2 && nums[i+2]==3){
+      return true; 
+    }
+  }
+  return false; 
+}

CodingBat/Warmup-2/arrayCount9.java

@@ -0,0 +1,17 @@
+/*
+Given an array of ints, return the number of 9's in the array.
+eg:
+arrayCount9([1, 2, 9]) → 1
+arrayCount9([1, 9, 9]) → 2
+arrayCount9([1, 9, 9, 3, 9]) → 3
+*/
+
+public int arrayCount9(int[] nums) {
+  int count = 0; 
+  for(int i=0; i<nums.length; i++){
+    if(nums[i]==9){
+      count += 1;
+    }
+ } 
+ return count; 
+}

CodingBat/Warmup-2/arrayFront9.java

@@ -0,0 +1,31 @@
+/*
+
+Given an array of ints, return true if one of the first 4 elements in the array is a 9. The array length may be less than 4.
+eg:
+arrayFront9([1, 2, 9, 3, 4]) → true
+arrayFront9([1, 2, 3, 4, 9]) → false
+arrayFront9([1, 2, 3, 4, 5]) → false
+*/
+
+public boolean arrayFront9(int[] nums) {
+  int end = nums.length;
+  if(end > 4) end = 4;
+  
+  for(int i=0; i<end; i++){
+    if(nums[i] == 9) return true;
+  }
+  return false; 
+
+  /*
+  if(nums.length < 4){
+    for(int i=0; i< nums.length; i++){
+      if(nums[i] == 9) return true;
+    }
+    return false; 
+  }
+  for(int i=0; i<4; i++){
+    if(nums[i] == 9) return true;
+  }
+  return false;
+  */
+}

CodingBat/Warmup-2/countXX.java

@@ -0,0 +1,17 @@
+/*
+Count the number of "xx" in the given string. We'll say that overlapping is allowed, so "xxx" contains 2 "xx".
+eg:
+countXX("abcxx") → 1
+countXX("xxx") → 2
+countXX("xxxx") → 3
+*/
+
+int countXX(String str) {
+  int count = 0; 
+  for(int i=0; i<str.length()-1; i++){
+    if(str.substring(i,i+2).equals("xx")){
+      count += 1;
+    }
+  }
+  return count;
+}

CodingBat/Warmup-2/doubleX.java

@@ -0,0 +1,19 @@
+/*
+
+Given a string, return true if the first instance of "x" in the string is immediately followed by another "x".
+eg:
+doubleX("axxbb") → true
+doubleX("axaxax") → false
+doubleX("xxxxx") → true
+*/
+
+boolean doubleX(String str) {
+  if (!str.contains("x")) return false;
+  
+  int firstX = str.indexOf("x");
+  if(firstX < str.length()-1){
+    return str.substring(firstX, firstX+2).equals("xx"); 
+  }else{
+    return false; 
+  }
+}

CodingBat/Warmup-2/frontTimes.java

@@ -0,0 +1,42 @@
+/*
+
+Given a string and a non-negative int n, we'll say that the front of the string is the first 3 chars, or whatever is there if the string is less than length 3. Return n copies of the front;
+eg:
+frontTimes("Chocolate", 2) → "ChoCho"
+frontTimes("Chocolate", 3) → "ChoChoCho"
+frontTimes("Abc", 3) → "AbcAbcAbc"
+*/
+
+public String frontTimes(String str, int n) {
+  /*
+  String front;
+  String result = "";
+  
+  if(str.length()<3){
+    for(int i=0; i<n; i++){
+      result += str;
+    }
+  }else{
+    front = str.substring(0,3);
+    for(int i=0; i<n; i++){
+      result += front; 
+    }
+  }
+  return result; 
+  */
+  
+  int frontLen = 3;
+  String front;
+  String result = ""; 
+  
+  if (frontLen > str.length()){
+    frontLen = str.length();
+  }
+  
+  front = str.substring(0, frontLen);
+  
+  for(int i =0; i<n; i++){
+    result += front; 
+  }
+  return result; 
+}

CodingBat/Warmup-2/last2.java

@@ -0,0 +1,21 @@
+/*
+Given a string, return the count of the number of times that a substring length 2 appears in the string and also as the last 2 chars of the string, so "hixxxhi" yields 1 (we won't count the end substring).
+eg:
+last2("hixxhi") → 1
+last2("xaxxaxaxx") → 1
+last2("axxxaaxx") → 2
+*/
+
+public int last2(String str) {
+  if(str.length()<3) return 0;
+  
+  int count = 0; 
+  String last = str.substring(str.length()-2); 
+  
+  for(int i=0; i<str.length()-2; i++){
+    if(str.substring(i,i+2).equals(last)){
+      count += 1;
+    }
+  }
+  return count; 
+}

CodingBat/Warmup-2/stringBits.java

@@ -0,0 +1,16 @@
+/*
+Given a string, return a new string made of every other char starting with the first, so "Hello" yields "Hlo".
+eg:
+stringBits("Hello") → "Hlo"
+stringBits("Hi") → "H"
+stringBits("Heeololeo") → "Hello"
+*/
+
+public String stringBits(String str) {
+  String result = "";
+  
+  for(int i=0; i<str.length(); i+=2){
+    result += str.charAt(i);
+  }
+  return result; 
+}

CodingBat/Warmup-2/stringMatch.java

@@ -0,0 +1,33 @@
+/*
+
+Given 2 strings, a and b, return the number of the positions where they contain the same length 2 substring. So "xxcaazz" and "xxbaaz" yields 3, since the "xx", "aa", and "az" substrings appear in the same place in both strings.
+eg:
+stringMatch("xxcaazz", "xxbaaz") → 3
+stringMatch("abc", "abc") → 2
+stringMatch("abc", "axc") → 0
+*/
+
+public int stringMatch(String a, String b) {
+  /*
+  int count = 0;
+  int length; 
+  if(a.length() > b.length()) length = b.length(); 
+  else length = a.length(); 
+  for(int i=0; i<length-1; i++){
+    if(a.substring(i,i+2).equals(b.substring(i,i+2))){
+      count += 1;
+    }
+  }
+  return count;
+  */
+  
+  int len = Math.min(a.length(), b.length());
+  int count = 0;
+  
+  for (int i=0; i<len-1; i++){
+    if(a.substring(i,i+2).equals(b.substring(i,i+2))){
+      count += 1;
+    }
+  }
+  return count; 
+}