在Android应用中设计一种算法以“倒退到上一句话”

Question

I'm making an app that flashes one word at a time on the screen. These words are currently created by making an array of strings called words[] and splitting up the main string (toRead) into words using split().

I've also made a Sentences class that is created using Breakiterator to split toRead into sentences. I store start and end for each sentence. However these start and end integers are the index of the characters in the toRead string. But my program sets the text by using the words[] array which indexes words.

Ex: One sentence could start at index 0 and end at index 20. (20 character long sentence with variable amount of words). And it may contain 5 words. So words[0] to word[4] contains this sentence.

What I'd like to do is to get the index of the word showing while my app is running, and figure out what sentence that word is in. Then when the "rewind sentence" button is pressed the index changes to the index of the first word in that sentence (or perhaps the sentence before).

I need some help coming up with the algorithm for doing this. I can think of some ways that would be very high in time complexity but I need something more efficient. Maybe using a hash function if necessary.

Edit: I'll try to be more clear.

The user will enter some sort of a string (the use case for my app is an article or a long essay). The string is called toRead . Then I have a function that takes an input of toRead and creates a String[] called words that has all of the words in the toRead string. So the first word is words[0], etc. In my app when you hit the "play" button it cycles through all the words in words[] one at a time, in order of index at a chosen words-per-minute. While this is going on, I'd like my rewind button to be able to know what sentence the user is on, and return to the beginning of that sentence (while continuing to cycle through the words) and if pressed again I'd like it to return to a sentence before that, and if again to a sentence before that, etc.

So far I've been able to split the toRead string into sentences using BreakIterator and a Sentence class that just has a start and end. So basically I have a bunch of Sentence objects with index values for where they begin and end, but these index values are the character numbers and not the word numbers (which is what I'm using to display each word).

Answer 1

HashMaps might be a way to go.

Map<String,String> myStrings = new HashMap<String,String>

String[] sentences = new String[256]; 
sentences[0] = "Hi how are you"; // etc etc blah blah
String[] words = new String[4];
words[0] = "Hi";  // etc etc

myStrings.add(sentence[0], words[0]);
myStrings.add(sentence[0], words[1]); // etc 

you can determine if a word exists in any given sentence like this

for (String value: myStrings.keySet()) {
    if (myStrings.get(value).has(words[index_you_want]) {   
         // do something
    }
}

Check out HashMaps in more detail and I'll bet that you can solve the rest of your problems

Answer 2

What you're doing is basically translating a 2 dimensional coordinates (sentences, word) to a linear coordinate in the original string.

You can create a list of indices to the start of words, it's essentially a running sum of the length of the words:

String s = "Andy builds car. Data entry fan.";
String[] words = s.split(" ");
int[] words_indexes = new int[words.length];
for (int i = 1; i < words.length; i++) {
    words_indexes[i] = words_indexes[i - 1] + words[i - 1].length + 1;
}

Then finding the position of the third word of the second sentence in the original string would be just:

words_indexes[index_of_sentence_in_words_indexes + index_of_word_in_sentence]

You should also be able to build the words_indexes array lazily as you go displaying the words to the user, that way you don't need to parse the entire thing first (although you really have to have a really, really long string for it to matter, even the longest essays can probably be indexed in a blink of an eye).

Answer 3

I'm still a bit confused about what you are trying to do, so this suggestion may be way off, but how about using a Zipper pattern?

You can get check the Functional Java API http://functionaljava.googlecode.com/svn/artifacts/3.0/javadoc/fj/data/Zipper.html

And for an explanation of what it is: What is the Zipper data structure and should I be using it?