## Coding Bat – posNeg

This exercise requires that the program look at two given integers and a boolean. If the Boolean is TRUE AND both integers are negative, then TRUE is returned. If the Boolean is FALSE only 1 integer can be negative for to return TRUE.

```public boolean posNeg(int a, int b, boolean negative) {

}```

As you can see, we start with 2 integer variables named “a” and “b” and a boolean named “negative”.

```public boolean posNeg(int a, int b, boolean negative) {
if (negative){
if (a < 0 && b < 0){
return true;
} else {
return false;
}
} else if ((a < 0 && b > 0) || (a > 0 && b < 0)) {
return true;
} else {
return false;
}
}```

This solution utilizes a nested if/then structure. Starting on line 2, we say IF the Boolean negative is TRUE, then proceed to line 3. If it is FALSE, we would jump to line 8.

On line 3, we now check to see if both “a” AND “b” are negative (less than 0). If they are, TRUE is returned (line 4). If they are not, FALSE is returned (lines 5-7).

Line 8 is executed if the Boolean on line 3 is FALSE. Line 8 looks to see if “a” is negative and “b” is positive OR “a” is positive and “b” is negative. If either case is TRUE, then TRUE is returned (line 9). If neither statement on line 8 is TRUE, then FALSE is returned (lines 10-12).

Coding Bat presents the following as their solution:

```public boolean posNeg(int a, int b, boolean negative) {
if (negative) {
return (a < 0 && b < 0);
}
else {
return ((a < 0 && b > 0) || (a > 0 && b < 0));
}
}```

In this solution, line 2 is identical to our line 2. However, their line 3 is shorter version of our lines (3-7). If both “a” AND “b” are not negative, then a FALSE is returned, otherwise a TRUE is returned.

Their lines 5-7 are our lines 8-12 and work the same way.

## Coding Bat – Arrays Cluster 1

Today, while I was attending meetings, I assigned my students to complete 4 Coding Bat logic exercises.

#### CODING BAT – COMMONEND

This exercise requires that the program return TRUE if the first integers or last integers of two given arrays are the same, otherwise, FALSE will be returned.

```public boolean commonEnd(int[] a, int[] b) {

}```

```public boolean commonEnd(int[] a, int[] b) {
int arrayALength = a.length;
int arrayBLength = b.length;
int lastA = a[arrayALength - 1];
int lastB = b[arrayBLength - 1];
int firstA = a[0];
int firstB = b[0];
if(firstA == firstB || lastA == lastB){
return true;
}
return false;
}```

The solution above starts by calculating the length of each array (lines 2 and 3). Remember, whenever you are asked to do anything with the “end” or “last” items, you will almost always need to calculate the length.

On lines 4 & 5, we are establishing variables to hold the last index of each array and lines 6 & 7 are holding the first index of each array.

Finally, lines 8 through 10 are a conditional statement comparing the first indices of each array and the last indices of each array. If either of them are equal, a TRUE is returned. However, if neither is TRUE, then FALSE is returned.

#### CODING BAT – MAKELAST

This exercise requires that the program calculate the length of a given array and create a new array that is double that length populated with zeros with the exception of the last index. The last index is to populated with the last index of the first array.

```public int[] makeLast(int[] nums) {

}```

```public int[] makeLast(int[] nums) {
int arrayLength = nums.length;
int arrayFinalLength = arrayLength * 2;
int arrayLast = nums[arrayLength - 1];
int[] num = new int[arrayFinalLength];
num[arrayLength - 1] = arrayLast;
return num;
}```

As always, since we are asked to do some operation with the “last” or “end”, we must calculate the length of the array. This is done on line 2.

On line 3, we created a variable to hold the length of the new array, which is double the length of the original array.

Line 4 is where we capture the last index of the original array.

On line 5, we create a new integer array named “num” which has a size assigned by the variable that was created on line 3.

On line 6, we replace the last index of the new array with the value of the variable created on line 4.

Finally, on line 7, we return the new array.

#### CODING BAT – MAKEPI

This exercise requires that the program return the first 3 digits of PI in an array.

```public int[] makePi() {

}```

```public int[] makePi() {
int pi[] = {3,1,4};
return pi;
}```

The solution above starts by creating a new integer array named “pi” which is assigned the integers of 3, 1, and 4 on line 2.

On line 3, the array is returned.

Many students struggle to make this problem more challenging than it needs to be. Some try to take the Math.PI constant and populate the array one index at a time. However, this is not necessary and is not outlined as a requirement in the problem.

