import java.util.ArrayList;
 
public class MyString{
 
	// ########## Data Objects ########## (
		private char[] theString, result;
//  )
	// ########## Constructors ########## (
		public MyString(){ // default
			theString = new char[] {'x'};
			result = new char[] {'x'};
		}
		public MyString(String s){ // parameterized
			theString = s.toCharArray();
			result = new char[] {'x'};
		}
		public MyString(char[] s){ // parameterized
			int length = s.length;
			theString = new char[length];
			for(int i=0; i<length; i++){
				theString[i] = s[i];
			}
			result = new char[] {'x'};
		}
		public MyString(MyString s){ // copy
			theString = s.contents();
			result = new char[] {'x'};
		}
//	)
	// ########## Accessors ########## (
		private char[] contents(){
			char[] s = theString;
			return s;
		}
		public int length(){
			return theString.length;
		}
		public String result(){
			return new String(result);
		}
		public String toString(){
			return new String(theString);
		}
		public char get(int n){
			return theString[n];
		}
//  )
	// ########## Mutators ########## (
		public MyString left(int n){
			int stringLength = theString.length;
			result = new char[n];
			if(n > stringLength){ 				// If the space is bigger than the string...
				for(int i=0; i<stringLength; i++){
					result[i] = theString[i];
				}
				for(int j=stringLength; j<n; j++){
					result[j] = ' ';
				}
			}
			if(n <= stringLength){ 				// If the space is the same size as the string or smaller...
				for(int i=0; i<n; i++){
					result[i] = theString[i];
				}
			}
			return new MyString(result);
		}
		public MyString right(int n){
			int stringLength = theString.length;
			int emptySpace = n - stringLength;
			result = new char[n];
			if(n > stringLength){ 				// If the space is bigger than the string...
				for(int j=0; j<emptySpace; j++){
					result[j] = ' ';
				}
				int count = 0;
				for(int i=emptySpace; i<n; i++){
					result[i] = theString[count];
					count++;
				}
			}
			if(n <= stringLength){ 				// If the space is the same size as the string or smaller...
				for(int j=0; j<n; j++){
					result[j] = theString[j];
				}
			}
			return new MyString(result);
		}
		public MyString mid(int n){
			int stringLength = theString.length;
			int emptySpace = n - stringLength;
			int leftPadding=0, rightPadding=0;
			result = new char[n];
			if(n > stringLength){ 				// If the space is bigger than the string...
				if ((emptySpace % 2) == 0){ // If the empty space size is even...
					leftPadding = (emptySpace / 2); // The left padding is equal to the right padding.
					rightPadding = leftPadding;
				}
				if ((emptySpace % 2) == 1){ // If the empty space size is odd...
					rightPadding = (emptySpace / 2) + 1; // The left padding is smaller than the right by 1 space.
					leftPadding = emptySpace / 2;
				}
				for(int i=0; i<leftPadding; i++){
					result[i] = ' ';
				}
				int count = 0;
				for(int j=leftPadding; j<(leftPadding + stringLength); j++){
					result[j] = theString[count];
					count++;
				}
				for(int k=(leftPadding + stringLength); k<n; k++){
					result[k] = ' ';
				}
			}
			if(n <= stringLength){ 				// If the space is the same size as the string or smaller...
				for(int j=0; j<n; j++){
					result[j] = theString[j];
				}
			}
			return new MyString(result);
		}
		public boolean has(String s){ // Determines whether or not a search term exists in our string (true or false).
			char[] searchString = s.toCharArray();
			int searchLength = searchString.length;
			int stringLength = theString.length;
			int foundAt = 0; // Location where a match is found...
			int charMatches = 0; // Counter for matching characters...
			boolean found = false; // To stop the test when a match is found...
 
			for(int i=0; i<stringLength; i++){ // For each letter in our string...
				if (searchLength > stringLength) { // If our search term is bigger than our main string itself...
					break; // Then obviously it will not be found, so prevent the CPU from wasting it's resources on the test...
				}
				if (theString[i] == searchString[0]) { // If a letter in our string matches the first letter of the search term...
					int k=i; // To count starting at our current position without messing up i.
					charMatches = 0; // For reset match count for each test. If not, some terms will not be found...
					for(int j=0; j<searchLength; j++){ // Then for each letter in the search term...
						if (k == stringLength) { // If k is equal to string length (if we have surpassed the boudary of our main string)...
							break; // Then end the for loop or else we get an error during runtime complaining about Array boundaries.
						}
						if (theString[k] == searchString[j]) { // If the letter we're at in our search term matches the corresponding letter in our main string...
							charMatches++; // Then count a character match.
						}
						k++; // Move to the next letter in our base string...
					}
					if (charMatches == searchLength) { // Finally, if the amount of matching letters equals the size of the search term...
						found = true; // Then we've found a matching sequence of characters!
						foundAt = i; // The match is at position i!
					}
				}
				if(found){break;} // We just want to find the first ocurrence for now, so break...
			}
			return found;
		}
		public int firstOcurrenceOf(String s, int n){ // Returns the position at which the search term is first encountered. The search begins at the desired starting point n.
			char[] searchString = s.toCharArray();
			int searchLength = searchString.length;
			int stringLength = theString.length;
			int start = n; // The location in in our string where we begin the search.
			int foundAt = 0; // Location where a match is found...
			int charMatches = 0; // Counter for matching characters...
			boolean found = false; // To stop the test when a match is found...
 
			for(int i=start; i<stringLength; i++){ // For each letter in our string...
				if (searchLength > stringLength || start >= stringLength) { // If our search term is bigger than our main string itself, or the starting point is outside the string's boundaries...
					break; // Then obviously our search term will not be found, so prevent the CPU from wasting it's resources on the test or encountering errors...
				}
				if (theString[i] == searchString[0]) { // If a letter in our string matches the first letter of the search term...
					int k=i; // To count starting at our current position without messing up i.
					charMatches = 0; // For reset match count for each test. If not, some terms will not be found...
					for(int j=0; j<searchLength; j++){ // Then for each letter in the search term...
						if (k == stringLength) { // If k is equal to string length (if we have surpassed the boudary of our main string)...
							break; // Then end the for loop or else we get an error during runtime complaining about Array boundaries.
						}
						if (theString[k] == searchString[j]) { // If the letter we're at in our search term matches the corresponding letter in our main string...
							charMatches++; // Then count a character match.
						}
						k++; // Move to the next letter in our base string...
					}
					if (charMatches == searchLength) { // Finally, if the amount of matching letters equals the size of the search term...
						found = true; // Then we've found a matching sequence of characters!
						foundAt = i; // The match is at position i!
					}
				}
				if(found){break;} // We just want to find the first ocurrence for now, so exit the loop...
			}
			return foundAt;
		}
		public int firstOcurrenceOf(String s){ // This is simply an overloaded version of the previous method so that if you leave off the "n" parameter, it defaults to 0.
			return firstOcurrenceOf(s, 0);
		}
		public int[] findAll(String s){ // Returns an array containing all the locations in our main string where a search term is found to begin.
			char[] searchString = s.toCharArray();
			int searchLength = searchString.length;
			int stringLength = theString.length;
			ArrayList<Integer> locations = new ArrayList<Integer>(); // Locations where a match is found...
			int foundAt[]; // The final array to output containing the locations of the ArrayList above...
			int charMatches = 0; // Counter for matching characters...
 
			boolean found = false; // To stop the test when a match is found...
 
			for(int i=0; i<stringLength; i++){ // For each letter in our string...
				if (searchLength > stringLength) { // If our search term is bigger than our main string itself...
					break; // Then obviously it will not be found, so prevent the CPU from wasting it's resources on the test...
				}
				if (theString[i] == searchString[0]) { // If a letter in our string matches the first letter of the search term...
					int k=i; // To count starting at our current position without messing up i.
					charMatches = 0; // For reset match count for each test. If not, some terms will not be found...
					for(int j=0; j<searchLength; j++){ // Then for each letter in the search term...
						if (k == stringLength) { // If k is equal to string length (if we have surpassed the boudary of our main string)...
							break; // Then end the for loop or else we get an error during runtime complaining about Array boundaries.
						}
						if (theString[k] == searchString[j]) { // If the letter we're at in our search term matches the corresponding letter in our main string...
							charMatches++; // Then count a character match.
						}
						k++; // Move to the next letter in our base string...
					}
					found = false; // Set to false for each test unless we find a matching term...
					if (charMatches == searchLength) { // Finally, if the amount of matching letters equals the size of the search term...
						found = true; // Then we've found a matching sequence of characters!
						locations.add(i); // The match is at position i. Add it to our ArrayList.
					}
				}
			}
			int termCount = locations.size();
			foundAt = new int[termCount];
			for (int h=0; h<termCount; h++) {
				foundAt[h] = locations.get(h);
			}
			return foundAt;
		}
		public MyString uppercase(){ // Turns the string to all uppercase.
			int stringLength = theString.length;
			result = new char[stringLength];
			for (int i=0; i<stringLength; i++) {
				if (theString[i] >= 97 && theString[i] <= 122) {
					result[i] = (char)(theString[i] - ('a' - 'A'));
				}
				else {
					result[i] = theString[i];
				}
			}
			return new MyString(result);
		}
		public MyString lowercase(){ // Turns the string to all lowercase.
			int stringLength = theString.length;
			result = new char[stringLength];
			for (int i=0; i<stringLength; i++) {
				if (theString[i] >= 65 && theString[i] <= 90) {
					result[i] = (char)(theString[i] + ('a' - 'A'));
				}
				else {
					result[i] = theString[i];
				}
			}
			return new MyString(result);
		}
		public MyString invert(){ // Inverts the string so it is spelled backwards.
			int stringLength = theString.length;
			result = new char[stringLength];
			for (int i=stringLength-1; i>=0; i--) {
				result[ (stringLength-1)-i ] = theString[i];
			}
			return new MyString(result);
		}
//  )
}