//Given a string and a non-negative int n, return a larger string that is n copies of the original

string.

//stringTimes("Hi", 2) → "HiHi"
//stringTimes("Hi", 3) → "HiHiHi"
//stringTimes("Hi", 1) → "Hi"

public String stringTimes(String str, int n) {

String temp = "";

for(int i = 0; i < n; i++){

temp += str;
}

return temp;
}

//---------------------------------

// Warmup-2 > doubleX

// Given a string, return true if the first instance of "x" in the string is immediately followed by
another "x".

// doubleX("axxbb") → true
// doubleX("axaxax") → false
// doubleX("xxxxx") → true

boolean doubleX(String str) {

boolean result = false;

if(str.length() > 1){

for(int i = 0; i < str.length() - 1; i++){

if(str.charAt(i) == 'x'){
if(str.charAt(i+1) == 'x'){
result = true;
break;
} else {
result = false;
break;
}
} else {
result = false;
// break;
 }
}
} else {
return false;
}

return result;
}

//---------------------------------

// Warmup-2 > last2

// 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).

// last2("hixxhi") → 1
// last2("xaxxaxaxx") → 1
// last2("axxxaaxx") → 2

public int last2(String str) {

if(str.length() < 2)
return 0;

String end = str.substring(str.length() - 2);

int count = 0;

for(int i = 0; i < str.length() - 2; i++) {

if(str.substring(i, i + 2).equals(end))
count++;
}

return count;
}

//---------------------------------

Warmup-2 > array123

//Given an array of ints, return true if the sequence of numbers 1, 2, 3 appears in the array
somewhere.

//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) {

boolean result = false;

for(int i=0; i < (nums.length-2); i++){

if(nums[i]==1 && nums[i+1]==2 && nums[i+2]==3){
result = true;
break;
} else {
result = false;
}
}
return result;
}

//---------------------------------

Warmup-2 > altPairs

Given a string, return a string made of the chars at indexes 0,1, 4,5, 8,9 ... so "kittens" yields
"kien".

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 = result + str.substring(i, end);
}

return result;
}

//---------------------------------

Warmup-2 > noTriples

// Given an array of ints, we'll say that a triple is a value appearing 3 times in a row in the
array. Return true if the array does not contain any triples.

// noTriples([1, 1, 2, 2, 1]) → true

// noTriples([1, 1, 2, 2, 2, 1]) → false
// noTriples([1, 1, 1, 2, 2, 2, 1]) → false
public boolean noTriples(int[] nums) {
boolean result = false;

if(nums.length < 3){

result = true;
} else {
for(int i=0; i < (nums.length-2); i++){

if(nums[i]==nums[i] && nums[i+1]==nums[i] && nums[i+2]==nums[i]){

result = false;
break;
} else {
result = true;
}
}
}
return result;

//---------------------------------

Warmup-2 > frontTimes

// 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;

// frontTimes("Chocolate", 2) → "ChoCho"
// frontTimes("Chocolate", 3) → "ChoChoCho"
// frontTimes("Abc", 3) → "AbcAbcAbc"

public String frontTimes(String str, int n) {

String temp = "";
int num = 3;
int len = str.length();

if(len < 3){

num = len;
}
 for(int i = 0; i < n; i++){
temp += str.substring(0, num);
}

return temp;
}

//---------------------------------

Warmup-2 > stringBits

// Given a string, return a new string made of every other char starting with the first, so
"Hello" yields "Hlo".

// stringBits("Hello") → "Hlo"
// stringBits("Hi") → "H"
// stringBits("Heeololeo") → "Hello"

public String stringBits(String str) {

String temp = "";

for (int i=0; i<str.length(); i+=2) {

temp += str.charAt(i);

}
return temp;
}

//---------------------------------

Warmup-2 > arrayCount9

Given an array of ints, return the number of 9's in the array.

arrayCount9([1, 2, 9]) → 1
arrayCount9([1, 9, 9]) → 2
arrayCount9([1, 9, 9, 3, 9]) → 3

public int arrayCount9(int[] nums) {

int cont = 0;

for(int i : nums){
 if(i == 9){
cont++;
}
}

return cont;
}

//---------------------------------

// Warmup-2 > arrayCount9

// Given an array of ints, return the number of 9's in the array.

// 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 n: nums){
if(n == 9){
count++;
}
}