## Coding Bat – Cluster 3

Today, while wrapping-up our conversation over arrays, we worked a series of 3 different basic array problems from Coding Bat.

#### CODING BAT – CIGARPARTY

This exercise requires that the program return true if number of cigars is between 40 and 60 on weekdays and at least 40 on weekends.

```public boolean cigarParty(int cigars, boolean isWeekend) {

}```

We start with a single integer named cigars and a boolean named isWeekend.

```public boolean cigarParty(int cigars, boolean isWeekend) {
if (isWeekend){
if (cigars >= 40){
return true;
}else{
return false;
}
}else{
if (cigars >=40 && cigars <=60){
return true;
}else{
return false;
}
}
}```

The solution above starts with a Boolean conditional to check to see if it is a weekend (line 2). If it is not a weekend, then the code jumps to line 8. However, if it is a weekend, the code continues on to line 3.

Line 3 looks to see if the number of cigars is at least 40. If it is, then a TRUE is returned, otherwise a FALSE is returned.

If it is not a weekend, the code jumped to line 8. Starting at line 9, we look to see if the number of cigars is between 40 and 60. If it is, then a TRUE is returned, otherwise a FALSE is returned.

#### CODING BAT – DATEFASHION

This exercise requires that the program calculate the probability of you and your date getting a table at a restaurant based upon how stylish the clothes you and your date are wearing.

```public int dateFashion(int you, int date) {

}```

```public int dateFashion(int you, int date) {
if (you <= 2 || date <= 2){
return 0;
}else if(you >= 8 || date >= 8){
return 2;
}else{
return 1;
}
}```

Our first Boolean conditional statement is located on line 2 where we check to see if either “you” or your “date” are wearing anything that is a 2 or lower. If so, then a “0” is returned.

If the first Boolean is FALSE, then we move to the second Boolean conditional statement on line 4 which is checking to see if either “you” or your “date” are wearing anything that is an 8 or higher. If so, then a “2” is returned.

Finally, if second Boolean is also FALSE, then we automatically return a “1” as the numbers for “you” and your “date” are between 2 and 8 exclusive of those numbers.

#### CODING BAT – SQUIRRELPLAY

This exercise requires that the program state whether the squirrels will come out to play. The squirrels like to play when the temperature is between 60 and 90 degrees, unless it is summer. In the summer, they will stay out up to 100 degrees.

```public boolean squirrelPlay(int temp, boolean isSummer) {

}```

We start with one integer variable named “temp” and a boolean variable named isSummer.

```public boolean squirrelPlay(int temp, boolean isSummer) {
if (isSummer){
if (temp >= 60 && temp <= 100){
return true;
}else{
return false;
}
}else{
if (temp >= 60 && temp <= 90){
return true;
}else{
return false;
}
}
}```

The solution above starts with a Boolean conditional to check to see if it is summer (line 2). If it is not summer, then the code jumps to line 8. However, if it is summer, the code continues on to line 3.

Line 3 looks to see if the temperature is between 60 and 100 degrees. If it is, then a TRUE is returned, otherwise a FALSE is returned.

If it is not summer, the code jumped to line 8. Starting at line 9, we look to see if the temperature is between 60 and 90 degrees. If it is, then a TRUE is returned, otherwise a FALSE is returned.

#### CODING BAT – ALARMCLOCK

This exercise requires that the program return what time the alarm clock with sound with the given criteria:

• If it is a vacation weekday, then the alarm will sound at 10:00.
• If it is a vacation weekend, then the alarm is off.
• If it a weekday, then the alarm will sound at 7:00.
• If it is a weekend, then the alarm will sound at 10:00.

```public String alarmClock(int day, boolean vacation) {

}```

As you can see, we have an integer variable named “day” and a Boolean variable named “vacation”.

```public String alarmClock(int day, boolean vacation) {
if (vacation){
if (day >= 1 && day <= 5){
return "10:00";
}else{
return "off";
}
}else{
if (day >= 1 && day <= 5){
return "7:00";
}else{
return "10:00";
}
}
}```

Staring at line 2, we have a Boolean conditional which looks to see if it is a vacation. If it is not a vacation day, then the code skips to line 8. If it is a vacation day, then we proceed to line 3 where we look to see if it is a weekday (days 1 through 5). If it is a weekday, the application will return the string “10:00” otherwise, the application returns the string “off”.

