The right way to split strings

The Wrong Way

One way to attack the problem is to try generating a list of word lengths, then convert that into a running total list, so that the problem is simply a matter of finding the index of the first value in a list greater than or equal to n. Consider the following code:

The plus(0) is needed to tack a zero at the end of the list so that the first list[i-1] loops back round to the end of the list and picks up the additive identity. Unfortunately this is “the wrong way” because the plus(0) does not update the variable list as used inside the closure. As a result, the output is not [1, 3, 6, 6], but [4, 6, 9, 9].

The Long Way

A slight improvement is to use a collect method, which allows a new list to be generated by an implicit foreach loop with a temporary variable to store the current total.

This method is “the long way” because apart from wasting a line on a temporary variable sum, it requires one chain of instructions to find how many words are allowed, and another chain to generate the desired string, in this case the quick.

The Right Way

After getting this far, it struck me that the problem was actually equivalent to taking a substring of the desired length, then removing any incomplete words from the end. The only problem with this method was determining whether the word at the end of the string was really incomplete, that is, whether taking a substring had cut at the end of a word or in the middle of one. These two cases could easily be dealt with by an if statement, and each branch of the if contains a rather simple one-liner:

It seems like this is “the right way”, then, especially as you could rewrite the above as a rather cumbersome one-liner using the ternary operator.

The Cunning Way

From a maintainability perspective, using an if statement (or even the ternary operator) nicely reflects the fact that there are two cases which have to be treated slightly differently. Sometimes, though, it’s only after you’ve written some code in the technically optimum way that you spot “the cunning way”. Instead of using an if statement to determine whether the substring cut into a word, the substring can be changed in a way which has no effect when cutting in the middle of a word, but effectively adds an extra word if the cut happens between words. This means that when the last word is removed, either the cut word is removed, or the extra word is removed, leaving only the whole words required. An example of this is shown below:

When threshold is 15, the plus() produces the string the quick brown # and when it is 14, the string the quick brown# is produced. That is why taking every word from zeroth to the penultimateth will produce the quick brown and the quick respectively.

Conclusion

Again, Groovy shows what a pretty language it is, and I really find that it reflects the way I naturally think about programming. Perhaps it would be more accurate to say that Groovy has taught me to think about programming in a way that is nicely expressible using Groovy’s syntax. In any case, it feels like when I am trying to solve these sorts of algorithmic problems using Groovy, the language is not as much of a hindrance as using other languages would be. Using the language may even have made me a better programmer, but I don’t think that coming up with a clever string splitting algorithm is a huge advance in the field of software. Actually, it sounds like the sort of thing Knuth was doing 30 years ago. Has anyone ever published a one-liner like this before?