Odd word problem: Difference between revisions

This is a rather straightforward approach, using recursion.

 

procedure Odd_Word_Problem is

end if;

end if;

 

Output:

{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}

The words and punctuation should be on a single line. Uses recursion.

# the character that followed it #

# "ch" should contain the first letter of the word on entry and will be #

main: (

reverse every other word

{{out}}

<pre>

 

=={{header|AutoHotkey}}==

loop, parse, str

if (A_LoopField ~= "[[:punct:]]")

else

res := toggle ? RegExReplace(res, ".*[[:punct:]]\K", A_LoopField ) : res A_LoopField

Outputs:<pre>what,si,the;gninaem,of:efil.</pre>

 

=={{header|BaCon}}==

 

FUNCTION get_odd()

CLOSE DEVICE in

 

This program uses recursion.

{{out}}

 

=={{header|Bracmat}}==

= dothis doother forward backward

. ( forward

& put$\n

& odd-word$"kansas.txt" { Real file, as Bracmat cannot read a single character from stdin. }

Output:

<pre>what,si,the;gninaem,of:efil.

 

=={{header|C}}==

 

#include <ctype.h>

 

{

}

 

{

 

=={{header|C++}}==

Tested with gcc 4.5, with "-std=c++0x" option.

 

#include <cctype>

#include <functional>

while( e ? odd() : even() ) e = !e;

return 0;

 

=={{header|Ceylon}}==

 

String[] meaning = ["what,", "is,", "the;", "meaning,", "of:", "life."];

String[] kansas = ["we,", "are,", "not,", "in,", "kansas;", "any,", "more."];

=> ",.:;".contains(char);

 

 

{{out}}

{{trans|Common Lisp}}

 

(char (.read *in*)))

 

((backward)))

(recur (not forward?)))) )

 

Examples:

 

what,si,the;gninaem,of:efil.

nil

user=> (odd-word "we,are;not,in,kansas;any,more.")

we,era;not,ni,kansas;yna,more.

 

=={{header|CoffeeScript}}==

 

isLastChar = (c) -> c is '.'

 

# 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).

 

===Same without comments===

 

isLastChar = (c) -> c is '.'

 

return not isLastChar(c)

 

===Testing code===

 

println = (z) -> console.log z

 

[testString, expectedResult, putBuffer, putBuffer is expectedResult]

 

 

Output in [[node.js]]:

=={{header|Common Lisp}}==

Even words are straightforward. For odd words, the final punctuation is printed by a closure passed back up the caller chain.