return count;
}

//---------------------------------

// Warmup-2 > stringMatch

// 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.

// stringMatch("xxcaazz", "xxbaaz") → 3
// stringMatch("abc", "abc") → 2
// stringMatch("abc", "axc") → 0

public int stringMatch(String a, String b) {

int min = Math.min(a.length(), b.length());
 int count = 0;

for(int i = 0; i < min - 1; i++) {

if(a.substring(i, i + 2).equals(b.substring(i, i + 2)))
count++;
}

return count;
}

//---------------------------------

// Warmup-2 > stringYak

// Suppose the string "yak" is unlucky. Given a string, return a version where all the "yak" are
removed, but the "a" can be any char. The "yak" strings will not overlap.

// stringYak("yakpak") → "pak"
// stringYak("pakyak") → "pak"
// stringYak("yak123ya") → "123ya"

public String stringYak(String str) {

String result = "";

for (int i = 0; i < str.length(); i++) {

if (i+2 < str.length() && str.charAt(i)=='y' && str.charAt(i+2)=='k') {
i = i + 2;
} else {
result = result + str.charAt(i);
}
}

return result;
}

//---------------------------------

// Warmup-2 > has271

// Given an array of ints, return true if it contains a 2, 7, 1 pattern: a value, followed by the
value plus 5, followed by the value minus 1. Additionally the 271 counts even if the "1" differs
by 2 or less from the correct value.

// has271([1, 2, 7, 1]) → true

// has271([1, 2, 8, 1]) → false
// has271([2, 7, 1]) → true

public boolean has271(int[] nums) {

int len = nums.length;

for (int i = 0; i < nums.length - 1; i++) {

if (i + 2 <= nums.length - 1){
int a = Math.abs(nums[i] - 1);
int b = Math.abs(a - nums[i + 2]);

if(nums[i+1] == nums[i] + 5 && b <= 2){

return true;
}
}
} return false;
}

//---------------------------------

// Warmup-2 > countXX

// Count the number of "xx" in the given string. We'll say that overlapping is allowed, so "xxx"
contains 2 "xx".

// 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++;
}
}
return count;
}

//---------------------------------

// Warmup-2 > stringSplosion

// Given a non-empty string like "Code" return a string like "CCoCodCode".

// stringSplosion("Code") → "CCoCodCode"
// stringSplosion("abc") → "aababc"
// stringSplosion("ab") → "aab"

public String stringSplosion(String str) {

int len = str.length();
String temp = "";

for(int i = 0; i < len + 1; i++){

temp += str.substring(0, i);
}

return temp;
}

//---------------------------------

// Warmup-2 > arrayFront9

// 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.
// 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) {

if (nums.length <= 4){

for (int i = 0; i < nums.length; i++){
if (nums[i] == 9){
return true;
}
}
} else {
for(int j = 0; j < 4; j++) {
if (nums[j] == 9){
return true;
}
}
}

return false;
}
//---------------------------------

// Warmup-2 > stringX

// Given a string, return a version where all the "x" have been removed. Except an "x" at the
very start or end should not be removed.

// stringX("xxHxix") → "xHix"
// stringX("abxxxcd") → "abcd"
// stringX("xabxxxcdx") → "xabcdx"

public String stringX(String str) {

String result = "";
int len = str.length();

for(int i = 0; i < len; i++){

char temp = str.charAt(i);
if (!(i > 0 && i < len - 1 && temp == 'x'))
result = result + temp;
}
return result;
}

//---------------------------------

// Warmup-2 > array667

// Given an array of ints, return the number of times that two 6's are next to each other in the
array. Also count instances where the second "6" is actually a 7.

// array667([6, 6, 2]) → 1
// array667([6, 6, 2, 6]) → 1
// array667([6, 7, 2, 6]) → 1

public int array667(int[] nums) {

int count = 0;

for(int i = 0; i < nums.length - 1; i++) {

if(nums[i] == 6 && (nums[i+1] == 6 || nums[i+1] == 7))
count++;
}

return count;
}
//---------------------------------

//---------------------------------