FizzBuzz

794 views
Skip to first unread message

keo...@gmail.com

unread,
Feb 28, 2007, 6:16:19 PM2/28/07
to
Hi,

recently there was a big fuzz on digg.com and the like about this
article:

http://tickletux.wordpress.com/2007/01/24/using-fizzbuzz-to-find-developers-who-grok-coding/

The author suggests that most self-called programmers can't solve the
following problem:

Write a program that prints the numbers from 1 to 100. But for
multiples of three print "Fizz" instead of the number and for the
multiples of five print "Buzz". For numbers which are multiples of
both three and five print "FizzBuzz".

As I am interested but not yet very proficient in stack based
programming languages, I ask you: how would you solve this problem in
FORTH?

Keo

Coos Haak

unread,
Feb 28, 2007, 7:21:47 PM2/28/07
to
Op 28 Feb 2007 15:16:19 -0800 schreef keo...@gmail.com:

Why are you interested in my solution?
Why don't you give it a try?
Then we'll discuss it further.

--
Coos

CHForth, 16 bit DOS applications
http://home.hccnet.nl/j.j.haak/forth.html

Cesar Rabak

unread,
Feb 28, 2007, 7:42:02 PM2/28/07
to
keo...@gmail.com escreveu:
[snipped]

> As I am interested but not yet very proficient in stack based
> programming languages, I ask you: how would you solve this problem in
> FORTH?
>

Did you study the solution given in the post # 53?

John Passaniti

unread,
Feb 28, 2007, 7:42:34 PM2/28/07
to
keo...@gmail.com wrote:
> As I am interested but not yet very proficient in stack based
> programming languages, I ask you: how would you solve this problem in
> FORTH?

: fizz? 3 mod 0= dup if ." fizz" endif ;
: buzz? 5 mod 0= dup if ." buzz" endif ;

: doit 101 1 do
i fizz?
i buzz?
or 0= if i . endif
cr
loop
;

Andreas Kochenburger

unread,
Mar 1, 2007, 8:29:46 AM3/1/07
to
Hi
did you recently lose your driver's license?

<keo...@gmail.com> schrieb im Newsbeitrag
news:1172704579.4...@z35g2000cwz.googlegroups.com...

Andrew Haley

unread,
Mar 2, 2007, 7:29:39 AM3/2/07
to

The code is over-factored, making it hard to read. There is also too
much stack noise: this problem really doesn't need DUP SWAP etc.

A simple solution is

: bang
100 1 do
i 15 mod 0= if ." FizzBuzz " else
i 3 mod 0= if ." Fizz " else
i 5 mod 0= if ." Buzz " else
i . then then then
loop ;

There are many more complex and efficient solutions possible.

( "the numbers from 1 to 100" is ambiguous. I'm assuming a half-open
interval. )

Andrew.

Doug Hoffman

unread,
Mar 2, 2007, 8:04:01 AM3/2/07
to
On Mar 2, 7:29 am, Andrew Haley <andre...@littlepinkcloud.invalid>
wrote:

> Cesar Rabak <csra...@yahoo.com.br> wrote:
> > keo...@gmail.com escreveu:
> > [snipped]
> >> As I am interested but not yet very proficient in stack based
> >> programming languages, I ask you: how would you solve this problem in
> >> FORTH?
>
> > Did you study the solution given in the post # 53?
>
> The code is over-factored, making it hard to read. There is also too
> much stack noise: this problem really doesn't need DUP SWAP etc.
>
> A simple solution is
>
> : bang
> 100 1 do
> i 15 mod 0= if ." FizzBuzz " else
> i 3 mod 0= if ." Fizz " else
> i 5 mod 0= if ." Buzz " else
> i . then then then
> loop ;

John Passaniti's solution is a bit cleaner IMO. He factors fizz and
buzz, which eliminates the need for 15 mod.

-Doug

Andrew Haley

unread,
Mar 2, 2007, 8:22:37 AM3/2/07
to

And adds a couple of DUPs and an OR. Shrug.

It's quite a clever solution. There's not much in it, really, and
either would be from my POV perfectly acceptable.

Andrew.

J Thomas

unread,
Mar 2, 2007, 10:48:03 AM3/2/07
to
On Mar 2, 7:29 am, Andrew Haley <andre...@littlepinkcloud.invalid>
wrote:
> Cesar Rabak <csra...@yahoo.com.br> wrote:
> > keo...@gmail.com escreveu:
> > [snipped]
> >> As I am interested but not yet very proficient in stack based
> >> programming languages, I ask you: how would you solve this problem in
> >> FORTH?
>
> > Did you study the solution given in the post # 53?
>
> The code is over-factored, making it hard to read. There is also too
> much stack noise: this problem really doesn't need DUP SWAP etc.

I don't see any problem with that code. It looks fine to me.

> A simple solution is
>
> : bang
> 100 1 do
> i 15 mod 0= if ." FizzBuzz " else
> i 3 mod 0= if ." Fizz " else
> i 5 mod 0= if ." Buzz " else
> i . then then then
> loop ;

Your solution looks fine to me too.

Your code brings up something for me. I notice those three then then
thens. Forth doesn't usually have a way to skip over the rest of a
loop and then repeat. We have ways to break out of the loop, but not a
command to skip to the end of the loop. So we have ugly things like
then then then to do it, both in DO loops and in BEGIN loops.

I've never felt the need for an improvement there. Multiple THENs
don't actually cause a performance hit, only a very slight compile-
time hit. Wil Baden made his THENS command which palliates it.

Somehow I never noticed until now that you can get a similar result
with multiple BEGINs.

: bang1
0 BEGIN BEGIN 1+ cr
dup 3 mod DUP 0= if ." Fizz" then
over 5 mod dup 0= if ." Buzz" then
or 0= UNTIL
dup .
dup 100 >
UNTIL ;

I certainly don't want to propose this as clear writing or even
adequate code (like, the method would run over if you changed the
limit to 99BEG), it's just that I never thought of this as a single
loop with a continuation. If you had a word that was just like UNTIL
except it left a copy of the dest, it would effectively skip to (but
not past) the end of the loop on failure or execute the rest of the
loop on success.

BEGIN ... SKIP-TO-REPEAT ... SKIP-TO-REPEAT ... SKIP-TO-REPEAT ...
WHILE ... REPEAT

Again, I've never felt the need to have something like this, I've
always just accepted THEN THEN THEN as good enough.

Additional control structure words might someimes make the flow of
control clearer, provided we all remembered what they did. What we
already have is adequate.

: bang2
101 0 do
i 3 mod 0= 1 and
i 5 mod 0= 2 and or
case
0 of i . endof
1 of Fizz endof
2 of Buzz endof
3 of FizzBuzz endof
endcase
loop ;

This one doesn't read better either, but at least the most common
cases are tested the most often. A jump table might be more efficient
but also less readable.

: DUP. dup . ;

CREATE TABLE
' DUP. ,
' Fizz ,
' Buzz ,
' FizzBuzz ,

: do-it
CELLS TABLE + @ EXECUTE ;

: which-action ( n -- n 0|1|2|3 )
dup
i 3 mod 0= 1 and
i 5 mod 0= 2 and or ;

: Bang3
0 begin
1+ dup 101 <
while
which-action do-it
repeat drop ;

I guess when the first methods I learned give a result that isn't too
long, then that's the most readable. There's nothing hard to
understand about nested IF THENs. Just, if they get too complex you
can lose track of how deeply they're nested and which places which
result happens.

Bruce McFarling

unread,
Mar 2, 2007, 11:03:12 AM3/2/07
to
On Mar 2, 7:29 am, Andrew Haley <andre...@littlepinkcloud.invalid>
wrote:
> A simple solution is

