Data commit

Task/Odd-word-problem/00-META.yaml

@@ -0,0 +1,2 @@
+---
+from: http://rosettacode.org/wiki/Odd_word_problem

Task/Odd-word-problem/00-TASK.txt

@@ -0,0 +1,32 @@
+;Task:
+Write a program that solves the [http://c2.com/cgi/wiki?OddWordProblem 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, [<b>.</b>]) appears after, and only after, the last word.
+
+
+;Example:
+A stream with six words: 
+:: <big><code>what,is,the;meaning,of:life.</code></big>   
+
+
+The task is to reverse the letters in every other word while leaving punctuations intact, producing:
+:: <big><code>what,si,the;gninaem,of:efil.</code></big> 
+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 &nbsp; "life" &nbsp; example given above, and also the text:
+:: <big><code>we,are;not,in,kansas;any,more.</code></big>
+<br><br>
+

Task/Odd-word-problem/ALGOL-68/odd-word-problem.alg

@@ -0,0 +1,75 @@
+# recursively reverses the current word in the input and returns the    #
+# the character that followed it                                        #
+# "ch" should contain the first letter of the word on entry and will be #
+# updated to the punctuation following the word on exit                 #
+PROC reverse word = ( REF CHAR ch )VOID:
+BEGIN
+
+    CHAR    next ch;
+
+    read( ( next ch ) );
+
+    IF ( next ch <= "Z" AND next ch >= "A" )
+    OR ( next ch <= "z" AND next ch >= "a" )
+    THEN
+        reverse word( next ch )
+    FI;
+
+    print( ( ch ) );
+
+    ch := next ch
+
+END; # reverse word #
+
+
+
+# recursively prints the current word in the input and returns the      #
+# character that followed it                                            #
+# "ch" should contain the first letter of the word on entry and will be #
+# updated to the punctuation following the word on exit                 #
+PROC normal word = ( REF CHAR ch )VOID:
+BEGIN
+
+    print( ( ch ) );
+    read ( ( ch ) );
+
+    IF ( ch <= "Z" AND ch >= "A" )
+    OR ( ch <= "z" AND ch >= "a" )
+    THEN
+        normal word( ch )
+    FI
+
+END; # normal word #
+
+
+
+# read and print words and punctuation from the input stream, reversing #
+# every second word                                                     #
+PROC reverse every other word = VOID:
+BEGIN
+
+    CHAR ch;
+
+    read( ( ch ) );
+
+    WHILE
+        ch /= "."
+    DO
+        normal word( ch );
+        IF ch /= "."
+        THEN
+            print( ( ch ) );
+            read ( ( ch ) );
+            reverse word( ch )
+        FI
+    OD;
+
+    print( ( ch ) )
+
+END; # reverse every other word #
+
+
+
+main: (
+    reverse every other word
+)

Task/Odd-word-problem/Ada/odd-word-problem.ada

@@ -0,0 +1,55 @@
+with Ada.Text_IO;
+
+procedure Odd_Word_Problem is
+
+   use Ada.Text_IO; -- Get, Put, and Look_Ahead
+
+   function Current return Character is
+      -- reads the current input character, without consuming it
+      End_Of_Line: Boolean;
+      C: Character;
+   begin
+      Look_Ahead(C, End_Of_Line);
+      if End_Of_Line then
+         raise Constraint_Error with "end of line before the terminating '.'";
+      end if;
+      return C;
+   end Current;
+
+   procedure Skip is
+      -- consumes the current input character
+      C: Character;
+   begin
+      Get(C);
+   end Skip;
+
+   function Is_Alpha(Ch: Character) return Boolean is
+   begin
+      return (Ch in  'a' .. 'z') or (Ch in 'A' .. 'Z');
+   end Is_Alpha;
+
+   procedure Odd_Word(C: Character) is
+   begin
+      if Is_Alpha(C) then
+         Skip;
+         Odd_Word(Current);
+         Put(C);
+      end if;
+   end Odd_Word;
+
+begin -- Odd_Word_Problem
+   Put(Current);
+   while Is_Alpha(Current) loop -- read an even word
+      Skip;
+      Put(Current);
+   end loop;
+   if Current /= '.' then -- read an odd word
+      Skip;
+      Odd_Word(Current);
+      Put(Current);
+      if Current /= '.' then -- read the remaining words
+         Skip;
+         Odd_Word_Problem;
+      end if;
+   end if;
+end Odd_Word_Problem;

Task/Odd-word-problem/AutoHotkey/odd-word-problem.ahk

@@ -0,0 +1,7 @@
+str := "what,is,the;meaning,of:life."
+loop, parse, str
+	if (A_LoopField ~= "[[:punct:]]")
+		res .= A_LoopField, toggle:=!toggle
+	else
+		res := toggle ? RegExReplace(res, ".*[[:punct:]]\K", A_LoopField ) : res A_LoopField
+MsgBox % res

Task/Odd-word-problem/BaCon/odd-word-problem.bacon

@@ -0,0 +1,42 @@
+OPEN "/dev/stdin" FOR DEVICE AS in
+
+FUNCTION get_odd()
+
+    LOCAL ch, letter
+
+    ch = MEMORY(1)
+    GETBYTE ch FROM in
+
+    IF NOT(REGEX(CHR$(PEEK(ch)), "[[:punct:]]")) THEN
+        letter = get_odd()
+        PRINT CHR$(PEEK(ch));
+    ELSE
+        letter = PEEK(ch)
+    END IF
+
+    FREE ch
+    RETURN letter
+
+END FUNCTION
+
+mem = MEMORY(1)
+PRINT "Enter string: ";
+
+WHILE TRUE
+
+    GETBYTE mem FROM in
+    PRINT CHR$(PEEK(mem));
+
+    IF REGEX(CHR$(PEEK(mem)), "[[:punct:]]") THEN
+        IF PEEK(mem) <> 46 THEN
+            POKE mem, get_odd()
+            PRINT CHR$(PEEK(mem));
+        END IF
+        IF PEEK(mem) = 46 THEN BREAK
+    END IF
+WEND
+
+FREE mem
+CLOSE DEVICE in
+
+PRINT

Task/Odd-word-problem/Bracmat/odd-word-problem.bracmat

@@ -0,0 +1,33 @@
+( ( odd-word
+  =   dothis doother forward backward
+    .   ( forward
+        =   ch
+          .   fil$:?ch
+            & put$!ch
+            & ( low$!ch:~<a:~>z&forward$
+              | !ch:~"."
+              )
+        )
+      & ( backward
+        =   ch
+          .   fil$:?ch
+            & (   low$!ch:~<a:~>z
+                & backward$() (put$!ch&)    { This reduces to the return value of backwards$()}
+              | '(.put$($ch)&$ch:~".")      { Macro, evaluates to a function with actual ch.  }
+              )
+        )
+      & fil$(!arg,r)
+      &   ((=forward$).(=(backward$)$))
+        : (?dothis.?doother)
+      &   whl
+        ' ( !(dothis.)
+          & (!doother.!dothis):(?dothis.?doother)
+          )
+      & (fil$(,SET,-1)|)                 { This is how a file is closed: seek the impossible. }
+  )
+& put$("what,is,the;meaning,of:life.","life.txt",NEW)
+& put$("we,are;not,in,kansas;any,more.","kansas.txt",NEW)
+& odd-word$"life.txt"
+& put$\n
+& odd-word$"kansas.txt"    { Real file, as Bracmat cannot read a single character from stdin. }
+);

Task/Odd-word-problem/C++/odd-word-problem.cpp

@@ -0,0 +1,36 @@
+#include <iostream>
+#include <cctype>
+#include <functional>
+
+using namespace std;
+
+bool odd()
+{
+  function<void ()> prev = []{};
+  while(true) {
+    int c = cin.get();
+    if (!isalpha(c)) {
+      prev();
+      cout.put(c);
+      return c != '.';
+    }
+    prev = [=] { cout.put(c); prev();  };
+  }
+}
+
+bool even()
+{
+  while(true) {
+    int c;
+    cout.put(c = cin.get());
+    if (!isalpha(c)) return c != '.';
+  }
+}
+
+
+int main()
+{
+  bool e = false;
+  while( e ? odd() : even() ) e = !e;
+  return 0;
+}

Task/Odd-word-problem/C/odd-word-problem.c

@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include <ctype.h>
+
+static int
+owp(int odd)
+{
+        int ch, ret;
+        ch = getc(stdin);
+        if (!odd) {
+                putc(ch, stdout);
+                if (ch == EOF || ch == '.')
+                        return EOF;
+                if (ispunct(ch))
+                        return 0;
+                owp(odd);
+                return 0;
+        } else {
+                if (ispunct(ch))
+                        return ch;
+                ret = owp(odd);
+                putc(ch, stdout);
+                return ret;
+        }
+}
+
+int
+main(int argc, char **argv)
+{
+        int ch = 1;
+        while ((ch = owp(!ch)) != EOF) {
+                if (ch)
+                        putc(ch, stdout);
+                if (ch == '.')
+                        break;
+        }
+        return 0;
+}

Task/Odd-word-problem/Ceylon/odd-word-problem.ceylon

@@ -0,0 +1,33 @@
+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);

Task/Odd-word-problem/Clojure/odd-word-problem-1.clj

@@ -0,0 +1,26 @@
+(defn next-char []
+  (char (.read *in*)))
+
+(defn forward []
+  (let [ch (next-char)]
+    (print ch)
+    (if (Character/isLetter ch)
+      (forward)
+      (not= ch \.))))
+
+(defn backward []
+  (let [ch (next-char)]
+    (if (Character/isLetter ch)
+      (let [result (backward)]
+        (print ch)
+        result)
+      (fn [] (print ch) (not= ch \.)))) )
+
+(defn odd-word [s]
+  (with-in-str s
+    (loop [forward? true]
+      (when (if forward?
+              (forward)
+              ((backward)))
+        (recur (not forward?)))) )
+    (println))

Task/Odd-word-problem/Clojure/odd-word-problem-2.clj

@@ -0,0 +1,6 @@
+user=> (odd-word "what,is,the;meaning,of:life.")
+what,si,the;gninaem,of:efil.
+nil
+user=> (odd-word "we,are;not,in,kansas;any,more.")
+we,era;not,ni,kansas;yna,more.
+nil

Task/Odd-word-problem/CoffeeScript/odd-word-problem-1.coffee

