// Given a string name, e.g. "Bob", return a greeting of the form "Hello Bob!". public String helloName(String name) { return ("Hello " + name + '!'); } // Given two strings, a and b, return the result of putting them together in the order abba, // e.g. "Hi" and "Bye" returns "HiByeByeHi". public String makeAbba(String a, String b) { return (a+b+b+a); } // The web is built with HTML strings like "Yay" which draws Yay as italic text. // In this example, the "i" tag makes and which surround the word "Yay". // Given tag and word strings, create the HTML string with tags around the word, e.g. "Yay". public String makeTags(String tag, String word) { return ('<' + tag + '>' + word + '<' + '/' + tag + '>'); } // Given an "out" string length 4, such as "<<>>", and a word, return a new string // where the word is in the middle of the out string, e.g. "<>". // Note: use str.substring(i, j) to extract the String starting at index i and going up to but not including index j. public String makeOutWord(String out, String word) { return (out.substring(0, 2) + word + out.substring(2, 4)); } // Given a string, return a new string made of 3 copies of the last 2 chars of the original string. // The string length will be at least 2. public String extraEnd(String str) { int len = str.length(); String temp = str.substring(len-2, len); return (temp + temp + temp); } // Given a string, return the string made of its first two chars, so the String "Hello" yields "He". // If the string is shorter than length 2, return whatever there is, so "X" yields "X", // and the empty string "" yields the empty string "".Note that str.length() returns the length of a string. public String firstTwo(String str) { if(str.length() >= 3) return str.substring(0, 2); return str; } // Given a string of even length, return the first half. So the string "WooHoo" yields "Woo". public String firstHalf(String str) { return str.substring(0, str.length()/2); } // Given a string, return a version without the first and last char, so "Hello" yields "ell". // The string length will be at least 2. public String withoutEnd(String str) { return str.substring(1, str.length()-1); } // Given 2 strings, a and b, return a string of the form short+long+short, with the shorter string on the outside // and the longer string on the inside. The strings will not be the same length, but they may be empty (length 0). public String comboString(String a, String b) { if(a.length() >= b.length()) return b+a+b; return a+b+a; } // Given 2 strings, return their concatenation, except omit the first char of each. // The strings will be at least length 1. public String nonStart(String a, String b) { return (a.substring(1) + b.substring(1)); } // Given a string, return a "rotated left 2" version where the first 2 chars are moved to the end. // The string length will be at least 2. public String left2(String str) { return (str.substring(2) + str.substring(0, 2));} // Given a string, return a "rotated right 2" version where the last 2 chars are moved to the start. // The string length will be at least 2. public String right2(String str) { int len = str.length()-2; return (str.substring(len) + str.substring(0, len)); } // Given a string, return a string length 1 from its front, unless front is false, // in which case return a string length 1 from its back. The string will be non-empty. public String theEnd(String str, boolean front) { if(front) return str.substring(0, 1); return str.substring(str.length()-1); } // Given a string, return a version without both the first and last char of the string. // The string may be any length, including 0. public String withouEnd2(String str) { int len = str.length(); if(len >= 3) return str.substring(1, len-1); return ""; } // Given a string of even length, return a string made of the middle two chars, // so the string "string" yields "ri". The string length will be at least 2. public String middleTwo(String str) { int half = str.length()/2-1; return str.substring(half, half+2); } // Given a string, return true if it ends in "ly". public boolean endsLy(String str) { int len = str.length(); if(len >= 2) return (str.substring(str.length()-2).equals("ly")); return false; } // Given a string and an int n, return a string made of the first and last n chars from the string. // The string length will be at least n. public String nTwice(String str, int n) { return (str.substring(0, n) + str.substring(str.length()-n)); } // Given a string and an index, return a string length 2 starting at the given index. // If the index is too big or too small to define a string length 2, use the first 2 chars. // The string length will be at least 2. public String twoChar(String str, int index) { if(index <= str.length()-2 && index >= 0) return str.substring(index, index+2); return str.substring(0, 2); } // Given a string of odd length, return the string length 3 from its middle, // so "Candy" yields "and". The string length will be at least 3. public String middleThree(String str) { int len = str.length()/2; return str.substring(len-1,len+2); } // Given a string, return true if "bad" appears starting at index 0 or 1 in the string, such as with "badxxx" or // "xbadxx" but not "xxbadxx". The string may be any length, including 0. Note: use .equals() to compare 2 strings. public boolean hasBad(String str) { int len = str.length(); if(len == 3 && str.equals("bad")) return true; else if(len >= 4) { if(str.substring(0, 3).equals("bad")) return true; return str.substring(1, 4).equals("bad"); } else return false; } // Given a string, return a string length 2 made of its first 2 chars. // If the string length is less than 2, use '@' for the missing chars. public String atFirst(String str) { int len = str.length(); if(len >= 2) return str.substring(0, 2); else if(len == 1) return (str.charAt(0)+"@"); else return "@@"; } // Given 2 strings, a and b, return a new string made of the first char of a and // the last char of b, so "yo" and "java" yields "ya". If either string is length 0 // use '@' for its missing char. public String lastChars(String a, String b) { int lenB = b.length(); String combStr = ""; combStr += (a.length() >= 1) ? a.charAt(0) : '@'; combStr += (lenB >= 1) ? b.charAt(lenB-1) : '@'; return combStr; } // Given two strings, append them together (known as "concatenation") and return the result. // However, if the concatenation creates a double-char, then omit one of the chars, so "abc" and "cat" yields "abcat". public String conCat(String a, String b) { int lenA = a.length(); int lenB = b.length(); if(lenA >= 1 && lenB >= 1) { if(a.charAt(lenA-1) == b.charAt(0)) return (a + b.substring(1)); else return (a + b); } return (a + b); } // Given a string of any length, return a new string where the last 2 chars // if present, are swapped, so "coding" yields "codign". public String lastTwo(String str) { int len = str.length(); if(len >= 2) return str.substring(0, len-2)+str.charAt(len-1)+str.charAt(len-2); else return str; } // Given a string, if the string begins with "red" or "blue" return that color string // otherwise return the empty string. public String seeColor(String str) { int len = str.length(); if(len >= 4) { if(str.substring(0, 4).equals("blue")) return "blue"; else if(str.substring(0, 3).equals("red")) return "red"; else return ""; } else if(len == 3) { if(str.substring(0, 3).equals("red")) return "red"; else return ""; } else return ""; } // Given a string, return true if the first 2 chars in the string also appear // at the end of the string, such as with "edited". public boolean frontAgain(String str) { int len = str.length(); if(len >= 2) return str.substring(0, 2).equals(str.substring(len-2, len)); else return false; } // Given two strings, append them together (known as "concatenation") and return the result. // However, if the strings are different lengths, omit chars from the longer string so it is the // same length as the shorter string. So "Hello" and "Hi" yield "loHi". The strings may be any length. public String minCat(String a, String b) { int lenA = a.length(); int lenB = b.length(); if(lenA >= lenB) return (a.substring(lenA-lenB) + b); else return (a + b.substring(lenB-lenA)); } // Given a string, return a new string made of 3 copies of the first 2 chars of the original string. // The string may be any length. If there are fewer than 2 chars, use whatever is there. public String extraFront(String str) { String temp; if(str.length() >= 3) temp = str.substring(0, 2); else temp = str; return (temp + temp + temp); } // Given a string, if a length 2 substring appears at both its beginning and end, // return a string without the substring at the beginning, so "HelloHe" yields "lloHe". // The substring may overlap with itself, so "Hi" yields "". Otherwise, return the original string unchanged. public String without2(String str) { int len = str.length(); if(len >= 2) { if(str.substring(0,2).equals(str.substring(len-2, len))) return str.substring(2); else return str; } else return str; } // Given a string, return a version without the first 2 chars. Except keep the first char // if it is 'a' and keep the second char if it is 'b'. The string may be any length. Harder than it looks. public String deFront(String str) { int len = str.length(); if(len >= 2) { StringBuilder stbuild = new StringBuilder(len); if(str.charAt(0) == 'a') stbuild.append('a'); if(str.charAt(1) == 'b') stbuild.append('b'); stbuild.append(str.substring(2)); return stbuild.toString(); } else if(len == 1 && str.charAt(0) == 'a') return "a"; else return ""; } // OR public String deFront(String str){ if(str.length() == 1 && str.charAt(0) != 'a') return ""; if(str.length() >= 2) { if(str.charAt(0) != 'a' && str.charAt(1) != 'b') { return str.substring(2); } else if(str.charAt(0) != 'a') { return str.substring(1); } else if(str.charAt(1) != 'b') { return "a" + str.substring(2); } } return str; } // Given a string and a second "word" string, we'll say that the word matches the string if it appears at // the front of the string, except its first char does not need to match exactly. On a match, return the // front of the string, or otherwise return the empty string. So, so with the string "hippo" the word // "hi" returns "hi" and "xip" returns "hip". The word will be at least length 1. public String startWord(String str, String word) { int lenStr = str.length(); int lenWord = word.length(); String temp; if(lenStr >= lenWord) { temp = str.substring(1, lenWord); if(word.substring(1).equals(temp)) return (str.charAt(0)+temp); else return ""; } else return ""; } // Given a string, if the first or last chars are 'x', return the string without those 'x' chars, // and otherwise return the string unchanged. public String withoutX(String str) { int len = str.length(); if(len >= 2) { char ch = str.charAt(0); StringBuilder stbuild = new StringBuilder(len); if(ch != 'x') stbuild.append(ch); stbuild.append(str.substring(1, len-1)); ch = str.charAt(len-1); if(ch != 'x') stbuild.append(ch); return stbuild.toString(); } else if(len == 1 && str.charAt(0) == 'x') return ""; else return str; } // Given a string, if one or both of the first 2 chars is 'x', return the string without those 'x' chars // and otherwise return the string unchanged. This is a little harder than it looks. public String withoutX2(String str) { int len = str.length(); if(len >= 2) { char ch = str.charAt(0); StringBuilder stbuild = new StringBuilder(len); if(ch != 'x') stbuild.append(ch); ch = str.charAt(1); if(ch != 'x') stbuild.append(ch); stbuild.append(str.substring(2)); return stbuild.toString(); } else if(len == 1 && str.charAt(0) == 'x') return ""; else return str; }