> : bang
> 100 1 do
> i 15 mod 0= if ." FizzBuzz " else
> i 3 mod 0= if ." Fizz " else
> i 5 mod 0= if ." Buzz " else
> i . then then then
> loop ;

Factor it and you'll be there. John Passaniti has a good factoring.

Doug Hoffman

unread,
Mar 2, 2007, 12:34:23 PM3/2/07
to
On Mar 2, 8:22 am, Andrew Haley <andre...@littlepinkcloud.invalid>
wrote:

> And adds a couple of DUPs and an OR. Shrug.

>
> It's quite a clever solution. There's not much in it, really, and
> either would be from my POV perfectly acceptable.

Yes. It's no big deal one way or the other. My first version looked
more like John's and was coded as fast as I could type it (as I
suspect was the case for you and John and most Forthers). But I do
worry a bit when I see triply nested IF-ELSE-THENs.

In the Mops kernel we have always had NIF, which is the same as 0=
IF. I find NIF to be very useful. Using that and after seeing John's
code, my favorite would be the following:

: fizz? ( n -- flag ) \ flag is 0 if hit
3 mod dup NIF ." Fizz" THEN ;

: buzz? ( n -- flag ) \ flag is 0 if hit
5 mod dup NIF ." Buzz" THEN ;

: FizzBuzz
101 1 DO cr
i fizz?
i buzz?
* IF i . THEN
LOOP ;


-Doug

p.s. Wait! I forgot to use objects! I must be coming down with the
flu or something. ;-)

Gerry

unread,
Mar 3, 2007, 9:37:16 AM3/3/07
to

Nothing wrong with other solutions but a simple solution avoiding
nested ifs etc uses bit vectors. The constants can be stuck in line

hex
1249 constant 3vec
0421 constant 5vec
4000 constant probe
3vec 5vec or constant 3or5vec
decimal

: bang
cr 0 101 1
do
?dup 0= if probe then
3or5vec over and 0= if i . then
3vec over and if ." fizz" then
5vec over and if ." buzz" then
1 rshift cr
loop
drop
;


Bruce McFarling

unread,
Mar 3, 2007, 10:31:29 AM3/3/07
to

one reason I find this one well factored is that when I tried, I
found it was easy to make the pretty printing as a separate factor:

: fizz? ( n -- fl ) 3 MOD 0= DUP IF ." Fizz" THEN ;
: buzz? ( n -- fl ) 5 MOD 0= DUP IF ." Buzz" THEN ;
: ?.fizzbuzz-WS ( fl1 fl2 -- fl1 fl2 )
2DUP AND IF CR ELSE 2DUP OR IF SPACE THEN THEN
;

: bang1 ( -- ) 101 1 DO
I fizz? I buzz? ?.fizzbuzz-WS
OR 0= IF I . THEN
LOOP
;

J Thomas

unread,
Mar 3, 2007, 11:09:46 AM3/3/07
to
On Mar 3, 9:37 am, "Gerry" <g...@jackson9000.fsnet.co.uk> wrote:

> Nothing wrong with other solutions but a simple solution avoiding
> nested ifs etc uses bit vectors. The constants can be stuck in line
>
> hex
> 1249 constant 3vec
> 0421 constant 5vec
> 4000 constant probe
> 3vec 5vec or constant 3or5vec
> decimal
>
> : bang
> cr 0 101 1
> do
> ?dup 0= if probe then
> 3or5vec over and 0= if i . then
> 3vec over and if ." fizz" then
> 5vec over and if ." buzz" then
> 1 rshift cr
> loop
> drop
> ;

Very nice! I think I can make that solution more readable, though less
efficient.


variable 5mod
variable 3mod

\ repeated test3 will count to 3 and then start over at 0. Leaves a
true flag every 3rd time.
: test3 ( -- flag )
3mod @ 1+ dup 3 = if drop 0 then dup 3mod ! 0= ;

: test5 ( -- flag )
5mod @ 1+ dup 5 = if drop 0 then dup 5mod ! 0= ;

: bang
0 3mod ! 0 5mod !
101 1 do
cr
test3 dup if ." Fizz" then 0=
test5 dup if ." Buzz" then 0=
and if i . then
loop ;


We could get rid of the if in the tests.

: test3 ( -- flag )
3mod @ 1+ dup 3 = 3 and xor dup 3mod ! 0= ;

We could get rid of the variables.