@@ -0,0 +1,36 @@
+isWordChar = (c) -> /^\w/.test c
+isLastChar = (c) -> c is '.'
+
+# Pass a function that returns an input character and one that outputs a
+# character. JS platforms' ideas of single-character I/O vary widely, but this
+# abstraction is adaptable to most or all.
+oddWord = (get, put) ->
+	forwardWord = ->
+		loop
+			# No magic here; buffer then immediately output.
+			c = get()
+			put(c)
+			unless isWordChar(c)
+				return not isLastChar(c)
+	
+	# NB: (->) is a CoffeeScript idiom for no-op.
+	reverseWord = (outputPending = (->)) ->
+		c = get()
+		if isWordChar(c)
+			# Continue word.
+			# Tell recursive call to output this character, then any previously
+			# pending characters, after the next word character, if any, has
+			# been output.
+			reverseWord ->
+				put(c)
+				outputPending()
+		else
+			# Word is done.
+			# Output previously pending characters, then this punctuation.
+			outputPending()
+			put(c)
+			return not isLastChar(c)
+	
+	# Alternate between forward and reverse until one or the other reports that
+	# the end-of-input mark has been reached (causing a return of false).
+	continue while forwardWord() and reverseWord()

Task/Odd-word-problem/CoffeeScript/odd-word-problem-2.coffee

@@ -0,0 +1,23 @@
+isWordChar = (c) -> /^\w/.test c
+isLastChar = (c) -> c is '.'
+
+oddWord = (get, put) ->
+	forwardWord = ->
+		loop
+			c = get()
+			put(c)
+			unless isWordChar(c)
+				return not isLastChar(c)
+	
+	reverseWord = (outputPending = (->)) ->
+		c = get()
+		if isWordChar(c)
+			reverseWord ->
+				put(c)
+				outputPending()
+		else
+			outputPending()
+			put(c)
+			return not isLastChar(c)
+	
+	continue while forwardWord() and reverseWord()

Task/Odd-word-problem/CoffeeScript/odd-word-problem-3.coffee

@@ -0,0 +1,27 @@
+# Redefine as necessary for target platform.
+println = (z) -> console.log z
+
+testData = [
+	[
+		"what,is,the;meaning,of:life."
+		"what,si,the;gninaem,of:efil."
+	]
+	[
+		"we,are;not,in,kansas;any,more."
+		"we,era;not,ni,kansas;yna,more."
+	]
+]
+
+results = for [testString, expectedResult] in testData
+	# This test machinery uses string buffers for input and output. If your JS
+	# platform sports single-character I/O, by all means, adapt to taste.
+	getCursor = 0
+	putBuffer = ""
+	get = ->
+		testString.charAt getCursor++
+	put = (c) ->
+		putBuffer += c
+	oddWord(get,put)
+	[testString, expectedResult, putBuffer, putBuffer is expectedResult]
+
+println result for result in results

Task/Odd-word-problem/Common-Lisp/odd-word-problem-1.lisp

