Re: [QUIZ] Befunge (#184)

Hi,

This post has not much to do with a solution of the current QUIZ, but some
ideas about extensions to the QUIZ, so feel free to stop reading (and sorry
for bothering you).

My current solution looks almost the same as the others, so it's not so
interesting.  But the QUIZ inspired me to another funny problem: Try to
generate Befunge-code automatically:

An easy observation is, that one can split up Befunge-code into some linear
pieces.  Each piece of code is then connected to up to two following pieces
(by a '|' or '_', I don't look at random-jumps here).  So the problem is
the following: given some linear pieces of codes and knowing their
connections, write a program that arranges those pieces in the 80x25 (or
whatever) lattice and add the right commands to realize the required
connections.  For example, assume a program that reads to variables and
prints the greater one.  The linear pieces are:

&:01p&:11p`     ... INPUT X,Y and TEST
01g.@           ... PRINT X
11g.@           ... PRINT Y

so you have 3 pieces, and two connection (one from the first to second and
one from the first to the third, depending on the topmost value on the
stack).

A very simple approach is to put each piece in one line, leave some lines
empty and use that empty lines to connect the pieces.  My implementation of
this approach is attached to this message.  The example above would
generate the following code (without the '#'):
###################
#v            > v #
#> &:01p&:11p`|>  #
#             >  v#
#                 #
#  01g.@        > #
#                 #
#                 #
#  11g.@         >#
###################

The attached program includes the euclidian algorithm as a second example,
i.e. the program generates a Befunge-program that reads two numbers and
computes the gcd.

I can imagine two interesting tasks:

1. write some simple high-level-language that can be compiled to linear
pieces of code with the correct connections.  Together with my example one
could create a language-to-Befunge compiler (i.e. using Befunge
as 'assembly').  The language should support conditionals (IF, THEN, ELSE)
and loops (WHILE), and perhaps, if you're really good, subroutines (the
latter would be more challenging, I think). 

2. write better arrangements of the code-pieces.  In my implementation much
space is wasted.  Remember, linear pieces do not need to be in one line,
the may contain turns or jumps or whatever.  So one can ask
  a. how to generate very compact code
  b. how to generate code with a visually nice layout (think of a program
     computing Pi whose code looks like a Pi :))
  c. ...

These are just a view thoughts about extensions to the nice QUIZ.

Bye,
Frank