(let ((stream (make-string-input-stream s)))

(loop for forwardp = t then (not forwardp)

(prog1 (backward stream) (write-char ch))

#'(lambda () (write-char ch) (char/= ch #\.)))) )

 

Examples:

 

what,si,the;gninaem,of:efil.

NIL

? (odd-word "we,are;not,in,kansas;any,more.")

we,era;not,ni,kansas;yna,more.

 

=={{header|D}}==

{{trans|C}}

import core.stdc.stdio, std.ascii;

 

bool i = true;

while (doChar(i = !i)) {}

{{out}}

<pre>what,is,the;meaning,of:life.

what,si,the;gninaem,of:efil.</pre>

 

=={{header|EchoLisp}}==

No character input stream in EchoLisp, which runs in a browser window. We simultate it with a character stream, with the only function '''read-char''', as specified in the task.

(lib 'sequences)

(define input-stream null)

 

{{out}}

(task "what,is,the;meaning,of:life.")

→ "what,si,the;gninaem,of:efil."

(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."

 

=={{header|Elixir}}==

{{trans|Erlang}}

def handle(s, false, i, o) when ((s >= "a" and s <= "z") or (s >= "A" and s <= "Z")) do

o.(s)

end

 

 

{{out}}

 

=={{header|Erlang}}==

handle(S, false, I, O) when (((S >= $a) and (S =< $z)) or ((S >= $A) and (S =< $Z))) ->

O(S),

O = fun(S) -> io:put_chars([S]) end,

handle(I(), false, I, O).

 

=={{header|F_Sharp|F#}}==

<p>A recursive solution.</p>

open System.Text.RegularExpressions

 

let rec loop () = forward() |> Out; loop()

loop()

{{out}}

<pre>

This code is difficult to follow, because it twists its control flow like spaghetti. These continuations form a [[singly-linked list]], where each continuation contains a letter and a previous continuation. The program effectively reverses this linked list.

 

IN: rosetta.odd-word

 

 

: odd-word ( string -- )

 

'''USE: rosetta.odd-word'''

=={{header|FALSE}}==

This solution uses recursion to read the backwards words, to output the characters after having done the rest of that word.

[s;!$'.=~[,^f;!]?]r: {reverse words}

[[$$$$'.=\',=|\';=|\':=|~][,^]#$'.=~[,^r;!]?]f: {forward words}

 

=={{header|Forth}}==

: ?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 ;

 

=={{header|Fortran}}==

By not allowing the use of arrays of characters to facilitate the reversing of texts, the obvious solution involves recursion with storage via the stack so that its last-on, first-off style will achieve the required goal. But alas, Fortran compilers were typically written for computers that did not employ a stack mechanism so recursion was not expected even after the introduction of Algol in the 1960s, and the failure of recursively-invoked routines to return correctly became accepted. The standard murmur was that "Fortran is not a recursive language" even though the language contains recursive definitions such as for arithmetic expressions. By contrast, the B6700 system ''did'' employ a hardware stack, and, without any fuss, recursion just worked.

 

INTEGER MSG,INF !I/O unit numbers.

LOGICAL DEFER !To stumble, or not to stumble.

WRITE (MSG,"('')") !End the line of output.

GO TO 10 !And have another go.

With file Confused.txt containing the obvious input, the output is

<pre>

 

If the ADVANCE feature is unavailable, then the file could be read as UNFORMATTED, one character at a go with a record length of one. And then would arise the annoyance of dealing with the ASCII world's usage of CR, CRLF, LFCR, or CR as markers for the ends of records.

 

=={{header|Go}}==

 

import (

}

}

Output:

<pre>

 

===Using <code>defer</code>===

 

import (

}

}

 

===Using channels and goroutines===

{{trans|Ruby}}

{{trans|Tcl}}

 

import (

close(f.in)

close(r.in)

 

=={{header|Haskell}}==

While it seems like this solution would break the task's rules, Haskell is non-strict, therefore this yields the same behavior of reading and printing one character at a time, without excess storage into a "string". To prove it, run the program and manually enter the input string (Windows command prompt does not respect buffering settings, but urxvt on on Linux does).

(BufferMode(..), getContents, hSetBuffering, stdin, stdout)

import Data.Char (isAlpha)

hSetBuffering stdin NoBuffering >> hSetBuffering stdout NoBuffering >> getContents >>=

putStr . takeWhile (/= '.') . parse >>

If the above is not acceptable, or if Haskell was implicitly strict, then this solution would satisfy the requirements:

isAlpha = flip elem $ ['a'..'z'] ++ ['A'..'Z']

 

main :: IO ()

main = hSetBuffering stdin NoBuffering >> hSetBuffering stdout NoBuffering >>

Linux urxvt output:

<pre>$ ./OddWord

The following recursive version is based on the non-deferred GO version. A co-expression is used to turn the parameter to the wrapper into a character at a time stream.

 

every OddWord(!["what,is,the;meaning,of:life.",

"we,are;not,in,kansas;any,more."])

if any(marks,s := @stream) then return s

return 1(oWord(stream,marks), writes(s))

 

Output:<pre>Input stream: what,is,the;meaning,of:life.

 

A slightly different solution which uses real I/O from stdin is:

repeat (while writes((any(&letters, c := reads(&input,1)),c))) |

(writes(c) ~== "." ~== writes(rWord())) | break write()

writes(\c)

return c1

And some sample runs:

<pre>

J also lacks character stream support, so this implementation uses a [[Odd_word_problem/TrivialCharacterStreamSupportForJ|stream-like implementation]].

 

outch y

return x

outch char=. do_char coroutine ''

end.

 

Note that in the couroutine-like support page we defined <code>u yield v y</code> such that it produces a result which, when returned to the <code>coroutine</code> helper verb, will cause the deferred execute <code>u v y</code> in a context where both u and v are expected to be coroutine verbs (they will produce a result either wrapped with <code>yield</code> or with <code>return</code>). Likewise <code>return</code> wraps the result with instructions for the <code>coroutine</code> helper, instructing it to use the returned result "as-is". (And, if <code>return</code> is used with an empty stack in the helper, that instance would be the result of the <code>coroutine</code> helper.)

With this implementation:

 

what,si,the;gninaem,of:efil.

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

 

That said, note that this implementation has significant overhead when compared to a more direct implementation of the algorithm.

 

=={{header|Java}}==

interface CharHandler {

CharHandler handle(char c) throws Exception;

new OddWord().loop();

}

Output is equivalent to that of the Python solution.

 

{{works with|Julia|0.6}}

{{trans|Python}}

io = "what,is,the;meaning,of:life."

i = 0

while evn ? odd() : even()

evn = !evn

 

{{out}}

=={{header|Kotlin}}==

{{trans|C}}

 

typealias Func = () -> Unit

println("\n")

}

 

{{out}}

 

=={{header|Lasso}}==

local(

isodd = false,

'new:\r'

odd_word_processor('what,is,the;meaning,of:life.')

 

{{out}}

 

=={{header|Lua}}==

local ch = io.read(1)

if ch:find("%w") then

end

 

{{out}}

<pre>$ echo what,is,the;meaning,of:life.|oddword.lua

We can pass by reference the lambda function but here we pass by reference the f factor, which for keyboard check the end, and for file work as file handler and at then end as a flag which check the end.

 

Module Checkit {

global out$

}

Checkit

===Using Closure===

Module OddWord {

k$=lambda$->""

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

OddWord

 

{{out}}

 

=={{header|Nim}}==

{{trans|Python}}

 

 

proc odd(prev = nothing): bool =

var e = false

while (if e: odd() else: even()):

<pre>$ echo "what,is,the;meaning,of:life." | ./oddword

what,si,the;gninaem,of:efil.

echo "we,are;not,in,kansas;any,more." | ./oddword

we,era;not,ni,kansas;yna,more.</pre>

 

=={{header|OCaml}}==

 

c >= 'a' && c <= 'z' ||

c >= 'A' && c <= 'Z'

let () =

try rev_odd_words ()

 

Executing:

=={{header|Ol}}==

Use string iterators.

(define (odd_word_problem words)

(letrec ((odd (lambda (s out)

(odd_word_problem "what,is,the;meaning,of:life.")

(odd_word_problem "we,are;not,in,kansas;any,more.")

 

Output:

 

===Closure version===

{

my ($f, $c) = @_;

}

}

===Recursion version===

{

my $c;

$n = 0; $l = 0;

}

===Threads (processes) version===

Perl still has weak threads support. Far more safe yet portable is to use processes (fork).

 

Here, fork is used instead of threads and pipe is used instead of conditional variable.

 

while (read STDIN, $_, 1) {

close R;

}

 

=={{header|Phix}}==

To test direct console input, comment out string s .. getchar(), and uncomment getc(0) and the prompt.<br>

Likewise use integer fn = open("somefile","r"), and getc(fn) should you want to test file i/o.

{{out}}

<pre>

=={{header|PHP}}==

{{trans|Python}}

$a = fgetc(STDIN);

if (!ctype_alpha($a)) {

while ($e ? $odd($prev) : $even()) {

$e = !$e;

 

=={{header|PicoLisp}}==

(use C

(loop

C

(prog1 (recurse (char)) (prin C)) ) ) ) ) ) )

Test:

Output:

<pre>what,si,the;gninaem,of:efil.

=={{header|PL/I}}==

 

declare (ch, ech) character (1);

declare odd file;

if ech = '.' then leave;

end;

file:

<pre>

=={{header|Prolog}}==

Works with SWI-Prolog.

read_line_to_codes(user_input, L),

even_word(L, Out, []),

[H],

even_word(T).

Output :

<pre>?- odd_word_problem.

=={{header|PureBasic}}==

This example uses recursion.

#True = 1

 

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

Sample output:

<pre>Enter a series of words consisting only of English letters (i.e. a-z, A-Z)

 

=={{header|Python}}==

 

def char_in(): return stdin.read(1)

e = False

while odd() if e else even():

what,si,the;gninaem,of:efil.

$ echo "we,are;not,in,kansas;any,more." | python odd.py

 

{{trans|Scheme}}

In this version, the action of printing the terminating punctuation is put in a closure and returned by <code>odd()</code>.

 

def char_in(): return stdin.read(1)

e = False

while odd()() if e else even():

 

===Using coroutines and recursion===

{{trans|Tcl}}

{{works with|Python|3.3+}}

 

def fwd(c):

if not c:

break

 

=={{header|Racket}}==

Simple solution, using a continuation thunk for the reverse parts.

#!/bin/sh

#|

;; (with-input-from-string "we,are;not,in,kansas;any,more." main)

;; ;; -> we,era;not,ni,kansas;yna,more.

 

=={{header|Raku}}==

(formerly Perl 6)

A recursive solution, with the added feature that it treats each line separately.

 

loop {

 

multi ow ($_ where /\w/) { ow(in) x .print; }

{{out}}

<pre>$ ./oddword

 

No recursion or the stack is used. &nbsp; The program could've been written without subroutines.

iFID_ = 'ODDWORD.IN' /*Note: numeric suffix is added later.*/

oFID_ = 'ODDWORD.' /* " " " " " " */

/*──────────────────────────────────────────────────────────────────────────────────────*/

rChar: if arg()==0 then do; x= charin(iFID); #= #+1; end /*read next char*/

{{out|output|text=&nbsp; when using the two (default) input files which contain:}}

:* &nbsp; input file &nbsp; '''ODDWORD.IN1''' &nbsp; ───► &nbsp; <tt> what,is,the;meaning,of:life. </tt>

 

=={{header|Ring}}==

# Project : Odd word problem

 

next

return cStr2

Output:

<pre>

{{trans|Tcl}}

{{works with|Ruby|1.9}}

fwd = proc {|c|

c =~ /[[:alpha:]]/ ? [(print c), fwd[Fiber.yield f]][1] : c }

until $stdin.eof?

coro = coro.resume($stdin.getc)

 

===Using continuations===

{{trans|Factor}}

{{libheader|continuation}}

require 'stringio'

 

 

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

 

=={{header|Run BASIC}}==

{{incorrect|Run BASIC|Restriction #1 violated - only single character I/O allowed. Restriction #2 violated - explicit storage in string for later reversal not allowed.}}

while not(eof(#f))

line input #f, a$

next ii

wend

<pre>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.</pre>

 

=={{header|Scala}}==

import java.io.PrintStream

 

 

process(Source.fromString("what,is,the;meaning,of:life."), System.out); println

{{out}}

<pre>what,si,the;gninaem,of:efil.

=={{header|Scheme}}==

Output is identical to python.

(let ((c (read-char)))

(if (char-alphabetic? c)

(if (if i ((odd)) (even))

(exit)

 

=={{header|Seed7}}==

include "chartype.s7i";

 

until delimiter = '.';

writeln;

 

{{out}}

Recursive solution:

{{trans|Perl}}

(var c = STDIN.getc) \\ return()

if (c ~~ /^[a-z]\z/i) {

l = false

}

{{out}}

<pre>

Although the input is handled as strings, they're all as single-character strings.

{{works with|Tcl|8.6}}

 

proc fwd c {

for {set coro f} {![eof stdin]} {} {

set coro [$coro [read stdin 1]]

Output is identical to Python and Scheme versions.

 

{{incorrect|Run BASIC|You are supposed to read characters one by one and not store them in arrays.}}

 

$$ MODE TUSCRIPT

inputstring=*

PRINT outputstring

ENDLOOP

Output:

<pre>

=={{header|VBA}}==

First way :

Dim i As Integer, count As Integer, l As Integer, flag As Boolean, temp As String

count = 1

ReverseWord = StrReverse(temp) & sep

c = c + Len(ReverseWord)

Second way :

Dim i&, count&, t$, cpt&, j&, l&, d&, f As Boolean

Const PUNCT As String = ",;:"

Next

OddWordSecond = t

To call Functions :

 

Sub Main()

Debug.Print "First way : " & OddWordFirst("what,is,the;meaning,of:life.")

Debug.Print "Second way : " & OddWordSecond("what,is,the;meaning,of:life.")

{{out}}

<pre>Input : we,are;not,in,kansas;any,more.

First way : what,si,the;gninaem,of:efil.

Second way : what,si,the;gninaem,of:efil.</pre>

 

=={{header|Wren}}==

{{trans|Kotlin}}

{{libheader|Wren-str}}

 

var fwrite = Fn.new { |ch|

Stdin.readByte() // remove \n from buffer

System.print("\n")

 

{{out}}

we,era;not,ni,kansas;yna,more.

 

</pre>

 

=={{header|zkl}}==

{{trans|D}}

fcn oddly(inStream){

inStream=inStream.walker(3); // character iterator: string, file, etc

while(doWord(inStream, tf.next(), Void)) {}

println();

Showing two different input streams:

{{out}}

<pre>