Looking at line 9, we are processing for a non-vacation day and look to see if it is a weekday (days 1 through 5) and then return the string “7:00” if it is a weekday. If it is a weekend, then we return the string “10:00”.

## Coding Bat – firstLast6

This exercise requires that the program analyze an array of integers and return TRUE if either the first or last integer is a 6. The array is guaranteed to have a minimum length of 1.

```public boolean firstLast6(int[] nums) {

}```

As you can see, we have a single integer array named nums.

```public boolean firstLast6(int[] nums) {
int first = nums[0];
int last = nums[nums.length-1];
if (first == 6 || last == 6){
return true;
}
return false;
}```

This solution utilizes a conditional if with the Boolean OR to solve the problem.

We start my declaring an integer variable named “first” to retrieve the value of index 0 (line 2).

We then declare an integer variable named “last” to retrieve the value of the last letter (Line 3)

As was the case when working with strings, to retrieve the last index of the array, we must first calculate its length and then subtract 1 from the total length. This will give us the value of the last index of the array.

Lines 4 through 6 are the conditional Boolean OR looking to see if either the first or last number are 6. If the Boolean is TRUE, then TRUE is returned.

## Coding Bat – sameFirstLast

This exercise requires that the program analyze an array of integers and return TRUE if the array has a length greater than 1 and the first index is the same as the last index.

```public boolean sameFirstLast(int[] nums) {

}```

As you can see, we have a single integer array named nums.

```public boolean sameFirstLast(int[] nums) {
if (nums.length >= 1){
int first = nums[0];
int last = nums[nums.length-1];
if (first == last){
return true;
}
return false;
}
return false;
}```

We start on line 2 checking to see if the array has a minimum length of 1. If is does not, we skip to line 10 and return FALSE. If the Boolean on line 2 is true, we proceed to line 3.

We then declare an integer variable named “first” to retrieve the value of index 0 (line 3).

We then declare an integer variable named “last” to retrieve the value of the last letter (Line 4)

As was the case when working with strings, to retrieve the last index of the array, we must first calculate its length and then subtract 1 from the total length. This will give us the value of the last index of the array.

Lines 5 through 7 are the conditional Boolean looking to see if the first and last index are the same value. If the Boolean is TRUE, then TRUE is returned.

## Starting with Arrays

Today, we started working with basic arrays in class. Before we got into them, we compared them to stacks. We discussed some of the applicable uses of stacks and how they are ideal for a queue where records must remain in the order they were received.

After the discussion reviewing stacks, I then compared them to a basic array. We discussed that while we can select and manipulate any index within an array, the array is a finite size. We discussed advantages and disadvantages of the two data structures. We then moved into practicing with some code.

```//Program Name: Starting with Arrays
//Programmer Name: Eric Evans, M.Ed.
//Programmer Organization: Ferris High School
//Program Date: Spring 2017

import java.util.*;

public class arrays1 {
public static void main(String args[]){
int myFirstArray[] = {100, 25, 63, 3, 12, 50, 85};

//Print the Array
for(int i=0; i<myFirstArray.length; i++){
System.out.print(myFirstArray[i] + " ");
}

//Alternate Way to Print the Array
System.out.println("");
for(int everyElement: myFirstArray){
System.out.print(everyElement + " ");
}

//Adding the Items in the Array
System.out.println("");
int total = 0;
for(int i=0; i<myFirstArray.length; i++){
total += myFirstArray[i];
}
System.out.println("Total is " + total);

//Sorting the Items in the Array
Arrays.sort(myFirstArray);
for(int everyElement: myFirstArray){
System.out.print(everyElement + " ");
}

//Locate the Largest Item in the Array
System.out.println("");
int max = myFirstArray[0];
for (int i=1;i<myFirstArray.length; i++){
if (myFirstArray[i] > max)max = myFirstArray[i];
}
System.out.println("Max is " + max);
}
}```

We started the notes by creating the array (line 10). We also discussed the difference between:

`int[] myFirstArray = {100, 25, 63, 3, 12, 50, 85};`

and

`int myFirstArray[] = {100, 25, 63, 3, 12, 50, 85};`

The first method is the preferred method for JAVA. The second method was added to the syntax to accommodate programmers who had worked in C++.

Lines 13 through 15 focus on how to display the contents of the array using the for loop..

On line 13, we have a for loop that will start iterating (counting) at 0 using the variable “i” to do the counting. The loop will continue to run until “i” is no longer less than the length of the array. After the loop is successfully run, “i” is incremented by 1.

