The third question on the 2017 AP Computer Science exam asked you to process a string, replacing the $Nth$ occurrence and finding the last occurrence.
As part of the question you were given a non-implemented method called findNthOccurrence that you were expected to use. It looked like this on the test.
public int findNthOccurrence(String str, int n) {
// Implementation not shown
}
If they’re going to give you a method stub like this, you should expect to use it somewhere in your solution. They probably wouldn’t bother defining a method like this if you weren’t expected to use it.
For part A you were to replace the $Nth$ occurrence of a substring in currentPhrase. They gave you a series of examples like this.
Phrase phrase1 = new Phrase("A cat ate late.");
phrase1.replaceNthOccurrence("at", 1, "rane");
System.out.println(phrase1);
The snippet should output "A crane at late." assuming you implement replaceNthOccurrence correctly.
Here is a working solution.
public void replaceNthOccurrence(String str, int n, String repl) {
int idxStart = findNthOccurrence(str, n);
if (idxStart >= 0) {
String front = currentPhrase.substring(0, idxStart);
String back = currentPhrase.substring(idxStart + str.length());
currentPhrase = front + repl + back;
}
}
We find the $Nth$ occurrence using the provided findNthOccurrence method. Note that we don’t see how findNthOccurrence is implemented, and we don’t really have to care.
If idxStart $\ge 0$ then the substring was found and we’ve got some work to do. If idxStart $\lt 0$ then it wasn’t found and we’re not going to change currentPhrase.
I made a variable called front that contains everything up to the substring we’re looking for and a variable called back of everything after it. The code the returns front concatenated with repl followed by back which creates a string with the $Nth$ occurrence of str replaced with repl.
The second part tasked you with finding the index of the last occurrence of a substring. And it specifically tells you that you must use findNthOccurrence to get full credit.
public int findLastOccurrence(String str) {
int lastIdx = -1;
int n = 0;
while (findNthOccurrence(str, n) > -1) {
lastIdx = findNthOccurrence(str, n);
n++;
}
return lastIdx;
}
This code keeps incrementing n as it looks for the $Nth$ occurrence. When that index value is -1 it means that the previous index was the last index.
This question bothered me a bit though. It seemed very arbitrary to have to solve this problem in this way when there’s a one line solution that’s using a method related to one in the AP subset. You should have learned about the indexOf method on a String that tells you where a substring is found. You may have also learned about lastIndexOf which tells you where the last occurrence of a substring is. lastIndexOf is not formally part of the AP Java subset, but many students learn about it because it’s so close to indexOf.
public int findLastOccurrence(String str) {
return currentPhrase.lastIndexOf(str);
}
I would imagine there will be a lot of packets with a similar solution written. Functionally using lastIndexOf would work, but wouldn’t get full credit since it doesn’t meet the requirement to use findNthOccurrence.
