Question

• In Java
• All methods listed below must be public and static.
• If your code is using a loop to modify or create a string, you need to use the StringBuilder class from the API.
• Keep the loops simple but also efficient. Remember that you want each loop to do only one "task" while also avoiding unnecessary traversals of the data.
• No additional methods are needed. However, you may write additional private helper methods, but you still need to have efficient and simple algorithms. Do not write helper methods that do a significant number of unnecessary traversals of the data.
• Important: you must not use either break or continue in your code. These two commands almost always are used to compensate for a poorly designed loop. Likewise, you must not write code that mimics what break does. Instead, re-write your loop so that the loop logic does not need break-type behavior.
• While it may be tempting to hunt through the API to find classes and methods that can shorten your code, you may not do that. The first reason is that this homework is an exercise in writing loops, not in using the API. The second reason is that in a lot of cases, the API methods may shorten the writing of your code but increase its running time. The only classes and methods you can use are listed below. Note: if a method you want to use from the API is not listed, you should not implement the method yourself so you can use it. Rather, you shoud look for the solution that does not need that method.

  You are allowed to use the following from the Java API:

  • class String
    • length
    • charAt
  • class StringBuilder
    • length
    • charAt
    • append
    • toString
  • class Character
    • any method

Create a class called HW2 that contains the following methods:

1. nthWord takes an int and a String as input and returns a String:
   The input int represents a number n that is assumed to be positive, and the output string contains every nth word of the input string, starting with the first word, separated by a single space. {\em For this method, a word is defined to be a sequence of non-space characters.} There should be no space at the end of the output string.

   > HW2.nthWord(3, "zero one    two  three four five six seven")
   "zero three six"
   

2. truncateAfter takes an int and a String as input and returns a String:
   The input string may contain hyphens and spaces that mark appropriate places to truncate the string. The output string will be a truncated version of the input string, and the input int value is the desired length of the output string. The output string should truncate the input string at the first legal spot such that the output string will have at least the desired length. If the truncation happens at a space, the space is not included in the output, but if the truncation happens at a hyphen, the hyphen is included. No other hyphens are included in the output, but the other spaces are. (If the input string does not have enough characters to meet the desired minimum, then the output should be the entire input string without the hyphens.)

   > HW2.truncateAfter(5, "La-te-ly the-re.")
   "Late-"
   > HW2.truncateAfter(6, "La-te-ly the-re.")
   "Lately"
   > HW2.truncateAfter(7, "La-te-ly the-re.")
   "Lately the-"
   

3. truncateBefore: the same as the truncateAfter method, but now the input int value is the maximum, and the string should be truncated at the latest possible point such that the resulting string has no more than the desired length.

Answer 1

[11:01 AM, 3/7/2019] Narasimha: ]Here are the first 4 methods

======================================================================================

public class HW2 {

public static boolean onlyEnglishLetters(String text) {

for (int i = 0; i < text.length(); i++) {
char letter = text.charAt(i);
if (('a' <= letter && letter <= 'z') || ('A' <= letter && letter <= 'Z')) {
continue;
} else {
return false;
}
}
return true;
}

public static String replaceKth(char find, char replace, int pos, String text) {

int frequency = 0;
int index = -1;
for (int i = 0; i < text.length(); i++) {
if (text.charAt(i) == find) {
frequency += 1;
if (frequency == pos) {
index = i;
break;
}
}
}
if (frequency == pos) {
return text.substring(0, index) + String.valueOf(replace) + text.substring(index + 1);
} else {
return text;
}
}

public static String interleave(String one, String two) {

StringBuilder build = new StringBuilder();
int lengthOne = one.length();
int lengthTwo = two.length();
int max = lengthOne > lengthTwo ? lengthOne : lengthTwo;

for (int i = 0; i < max; i++) {
if (i < one.length()) {
build.append(one.charAt(i));
}
if (i < two.length()) {
build.append(two.charAt(i));
}
}
return build.toString();

}

public static String blankWords(String text) {

String[] words = text.split("\\s+");
StringBuilder builder = new StringBuilder();
for (String word : words) {
if (word.length() <= 2) {
builder.append(word).append(" ");
} else {
for (int i = 0; i < word.length(); i++) {
if (i == 0 || i == word.length() - 1) {
builder.append(word.charAt(i));
} else {
builder.append("-");
}
}
builder.append(" ");
}
}
return builder.substring(0, builder.length() - 1).toString();
}

public static void main(String[] args) {
System.out.println(replaceKth('a', 'x', 6, "aaaaa"));
System.out.println(interleave("abcde", "ABC"));
System.out.println(blankWords("This is a Test ."));
}
}