On line 14, we have what will be executed in each iteration of the loop. The instruction says to print myFirstArray[i].

Remember, the first time through the loop, i = 0. So, line 14 will print index 0 of myFirstArray, which is the first record in the array. The second time through the loop, i = 1. At this point, it will print index 1 of myFirstArray, which is the second record in the array. This process will continue until the end of the array is reached.

Lines 19 through 21 focus on how to display the contents of the array using the foreach loop.

On line 19, we start with a for loop but the conditions are completely different. We declare an integer variable named “everyElement” and set it to have the value received from myFirstArray.

Line 20 prints the value of the variable “everyElement”.

The foreach loop runs through until each and every record has been touched.

Lines 25 through 29 discuss how to calculate the sum of the array.

On line 25, we declare an integer variable named “total” with an initial value of 0.

On line 26, we create a for loop identical to the one used on line 13. This will allow us to traverse the entire array.

On line 27, we take the variable “total” and add the currently selected index to it.

• On the first pass, we have 0 + 100 = 100
• On the second pass, we have 100 + 25 = 125
• On the third pass, we have 125 + 63 = 188
• On the fourth pass, we have 188 + 3 = 191
• On the fifth pass, we have 191 + 12 = 203
• On the sixth pass, we have 203 + 50 = 253
• On the seventh and final pass, we have 253 + 85 = 338

This section could have been solved also using a foreach loop as outlined below:

```int total = 0;
for(int everyElement: myFirstArray){
total += everyElement;
}
System.out.println("Total is " + total);```

Lines 32 through 35 cover how to sort an array.

Line 32 uses the sort function of the Arrays sub-library of the java.util library to sort the array. The sort function was imported on line 6.