@@ -0,0 +1,19 @@
+(defun odd-word (s)
+  (let ((stream (make-string-input-stream s)))
+    (loop for forwardp = t then (not forwardp)
+          while (if forwardp
+                    (forward stream)
+                    (funcall (backward stream)))) ))
+
+(defun forward (stream)
+  (let ((ch (read-char stream)))
+    (write-char ch)
+    (if (alpha-char-p ch)
+	(forward stream)
+        (char/= ch #\.))))
+
+(defun backward (stream)
+  (let ((ch (read-char stream)))
+    (if (alpha-char-p ch)
+        (prog1 (backward stream) (write-char ch))
+        #'(lambda () (write-char ch) (char/= ch #\.)))) )

Task/Odd-word-problem/Common-Lisp/odd-word-problem-2.lisp

@@ -0,0 +1,6 @@
+? (odd-word "what,is,the;meaning,of:life.")
+what,si,the;gninaem,of:efil.
+NIL
+? (odd-word "we,are;not,in,kansas;any,more.")
+we,era;not,ni,kansas;yna,more.
+NIL

Task/Odd-word-problem/D/odd-word-problem.d

@@ -0,0 +1,19 @@
+bool doChar(in bool odd, in void delegate() nothrow f=null) nothrow {
+    import core.stdc.stdio, std.ascii;
+
+    immutable int c = getchar;
+    if (!odd)
+        c.putchar;
+    if (c.isAlpha)
+        return doChar(odd, { c.putchar; if (f) f(); });
+    if (odd) {
+        if (f) f();
+        c.putchar;
+    }
+    return c != '.';
+}
+
+void main() {
+    bool i = true;
+    while (doChar(i = !i)) {}
+}

Task/Odd-word-problem/Delphi/odd-word-problem.delphi

@@ -0,0 +1,42 @@
+program Odd_word_problem;
+
+{$APPTYPE CONSOLE}
+
+uses
+  System.SysUtils,
+  System.Console,
+  System.Character;
+
+function doChar(isOdd: boolean; f: TProc = nil): Boolean;
+begin
+  var c: char := Console.ReadKey(True).KeyChar;
+
+  if not isOdd then
+    Write(c);
+
+  if c.IsLetter then
+    exit(doChar(isOdd,
+      procedure
+      begin
+        Write(c);
+        if assigned(f) then
+          f();
+      end));
+
+  if isOdd then
+  begin
+    if Assigned(f) then
+      f();
+    write(c);
+  end;
+
+  exit(c <> '.');
+
+end;
+
+begin
+  var i: boolean := false;
+  while doChar(i) do
+    i := not i;
+  readln;
+end.

Task/Odd-word-problem/EchoLisp/odd-word-problem-1.l

@@ -0,0 +1,30 @@
+(lib 'sequences)
+(define input-stream null)
+(define output-stream "")
+
+;;---------------------------
+;; character I/O simulation
+;; --------------------------
+(define (read-char) (next input-stream)) ;; #f if EOF
+(define (write-char c) (when c (set! output-stream (string-append output-stream c))))
+
+(define (init-streams sentence)
+	(set! input-stream (procrastinator sentence))
+	(set! output-stream ""))
+
+;;---------------------------------
+;; task , using read-char/write-char
+;;----------------------------------
+
+(define (flop) ; reverses,  and returns first non-alpha after word, or EOF
+	(define c (read-char))
+	(if (string-alphabetic? c) (begin0 (flop) (write-char c)) c))
+	
+(define (flip)
+    (define c (read-char))
+    (if (string-alphabetic? c) (begin (write-char c)  (flip)) c))
+
+(define (task sentence)
+	 (init-streams sentence)
+	 (while (and (write-char (flip)) (write-char (flop))))
+	 output-stream )

Task/Odd-word-problem/EchoLisp/odd-word-problem-2.l

@@ -0,0 +1,5 @@
+(task "what,is,the;meaning,of:life.")
+    → "what,si,the;gninaem,of:efil."
+; check diacritical
+(task "Longtemps,je me suis couché,héhé,hôhô,de bonne heure.")
+    → "Longtemps,ej me sius couché,éhéh,hôhô,ed bonne erueh."

Task/Odd-word-problem/Elixir/odd-word-problem.elixir

@@ -0,0 +1,26 @@
+defmodule Odd_word do
+  def handle(s, false, i, o) when ((s >= "a" and s <= "z") or (s >= "A" and s <= "Z")) do
+    o.(s)
+    handle(i.(), false, i, o)
+  end
+  def handle(s, t, i, o) when ((s >= "a" and s <= "z") or (s >= "A" and s <= "Z")) do
+    d = handle(i.(), :rec, i, o)
+    o.(s)
+    if t == true, do: handle(d, t, i, o), else: d
+  end
+  def handle(s, :rec, _, _), do: s
+  def handle(?., _, _, o), do: o.(?.); :done
+  def handle(:eof, _, _, _), do: :done
+  def handle(s, t, i, o) do
+    o.(s)
+    handle(i.(), not t, i, o)
+  end
+
+  def main do
+    i = fn() -> IO.getn("") end
+    o = fn(s) -> IO.write(s) end
+    handle(i.(), false, i, o)
+  end
+end
+
+Odd_word.main

Task/Odd-word-problem/Erlang/odd-word-problem.erl

@@ -0,0 +1,16 @@
+handle(S, false, I, O) when (((S >= $a) and (S =< $z)) or ((S >= $A) and (S =< $Z))) ->
+    O(S),
+    handle(I(), false, I, O);
+handle(S, T, I, O) when (((S >= $a) and (S =< $z)) or ((S >= $A) and (S =< $Z))) ->
+    D = handle(I(), rec, I, O),
+    O(S),
+    case T of true -> handle(D, T, I, O); _ -> D end;
+handle(S, rec, _, _) -> S;
+handle($., _, _, O) -> O($.), done;
+handle(eof, _, _, _) -> done;
+handle(S, T, I, O) -> O(S), handle(I(), not T, I, O).
+
+main([]) ->
+    I = fun() -> hd(io:get_chars([], 1)) end,
+    O = fun(S) -> io:put_chars([S]) end,
+    handle(I(), false, I, O).

Task/Odd-word-problem/F-Sharp/odd-word-problem.fs

@@ -0,0 +1,34 @@
+open System
+open System.Text.RegularExpressions
+
+let mutable Inp = Console.In
+
+let Out c = printf "%c" c; (if c = '.' then Environment.Exit 0)
+
+let In() = Inp.Read() |> Convert.ToChar
+
+let (|WordCharacter|OtherCharacter|) c =
+    if Regex.IsMatch(c.ToString(),"[a-zA-Z]") then
+        WordCharacter
+    else
+        OtherCharacter
+
+let rec forward () =
+    let c = In()
+    let rec backward () : char =
+        let c = In()
+        match c with
+        | WordCharacter ->
+            let s = backward() in Out c; s
+        | OtherCharacter -> c
+    Out c
+    match c with
+    | WordCharacter -> forward()
+    | OtherCharacter -> backward()
+
+[<EntryPoint>]
+let main argv =
+    if argv.Length > 0 then Inp <- new System.IO.StringReader(argv.[0])
+    let rec loop () = forward() |> Out;  loop()
+    loop()
+    0

Task/Odd-word-problem/FALSE/odd-word-problem.false

@@ -0,0 +1,4 @@
+[$$$$'.=\',=|\';=|\':=|~[^s;!\,]?]s:              {recursive reading}
+[s;!$'.=~[,^f;!]?]r:                              {reverse words}
+[[$$$$'.=\',=|\';=|\':=|~][,^]#$'.=~[,^r;!]?]f:   {forward words}
+^f;!,                                             {start}

Task/Odd-word-problem/Factor/odd-word-problem.factor

@@ -0,0 +1,62 @@
+USING: continuations kernel io io.streams.string locals unicode.categories ;
+IN: rosetta.odd-word
+
+<PRIVATE
+! Save current continuation.
+: savecc ( -- continuation/f )
+    [ ] callcc1 ; inline
+
+! Jump back to continuation, where savecc will return f.
+: jump-back ( continuation -- )
+    f swap continue-with ; inline
+PRIVATE>
+
+:: read-odd-word ( -- )
+    f :> first-continuation!
+    f :> last-continuation!
+    f :> reverse!
+    ! Read characters. Loop until end of stream.
+    [ read1 dup ] [
+        dup Letter? [
+            ! This character is a letter.
+            reverse [
+                ! Odd word: Write letters in reverse order.
+                last-continuation savecc dup [
+                    last-continuation!
+                    2drop       ! Drop letter and previous continuation.
+                ] [
+                    ! After jump: print letters in reverse.
+                    drop                ! Drop f.
+                    swap write1         ! Write letter.
+                    jump-back           ! Follow chain of continuations.
+                ] if
+            ] [
+                ! Even word: Write letters immediately.
+                write1
+            ] if
+        ] [
+            ! This character is punctuation.
+            reverse [
+                ! End odd word. Fix trampoline, follow chain of continuations
+                ! (to print letters in reverse), then bounce off trampoline.
+                savecc dup [
+                    first-continuation!
+                    last-continuation jump-back
+                ] [ drop ] if
+                write1                  ! Write punctuation.
+                f reverse!              ! Begin even word.
+            ] [
+                write1                  ! Write punctuation.
+                t reverse!              ! Begin odd word.
+                ! Create trampoline to bounce to (future) first-continuation.
+                savecc dup [
+                    last-continuation!
+                ] [ drop first-continuation jump-back ] if
+            ] if
+        ] if
+    ] while
+    ! Drop f from read1. Then print a cosmetic newline.
+    drop nl ;
+
+: odd-word ( string -- )
+    [ read-odd-word ] with-string-reader ;

Task/Odd-word-problem/Forth/odd-word-problem.fth

@@ -0,0 +1,6 @@
+: word?  dup [char] . <> over bl <> and ;
+: ?quit  dup [char] . = if emit quit then ;
+: eatbl  begin dup bl = while drop key repeat ?quit ;
+: even   begin word? while emit key repeat ;
+: odd    word? if key recurse swap emit then ;
+: main   cr key eatbl begin even eatbl space odd eatbl space again ;

Task/Odd-word-problem/Fortran/odd-word-problem.f

@@ -0,0 +1,41 @@
+      MODULE ELUDOM	!Uses the call stack for auxiliary storage.
+       INTEGER MSG,INF	!I/O unit numbers.
+       LOGICAL DEFER	!To stumble, or not to stumble.
+       CONTAINS
+        CHARACTER*1 RECURSIVE FUNCTION GET(IN)	!Returns one character, going forwards.
+         INTEGER IN	!The input file.
+         CHARACTER*1 C	!The single character to be read therefrom.
+          READ (IN,1,ADVANCE="NO",EOR=3,END=4) C	!Thus. Not advancing to the next record.
+    1     FORMAT (A1,$)	!For output, no advance to the next line either.
+    2     IF (("A"<=C .AND. C<="Z").OR.("a"<=C .AND. C<="z")) THEN	!Unsafe for EBCDIC.
+            IF (DEFER) THEN	!Are we to reverse the current text?
+              GET = GET(IN)	!Yes. Go for the next letter.
+              WRITE (MSG,1) C	!And now, backing out, reveal the letter at this level.
+              RETURN		!Retreat another level.
+            END IF		!Thus passing back the ending non-letter that was encountered.
+           ELSE		!And if we've encountered a non-letter,
+            DEFER = .NOT. DEFER	!Then our backwardness flips.
+          END IF	!Enough inspection of C.
+    3     GET = C	!Pass it back.
+          RETURN	!And we're done.
+    4     GET = CHAR(0)	!Reserving this for end-of-file.
+        END FUNCTION GET!That was strange.
+      END MODULE ELUDOM	!But as per the specification.
+
+      PROGRAM CONFUSED	!Just so.
+      USE ELUDOM	!Forwards? Backwards?
+      CHARACTER*1 C	!A scratchpad for multiple inspections.
+      MSG = 6	!Standard output.
+      INF = 10	!This will do.
+      OPEN (INF,NAME = "Confused.txt",STATUS="OLD",ACTION="READ")	!Go for the file.
+
+Chew through the input. A full stop marks the end.
+   10 DEFER = .FALSE.	!Start off going forwards.
+   11 C = GET(INF)		!Get some character from file INF.
+      IF (ICHAR(C).LE.0) STOP		!Perhaps end-of-file is reported.
+      IF (C.NE." ") WRITE (MSG,12) C	!Otherwise, write it. A blank for end-of-record.
+   12 FORMAT (A1,$)			!Obviously, not finishing the line each time.
+      IF (C.NE.".") GO TO 11	!And if not a full stop, do it again.
+      WRITE (MSG,"('')")	!End the line of output.
+      GO TO 10		!And have another go.
+      END	!That was confusing.

Task/Odd-word-problem/FreeBASIC/odd-word-problem.basic

@@ -0,0 +1,31 @@
+Dim Shared As Integer n1 = 1
+
+Function reverseString(texto As String) As String
+    Dim As Integer x, lt = Len(texto)
+    For x = 0 To lt Shr 1 - 1
+        Swap texto[x], texto[lt - x - 1]
+    Next x
+    Return texto
+End Function
+
+Sub process(texto As String)
+    Dim As Integer c = 0, n2
+    Dim As String tmptexto
+
+    Print "Input stream:  "; texto
+    Print "Output stream: ";
+    Do
+        n2 = Instr(texto, Any ",;:.")
+        tmptexto = Mid(texto, n1, n2-1)
+        Print Iif(c Mod 2 = 0, tmptexto, reverseString(tmptexto)); Mid(texto, n2, 1);
+        If Mid(texto, n2, 1) = "." Then Exit Do
+        texto = Mid(texto, n2+1, Len(texto))
+        c += 1
+    Loop
+    Print !"\n"
+End Sub
+
+process("what,is,the;meaning,of:life.")
+process("we,are;not,in,kansas;any,more.")
+
+Sleep

Task/Odd-word-problem/Go/odd-word-problem-1.go

@@ -0,0 +1,52 @@
+package main
+
+import (
+    "bytes"
+    "fmt"
+    "io"
+    "os"
+    "unicode"
+)
+
+func main() {
+    owp(os.Stdout, bytes.NewBufferString("what,is,the;meaning,of:life."))
+    fmt.Println()
+    owp(os.Stdout, bytes.NewBufferString("we,are;not,in,kansas;any,more."))
+    fmt.Println()
+}
+
+func owp(dst io.Writer, src io.Reader) {
+    byte_in := func () byte {
+        bs := make([]byte, 1)
+        src.Read(bs)
+        return bs[0]
+    }
+    byte_out := func (b byte) { dst.Write([]byte{b}) }
+    var odd func() byte
+    odd = func() byte {
+        s := byte_in()
+        if unicode.IsPunct(rune(s)) {
+            return s
+        }
+        b := odd()
+        byte_out(s)
+        return b
+    }
+    for {
+        for {
+            b := byte_in()
+            byte_out(b)
+            if b == '.' {
+                return
+            }
+            if unicode.IsPunct(rune(b)) {
+                break
+            }
+        }
+        b := odd()
+        byte_out(b)
+        if b == '.' {
+            return
+        }
+    }
+}

Task/Odd-word-problem/Go/odd-word-problem-2.go

@@ -0,0 +1,52 @@
+package main
+
+import (
+    "bytes"
+    "fmt"
+    "io"
+    "os"
+    "unicode"
+)
+
+func main() {
+    owp(os.Stdout, bytes.NewBufferString("what,is,the;meaning,of:life."))
+    fmt.Println()
+    owp(os.Stdout, bytes.NewBufferString("we,are;not,in,kansas;any,more."))
+    fmt.Println()
+}
+
+func owp(dst io.Writer, src io.Reader) {
+    byte_in := func () byte {
+        bs := make([]byte, 1)
+        src.Read(bs)
+        return bs[0]
+    }
+    byte_out := func (b byte) { dst.Write([]byte{b}) }
+    odd := func() byte {
+        for {
+            b := byte_in()
+            if unicode.IsPunct(int(b)) {
+                return b
+            }
+            defer byte_out(b)
+        }
+        panic("impossible")
+    }
+    for {
+        for {
+            b := byte_in()
+            byte_out(b)
+            if b == '.' {
+                return
+            }
+            if unicode.IsPunct(rune(b)) {
+                break
+            }
+        }
+        b := odd()
+        byte_out(b)
+        if b == '.' {
+            return
+        }
+    }
+}

Task/Odd-word-problem/Go/odd-word-problem-3.go

@@ -0,0 +1,89 @@
+package main
+
+import (
+    "bytes"
+    "fmt"
+    "io"
+    "os"
+    "unicode"
+)
+
+func main() {
+    owp(os.Stdout, bytes.NewBufferString("what,is,the;meaning,of:life."))
+    fmt.Println()
+    owp(os.Stdout, bytes.NewBufferString("we,are;not,in,kansas;any,more."))
+    fmt.Println()
+}
+
+type Coroutine struct {
+    out <-chan Coroutine
+    in chan<- byte
+}
+
+func owp(dst io.Writer, src io.Reader) {
+    byte_in := func () (byte, error) {
+        bs := make([]byte, 1)
+        _, err := src.Read(bs)
+        return bs[0], err
+    }
+    byte_out := func (b byte) { dst.Write([]byte{b}) }
+
+    var f, r Coroutine
+
+    f = func () Coroutine {
+        out := make(chan Coroutine)
+	in := make(chan byte)
+        var fwd func (byte) byte
+        fwd = func (c byte) (z byte) {
+            if unicode.IsLetter(rune(c)) {
+                byte_out(c)
+                out <- f
+                z = fwd(<- in)
+            } else {
+                z = c
+            }
+            return
+        }
+        go func () {
+            for {
+                x, ok := <- in
+                if !ok { break }
+                byte_out(fwd(x))
+                out <- r
+            }
+        } ()
+        return Coroutine{ out, in }
+    } ()
+    r = func () Coroutine {
+        out := make(chan Coroutine)
+	in := make(chan byte)
+        var rev func (byte) byte
+        rev = func (c byte) (z byte) {
+            if unicode.IsLetter(rune(c)) {
+                out <- r
+                z = rev(<- in)
+                byte_out(c)
+            } else {
+                z = c
+            }
+            return
+        }
+        go func () {
+            for {
+                x, ok := <- in
+                if !ok { break }
+                byte_out(rev(x))
+                out <- f
+            }
+        } ()
+        return Coroutine{ out, in }
+    } ()
+
+    for coro := f; ; coro = <- coro.out {
+        c, err := byte_in()
+        if err != nil { break }
+        coro.in <- c
+    }
+    close(f.in)
+    close(r.in)
+}

Task/Odd-word-problem/Haskell/odd-word-problem-1.hs

@@ -0,0 +1,21 @@
+import System.IO
+       (BufferMode(..), getContents, hSetBuffering, stdin, stdout)
+import Data.Char (isAlpha)
+
+split :: String -> (String, String)
+split = span isAlpha
+
+parse :: String -> String
+parse [] = []
+parse l =
+  let (a, w) = split l
+      (b, x) = splitAt 1 w
+      (c, y) = split x
+      (d, z) = splitAt 1 y
+  in a <> b <> reverse c <> d <> parse z
+
+main :: IO ()
+main =
+  hSetBuffering stdin NoBuffering >> hSetBuffering stdout NoBuffering >> getContents >>=
+  putStr . takeWhile (/= '.') . parse >>
+  putStrLn "."

Task/Odd-word-problem/Haskell/odd-word-problem-2.hs

@@ -0,0 +1,31 @@
+isAlpha :: Char -> Bool
+isAlpha = flip elem $ ['a'..'z'] ++ ['A'..'Z']
+
+parse :: IO ()
+parse = do
+  x <- getChar
+  putChar x
+  case () of
+   _ | x == '.'  -> return ()
+     | isAlpha x -> parse
+     | otherwise -> do
+         c <- revParse
+         putChar c
+         if c == '.'
+           then return ()
+           else parse
+
+revParse :: IO Char
+revParse = do
+  x <- getChar
+  case () of
+   _ | x == '.'  -> return x
+     | isAlpha x -> do
+         c <- revParse
+         putChar x
+         return c
+     | otherwise -> return x
+
+main :: IO ()
+main = hSetBuffering stdin NoBuffering >> hSetBuffering stdout NoBuffering >>
+       parse >> putStrLn ""

Task/Odd-word-problem/Icon/odd-word-problem-1.icon

@@ -0,0 +1,22 @@
+procedure main()
+every OddWord(!["what,is,the;meaning,of:life.",
+                "we,are;not,in,kansas;any,more."])
+end
+
+procedure OddWord(stream)                     #: wrapper for demonstration
+   write("Input stream: ",stream)
+   writes("Output stream: ") & eWord(create !stream,'.,;:') & write()
+end
+
+procedure eWord(stream,marks)                 #: handle even words
+   repeat {
+      repeat
+         writes(@stream) ? if ="." then return else if any(marks) then break
+      if writes(oWord(stream,marks)) == '.' then return
+      }
+end
+
+procedure oWord(stream,marks)                 #: handle odd words (reverse)
+   if any(marks,s := @stream) then return s
+   return 1(oWord(stream,marks), writes(s))
+end

Task/Odd-word-problem/Icon/odd-word-problem-2.icon

@@ -0,0 +1,10 @@
+procedure main(A)
+    repeat (while writes((any(&letters, c := reads(&input,1)),c))) |
+           (writes(c) ~== "." ~== writes(rWord())) | break write()
+end
+
+procedure rWord(c)
+    c1 := rWord((any(&letters, c1 := reads(&input,1)),c1))
+    writes(\c)
+    return c1
+end

Task/Odd-word-problem/J/odd-word-problem-1.j

@@ -0,0 +1,26 @@
+putch=: 4 :0                 NB. coroutine verb
+  outch y
+  return x
+)
+
+isletter=: toupper ~: tolower
+
+do_char=: 3 :0                 NB. coroutine verb
+  ch=. getch''
+  if. isletter ch do.
+    if. odd do.
+      putch&ch yield do_char '' return.
+    end.
+  else.
+    odd=: -. odd
+  end.
+  return ch
+)
+
+evenodd=: 3 :0
+  clear_outstream begin_instream y
+  odd=: 0
+  whilst. '.'~:char do.
+    outch char=. do_char coroutine ''
+  end.
+)

Task/Odd-word-problem/J/odd-word-problem-2.j

@@ -0,0 +1,4 @@
+   evenodd 'what,is,the;meaning,of:life.'
+what,si,the;gninaem,of:efil.
+   evenodd 'we,are;not,in,kansas;any,more.'
+we,era;not,ni,kansas;yna,more.

Task/Odd-word-problem/Java/odd-word-problem.java

@@ -0,0 +1,57 @@
+public class OddWord {
+    interface CharHandler {
+	CharHandler handle(char c) throws Exception;
+    }
+    final CharHandler fwd = new CharHandler() {
+	public CharHandler handle(char c) {
+	    System.out.print(c);
+	    return (Character.isLetter(c) ? fwd : rev);
+	}
+    };
+    class Reverser extends Thread implements CharHandler {
+	Reverser() {
+	    setDaemon(true);
+	    start();
+	}
+	private Character ch; // For inter-thread comms
+	private char recur() throws Exception {
+	    notify();
+	    while (ch == null) wait();
+	    char c = ch, ret = c;
+	    ch = null;
+	    if (Character.isLetter(c)) {
+		ret = recur();
+		System.out.print(c);
+	    }
+	    return ret;
+	}
+	public synchronized void run() {
+	    try {
+		while (true) {
+		    System.out.print(recur());
+		    notify();
+		}
+	    } catch (Exception e) {}
+	}
+	public synchronized CharHandler handle(char c) throws Exception {
+	    while (ch != null) wait();
+	    ch = c;
+	    notify();
+	    while (ch != null) wait();
+	    return (Character.isLetter(c) ? rev : fwd);
+	}
+    }
+    final CharHandler rev = new Reverser();
+
+    public void loop() throws Exception {
+	CharHandler handler = fwd;
+	int c;
+	while ((c = System.in.read()) >= 0) {
+	    handler = handler.handle((char) c);
+	}
+    }
+
+    public static void main(String[] args) throws Exception {
+	new OddWord().loop();
+    }
+}

Task/Odd-word-problem/Julia/odd-word-problem.julia

@@ -0,0 +1,33 @@
+# io = readstring(STDIN)
+io = "what,is,the;meaning,of:life."
+i  = 0
+
+readbyte!() = io[global i += 1]
+writebyte(c) = print(Char(c))
+
+function odd(prev::Function = () -> false)
+    a = readbyte!()
+    if !isalpha(a)
+        prev()
+        writebyte(a)
+        return a != '.'
+    end
+
+    # delay action until later, in the shape of a closure
+    clos() = (writebyte(a); prev())
+
+    return odd(clos)
+end
+
+function even()
+    while true
+        c = readbyte!()
+        writebyte(c)
+        if !isalpha(c) return c != '.' end
+    end
+end
+
+evn = false
+while evn ? odd() : even()
+    evn = !evn
+end

Task/Odd-word-problem/Kotlin/odd-word-problem.kotlin

@@ -0,0 +1,31 @@
+// version 1.1.3
+
+typealias Func = () -> Unit
+
+fun doChar(odd: Boolean, f: Func?): Boolean {
+    val c = System.`in`.read()
+    if (c == -1) return false // end of stream reached
+    val ch = c.toChar()
+
+    fun writeOut() {
+        print(ch)
+        if (f != null) f()
+    }
+
+    if (!odd) print(ch)
+    if (ch.isLetter()) return doChar(odd, ::writeOut)
+    if (odd) {
+        if (f != null) f()
+        print(ch)
+    }
+    return ch != '.'
+}
+
+fun main(args: Array<String>) {
+    repeat(2) {
+        var b = true
+        while (doChar(!b, null)) b = !b
+        System.`in`.read() // remove '\n' from buffer
+        println("\n")
+    }
+}

Task/Odd-word-problem/Lasso/odd-word-problem.lasso

@@ -0,0 +1,54 @@
+define odd_word_processor(str::string) => {
+	local(
+		isodd 		= false,
+		pos 		= 1,
+		invpos	 	= 1,
+		lastpos		= 1
+	)
+	while(#str->get(#pos) != '.' && #pos <= #str->size) => {
+		if(not #str->isAlpha(#pos)) => {
+			not #isodd ? #isodd = true | #isodd = false	
+		}
+		if(#isodd) => {
+			#lastpos = 1
+			#invpos = 1
+			while(#str->isAlpha(#pos+#lastpos) && #pos+#lastpos <= #str->size) => {
+				#lastpos++
+			}
+			'odd lastpos: '+#lastpos+'\r'
+			local(maxpos = #pos+#lastpos-1)
+			while(#invpos < (#lastpos+1)/2) => {
+				local(i,o,ipos,opos)
+				#ipos = #pos+#invpos
+				#opos = #pos+(#lastpos-#invpos)
+				#i = #str->get(#ipos)
+				#o = #str->get(#opos)
+				
+				//'switching '+#i+' and '+#o+'\r'
+				
+				//'insert '+#o+' at '+(#ipos)+'\r'
+				#str = string_insert(#str,-position=(#ipos),-text=#o)
+	
+				//'remove redundant pos '+(#ipos+1)+'\r'
+				#str->remove(#ipos+1,1)
+				
+				//'insert '+#i+' at '+(#opos)+'\r'
+				#str = string_insert(#str,-position=(#opos),-text=#i)
+	
+				//'remove redundant pos '+(#opos+1)+'\r'
+				#str->remove(#opos+1,1)
+				
+				#invpos++
+			}
+			#pos += #lastpos - 1
+		}
+		//#str->get(#pos) + #isodd + '\r'
+		#pos += 1
+	}
+	return #str
+}
+
+'orig:\rwhat,is,the;meaning,of:life.\r'
+'new:\r'
+odd_word_processor('what,is,the;meaning,of:life.')
+'\rShould have:\rwhat,si,the;gninaem,of:efil.'

Task/Odd-word-problem/Lua/odd-word-problem.lua

@@ -0,0 +1,23 @@
+function reverse()
+  local ch = io.read(1)
+  if ch:find("%w") then
+    local rc = reverse()
+    io.write(ch)
+    return rc
+  end
+  return ch
+end
+
+function forward()
+  ch = io.read(1)
+  io.write(ch)
+  if ch == "." then return false end
+  if not ch:find("%w") then
+    ch = reverse()
+    if ch then io.write(ch) end
+    if ch == "." then return false end
+  end
+  return true
+end
+
+while forward() do end

Task/Odd-word-problem/M2000-Interpreter/odd-word-problem-1.m2000

@@ -0,0 +1,87 @@
+Module Checkit {
+       global out$
+       document out$
+      Function PrepareStream$ (buf$) {
+            \\ get a temporary file
+            if buf$="" then {
+                  class ref {
+                         f
+                  class:
+                        module ref (.f) { }
+                  }
+                  \\ make f closure by reference
+                  m->ref(false)
+                  =lambda$  m->{
+                        if m=>f then exit
+                        r$=Key$
+                        m=>f=r$="."
+                        =r$
+                  }
+                  \\ exit function
+                  break
+            }
+            name$=tempname$
+            \\ we use Ansi type files
+            Open name$ for output as F
+                  Print #F, buf$;
+            Close #F
+            Open name$ for input as #f
+            class ref {
+                   f
+            class:
+                  module ref (.f) { }
+            }
+            \\ make f closure by reference
+            m->ref(f)
+            =lambda$ m -> {
+                  if m=>f=-1000 then exit
+                  def r$
+                  if not eof(#m=>f) then  r$=Input$(#m=>f,2)
+                  =r$
+                  if r$="" or r$="." then close #m=>f : m=>f=-1000
+            }
+      }
+      Module Odd(c$) {
+            one$=""
+            Module MyEven(c$, &last$) {
+                 one$=If$(last$=""->c$(), last$)
+                 if one$="" then exit
+                 if not one$ ~"[a-zA-Z]" Then last$=one$: exit
+                 \\ print before
+                 Print one$;
+                 out$<=one$
+                 Call MyEven, c$, &last$
+            }
+            Module MyOdd(c$, &last$) {
+                 one$=If$(last$=""->c$(), last$)
+                 if one$="" then exit
+                 if not one$ ~"[a-zA-Z]" Then last$=one$: exit
+                 Call MyOdd, c$, &last$
+                 \\ print after
+                 Print one$;
+                  out$<=one$
+            }
+            Do {
+                  one$=""
+                  Call MyEven, c$, &one$
+                  if one$="" then exit
+                  Print one$;
+                  out$<=one$
+                  one$=""
+                  Call MyOdd, c$, &one$
+                  if one$="" then exit
+                  Print one$;
+                  out$<=one$
+            }   Always
+            Print
+            out$<={
+            }
+      }
+      \\ Feeding keyboard
+      keyboard "what,is,the;meaning,of:life."
+      Odd PrepareStream$("")
+      \\ Use a file for input
+      Odd PrepareStream$("we,are;not,in,kansas;any,more.")
+      clipboard out$
+}
+Checkit

Task/Odd-word-problem/M2000-Interpreter/odd-word-problem-2.m2000

@@ -0,0 +1,22 @@
+Module OddWord {
+      k$=lambda$->""
+      state=false
+      odd=True
+      do {
+            a$=key$
+            if a$ ~"[a-zA-Z]" then {
+                  If state Else state~ : odd~
+                  if state and odd then k$=lambda$ k$, a$->a$+k$() : Continue
+                  Print a$;
+            } Else {
+                  If state Then state~
+                  if odd then Print k$(); : k$=lambda$->""
+                  Print a$;
+            }
+      } until a$="."
+      Print
+}
+keyboard "what,is,the;meaning,of:life."
+OddWord
+Keyboard "we,are;not,in,kansas;any,more."
+OddWord

Task/Odd-word-problem/Nim/odd-word-problem-1.nim

@@ -0,0 +1,30 @@
+import unicode
+
+type Proc = proc(): bool {.closure.}
+
+var nothing: Proc = proc(): bool {.closure.} = false
+
+proc odd(prev = nothing): bool =
+  let a = stdin.readChar()
+  if not isAlpha(Rune(ord(a))):
+    discard prev()
+    stdout.write(a)
+    return a != '.'
+
+  # delay action until later, in the shape of a closure
+  proc clos(): bool =
+    stdout.write(a)
+    prev()
+
+  return odd(clos)
+
+proc even(): bool =
+  while true:
+    let c = stdin.readChar()
+    stdout.write(c)
+    if not isAlpha(Rune(ord(c))):
+      return c != '.'
+
+var e = false
+while (if e: odd() else: even()):
+  e = not e

Task/Odd-word-problem/Nim/odd-word-problem-2.nim

@@ -0,0 +1,24 @@
+import strutils
+
+proc reverseWord(ch: var char) =
+  var nextch = stdin.readChar()
+  if nextch.isAlphaAscii():
+    reverseWord(nextch)
+  stdout.write(ch)
+  ch = nextch
+
+proc normalWord(ch: var char) =
+  stdout.write(ch)
+  ch = stdin.readChar()
+  if ch.isAlphaAscii():
+    normalWord(ch)
+
+var ch = stdin.readChar()
+
+while ch != '.':
+  normalWord(ch)
+  if ch != '.':
+    stdout.write(ch)
+    ch = stdin.readChar()
+    reverseWord(ch)
+stdout.write(ch)

Task/Odd-word-problem/OCaml/odd-word-problem.ocaml

@@ -0,0 +1,25 @@
+let is_alpha c =
+  c >= 'a' && c <= 'z' ||
+  c >= 'A' && c <= 'Z'
+
+let rec odd () =
+  let c = input_char stdin in
+  if is_alpha c
+  then (let e = odd () in print_char c; e)
+  else (c)
+
+let rec even () =
+  let c = input_char stdin in
+  if is_alpha c
+  then (print_char c; even ())
+  else print_char c
+
+let rev_odd_words () =
+  while true do
+    even ();
+    print_char (odd ())
+  done
+
+let () =
+  try rev_odd_words ()
+  with End_of_file -> ()

Task/Odd-word-problem/Ol/odd-word-problem.ol

@@ -0,0 +1,31 @@
+(define (odd_word_problem words)
+   (letrec ((odd (lambda (s out)
+               (let loop ((s s) (l '()))
+                  (cond
+                     ((null? s)
+                        out)
+                     ((pair? s)
+                        (if (<= #\a (car s) #\z)
+                           (loop (cdr s) (cons (car s) l))
+                           (even (cdr s) (cons (cons (reverse l) (car s)) out))))
+                     (else
+                        (loop (s) l))))))
+            (even (lambda (s out)
+               (let loop ((s s) (l '()))
+                  (cond
+                     ((null? s)
+                        out)
+                     ((pair? s)
+                        (if (<= #\a (car s) #\z)
+                           (loop (cdr s) (cons (car s) l))
+                           (odd (cdr s) (cons (cons l (car s)) out))))
+                     (else
+                        (loop (s) l)))))))
+      (for-each (lambda (p)
+                  (display (runes->string (car p)))
+                  (display (string (cdr p))))
+         (reverse
+            (odd (str-iter words) '()))))
+      (print))
+(odd_word_problem "what,is,the;meaning,of:life.")
+(odd_word_problem "we,are;not,in,kansas;any,more.")

Task/Odd-word-problem/PHP/odd-word-problem.php

@@ -0,0 +1,27 @@
+$odd = function ($prev) use ( &$odd ) {
+	$a = fgetc(STDIN);
+	if (!ctype_alpha($a)) {
+		$prev();
+		fwrite(STDOUT, $a);
+		return $a != '.';
+	}
+	$clos = function () use ($a , $prev) {
+		fwrite(STDOUT, $a);
+		$prev();
+	};
+	return $odd($clos);
+};
+$even = function () {
+	while (true) {
+		$c = fgetc(STDIN);
+		fwrite(STDOUT, $c);
+		if (!ctype_alpha($c)) {
+			return $c != ".";
+		}
+	}
+};
+$prev = function(){};
+$e = false;
+while ($e ? $odd($prev) : $even()) {
+	$e = !$e;
+}

Task/Odd-word-problem/PL-I/odd-word-problem.pli

@@ -0,0 +1,25 @@
+test: procedure options (main);  /* 2 August 2014 */
+   declare (ch, ech) character (1);
+   declare odd file;
+
+get_word: procedure recursive;
+   declare ch character (1);
+
+   get file (odd) edit (ch) (a(1));
+   if index('abcdefghijklmnopqrstuvwxyz', ch) > 0 then call get_word;
+   if index('abcdefghijklmnopqrstuvwxyz', ch) > 0 then
+      put edit (ch) (a);
+   else ech = ch;
+end get_word;
+
+   open file (odd) input title ('/ODDWORD.DAT,TYPE(text),recsize(100)');
+   do forever;
+      do  until (index('abcdefghijklmnopqrstuvwxyz', ch) = 0 );
+         get file (odd) edit (ch) (a(1)); put edit (ch) (a);
+      end;
+      if ch = '.' then leave;
+      call get_word;
+      put edit (ech) (a);
+      if ech = '.' then leave;
+   end;
+end test;

Task/Odd-word-problem/Perl/odd-word-problem-1.pl

@@ -0,0 +1,20 @@
+sub r
+{
+	my ($f, $c) = @_;
+	return sub { print $c; $f->(); };
+}
+
+$r = sub {};
+
+while (read STDIN, $_, 1) {
+	$w = /^[a-zA-Z]$/;
+	$n++ if ($w && !$l);
+	$l = $w;
+	if ($n & 1 || !$w) {
+		$r->(); $r = sub{};
+		print;
+	} else {
+		$r = r($r, $_);
+	}
+}
+$r->();

Task/Odd-word-problem/Perl/odd-word-problem-2.pl

@@ -0,0 +1,26 @@
+sub rev
+{
+	my $c;
+	read STDIN, $c, 1;
+	if ($c =~ /^[a-zA-Z]$/) {
+		my $r = rev();
+		print $c;
+		return $r;
+	} else {
+		return $c;
+	}
+}
+
+while (read STDIN, $_, 1) {
+	$w = /^[a-zA-Z]$/;
+	$n++ if ($w && !$l);
+	$l = $w;
+	if ($n & 1) {
+		print;
+	} else {
+		my $r = rev();
+		print $_;
+		print $r;
+		$n = 0; $l = 0;
+	}
+}

Task/Odd-word-problem/Perl/odd-word-problem-3.pl

@@ -0,0 +1,24 @@
+$|=1;
+
+while (read STDIN, $_, 1) {
+	$w = /^[a-zA-Z]$/;
+	$n++ if ($w && !$l);
+	$l = $w;
+	if ($n & 1 || !$w) {
+		close W; while(wait()!=-1){}
+		print;
+	} else {
+		open W0, ">&", \*W;
+		close W;
+		pipe R,W;
+		if (!fork()) {
+			close W;
+			<R>;
+			print $_;
+			close W0;
+			exit;
+		}
+		close W0;
+		close R;
+	}
+}

Task/Odd-word-problem/Phix/odd-word-problem.phix

@@ -0,0 +1,36 @@
+(phixonline)-->
+ <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
+ <span style="color: #004080;">string</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"what,is,the;meaning,of:life."</span>
+ <span style="color: #000080;font-style:italic;">--string s = "we,are;not,in,kansas;any,more."</span>
+ <span style="color: #004080;">integer</span> <span style="color: #000000;">i</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
+
+ <span style="color: #008080;">function</span> <span style="color: #000000;">getchar</span><span style="color: #0000FF;">()</span>
+     <span style="color: #000000;">i</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
+     <span style="color: #008080;">return</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+
+ <span style="color: #008080;">function</span> <span style="color: #000000;">wrod</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">rev</span><span style="color: #0000FF;">)</span>
+     <span style="color: #004080;">integer</span> <span style="color: #000000;">ch</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">getchar</span><span style="color: #0000FF;">(),</span> <span style="color: #000000;">nch</span>
+ <span style="color: #000080;font-style:italic;">--  integer ch = getc(0), nch</span>
+     <span style="color: #008080;">if</span> <span style="color: #008080;">not</span> <span style="color: #7060A8;">find</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ch</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" .,:;!?"</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
+         <span style="color: #008080;">if</span> <span style="color: #000000;">rev</span> <span style="color: #008080;">then</span>
+             <span style="color: #000000;">nch</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">wrod</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rev</span><span style="color: #0000FF;">)</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+         <span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">ch</span><span style="color: #0000FF;">)</span>
+         <span style="color: #008080;">if</span> <span style="color: #008080;">not</span> <span style="color: #000000;">rev</span> <span style="color: #008080;">then</span>
+             <span style="color: #000000;">nch</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">wrod</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rev</span><span style="color: #0000FF;">)</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+         <span style="color: #000000;">ch</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">nch</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #008080;">return</span> <span style="color: #000000;">ch</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+
+ <span style="color: #000080;font-style:italic;">--puts(1,"Enter words separated by a single punctuation mark (i.e. !?,.;:) and ending with .\n")</span>
+ <span style="color: #004080;">integer</span> <span style="color: #000000;">rev</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
+ <span style="color: #008080;">while</span> <span style="color: #000000;">1</span> <span style="color: #008080;">do</span>
+     <span style="color: #004080;">integer</span> <span style="color: #000000;">ch</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">wrod</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rev</span><span style="color: #0000FF;">)</span>
+     <span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">ch</span><span style="color: #0000FF;">)</span>
+     <span style="color: #008080;">if</span> <span style="color: #000000;">ch</span><span style="color: #0000FF;">=</span><span style="color: #008000;">'.'</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #000000;">rev</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">-</span><span style="color: #000000;">rev</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
+<!--

Task/Odd-word-problem/PicoLisp/odd-word-problem-1.l

@@ -0,0 +1,14 @@
+(de oddWords ()
+   (use C
+      (loop
+         (until (sub? (prin (setq C (char))) "!,.:;?"))
+         (T (= "." C))
+         (setq C (char))
+         (T
+            (= "."
+               (prin
+                  (recur (C)
+                     (if (sub? C "!,.:;?")
+                        C
+                        (prog1 (recurse (char)) (prin C)) ) ) ) ) ) )
+   (prinl) ) )

Task/Odd-word-problem/PicoLisp/odd-word-problem-2.l

@@ -0,0 +1,2 @@
+(in "txt1" (oddWords))
+(in "txt2" (oddWords))

Task/Odd-word-problem/Prolog/odd-word-problem.pro

@@ -0,0 +1,27 @@
+odd_word_problem :-
+	read_line_to_codes(user_input, L),
+	even_word(L, Out, []),
+	string_to_list(Str, Out),
+	writeln(Str).
+
+even_word(".") --> ".".
+
+even_word([H | T]) -->
+	{char_type(H,alnum)},
+	[H],
+	even_word(T).
+
+even_word([H | T]) -->
+	[H],
+	odd_word(T, []).
+
+odd_word(".", R) --> R, ".".
+
+odd_word([H|T], R) -->
+	{char_type(H,alnum)},
+	odd_word(T, [H | R]).
+
+odd_word([H|T], R) -->
+	R,
+	[H],
+	even_word(T).

Task/Odd-word-problem/PureBasic/odd-word-problem.basic

@@ -0,0 +1,58 @@
+#False = 0
+#True = 1
+
+Global *inputPtr.Character
+
+Macro nextChar()
+  *inputPtr + SizeOf(Character)
+EndMacro
+
+Procedure isPunctuation(c.s)
+  If FindString("!?()[]{},.;:-'" + #DQUOTE$, c)
+    ProcedureReturn #True
+  EndIf
+  ProcedureReturn #False
+EndProcedure
+
+Procedure oddWord()
+  Protected c.c
+  c = *inputPtr\c
+  If isPunctuation(Chr(*inputPtr\c))
+    ProcedureReturn
+  Else
+    nextChar()
+    oddWord()
+  EndIf
+  Print(Chr(c))
+EndProcedure
+
+Procedure oddWordProblem(inputStream.s)
+  *inputPtr = @inputStream
+  Define isOdd = #False
+  While *inputPtr\c
+    If isOdd
+      oddWord()
+    Else
+      Repeat
+        Print(Chr(*inputPtr\c))
+        nextChar()
+      Until isPunctuation(Chr(*inputPtr\c))
+    EndIf
+    Print(Chr(*inputPtr\c))
+    isOdd ! 1 ;toggle word indicator
+    nextChar()
+  Wend
+EndProcedure
+
+Define inputStream.s
+If OpenConsole()
+  Repeat
+    PrintN(#CRLF$ + #CRLF$ + "Enter a series of words consisting only of English letters (i.e. a-z, A-Z)")
+    PrintN("and that are separated by a punctuation mark (i.e. !?()[]{},.;:-' or " + #DQUOTE$ + ").")
+    inputStream = Input()
+    oddWordProblem(inputStream) ;assume input is correct
+  Until inputStream = ""
+
+  Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
+  CloseConsole()
+EndIf

Task/Odd-word-problem/Python/odd-word-problem-1.py

@@ -0,0 +1,28 @@
+from sys import stdin, stdout
+
+def char_in(): return stdin.read(1)
+def char_out(c): stdout.write(c)
+
+def odd(prev = lambda: None):
+	a = char_in()
+	if not a.isalpha():
+		prev()
+		char_out(a)
+		return a != '.'
+
+	# delay action until later, in the shape of a closure
+	def clos():
+		char_out(a)
+		prev()
+
+	return odd(clos)
+
+def even():
+	while True:
+		c = char_in()
+		char_out(c)
+		if not c.isalpha(): return c != '.'
+
+e = False
+while odd() if e else even():
+	e = not e

Task/Odd-word-problem/Python/odd-word-problem-2.py

@@ -0,0 +1,4 @@
+$ echo "what,is,the;meaning,of:life." | python odd.py
+what,si,the;gninaem,of:efil.
+$ echo "we,are;not,in,kansas;any,more." | python odd.py
+we,era;not,ni,kansas;yna,more.

Task/Odd-word-problem/Python/odd-word-problem-3.py

@@ -0,0 +1,28 @@
+from sys import stdin, stdout
+
+def char_in(): return stdin.read(1)
+def char_out(c): stdout.write(c)
+
+def odd():
+	a = char_in()
+	if a.isalpha():
+		r = odd()
+		char_out(a)
+		return r
+
+	# delay printing terminator until later, in the shape of a closure
+	def clos():
+		char_out(a)
+		return a != '.'
+
+	return clos
+
+def even():
+	while True:
+		c = char_in()
+		char_out(c)
+		if not c.isalpha(): return c != '.'
+
+e = False
+while odd()() if e else even():
+	e = not e

Task/Odd-word-problem/Python/odd-word-problem-4.py

@@ -0,0 +1,33 @@
+from sys import stdin, stdout
+
+def fwd(c):
+    if c.isalpha():
+        return [stdout.write(c), (yield from fwd((yield f)))][1]
+    else:
+        return c
+
+def rev(c):
+    if c.isalpha():
+        return [(yield from rev((yield r))), stdout.write(c)][0]
+    else:
+        return c
+
+def fw():
+    while True:
+        stdout.write((yield from fwd((yield r))))
+
+def re():
+    while True:
+        stdout.write((yield from rev((yield f))))
+
+f = fw()
+r = re()
+next(f)
+next(r)
+
+coro = f
+while True:
+    c = stdin.read(1)
+    if not c:
+        break
+    coro = coro.send(c)

Task/Odd-word-problem/Quackery/odd-word-problem.quackery

@@ -0,0 +1,23 @@
+[ upper dup lower != ] is letter    ( c --> b )
+
+               forward is backwords ( $ --> $ )
+
+[ [ behead
+    dup letter while
+    emit again ]
+  dup emit
+  char . !=
+  if backwords ]       is forwords  ( $ --> $ )
+
+[ [ behead
+    dup letter while
+    swap recurse
+    rot emit ]
+  dup emit
+  char . !=
+  if forwords ]  resolves backwords ( $ --> $ )
+
+[ forwords drop cr ]   is oddwords  ( $ -->   )
+
+$ "we,are;not,in,kansas;any,more." oddwords
+$ "what,is,the;meaning,of:life."   oddwords

Task/Odd-word-problem/REXX/odd-word-problem.rexx

@@ -0,0 +1,31 @@
+/*REXX program solves the  odd word problem  by only using  (single) byte  input/output.*/
+                           iFID_ = 'ODDWORD.IN'  /*Note:  numeric suffix is added later.*/
+                           oFID_ = 'ODDWORD.'    /*  "       "       "    "   "     "   */
+     do case=1  for 2;                #= 0       /*#:  is the number of characters read.*/
+     iFID= iFID_  ||  case                       /*read   ODDWORD.IN1  or  ODDWORD.IN2  */
+     oFID= oFID_  ||  case                       /*write  ODDWORD.1    or  ODDWORD.2    */
+     say;   say;    say '════════ reading file: '        iFID        "════════"                /* ◄■■■■■■■■■ optional. */
+
+         do  until x==.                          /* [↓]  perform until reaching a period*/
+                do  until \datatype(x, 'M')      /* [↓]     "      "   punctuation found*/
+                call rChar                       /*read  a single character.            */
+                call wChar                       /*write "    "       "                 */
+                end   /*until \data···*/         /* [↑]  read/write until punctuation.  */
+         if x==.  then leave                     /*is this the end─of─sentence (period)?*/
+         call readLetters;            punct= #   /*save the location of the punctuation.*/
+                do j=#-1  by -1                  /*read some characters backwards.      */
+                call rChar j                     /*read previous word (backwards).      */
+                if \datatype(x, 'M')  then leave /*Found punctuation?   Then leave  J.  */
+                call wChar                       /*write a character (which is a letter)*/
+                end   /*j*/                      /* [↑]  perform for  "even"  words.    */
+         call rLett                              /*read letters until punctuation found.*/
+         call wChar;                  #= punct   /*write a char;  punctuation location. */
+         end      /*until x==.*/
+     end          /*case*/                       /* [↑]  process both of the input files*/
+exit                                             /*stick a fork in it,  we're all done. */
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+rLett: do  until  \datatype(x, 'M');         call rChar;             end;         return
+wChar: call charout , x  /*console*/;        call charout oFID, x  /*file*/;      return
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+rChar: if arg()==0  then do; x= charin(iFID); #= #+1; end  /*read  next  char*/
+                    else     x= charin(iFID, arg(1) );     /*  " specific  " */   return

Task/Odd-word-problem/Racket/odd-word-problem.rkt

@@ -0,0 +1,26 @@
+#!/bin/sh
+#|
+exec racket -tm- "$0" "$@"
+|#
+
+#lang racket
+
+(define (even k)
+  (define c (read-char))
+  (cond [(eq? c eof) (k)]
+        [(not (char-alphabetic? c)) (k) (write-char c) (odd)]
+        [else (even (λ() (write-char c) (k)))]))
+
+(define (odd)
+  (define c (read-char))
+  (unless (eq? c eof)
+    (write-char c)
+    (if (char-alphabetic? c) (odd) (even void))))
+
+(provide main)
+(define (main) (odd) (newline))
+
+;; (with-input-from-string "what,is,the;meaning,of:life." main)
+;; ;; -> what,si,the;gninaem,of:efil.
+;; (with-input-from-string "we,are;not,in,kansas;any,more." main)
+;; ;; -> we,era;not,ni,kansas;yna,more.

Task/Odd-word-problem/Raku/odd-word-problem.raku

@@ -0,0 +1,12 @@
+my &in = { $*IN.getc // last }
+
+loop {
+    ew(in);
+    ow(in).print;
+}
+
+multi ew ($_ where /\w/) { .print; ew(in); }
+multi ew ($_)            { .print; next when "\n"; }
+
+multi ow ($_ where /\w/) { ow(in) x .print; }
+multi ow ($_)            { $_; }

Task/Odd-word-problem/Ring/odd-word-problem.ring

@@ -0,0 +1,43 @@
+# Project : Odd word problem
+
+test = "what,is,the;meaning,of:life."
+n1 = 1
+testarr = []
+testorigin = test
+test = substr(test, ",", " ")
+test = substr(test, ";", " ")
+test = substr(test, ":", " ")
+test = substr(test, ".", " ")
+
+while true
+      n2 = substring(test, " ", n1)
+      n3 = substring(test, " ", n2 + 1)
+      if n2>0 and n3>0
+         strcut = substr(test, n2 + 1, n3 - n2)
+         strcut = trim(strcut)
+         if strcut != ""
+            add(testarr, strcut)
+            n1 = n3 + 1
+         else
+            exit
+         ok
+      ok
+end
+
+for n = 1 to len(testarr)
+    strrev = revstr(testarr[n])
+    testorigin = substr(testorigin, testarr[n], strrev)
+next
+see testorigin + nl
+
+func Substring str,substr,n
+     newstr=right(str,len(str)-n+1)
+     nr = substr(newstr, substr)
+     return n + nr -1
+
+func revstr(cStr)
+     cStr2 = ""
+     for x = len(cStr) to 1 step -1
+         cStr2 += cStr[x]
+     next
+     return cStr2

Task/Odd-word-problem/Ruby/odd-word-problem-1.rb

@@ -0,0 +1,13 @@
+f, r = nil
+fwd = proc {|c|
+  c =~ /[[:alpha:]]/ ? [(print c), fwd[Fiber.yield f]][1] : c }
+rev = proc {|c|
+  c =~ /[[:alpha:]]/ ? [rev[Fiber.yield r], (print c)][0] : c }
+
+(f = Fiber.new { loop { print fwd[Fiber.yield r] }}).resume
+(r = Fiber.new { loop { print rev[Fiber.yield f] }}).resume
+
+coro = f
+until $stdin.eof?
+  coro = coro.resume($stdin.getc)
+end

Task/Odd-word-problem/Ruby/odd-word-problem-2.rb

@@ -0,0 +1,71 @@
+require 'continuation' unless defined? Continuation
+require 'stringio'
+
+# Save current continuation.
+def savecc(*data)
+  # With MRI 1.8 (but not 1.9), the array literal
+  #   [callcc {|cc| cc}, *data]
+  # used the wrong return value from callcc. The workaround is to
+  # put callcc outside the array literal.
+  continuation = callcc {|cc| cc}
+  [continuation, *data]
+end
+
+# Jump back to continuation, where savecc will return [nil, *data].
+def jump_back(continuation)
+  continuation[nil]
+end
+
+def read_odd_word(input, output)
+  first_continuation, last_continuation = nil
+  reverse = false
+  # Read characters. Loop until end of stream.
+  while c = input.getc
+    c = c.chr   # For Ruby 1.8, convert Integer to String.
+    if c =~ /[[:alpha:]]/
+      # This character is a letter.
+      if reverse
+        # Odd word: Write letters in reverse order.
+        saving, last_continuation, c = savecc(last_continuation, c)
+        if saving
+          last_continuation = saving
+        else
+          # After jump: print letters in reverse.
+          output.print c
+          jump_back last_continuation
+        end
+      else
+        # Even word: Write letters immediately.
+        output.print c
+      end
+    else
+      # This character is punctuation.
+      if reverse
+        # End odd word. Fix trampoline, follow chain of continuations
+        # (to print letters in reverse), then bounce off trampoline.
+        first_continuation, c = savecc(c)
+        if first_continuation
+          jump_back last_continuation
+        end
+        output.print c      # Write punctuation.
+        reverse = false     # Begin even word.
+      else
+        output.print c      # Write punctuation.
+        reverse = true      # Begin odd word.
+        # Create trampoline to bounce to (future) first_continuation.
+        last_continuation, = savecc
+        unless last_continuation
+          jump_back first_continuation
+        end
+      end
+    end
+  end
+  output.puts   # Print a cosmetic newline.
+end
+
+def odd_word(string)
+  read_odd_word StringIO.new(string), $stdout
+end
+
+odd_word "what,is,the;meaning,of:life."
+odd_word "we,are;not,in,kansas;any,more."

Task/Odd-word-problem/Run-BASIC/odd-word-problem.basic

@@ -0,0 +1,31 @@
+open "oddWord.txt" for input as #f               ' read input stream
+while not(eof(#f))
+line input #f, a$
+oddW$  = ""                                      ' begin the result oddW with blank
+px     = 0                                       ' begin word search location with 0
+count  = 0                                       ' begin the word count to 0
+while x < len(a$)                                ' look at each character
+	x    = instr(a$,",",px)                  ' search for comma (,)
+	if x = 0 then x = len(a$)                ' no more commas?
+	x1   = instr(a$,";",px)                  ' search for (;)
+	x2   = instr(a$,":",px)                  ' search for (:)
+	if x1 <> 0 then x = min(x,x1)            ' what came first the , ; or :
+	if x2 <> 0 then x = min(x,x2)
+
+	w$  = mid$(a$,px,x - px)                 ' get the word seperated by , ; or :
+
+	if count and 1 then                      ' is it the odd word
+	        w1$ = ""
+		for i = len(w$) to 1 step -1
+			w1$ = w1$ + mid$(w$,i,1) ' reverse odd words
+		next i
+		w$ = w1$
+	end if
+        oddW$ = oddW$ + w$ + mid$(a$,x,1)        ' add the word to the end of oddW$
+	px    = x + 1                            ' bump word search location for next while
+	count = count + 1                        ' count the words
+wend
+print a$;" -> ";oddW$                            ' print the original and result
+next ii
+wend
+close #f

Task/Odd-word-problem/Scala/odd-word-problem.scala

@@ -0,0 +1,17 @@
+import scala.io.Source
+import java.io.PrintStream
+
+def process(s: Source, p: PrintStream, w: Int = 0): Unit = if (s.hasNext) s.next match {
+  case '.' => p append '.'
+  case c if !Character.isAlphabetic(c) => p append c; reverse(s, p, w + 1)
+  case c => p append c; process(s, p, w)
+}
+
+def reverse(s: Source, p: PrintStream, w: Int = 0, x: Char = '.'): Char = s.next match {
+  case c if !Character.isAlphabetic(c) => p append x; c
+  case c => val n = reverse(s, p, w, c);
+    if (x == '.') {p append n; process(s, p, w + 1)} else p append x; n
+}
+
+process(Source.fromString("what,is,the;meaning,of:life."), System.out); println
+process(Source.fromString("we,are;not,in,kansas;any,more."), System.out); println

Task/Odd-word-problem/Scheme/odd-word-problem.ss

@@ -0,0 +1,19 @@
+(define (odd)
+  (let ((c (read-char)))
+    (if (char-alphabetic? c)
+      (let ((r (odd)))
+	(write-char c)
+	r)
+      (lambda () (write-char c) (char=? c #\.)))))
+
+(define (even)
+  (let ((c (read-char)))
+    (write-char c)
+    (if (char-alphabetic? c)
+      (even)
+      (char=? c #\.))))
+
+(let loop ((i #f))
+  (if (if i ((odd)) (even))
+    (exit)
+    (loop (not i))))

Task/Odd-word-problem/Seed7/odd-word-problem.seed7

@@ -0,0 +1,35 @@
+$ include "seed7_05.s7i";
+  include "chartype.s7i";
+
+const func char: doChar (in boolean: doReverse) is func
+  result
+    var char: delimiter is ' ';
+  local
+    var char: ch is ' ';
+  begin
+    ch := getc(IN);
+    if ch in letter_char then
+      if doReverse then
+        delimiter := doChar(doReverse);
+        write(ch);
+      else
+        write(ch);
+        delimiter := doChar(doReverse);
+      end if;
+    else
+      delimiter := ch;
+    end if;
+  end func;
+
+const proc: main is func
+  local
+    var char: delimiter is ' ';
+    var boolean: doReverse is FALSE;
+  begin
+    repeat
+      delimiter := doChar(doReverse);
+      write(delimiter);
+      doReverse := not doReverse;
+    until delimiter = '.';
+    writeln;
+  end func;

Task/Odd-word-problem/Sidef/odd-word-problem.sidef

@@ -0,0 +1,24 @@
+func rev {
+    (var c = STDIN.getc) \\ return()
+    if (c ~~ /^[a-z]\z/i) {
+        var r = rev()
+        print c
+        return r
+    }
+    return c
+}
+
+var (n=0, l=false)
+while (defined(var c = STDIN.getc)) {
+    var w = (c ~~ /^[a-z]\z/i)
+    ++n if (w && !l)
+    l = w
+    if (n & 1) {
+        print c
+    } else {
+        var r = rev()
+        print(c, r)
+        n = 0
+        l = false
+    }
+}

Task/Odd-word-problem/TUSCRIPT/odd-word-problem.tu

@@ -0,0 +1,18 @@
+$$ MODE TUSCRIPT
+inputstring=*
+DATA what,is,the;meaning,of:life.
+DATA we,are;not,in,kansas;any,more.
+
+BUILD C_GROUP >[pu]=".,;:-"
+
+LOOP i=inputstring
+pu=STRINGS (i,"|>[pu]|")
+wo=STRINGS (i,"|<></|")
+outputstring=""
+ loop n,w=wo,p=pu
+ r=MOD(n,2)
+ IF (r==0) w=TURN (w)
+ outputstring=CONCAT(outputstring,w,p)
+ENDLOOP
+PRINT outputstring
+ENDLOOP

Task/Odd-word-problem/Tcl/odd-word-problem.tcl

@@ -0,0 +1,13 @@
+package require Tcl 8.6
+
+proc fwd c {
+    expr {[string is alpha $c] ? "[fwd [yield f][puts -nonewline $c]]" : $c}
+}
+proc rev c {
+    expr {[string is alpha $c] ? "[rev [yield r]][puts -nonewline $c]" : $c}
+}
+coroutine f while 1 {puts -nonewline [fwd [yield r]]}
+coroutine r while 1 {puts -nonewline [rev [yield f]]}
+for {set coro f} {![eof stdin]} {} {
+    set coro [$coro [read stdin 1]]
+}

Task/Odd-word-problem/V-(Vlang)/odd-word-problem.v

@@ -0,0 +1,24 @@
+const str = 'what,is,the;meaning,of:life.'
+
+fn main() {
+	mut temp, mut new_str := '', ''
+	mut switch := true
+	for field in str {
+		temp += field.ascii_str()
+		if field.is_alnum() == false {
+			if switch == true {
+				new_str += temp
+				temp =''			
+				switch = false
+				continue
+			}		
+			else {
+				new_str += temp.all_before_last(field.ascii_str()).reverse() + field.ascii_str()
+				temp =''			
+				switch = true
+				continue
+			}
+		}		
+	}
+	println(new_str)
+}

Task/Odd-word-problem/VBA/odd-word-problem-1.vba

@@ -0,0 +1,35 @@
+Private Function OddWordFirst(W As String) As String
+Dim i As Integer, count As Integer, l As Integer, flag As Boolean, temp As String
+   count = 1
+   Do
+      flag = Not flag
+      l = FindNextPunct(i, W) - count + 1
+      If flag Then
+         temp = temp & ExtractWord(W, count, l)
+      Else
+         temp = temp & ReverseWord(W, count, l)
+      End If
+   Loop While count < Len(W)
+   OddWordFirst = temp
+End Function
+
+Private Function FindNextPunct(d As Integer, W As String) As Integer
+Const PUNCT As String = ",;:."
+   Do
+      d = d + 1
+   Loop While InStr(PUNCT, Mid(W, d, 1)) = 0
+   FindNextPunct = d
+End Function
+
+Private Function ExtractWord(W As String, c As Integer, i As Integer) As String
+   ExtractWord = Mid(W, c, i)
+   c = c + Len(ExtractWord)
+End Function
+
+Private Function ReverseWord(W As String, c As Integer, i As Integer) As String
+Dim temp As String, sep As String
+   temp = Left(Mid(W, c, i), Len(Mid(W, c, i)) - 1)
+   sep = Right(Mid(W, c, i), 1)
+   ReverseWord = StrReverse(temp) & sep
+   c = c + Len(ReverseWord)
+End Function

Task/Odd-word-problem/VBA/odd-word-problem-2.vba

@@ -0,0 +1,39 @@
+Private Function OddWordSecond(Words As String) As String
+Dim i&, count&, t$, cpt&, j&, l&, d&, f As Boolean
+Const PUNCT As String = ",;:"
+   For i = 1 To Len(Words)
+      'first word
+      If i = 1 Then
+         cpt = 1
+         Do
+            t = t & Mid(Words, cpt, 1)
+            cpt = cpt + 1
+         Loop While InStr(PUNCT, Mid(Words, cpt, 1)) = 0 And cpt < Len(Words)
+         i = cpt
+         t = t & Mid(Words, i, 1)
+      End If
+      If Right(t, 1) = "." Then Exit For
+      'Odd words ==> reverse
+      While InStr(PUNCT, Mid(Words, cpt + 1, 1)) = 0 And cpt < Len(Words)
+         cpt = cpt + 1
+      Wend
+      l = IIf(f = True, i, i + 1)
+      d = IIf(cpt = Len(Words), cpt - 1, cpt)
+      For j = d To l Step -1
+         t = t & Mid(Words, j, 1)
+      Next
+      If cpt = Len(Words) Then t = t & ".": Exit For
+      f = True
+      i = cpt + 1
+      t = t & Mid(Words, i, 1)
+      'Even words
+      cpt = i + 1
+      t = t & Mid(Words, cpt, 1)
+      Do
+         cpt = cpt + 1
+         t = t & Mid(Words, cpt, 1)
+      Loop While InStr(PUNCT, Mid(Words, cpt, 1)) = 0 And cpt < Len(Words)
+      i = cpt
+   Next
+   OddWordSecond = t
+End Function

Task/Odd-word-problem/VBA/odd-word-problem-3.vba

@@ -0,0 +1,11 @@
+Option Explicit
+
+Sub Main()
+   Debug.Print "Input : " & "we,are;not,in,kansas;any,more."
+   Debug.Print "First way : " & OddWordFirst("we,are;not,in,kansas;any,more.")
+   Debug.Print "Second way : " & OddWordSecond("we,are;not,in,kansas;any,more.")
+   Debug.Print ""
+   Debug.Print "Input : " & "what,is,the;meaning,of:life."
+   Debug.Print "First way : " & OddWordFirst("what,is,the;meaning,of:life.")
+   Debug.Print "Second way : " & OddWordSecond("what,is,the;meaning,of:life.")
+End Sub

Task/Odd-word-problem/Wren/odd-word-problem.wren

@@ -0,0 +1,34 @@
+import "io" for Stdin,Stdout
+import "/str" for Char
+
+var fwrite = Fn.new { |ch|
+    System.write(ch)
+    Stdout.flush()
+}
+
+var doChar // recursive
+doChar = Fn.new { |odd, f|
+    var c = Stdin.readByte()
+    if (!c) return false // end of stream reached
+    var ch = String.fromByte(c)
+
+    var writeOut = Fn.new {
+        fwrite.call(ch)
+        if (f) f.call()
+    }
+
+    if (!odd) fwrite.call(ch)
+    if (Char.isLetter(ch)) return doChar.call(odd, writeOut)
+    if (odd) {
+        if (f) f.call()
+        fwrite.call(ch)
+    }
+    return ch != "."
+}
+
+for (i in 0..1) {
+    var b = true
+    while (doChar.call(!b, null)) b = !b
+    Stdin.readByte() // remove \n from buffer
+    System.print("\n")
+}

Task/Odd-word-problem/XPL0/odd-word-problem.xpl0

@@ -0,0 +1,33 @@
+proc OWP;
+int B;
+        func Odd;
+        int S, B;
+        [S:= ChIn(8);
+        if S < ^A then \punct\ return S;
+        B:= Odd;
+        ChOut(0, S);
+        return B;
+        ];
+
+[OpenI(8);
+loop    [loop   [B:= ChIn(8);
+                ChOut(0, B);
+                if B = ^. then return;
+                if B < ^A \punct\ then quit;
+                ];
+        B:= Odd;
+        ChOut(0, B);
+        if B = ^. then return;
+        ];
+];
+
+[OpenO(8);
+Text(8, "what,is,the;meaning,of:life. ");
+OWP;
+CrLf(0);
+
+OpenO(8);
+Text(8, "we,are;not,in,kansas;any,more. ");
+OWP;
+CrLf(0);
+]

Task/Odd-word-problem/Zkl/odd-word-problem-1.zkl

@@ -0,0 +1,15 @@
+var [const] delim=",:;/?!@#$%^&*()_+", stop=".";
+fcn oddly(inStream){
+   inStream=inStream.walker(3);  // character iterator: string, file, etc
+   doWord:=fcn(inStream,rev,f){  // print next word forewards or reverse
+      c:=inStream.next();
+      if(not rev) c.print();
+      if(not (c==stop or delim.holds(c)))
+	 return(self.fcn(inStream,rev,'{ c.print(); f(); }));
+      if(rev){ f(); c.print(); }
+      return(c!=stop);
+   };
+   tf:=Walker.cycle(False,True);  // every other word printed backwords
+   while(doWord(inStream, tf.next(), Void)) {}
+   println();
+}

Task/Odd-word-problem/Zkl/odd-word-problem-2.zkl

@@ -0,0 +1,2 @@
+oddly("what,is,the;meaning,of:life.");
+oddly(Data(0,String,"we,are;not,in,kansas;any,more."));