: test3 ( n -- n' flag )
1+ dup 3 = 3 and xor dup 0= ;

We could factor the test to get rid of the constants.

: testN ( n limit -- n' limit flag )
>r 1+ dup r@ = r@ and xor r> over 0= ;

But it isn't getting more readable.

We can write for size and speed -- for efficiency. But an optimising
compiler might likely do it better. It isn't clear what to optimise,
either. On some processors MOD is slow. On others it isnt. With an
onchip data stack fetching variables might be very slow. Or maybe not.
Branches might be slow, but maybe not a few extra calls worth. It
makes no sense to try to optimise portable code beyond the obvious
things like taking unneeded calculations out of loops.

We can write for simplicity, to make the whole thing simpler which
reduces debugging effort and maybe decreases maintenance costs, and
the simpler code may be easier to find algorithmic improvements etc.
But simplicity is an esthetic judgement. What looks simple to one
person may look complex to another. My preference is to make it look
simpler to *me* since if the code ever does get maintained by someone
else I can't predict who'll do it. So I might as well get the benefits
now.

Writing to be easy for other people to read, it's better to avoid
subtle ideas. Anything that people find hard to understand before the
first cup of coffee is a problem.

This time around I'd say that all the 1-minute solutions are good, and
the things I put more time into come out worse.

Bruce McFarling

unread,
Mar 3, 2007, 12:17:08 PM3/3/07
to
On Mar 3, 11:09 am, "J Thomas" <jethom...@gmail.com> wrote:
> Writing to be easy for other people to read, it's better to avoid
> subtle ideas. Anything that people find hard to understand before the
> first cup of coffee is a problem.

That's why I liked John Passiniti's factoring ... it was easy enough
for me to read to directly add the pretty printing into the main loop
when I didn't like the way it printed ... it only took two iterations
to get it exactly right, which would be a record for me ... and then
that could come directly out as a word rather than being handled in
multiple locations.

The test of whether something is easy for other people to read
is other people trying to add a capability.

Gerry

unread,
Mar 3, 2007, 1:16:10 PM3/3/07
to

I'm not disagreeing with you but would just point out that it's
trivial to add pretty printing to other versions.

hex
1249 constant 3vec
0421 constant 5vec
4000 constant probe
3vec 5vec or constant 3or5vec
decimal

: bang
cr 0 101 1
do
?dup 0= if probe then

3or5vec over and 0= if i 2 .r then


3vec over and if ." fizz" then
5vec over and if ." buzz" then

dup 1 = if cr else space then
1 rshift
loop
drop
;

Frank Buss

unread,
Mar 3, 2007, 3:30:50 PM3/3/07
to
On Mar 2, 7:29 am, Andrew Haley <andre...@littlepinkcloud.invalid>
> wrote:
>> A simple solution is
>>
>>: bang
>> 100 1 do
>> i 15 mod 0= if ." FizzBuzz " else
>> i 3 mod 0= if ." Fizz " else
>> i 5 mod 0= if ." Buzz " else
>> i . then then then
>> loop ;

You wouldn't get the job, because you missed 100.

My first try was this:

: fizzbuzz
101 1 do
i 3 mod 0 = dup if ." Fizz" then
i 5 mod 0 = dup if ." Buzz" then
invert swap invert and if i . then
cr
loop ;

A bit like John's solution (is ENDIF ANS Forth?), but I have still to learn
more Forth.

--
Frank Buss, f...@frank-buss.de
http://www.frank-buss.de, http://www.it4-systems.de

Bruce McFarling

unread,
Mar 3, 2007, 5:29:22 PM3/3/07
to
On Mar 3, 1:16 pm, "Gerry" <g...@jackson9000.fsnet.co.uk> wrote:
> I'm not disagreeing with you but would just point out that it's
> trivial to add pretty printing to other versions.

The fact that you can add it to yours factored out as a single
word (I'll take your word for it that it factors out) is nowhere
near the same stress test as the fact that I can add it factored
out as a single word to John's.

But, yes, right aligned is even prettier

: fizz? ( n -- fl ) 3 MOD 0= DUP IF ." Fizz" THEN ;
: buzz? ( n -- fl ) 5 MOD 0= DUP IF ." Buzz" THEN ;

: ?.number ( n fl1 fl2 -- fl1 fl2 )
2DUP 2>R OR 0= IF 2 .R THEN 2R> ;

: .FizzBuzz-WS ( fl1 fl2 -- ) AND IF CR ELSE SPACE THEN ;

: .FizzBuzz-item ( n -- ) DUP fizz? OVER buzz? ?.number .FizzBuzz-WS ;

: bang1 ( -- ) 101 1 DO I .FizzBuzz-item LOOP ;

CR CR .( bang1 ) CR bang1 CR CR

Doug Hoffman

unread,
Mar 3, 2007, 6:13:45 PM3/3/07
to
On Feb 28, 7:42 pm, John Passaniti <n...@JapanIsShinto.com> wrote:

My first solution (i.e. 1-minute solution) was this:

: fizz? ( n -- flag )

3 mod 0= ;

: buzz? ( n -- flag )

5 mod 0= ;

0 value notfound

: FizzBuzz
101 1 DO cr true to notfound
i fizz? IF ." Fizz" false to notfound THEN
i buzz? IF ." Buzz" false to notfound THEN
notfound IF i . THEN
LOOP ;

Interesting that we both chose exactly the same names to factor out.

I knew that a local variable would be better than a global, but I was
thinking in terms of something that might be viewed by many non-Forth
programmers. But I also had a nagging feeling that something was not
quite right. When I saw your solution it answered that question as
you had the better, no variable at all, solution. Nice.

-Doug

Andrew Haley

unread,
Mar 4, 2007, 6:53:17 AM3/4/07
to
Frank Buss <f...@frank-buss.de> wrote:
> On Mar 2, 7:29 am, Andrew Haley <andre...@littlepinkcloud.invalid>
>> wrote:
>>> A simple solution is
>>>
>>>: bang
>>> 100 1 do
>>> i 15 mod 0= if ." FizzBuzz " else
>>> i 3 mod 0= if ." Fizz " else
>>> i 5 mod 0= if ." Buzz " else
>>> i . then then then
>>> loop ;

> You wouldn't get the job, because you missed 100.

When you removed my "I'm assuming a half-open interval" comment, were
you being deliberately deceitful?

Andrew.

J Thomas

unread,
Mar 5, 2007, 12:41:24 PM3/5/07
to
On Mar 3, 9:37 am, "Gerry" <g...@jackson9000.fsnet.co.uk> wrote:

> Nothing wrong with other solutions but a simple solution avoiding
> nested ifs etc uses bit vectors. The constants can be stuck in line
>
> hex
> 1249 constant 3vec
> 0421 constant 5vec
> 4000 constant probe
> 3vec 5vec or constant 3or5vec
> decimal
>
> : bang
> cr 0 101 1
> do
> ?dup 0= if probe then
> 3or5vec over and 0= if i . then
> 3vec over and if ." fizz" then
> 5vec over and if ." buzz" then
> 1 rshift cr
> loop
> drop
> ;

....

> As the perpetrator of this solution I'm very interested to know if it
> is generally considered good or bad, be as rude as you like I'm not
> the suicidal type. I'm rather surprised that you found it hard to read
> - I suppose a 2 line comment describing the method would have helped.

Yes, I think a 2 line comment would have done wonders.

I looked at it and saw some magic numbers. What are they for? Then I
looked at what you were doing with them, and it appeared you were
taking the I value and doing OVER AND 0= and getting correct results.
How could you do that? Did you have some advanced mathematical method
I'd never heard of? I tried to imagine how it could work and had no
idea. So before I did anything else I copied the code to a Forth and
tried it and verified that yes indeed, it did work.

Then I held my breath and decided that no matter how arcane it was, I
could understand it, all I had to do was study it. I looked closer at
the magic numbers. When I switched from hex to binary in my head I
noticed that 3vec had every third bit set. Ah! And then 5vec had every
fifth bit set. Then it was obvious except for the details. probe was
set to #4000, it needed to be reset precisely when both cycles were
complete, so bit 14 was the first digit that would work, do it exactly
15 times and reset. If the numbers had been 5 and 7 it would have been
harder to do.

There's nothing wrong with this. On a system where division is slow it
will run fast. On a system where nesting is slow and division is fast,
it will run slow. It isn't a method that's obvious with no comments
before the first cup of coffee. I was slow to see it partly because I
was ready to believe it might be something arcane I'd never seen
before at all, that I might have trouble with.

If we're going to judge readability, compare it with Andrew Haley's
solution.

: bang
100 1 do
i 15 mod 0= if ." FizzBuzz " else
i 3 mod 0= if ." Fizz " else
i 5 mod 0= if ." Buzz " else
i . then then then
loop ;

This solution has absolutely nothing unexpected. First case. Second
case. Third case. Fourth case. Precisely one of the four paths will be
taken. No trickiness about executing the Buzz path after the Fizz path
has already gone through. Nothing tricky anywhere. The code is bigger
than other good solutions. It will take longer to run than some --
more than half the time you do 3 mods and 3 elses. But there's nothing
here that can be misunderstood.

Readability isn't the only issue. Speaking for myself, I like to see
elegant solutions and new ideas. But the most-readable code won't have
anything new and it won't have anything that's shorter than
unexpected. Ideally it will appear to do exactly what the specs call
for, one requirement matching up with one stretch of code. So you go
down the list and see yes it did this, yes it did that, until you get
to the end. The only way Andrew's code misses this (apart from the
idea shared by everybody except computer programmers that when you say
"one to a hundred" it means start from 1 and continue until you've
done 100) is that the divisible-by-both case comes out of order.

Andrew Haley

unread,
Mar 5, 2007, 1:15:33 PM3/5/07
to
J Thomas <jeth...@gmail.com> wrote:

> If we're going to judge readability, compare it with Andrew Haley's
> solution.

> : bang
> 100 1 do
> i 15 mod 0= if ." FizzBuzz " else
> i 3 mod 0= if ." Fizz " else
> i 5 mod 0= if ." Buzz " else
> i . then then then
> loop ;

> This solution has absolutely nothing unexpected. First case. Second
> case. Third case. Fourth case. Precisely one of the four paths will be
> taken. No trickiness about executing the Buzz path after the Fizz path
> has already gone through. Nothing tricky anywhere. The code is bigger
> than other good solutions.

No it isn't. AFAIK it's the smallest, both in the size of the source
and the object. John Passaniti's gets close, but it's 584 bytes long
whereas mine was 576. [AMD64 gforth.] Not that I was trying for small
size -- that was just a side-effect of a simple solution.

Andrew.

J Thomas

unread,
Mar 5, 2007, 2:12:20 PM3/5/07
to
On Mar 5, 1:15 pm, Andrew Haley <andre...@littlepinkcloud.invalid>
wrote:
> J Thomas <jethom...@gmail.com> wrote:

> > This solution has absolutely nothing unexpected. First case. Second
> > case. Third case. Fourth case. Precisely one of the four paths will be
> > taken. No trickiness about executing the Buzz path after the Fizz path
> > has already gone through. Nothing tricky anywhere. The code is bigger
> > than other good solutions.
>
> No it isn't. AFAIK it's the smallest, both in the size of the source
> and the object. John Passaniti's gets close, but it's 584 bytes long
> whereas mine was 576. [AMD64 gforth.] Not that I was trying for small
> size -- that was just a side-effect of a simple solution.

I'm surprised. It has redundant code, I'd expect it to be larger.

John's code has surplus definitions and surplus calls due to his
factoring. If the headers count that will push up his size, if you
only count code then it's just a couple of extra calls.

With gForth 0.6.2

unused : bang


100 1 do
i 15 mod 0= if ." FizzBuzz " else
i 3 mod 0= if ." Fizz " else
i 5 mod 0= if ." Buzz " else
i . then then then

loop ; unused - .

got 304.

unused : bang
101 1 do
cr
i 3 mod 0= dup if ." Fizz" then
i 5 mod 0= dup if ." Buzz" then
or 0= if i . then
loop ; unused - .

gave 228.

: bang
101 1 do
cr
i 5 mod 0=
i 3 mod 0=
2dup or 0= if i . then
if ." Fizz" then
if ." Buzz" then
loop ;

gave 224 because it uses 2DUP in place of DUP DUP . It's harder to
read.

Andrew Haley

unread,
Mar 5, 2007, 2:32:50 PM3/5/07
to
J Thomas <jeth...@gmail.com> wrote:
> On Mar 5, 1:15 pm, Andrew Haley <andre...@littlepinkcloud.invalid>
> wrote:
>> J Thomas <jethom...@gmail.com> wrote:

>> > This solution has absolutely nothing unexpected. First case. Second
>> > case. Third case. Fourth case. Precisely one of the four paths will be
>> > taken. No trickiness about executing the Buzz path after the Fizz path
>> > has already gone through. Nothing tricky anywhere. The code is bigger
>> > than other good solutions.
>>
>> No it isn't. AFAIK it's the smallest, both in the size of the source
>> and the object. John Passaniti's gets close, but it's 584 bytes long
>> whereas mine was 576. [AMD64 gforth.] Not that I was trying for small
>> size -- that was just a side-effect of a simple solution.

> I'm surprised. It has redundant code, I'd expect it to be larger.

> John's code has surplus definitions and surplus calls due to his
> factoring. If the headers count

Well, yeah. Of course they count! I mean, someone had to pay for
that RAM they're in...

> that will push up his size, if you only count code then it's just a
> couple of extra calls.

Andrew.

John Passaniti

unread,
Mar 6, 2007, 1:46:03 AM3/6/07
to
J Thomas wrote:
> I'm surprised. It has redundant code, I'd expect it to be larger.

The point of FizzBuzz is that it is part of a coding skill test given to
job candidates. The author's claim is that many job candidates can't
code, and tests like FizzBuzz are used to weed such weaker candidates out.

My response in comp.lang.forth was simply to provide the original poster
an example of what he wanted-- how would the solution to FizzBuzz look
in Forth. One assumes that the original poster understood that there
are endless variations on a theme. One assumes the original poster
understands that one can optimize for different things-- size, speed,
clarity, programmer effort, generality, reusability, etc.

> John's code has surplus definitions and surplus calls due to his
> factoring. If the headers count that will push up his size, if you
> only count code then it's just a couple of extra calls.

If the problem statement for FizzBuzz had said, "minimize code size" or
"generalize your code so that other multiples can print out different
messages" then the choices I made would have been different. This is
why context matters. In a job interview, I would have taken less than a
minute to code my solution and would have been able to move on to other
problems. Those of you who are agonizing over if an additional term
could be factored out or are counting the number of bytes generated are
the ones who might have less time for the more substantive questions
during the interview.

Gerry

unread,
Mar 6, 2007, 6:57:30 AM3/6/07
to

Sorry I caused you some grief with the code. I must make an effort
with making my code more readable, after all its far less effort for 1
writer to do that compared to n readers decoding something.

Gerry

Doug Hoffman

unread,
Mar 6, 2007, 7:59:49 AM3/6/07
to
On Mar 6, 1:46 am, John Passaniti <put-my-first-name-

Your solution, in addition to excellent clarity and simplicity, IMO,
is also easily extensible. Consider the case where the problem is
expanded to include Boom (divisible by 7) and Zapp (divisible by 9):

: boom? ( n -- flag ) \ 0 if hit
7 mod 0= dup IF ." Boom" THEN ;

: zapp? ( n -- flag ) \ 0 if hit
9 mod 0= dup IF ." Zapp" THEN ;

: FizzBuzzBoomZapp
101 1 DO cr


i fizz?
i buzz? or

i boom? or
i zapp? or
0= IF i . THEN
LOOP ;

This is a reasonable variation of the original problem.
So 42 would yield FizzBoom and 45 would yield FizzBuzzZapp and so
forth. Two of your original definitions were re-usable.

-Doug

J Thomas

unread,
Mar 6, 2007, 8:32:01 AM3/6/07
to
On Mar 6, 1:46 am, John Passaniti <put-my-first-name-
h...@JapanIsShinto.com> wrote:
> J Thomas wrote:
> > I'm surprised. It has redundant code, I'd expect it to be larger.
>
> The point of FizzBuzz is that it is part of a coding skill test given to
> job candidates. The author's claim is that many job candidates can't
> code, and tests like FizzBuzz are used to weed such weaker candidates out.
>
> My response in comp.lang.forth was simply to provide the original poster
> an example of what he wanted-- how would the solution to FizzBuzz look
> in Forth. One assumes that the original poster understood that there
> are endless variations on a theme. One assumes the original poster
> understands that one can optimize for different things-- size, speed,
> clarity, programmer effort, generality, reusability, etc.
>
> > John's code has surplus definitions and surplus calls due to his
> > factoring. If the headers count that will push up his size, if you
> > only count code then it's just a couple of extra calls.
>
> If the problem statement for FizzBuzz had said, "minimize code size" or
> "generalize your code so that other multiples can print out different
> messages" then the choices I made would have been different.

I didn't at all intend to criticise your code. I think it is
excellent. The factoring is not a bad thing -- though I think the code
is a little more readable without it, and the factored definitions
that are used only once increase the code size a little. That isn't
any big deal, and in the context you were responding to -- a job
interview for a Forth job -- would show that you have the factoring
concept firmly in mind.

The lesson I got from this is that factoring into small short pieces
can impede readability, and that careful naming can reduce that
problem.

The lesson I got from my own experiments was that anything tricky
reduces readability and should be used only when there are clear
advantages that override that disadvantage.

Again, I meant no criticism. I thought that every solution except mine
was excellent. Gerry's solution had the disadvantage of not being what
a beginning Forth programmer would expect, which made it harder to
read. But in some systems his tests would be far faster. Of course,
more than half the time you're doing up to 3 mods or dmods to generate
a numeric string to . so it won't be that big a percentage
improvement.

Once again, as you point out, there was nothing about minimising code
size in the specs and there's no shame in not having the smallest code
when compiled on some particular system. I have no complaint about
your 1-minute code. I don't think it should be the standard for
judging code size since it's large, and that says nothing bad about
you or your code.

J Thomas

unread,
Mar 6, 2007, 8:37:35 AM3/6/07
to
On Mar 6, 6:57 am, "Gerry" <g...@jackson9000.fsnet.co.uk> wrote:

> Sorry I caused you some grief with the code. I must make an effort
> with making my code more readable, after all its far less effort for 1
> writer to do that compared to n readers decoding something.

It's no big deal. I wanted to note that code is more readable when it
does nothing unexpected. Your innovative solution was fundamentally
harder to read because it was innovative. Writing carefully to expose
your methods, along with careful documentation, could palliate that.
But anything that your readers don't expect is harder to read than
what they do expect, and there's no getting around that.

The Beez'

unread,
Mar 6, 2007, 10:27:38 AM3/6/07
to
This is a slight variation on that one (4tH only):

: zap dup 0 .r ; : fizz ." Fizz" ; : buzz ." Buzz" ; : fizzbuzz fizz
buzz ;
create foo ' zap , ' fizz , ' buzz , ' fizzbuzz ,
:this foo does> >r dup 5 mod 0= 2* over 3 mod 0= + cells r> + @c
execute drop ;
: bar 101 1 do i foo space loop ; bar

Hans Bezemer

Bruce McFarling

unread,
Mar 6, 2007, 10:34:22 AM3/6/07
to
On Mar 6, 6:57 am, "Gerry" <g...@jackson9000.fsnet.co.uk> wrote:
> Sorry I caused you some grief with the code. I must make
> an effort with making my code more readable, after all
> its far less effort for 1 writer to do that compared to
> n readers decoding something.

Ah, but a benefit of open-source is that the effort by
the one writer does not have to always be the code author.

Applying the rule, "explain magic numbers", I reckon
it gets to between first and second cup of coffee
stage for me, which for reasonably handy programmers
would probably push it back before the first cup.

hex

1249 constant 3vec \ = 0001001001001001, each 3rd bit set
0421 constant 5vec \ = 0000010000100001, each 5th bit set
4000 constant probe \ = 0100000000000000, edge of frame

Jerry Avins

unread,
Mar 6, 2007, 1:33:08 PM3/6/07
to

I prefer

binary

0001001001001001 constant 3vec \ each 3rd bit set
0000010000100001 constant 5vec \ 5th bit set
0100000000000000 constant probe \ edge of frame


3vec 5vec or constant 3or5vec

decimal

When a particular BASE is native to the problem, use it.

Jerry
--
Engineering is the art of making what you want from things you can get.
¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯

Bruce McFarling

unread,
Mar 6, 2007, 3:32:05 PM3/6/07
to
On Mar 6, 1:33 pm, Jerry Avins <j...@ieee.org> wrote:
> > hex
> > 1249 constant 3vec \ = 0001001001001001, each 3rd bit set
> > 0421 constant 5vec \ = 0000010000100001, each 5th bit set
> > 4000 constant probe \ = 0100000000000000, edge of frame
> > 3vec 5vec or constant 3or5vec
> > decimal

> I prefer

> binary
> 0001001001001001 constant 3vec \ each 3rd bit set
> 0000010000100001 constant 5vec \ 5th bit set
> 0100000000000000 constant probe \ edge of frame
> 3vec 5vec or constant 3or5vec
> decimal

Meaning that the commented above is better than the
uncommented, and the base that conveys the information
directly is even better?

I have no problem with that ranking at all.

numbers conv

ata...@gismu.com

unread,
Mar 7, 2007, 1:12:59 AM3/7/07
to
In pygmy forth:

: n DUP . 1+ ;
: f ." Fizz " 1+ ;
: b ." Buzz " 1+ ;
: fb ." FizzBuzz " 1+ ;
: y n n f n b f n n f b ;
: x y n f n n fb ;
: go 1 x x x x x x y DROP ;

Doug Hoffman

unread,
Mar 7, 2007, 7:35:23 AM3/7/07
to

Well, sometimes brute force will work. But if the problem description
changes then that approach often isn't helpful. For example, try
that for solving the FizzBuzzBoomZapp problem for say 1 through 1000.

-Doug

Bruce McFarling

unread,
Mar 7, 2007, 10:03:26 AM3/7/07
to
On Mar 7, 7:35 am, "Doug Hoffman" <dhoff...@talkamerica.net> wrote:
012345678901234567890123456789012345678901234567890123456789

> Well, sometimes brute force will work. But if the problem
> description changes then that approach often isn't
> helpful. For example, try that for solving the
> FizzBuzzBoomZapp problem for say 1 through 1000.

Ah, but you only have to find the LCD of the factors and
implement it for the LCD, with the numbers adding a value
passed to them on the stack and passing that value on
unmodified, then find the Modulus of the loop limit and
do a simple FOR loop, adding the LCD each time through
the loop, followed by enough of the LCD sequence to get
through to the loop terminus.

Of course, implementing the LCD and Modulus routines
are left as an exercise for the reader.

Doug Hoffman

unread,
Mar 7, 2007, 10:10:14 AM3/7/07
to

Or you could just use:

: FizzBuzzBoomZapp
1001 1 DO cr


i fizz?
i buzz? or
i boom? or
i zapp? or
0= IF i . THEN
LOOP ;

Q.E.D.

-Doug

J Thomas

unread,
Mar 7, 2007, 10:55:33 AM3/7/07
to

Which way is brute force? One way you do the calculations once and
never again. The other way you repeat them every time.

However, if the critical values are 3 5 7 11 then the least common
multiple is 1155 . You aren't going to have a lot of regular repeating
patterns in that. Better to use bit vectors or simulated bit vectors
than try to code it all into the definition.

I find your way far more readable. Anything innovative is harder to
read because the reader has to think.

Doug Hoffman

unread,
Mar 7, 2007, 12:06:19 PM3/7/07
to

It also took less than 30 seconds to code and worked first time
through.

Anything innovative is harder to
> read because the reader has to think.

What is the goal? Solving a problem or being "innovative"? One could
argue that John P's approach is indeed innovative, if that is deemed
important here.

-Doug

Bruce McFarling

unread,
Mar 7, 2007, 12:28:18 PM3/7/07
to
On Mar 7, 12:06 pm, "Doug Hoffman" <dhoff...@talkamerica.net> wrote:
> > > : FizzBuzzBoomZapp
> > > 1001 1 DO cr
> > > i fizz?
> > > i buzz? or
> > > i boom? or
> > > i zapp? or
> > > 0= IF i . THEN
> > > LOOP ;

> What is the goal? Solving a problem or being "innovative"?


> One could argue that John P's approach is indeed innovative,
> if that is deemed important here.

I prefer:

: bang3 ( -- ) 1001 1 DO i .FizzBuzzBoomZapp LOOP ;

John's approach translates directly to

: .FizzBuzzBoomZapp ( n -- )
DUP >R fizz?
R@ buzz? or
R@ boom? or
R@ zapp? or


0= IF i . THEN

RDROP ;

: bang3 ( -- ) 1001 1 DO i .FizzBuzzBoomZapp LOOP ;

Of course, it only makes a difference when it is
a real problem with a real world side-effect
as the primary target, and it comes time to
determine why the loop is not working correctly.
At that point, you'll want to do that factoring
between the loop and the loop action if you haven't
done so already.

As far as readability, if you are in the habit
of reading from back to front, the longer the
individual definition the more annoying.

Clever Monkey

unread,
Mar 7, 2007, 2:06:49 PM3/7/07
to

We have our Obfuscated Forth Contest winner.

Ian Osgood

unread,
Mar 7, 2007, 3:03:28 PM3/7/07
to
On Mar 6, 4:59 am, "Doug Hoffman" <dhoff...@talkamerica.net> wrote:

> Your solution, in addition to excellent clarity and simplicity, IMO,
> is also easily extensible. Consider the case where the problem is
> expanded to include Boom (divisible by 7) and Zapp (divisible by 9):
>
> : boom? ( n -- flag ) \ 0 if hit
> 7 mod 0= dup IF ." Boom" THEN ;
>
> : zapp? ( n -- flag ) \ 0 if hit
> 9 mod 0= dup IF ." Zapp" THEN ;
>
> : FizzBuzzBoomZapp
> 101 1 DO cr
> i fizz?
> i buzz? or
> i boom? or
> i zapp? or
> 0= IF i . THEN
> LOOP ;
>
> This is a reasonable variation of the original problem.
> So 42 would yield FizzBoom and 45 would yield FizzBuzzZapp and so
> forth. Two of your original definitions were re-usable.
>
> -Doug

Exercise: use CREATE-DOES> to remove the duplication between the *?
words.

Ian

Chuck Adams

unread,
Mar 7, 2007, 3:09:42 PM3/7/07
to
I believe my answer to the problem would go something like this:

: fizzbuzzoff ." I don't care for gimmicks. Good day" ;

When I interview a candidate, I prefer to pose real challenges that
touch on experience. No one interviewing an engineer asks them to
build a birdhouse.


John Passaniti

unread,
Mar 7, 2007, 6:44:49 PM3/7/07
to
Chuck Adams wrote:
> I believe my answer to the problem would go something like this:
>
> : fizzbuzzoff ." I don't care for gimmicks. Good day" ;
>
> When I interview a candidate, I prefer to pose real challenges that
> touch on experience.

I've worked with engineers who were terrible programmers. I've also
worked with engineers who simply didn't have a lot of experience
programming. Being a great engineer says nothing about your ability to
express the solution to a problem in code. The point of FizzBuzz-style
questions is to weed these candidates out (or to better identify their
strengths if they are hired).

FizzBuzz-style questions are also great if they have an element of
ambiguity to them. This forces the candidate to not just dive into the
problem, but to interact with you and resolve any questions and clarify
requirements. And quite often I've found, you learn the most about a
candidate not by the actual work on solving the FizzBuzz-style question,
but prior to it-- during the part when there is a back-and-forth in
better defining the problem. Are they asking intelligent questions?
Are they over-analyzing the problem? Are they asking questions because
they suffer from "specification paralysis."

> No one interviewing an engineer asks them to
> build a birdhouse.

Your refusal to do a FizzBuzz-style question because it doesn't pose a
"real challenge" would itself tell me something about your character and
likely experience. It might also say something about your respect for
others.

In terms of character, it might indicate you are a prima donna engineer
who likely wouldn't fit in with our company's culture. We don't believe
that any of us are so special that we are "above" any kind of work.

In terms of experience, your refusal to do a FizzBuzz-style question
might indicate a lack of real-world experience. Because in the real
world, although it sure would be nice if you could always be presented
with the most challenging work possible, sometimes you have to get your
hands dirty and just sling out some low-level code to solve an immediate
problem.

In terms of respect, you are applying for a job and you likely aren't
the only one. Most companies (like the one I work for) don't have
infinite resources, so any new hires represent a serious investment by
the company in you. The company conducts a job interview not to amuse
you for an afternoon, but to tell if an investment in you is worthwhile.
So we will ask you FizzBuzz-style questions as well as higher-level
questions to determine if you're the best candidate for the job.

Don't want to take the test? That's nice. Don't let the door slam you
on the ass on your way out.

Doug Hoffman

unread,
Mar 7, 2007, 7:51:30 PM3/7/07
to
On Mar 7, 12:28 pm, "Bruce McFarling" <agil...@netscape.net> wrote:

> John's approach translates directly to
>
> : .FizzBuzzBoomZapp ( n -- )
> DUP >R fizz?
> R@ buzz? or
> R@ boom? or
> R@ zapp? or
> 0= IF i . THEN
> RDROP ;
>
> : bang3 ( -- ) 1001 1 DO i .FizzBuzzBoomZapp LOOP ;
>
> Of course, it only makes a difference when it is
> a real problem with a real world side-effect
> as the primary target, and it comes time to
> determine why the loop is not working correctly.
> At that point, you'll want to do that factoring
> between the loop and the loop action if you haven't
> done so already.

Yes. I agree that is a reasonable factoring. As you say, it allows
for easy testing of the inner engine, divorced from the loop.

-Doug

Ron Aaron

unread,
Mar 7, 2007, 8:06:56 PM3/7/07
to
On Feb 28, 3:16 pm, keo...@gmail.com wrote:

Here's a solution (not the simplest) using Reva (note there are
distinctly non ANS words here):

create fizzbuzz " FizzBuzz" here,
variable fizzed

: fizzbuzz? ( i a mod -- i )
2 pick swap mod
0if 4 type fizzed on ;then drop ;

: num? ( i -- ) fizzed @ if space drop ;then . ;
: fizz? ( i -- i ) fizzbuzz 3 fizzbuzz? ;
: buzz? ( i -- i ) fizzbuzz cell+ 5 fizzbuzz? ;

: fb 101 1 do fizzed off i fizz? buzz? num? loop ;


I tried to avoid using conditionals and preferred to factor pretty
heavily. It depends on 4 byte cells, which Reva uses. It also adds a
space after the output word, for cleaner looking output.

Bruce McFarling

unread,
Mar 7, 2007, 9:58:10 PM3/7/07
to
On Mar 7, 12:28 pm, "Bruce McFarling" <agil...@netscape.net> wrote:
> John's approach translates directly to
>
> : .FizzBuzzBoomZapp ( n -- )
> DUP >R fizz?
> R@ buzz? or
> R@ boom? or
> R@ zapp? or
> 0= IF i . THEN
> RDROP ;

> : bang3 ( -- ) 1001 1 DO i .FizzBuzzBoomZapp LOOP ;

That'll teach me to send code from a computer without
a Forth installed:

: .FizzBuzzBoomZapp ( n -- )
DUP >R fizz?
R@ buzz? or
R@ boom? or
R@ zapp? or

0= IF R@ . THEN
RDROP ;

The last, conditional, I is, after all, which its
an RDROP at the end instead of a final R> ... and
then I didn't replace it.

Bernd Paysan

unread,
Mar 8, 2007, 4:57:06 AM3/8/07
to
Clever Monkey wrote:

Is it obfuscated? I think it's the ColorForth entry, because it uses the
most simple basics (apart from ." and .), and doesn't loop.

--
Bernd Paysan
"If you want it done right, you have to do it yourself"
http://www.jwdt.com/~paysan/

Andrew Haley

unread,
Mar 8, 2007, 5:14:18 AM3/8/07
to
Chuck Adams <cja...@gmail.com> wrote:
> I believe my answer to the problem would go something like this:

> : fizzbuzzoff ." I don't care for gimmicks. Good day" ;

> When I interview a candidate, I prefer to pose real challenges that
> touch on experience.

Sure, but these microproblems can be very revealing. Some apparently
fantastically knowledgeable people can fail, and that tells you
something. Also, having written code in an interview such a
microproblem, I was once asked what code the compiler I used would
generate for it. That, I tell you, really separates the sheep from
the goats.

Andrew.

Clever Monkey

unread,
Mar 8, 2007, 2:19:34 PM3/8/07
to
Bernd Paysan wrote:
> Clever Monkey wrote:
>
>> ata...@gismu.com wrote:
>>> In pygmy forth:
>>>
>>> : n DUP . 1+ ;
>>> : f ." Fizz " 1+ ;
>>> : b ." Buzz " 1+ ;
>>> : fb ." FizzBuzz " 1+ ;
>>> : y n n f n b f n n f b ;
>>> : x y n f n n fb ;
>>> : go 1 x x x x x x y DROP ;
>>>
>> We have our Obfuscated Forth Contest winner.
>
> Is it obfuscated? I think it's the ColorForth entry, because it uses the
> most simple basics (apart from ." and .), and doesn't loop.
>
It's obfuscated to my eyes, but I don't think in Forth anymore.

Doug Hoffman

unread,
Mar 9, 2007, 5:50:40 PM3/9/07
to

Once again I see words. But no results. Where is the better
definition?

Chuck Adams

unread,
Mar 9, 2007, 6:28:43 PM3/9/07
to
On Mar 7, 3:44 pm, John Passaniti <n...@JapanIsShinto.com> wrote:
[... cut to the summary, we all have threaded readers ...]

> Don't want to take the test? That's nice. Don't let the door slam you
> on the ass on your way out.

I answer technical questions just fine, and I ask them as well when
interviewing candidates. But of course, I always run into people
online who talk about who they'd "fire on the spot", or who they
wouldn't consider hiring based on some narrow technical case, and I'm
always curious as to whether they've ever actually been in that
position, or if it's just another case of "If I Ran the Zoo", or the
phenomenom where everyone on the internet is an amateur lawyer.

Consider for a moment that my answer was hyperbole. Consider what an
awesome waste of time it was to dress me down in such voluminous
prose. Maybe it's just that this microproblem was just so durned
silly... but I still stand by my aspersion.

chuck

J Thomas

unread,
Mar 9, 2007, 6:34:39 PM3/9/07
to
On Mar 9, 5:50 pm, "Doug Hoffman" <dhoff...@talkamerica.net> wrote:
> On Mar 7, 10:55 am, "J Thomas" <jethom...@gmail.com> wrote:
> > On Mar 7, 10:10 am, "Doug Hoffman" <dhoff...@talkamerica.net> wrote:
>
> > > Well, sometimes brute force will work. But if the problem description
> > > changes then that approach often isn't helpful. For example, try
> > > that for solving the FizzBuzzBoomZapp problem for say 1 through 1000.

> > Which way is brute force? One way you do the calculations once and


> > never again. The other way you repeat them every time.
>
> > However, if the critical values are 3 5 7 11 then the least common
> > multiple is 1155 . You aren't going to have a lot of regular repeating
> > patterns in that. Better to use bit vectors or simulated bit vectors
> > than try to code it all into the definition.
>
> Once again I see words. But no results. Where is the better
> definition?

It depends on your needs which is better.

The way you implied was brute force did an absolute minimum of
calculation at runtime. It had the loop unrolled, but factored. very
elegant, though you had to understand what it was doing to read the
code.

The other extreme did three divisions every time. It seemed to come
natural to a lot of people.

The intermediate did three table lookups every time, and it had things
arranged so the tables were bit-vectors and were easy to access. No
divisions, ever, except for those inherent in printing out numbers.
(Do it in hex and you can avoid those too.) Slower than the loop-
unrolling method, simpler than the brute force method, but again you
have to understand how it works to read the code.

I pointed out that the advantages of loop-unrolling for this problem
evaporate when the problem changes with more prime numbers and higher
N. Cycle length 15 is easy. Cycle length 1155 is not so easy. You
could find shorter cycles that do get repeated and alternate them, and
the code will be even less readable.

But the table lookups work fine then. You can use 4 tables for 4
variables, and OR the results.

> Once again I see words. But no results. Where is the better
> definition?

Was I unclear? Which is best depends on your goals. The loop-unrolling
method is the fastest. The bit-vector method is the most elegant. The
brute force method is the most readable.

Doug Hoffman

unread,
Mar 9, 2007, 7:15:26 PM3/9/07
to
On Mar 9, 6:34 pm, "J Thomas" <jethom...@gmail.com> wrote:

[big snip]

> Was I unclear?

Yes.

> Which is best depends on your goals. The loop-unrolling
> method is the fastest. The bit-vector method is the most elegant. The
> brute force method is the most readable.

Let's just solve the problem. My programming time is valuable. Last
I heard computers are pretty good at executing code. Where is the
better (elegant? maintainable? whatever?) solution?

J Thomas

unread,
Mar 9, 2007, 7:28:05 PM3/9/07
to

Now you are unclear. Tell us what "good" means to you and then you can
tell us what solution you like best.

Doug Hoffman

unread,
Mar 9, 2007, 7:53:07 PM3/9/07
to

Let's just solve the problem. Where is your solution (based on
elegance, maintainabillty, whatever, you pick)? I've already given my
solution.

J Thomas

unread,
Mar 9, 2007, 8:34:13 PM3/9/07
to

I like most of the solutions that have been presented. But if you want
the ultimate of maintainability, something like this is likely to be
good:

10 FOR I = 1 TO 100
20 IF (I MOD 3 = 0) THEN PRINT "Fizz";
30 IF (I MOD 5 = 0) THEN PRINT "Buzz";
40 IF ((I MOD 3 <> 0) AND (I MOD 5 <> 0)) THEN PRINT I;
50 PRINT
60 NEXT I

I don't really think that BASIC is easier to learn than Forth. But a
lot of people think it is, and a lot of people learn it very quickly
-- maybe partly because their confidence is so high. Practically
anybody can quickly learn enough BASIC to maintain this program.

It just doesn't get much more readable and maintainable than this.

Your time is valuable. The time of a high-school graduate who can
maintain a program like this is not. This program is the cheapest to
maintain.

Doug Hoffman

unread,
Mar 9, 2007, 8:49:26 PM3/9/07
to
On Mar 9, 8:34 pm, "J Thomas" <jethom...@gmail.com> wrote:


> I like most of the solutions that have been presented. But if you want
> the ultimate of maintainability, something like this is likely to be
> good:
>
> 10 FOR I = 1 TO 100
> 20 IF (I MOD 3 = 0) THEN PRINT "Fizz";
> 30 IF (I MOD 5 = 0) THEN PRINT "Buzz";
> 40 IF ((I MOD 3 <> 0) AND (I MOD 5 <> 0)) THEN PRINT I;
> 50 PRINT
> 60 NEXT I
>
> I don't really think that BASIC is easier to learn than Forth. But a
> lot of people think it is, and a lot of people learn it very quickly
> -- maybe partly because their confidence is so high. Practically
> anybody can quickly learn enough BASIC to maintain this program.

You didn't solve the problem. The problem was clearly defined as
FizzBuzzBoomZapp. From 1 to 1000. Read up a few posts if you didn't
catch that. (Hint: It might help to use Forth. I'm fairly certain
this is a Forth newsgroup.)

ata...@gismu.com

unread,
Mar 9, 2007, 10:20:30 PM3/9/07
to

(Hope this isn't a dupe. Waited a day and didn't see my reply...)

Yes, it is a color forth or machine forth inspired solution.
But there is nothing particularly machine or color forth
specific. It really is just basic forth. If the toy names for
the toy problem don't suit you, here is a version with long
names and very slightly refactored. I find it harder to read
than the original.

: show.number DUP . 1+ ;
: show.fizz ." Fizz " 1+ ;
: show.buzz ." Buzz " 1+ ;
: show.fizz.buzz ." FizzBuzz " 1+
;
: show.1.5 show.number show.number show.fizz
show.number show.buzz
;
: show.6.10 show.fizz show.number show.number
show.fizz show.buzz
;
: show.11.15 show.number show.fizz show.number
show.number show.fizz.buzz
;
: show.10 show.1.5 show.6.10 ;
: show.15 show.10 show 11.15 ;
: show.30 show.15 show.15 ;
: show.90 show.30 show.30 show.30 ;
: go 1 show.90 show.10 DROP ;


Now the following code is much more fun! I have tried to solve
the Fizz Buzz Boom Zap problem with a machine forth like forth:
no "-", "/", "*", "mod", or any kind of loop; but with multiple
exit points, recursion, and tail recursion elimination. Since
it has to produce output, I will assume the usual ., .", and
type. Sadly I don't have a colorForth or machine forth that I
can use to debug the code. Worse still, my forth foo isn't good
enough to teach my forth about the needed machine forth
behavior.

I will use the A register operations. They are primitives in
various machine forths, here are working def's for other forths.

variable A
: A@ A @ ;
: A! A ! ;
: @A A@ @ ;
: !A+ A@ ! A@ cell + A! ;

( Here are some challenge problems. Define these words so they
act like the machine forth versions. )

( "XIF" acts like "dup if" and "XTHEN" like "then" )
: XIF ; immediate
: XTHEN ; immediate

( Acts like ":" but needs to allow recursion. )
: X: ; immediate

( Something like ";" This is probably a tough exercise.
Remember, it should translate tail calls to jumps -- tail
recursion elimination at the least. The easy way out is just a
jump to next. )
: X; ; immediate

( The pair X: ;X have to somehow manage compile vs. interpret.
Colored words might help. )

( --------- Now the real code --------- )

X: 1- -1 + X; X: 1+ 1 + X;

X: mod1+ ( mod n -- n+1 )
( only works for n such that 0 <= n < mod )
1+ swap over xor XIF drop X; XTHEN swap drop X;

X: p.name? ( f name mod -- f )
@A mod1+ dup !A+ ( f name new.residue ;
m[A] = new.residue )
XIF drop drop X; XTHEN ( f )
drop type drop 0 X; ( 0 )

X: Fizz? " Fizz" 3 p.name? X;
X: Buzz? " Buzz" 5 p.name? X;
X: Boom? " Boom" 7 p.name? X; ( or 9 )
X: Zap? " Zap" 11 p.name? X;
X: Number? ( f -- f ; m[A] incremented )
@A 1+ !A XIF @A . X; XTHEN ." " X;

( a: how exactly does color forth do this? b: how would you do
it without colors? The "2 2 +" is just to emphasize at the
problem. )
variable fbbz.residues 2 2 + allot

X: go1 ( -- )
fbbz.residues A!
1 Fizz? Buzz? Boom? Zap? Number? drop X;

X: go.loop go1 1- XIF go.loop X; XTHEN X;
X: go fbbz.residues A!
0 !A+ 0 !A+ 0 !A+ 0 !A+ 0 !A+
1000 go.loop X;

J Thomas

unread,
Mar 9, 2007, 10:41:47 PM3/9/07
to

Have I done something that offended you? I think I'm detecting a
certain coolness to your tone. I remember years when this newsgroup
was nice and mellow, experts and hobbyists and newbies got along real
well. And only a few years ago the only real irritants were Jeff Fox
and John Passaniti. Oh well.

I like your solution to the 4 variable problem. If there's any
improvement to be made it would be factoring your 4 subroutines, which
repeat the exact same code 4 times and change only the data.

Here's one way:

: makesub ( n -- ) ( E: i -- 0|n )
CREATE C, PARSE-NAME STRING,
DOES> TUCK C@ MOD TUCK 0= IF 1+ COUNT TYPE 0 THEN DROP ;

3 makesub fizz? Fizz
5 makesub buzz? Buzz
7 makesub boom? Boom
9 makesub zapp? Zapp

I find this code harder to read, but I'm guessing it might be slightly
more maintainable since instead of copying and pasting the definition
you could just do

11 makesub zilch? Zilch

etc.

On the other hand, if you're going to have a whole series of them, why
name them? You could put the addresses of the data structures into an
array, and loop through the array. But this is overkill.

I think this is somewhat less readable. But the code should be
smaller. We re-use the same code 4 times. When should we sacrifice
readability for size? On memory-limited systems, one of Forth's
traditional niches?


Now, the bit-array approach is very nice but it depends on 3 5 *
fitting into a cell, and 3 5 * 7 * does not fit except in a few
systems. We can do without the double, triple, and quadruple bit-
arrays. I'll use a similar method that I think is more readable.

in place of .... 3 MOD DUP 0= IF ." Fizz" THEN

we can use

.... 1 fizzle DUP 2@ = IF ! ." Fizz" FALSE EXIT THEN +! TRUE ....

We count to three, when we get there we reset the counter.

One advantage of this approach is that it can be maintained by
somebody who isn't real clear what MOD does. And it's faster when MOD
is slow compared to this long expression.

Anyway, I liked your solution. And if you want readability, nothing
can beat the BASIC version which I won't bother to modify for you.

Doug Hoffman

unread,
Mar 10, 2007, 5:37:01 AM3/10/07
to
On Mar 9, 10:41 pm, "J Thomas" <jethom...@gmail.com> wrote:
> On Mar 9, 8:49 pm, "Doug Hoffman" <dhoff...@talkamerica.net> wrote:
>
> > On Mar 9, 8:34 pm, "J Thomas" <jethom...@gmail.com> wrote:
>
> > > I like most of the solutions that have been presented. But if you want
> > > the ultimate of maintainability, something like this is likely to be
> > > good:
>
> > > 10 FOR I = 1 TO 100
> > > 20 IF (I MOD 3 = 0) THEN PRINT "Fizz";
> > > 30 IF (I MOD 5 = 0) THEN PRINT "Buzz";
> > > 40 IF ((I MOD 3 <> 0) AND (I MOD 5 <> 0)) THEN PRINT I;
> > > 50 PRINT
> > > 60 NEXT I
>
> > > I don't really think that BASIC is easier to learn than Forth. But a
> > > lot of people think it is, and a lot of people learn it very quickly
> > > -- maybe partly because their confidence is so high. Practically
> > > anybody can quickly learn enough BASIC to maintain this program.
>
> > You didn't solve the problem. The problem was clearly defined as
> > FizzBuzzBoomZapp. From 1 to 1000. Read up a few posts if you didn't
> > catch that. (Hint: It might help to use Forth. I'm fairly certain
> > this is a Forth newsgroup.)
>
> Have I done something that offended you? I think I'm detecting a
> certain coolness to your tone.

Earlier you wrote:

> Which way is brute force? One way you do the
> calculations once and never again. The other
> way you repeat them every time.

> However, if the critical values are 3 5 7 11
> then the least common multiple is 1155 .
> You aren't going to have a lot of regular repeating
> patterns in that. Better to use bit vectors or
> simulated bit vectors than try to code it all into
> the definition.

I wanted to see this "better" definition. Its existence was as I
suspected.


J Thomas

unread,
Mar 10, 2007, 7:11:37 AM3/10/07
to
On Mar 10, 5:37 am, "Doug Hoffman" <dhoff...@talkamerica.net> wrote:

> > Have I done something that offended you? I think I'm detecting a
> > certain coolness to your tone.

> Earlier you wrote:

> > Which way is brute force? One way you do the
> > calculations once and never again. The other
> > way you repeat them every time.
> > However, if the critical values are 3 5 7 11
> > then the least common multiple is 1155 .
> > You aren't going to have a lot of regular repeating
> > patterns in that. Better to use bit vectors or
> > simulated bit vectors than try to code it all into
> > the definition.
>
> I wanted to see this "better" definition. Its existence was as I
> suspected.

?? Did it soun