Line 33 is a foreach loop (identical to the one seen on line 19.

Line 34 prints the array as it did on line 20.

This section could have been solved also using a traditional for loop as outlined below:

```Arrays.sort(myFirstArray);
for(int i=0; i<myFirstArray.length; i++){
System.out.print(myFirstArray[i] + " ");
}```

Finally, in lines 39 to 43, we analyze how to locate the largest item in the array.

We start by declaring an integer variable named “max” and assign it the value of index 0 of the array. Since the array was just sorted on line 32, index 0 is now 3. As such, the variable “max” now has a value of 3.

Line 40 uses a slightly modified for loop as it starts iterating at 1 and not 0 as we did on line 13 and on line 26.

Line 41 uses a conditional if statement to check if the current iterated index of the array is greater than the variable “max”. If the statement is TRUE, the variable “max” is assigned the value of the iterated index. If is it FALSE, the variable “max” remains with its currently assigned value. This process repeats until the entire array is traversed.

As has been the case through all of this, you could use a foreach loop on this section of the problem as well. Here is what that code would look like with a foreach loop:

```int max = myFirstArray[0];
for (int everyElement: myFirstArray){
if (everyElement > max)max = everyElement;
}
System.out.println("Max is " + max);
```

Here is the code using traditional for loops:

```//Program Name: Starting with Arrays
//Programmer Name: Eric Evans, M.Ed.
//Programmer Organization: Ferris High School
//Program Date: Spring 2017

import java.util.*;

public class arrays1 {
public static void main(String args[]){
int myFirstArray[] = {100, 25, 63, 3, 12, 50, 85};

//Print the Array with for Loop
for(int i=0; i<myFirstArray.length; i++){
System.out.print(myFirstArray[i] + " ");
}

//Print the Array with foreach Loop
System.out.println("");
for(int everyElement: myFirstArray){
System.out.print(everyElement + " ");
}

//Adding the Items in the Array
System.out.println("");
int total = 0;
for(int i=0; i<myFirstArray.length; i++){
total += myFirstArray[i];
}
System.out.println("Total is " + total);

//Sorting the Items in the Array
Arrays.sort(myFirstArray);
for(int i=0; i<myFirstArray.length; i++){
System.out.print(myFirstArray[i] + " ");
}

//Locate the Largest Item in the Array
System.out.println("");
int max = myFirstArray[0];
for (int i=1;i<myFirstArray.length; i++){
if (myFirstArray[i] > max)max = myFirstArray[i];
}
System.out.println("Max is " + max);
}
}```

Here is the code use foreach loops:

```//Program Name: Starting with Arrays
//Programmer Name: Eric Evans, M.Ed.
//Programmer Organization: Ferris High School
//Program Date: Spring 2017

import java.util.*;

public class arrays1 {
public static void main(String args[]){
int myFirstArray[] = {100, 25, 63, 3, 12, 50, 85};

//Print the Array with for Loop
for(int i=0; i<myFirstArray.length; i++){
System.out.print(myFirstArray[i] + " ");
}

//Print the Array with foreach Loop
System.out.println("");
for(int everyElement: myFirstArray){
System.out.print(everyElement + " ");
}

//Adding the Items in the Array
System.out.println("");
int total = 0;
for(int everyElement: myFirstArray){
total += everyElement;
}
System.out.println("Total is " + total);

//Sorting the Items in the Array
Arrays.sort(myFirstArray);
for(int everyElement: myFirstArray){
System.out.print(everyElement + " ");
}

//Locate the Largest Item in the Array
System.out.println("");
int max = myFirstArray[0];
for (int everyElement: myFirstArray){
if (everyElement > max)max = everyElement;
}
System.out.println("Max is " + max);
}
}```

As you can see, both result in the same number of lines of code. It would ultimately be programmer’s preference and customer request for which loop structure would be used.

## Coding Bat – delDel

This exercise requires that the program analyze a string to see if it contains the word “del” starting at index position 1. If it does, it is to remove it and display the word with the “del” removed.

```public String delDel(String str) {

}```

As you can see, we have a single string variable named “str”.

```public String delDel(String str) {
if(str.length()>=4 && str.substring(1,4).equals("del")){
return str.substring(0, 1) + str.substring(4);
}
return str;
}```

This solution utilizes a conditional if with the Boolean AND to solve the problem.

We start by looking to see if the string is 4 or more characters in length AND if the string starting at index 1 to 4 is “del”.

If this Boolean is TRUE, then we return the string from index 0 to 1 concatenated with the string from index 4 to the end.

If this Boolean is FALSE, then we simply return the string unmodified.

## Coding Bat – Cluster 2

Today, while I was working with the FTC 11242 (ERROR 404) robotics team at Ferris Intermediate School for our community outreach efforts, my Computer Science class was assigned to complete 4 different Coding Bat assignments.

#### CODING BAT – firstTwo

This exercise requires that the program return only the first two characters of a provided string.

```public String firstTwo(String str) {

}```

```public String firstTwo(String str) {
if (str.length() < 2){
return str;
}
String firstTwo = str.substring(0,2);
return firstTwo;
}```

The solution above first uses the length method of the String class to determine if the string is less than 2 characters long. If it is, then the entered string is returned as the solution (lines 2 – 4).

Lines 5 – 6 are executed if the string is 2 or more characters in length and uses the substring method of the String class to capture the characters from index 0 to index 2 (first 2 letters of the string) and assigns them to the variable named firstTwo and then returns the value of that variable.

#### CODING BAT – extraEnd

This exercise requires that the program take the last two letters of the provided string and create a new string that repeats them 3 times.

```public String extraEnd(String str) {

}```

```public String extraEnd(String str) {
int strLength = str.length();
String lastTwo = str.substring(strLength - 2, strLength);
String extraEnd = lastTwo + lastTwo + lastTwo;
return extraEnd;
}```

Whenever we are doing something involving the end of a string, we must first calculate the length of the string (line 2).

Once we know the length of the string, we can come back 2 characters (line 3).

We then use concatenate to repeat the last 2 characters 3 times (line 4) and output the final solution (line 5).

#### CODING BAT – conCat

This exercise requires that the program take two entered strings and concatenate the first with the last. However, if the last character of the first string and the first character of the last string are the same, they are NOT to be repeated and one is to be removed.

```public String conCat(String a, String b) {

}```

```public String conCat(String a, String b) {
int aLength = a.length();
int bLength = b.length();
if (aLength == 0 || bLength == 0){
return a + b;
}
String aLastLetter = a.substring(aLength - 1, aLength);
String bFirstLetter = b.substring(0,1);
if (aLastLetter.equals(bFirstLetter)){
return a + b.substring(1, bLength);
}
return a + b;
}```

The solution above first determines the length of the two strings (lines 2 – – 3). We then look to see if either of the strings is empty (lines 4 – 6) and return the strings as they are.

If both of the strings have text, we then look to see what the last letter of string a is (line 7) and the first letter of string b (line 8). We then compare these two letters to see if they are the same (line 9). If they are, we return string a concatenated with string b with the first letter of string b removed.

If line 9 is false, then we simply return string a concatenated with string b.

#### CODING BAT – theEnd

This exercise requires that the program display either the first letter of the string (if the Boolean front is true) or the last letter of the string (if the Boolean front is false).

```public String theEnd(String str, boolean front) {

}```

As you can see, we have a string variable named str and a Boolean with the value of front.

```public String theEnd(String str, boolean front) {
int strLength = str.length();
String strFirstLetter = str.substring (0,1);
String strLastLetter = str.substring (strLength - 1, strLength);
if (front == true){
return strFirstLetter;
}
return strLastLetter;
}```

As always, when we’re asked to do anything with the end of a string, we must first calculate the length of the string (line 2).

We then create variables for the first letter and last letter of the string using the substring method of the String class (lines 3 – 4).

Line 5 looks to see if the Boolean is true. If it is, we return the value of the variable for the first letter of the string (line 6). Otherwise, we return the value of the variable for the last letter of the string (line 8).

## Coding Bat – or35

This exercise requires that the program return the value of true if the given number is evenly divisible by either 3 or 5. The instructions encourage us to utilize modulus division to solve this problem.

As a reminder, modulus division is the “remainder” after you solve a division problem.

```public boolean or35(int n) {

}```

As you can see, we have a single integer variable named “n”.

```public boolean or35(int n) {
return (n % 3 == 0) || (n % 5 == 0);
}```

The provided solution does not utilize variables beyond the single provided n.

```public boolean or35(int n) {
double modFive = n % 5;
double modThree = n % 3;
if (modFive == 0 || modThree == 0){
return true;
}
return false;
}```

An alternative solution could use variables for the division and inside the conditional statements.

## Coding Bat – Cluster 1

Today, while I was working with the FTC 11242 (ERROR 404) robotics team at Ferris Intermediate School for our community outreach efforts, my Computer Science class was assigned to complete 4 different Coding Bat assignments.

#### Coding Bat – helloName

This exercise requires that the program return an entered name with the word Hello appended to the front and an exclamation point following the name.

```public String helloName(String name) {

}```

```public String helloName(String name) {
return "Hello " + name + "!";
}```

The solution above simply uses the concatenate function to append “Hello ” in front of the name variable and the “!” following it.

#### Coding Bat – makeAbba

This exercise requires that the program take two input strings of text and place them into the A-B-B-A order.

For example, let’s say that string A is “cat” and string B is “dog”. The output would be catdogdogcat.

```public String makeAbba(String a, String b) {

}```

```public String makeAbba(String a, String b) {
return a + b + b + a;
}```

The solution above simply uses the concatenate function to append variable a to variable b to variable b to variable a.

#### Coding Bat – makeTags

This exercise requires that the program take two entered strings of which the first is an HTML tag and create a formatted HTML instruction with open and closing tags enclosing the second entered string.

```public String makeTags(String tag, String word) {

}```

```public String makeTags(String tag, String word) {
return "<" + tag + ">" + word + "</" + tag + ">";
}```

The solution above simply uses the concatenate function to append the correct text and variables in an HTML syntax structure.

#### Coding Bat – withoutX

This exercise requires that the program take an entered string that if it start with or ends with “x” the “x” is removed. If there is an “x” in the middle of the letter, it remains.

```public String withoutX(String str) {

}```

As you can see, we have a string variable named str.

```public String withoutX(String str) {
int count = str.length();
if (count == 0){
return str;
}
int secondToLastLetter = count - 1;
String firstLetter = str.substring(0, 1);
String lastLetter = str.substring(secondToLastLetter, count);
if (str.equals("x")){
str = "";
}
else if (firstLetter.equals("x") && (lastLetter.equals("x"))){
str = str.substring(1,secondToLastLetter);
}
else if (firstLetter.equals("x")){
str = str.substring(1,count);
}
else if (lastLetter.equals("x")){
str = str.substring(0,secondToLastLetter);
}
return str;
}```

You can see that this problem was little bit more involved because the testing data set included an empty string and a string that was just a single letter x.

Lines 3 – 5 address the situation of a null or empty string.

Lines 6 – 8 create local variables to be used in the other cases presented.

Lines 9 – 11 address the situation of only the letter x.

Lines 12 – 14 address the situation of an x at the front AND an x at the end.

Lines 15 – 17 address the situation of an x only at the front.

Lines 18 – 20 address the situation of an x only at the end.

Line 21 returns what the string will look like with the necessary letter x’s removed.