Task

Write a program that solves the odd word problem with the restrictions given below.



Description

You are promised an input stream consisting of English letters and punctuations.

It is guaranteed that:

 the words (sequence of consecutive letters) are delimited by one and only one punctuation,
 the stream will begin with a word,
 the words will be at least one letter long,   and 
 a full stop (a period, [.]) appears after, and only after, the last word.


Example

A stream with six words:

 what,is,the;meaning,of:life. 


The task is to reverse the letters in every other word while leaving punctuations intact, producing:

 what,si,the;gninaem,of:efil. 
while observing the following restrictions:

 Only I/O allowed is reading or writing one character at a time, which means: no reading in a string, no peeking ahead, no pushing characters back into the stream, and no storing characters in a global variable for later use;
 You are not to explicitly save characters in a collection data structure, such as arrays, strings, hash tables, etc, for later reversal;
 You are allowed to use recursions, closures, continuations, threads, co-routines, etc., even if their use implies the storage of multiple characters.


Test cases

Work on both the   "life"   example given above, and also the text:

 we,are;not,in,kansas;any,more.


 
String[] meaning = ["what,", "is,", "the;", "meaning,", "of:", "life."];
String[] kansas = ["we,", "are,", "not,", "in,", "kansas;", "any,", "more."];
 
shared void run() {
    print("".join(reverseWords(meaning)));
    print("".join(reverseWords(kansas)));
}
 
String[] reverseWords(String[] words)
    => recursiveReverseWords(words, []);
 
String[] recursiveReverseWords(String[] remOrig, String[] revWords)
    => if (nonempty remOrig)
        then recursiveReverseWords(remOrig.rest,
                                   revWords.withTrailing(reverseWordRecursive(remOrig.first.sequence(),
                                                                              [],
                                                                              revWords.size.even)))
        else revWords;
 
String reverseWordRecursive(Character[] remOldChars, Character[] revChars, Boolean isEven)
    => if (nonempty remOldChars)
        then let (char = remOldChars.first) reverseWordRecursive(remOldChars.rest,
                                                                 conditionalAddChar(char, revChars, isEven),
                                                                 isEven)
        else String(revChars);
 
Character[] conditionalAddChar(Character char, Character[] chars, Boolean isEven)
    => if (isEven || isPunctuation(char))
        then chars.withTrailing(char)
        else chars.withLeading(char);
 
Boolean isPunctuation(Character char)
    => ",.:;".contains(char);
 
 