```Here's my solution. It's a combination of iteration and recursion.
Drawing the fractal is itself iterative, but the rotate method is
recursive. The -f option writes output to a file rather than the
console. My program displays the output in simple ASCII and I did not
use the turtle graphics approach.

# file: fractal.rb
# author: Drew Olson

# Fractal class holds our fractal representation
class Fractal
def initialize level
raise ArgumentError if level<0
@fractal = build_fractal level
end

# to print the fractal, we flip the array (to print with base of the
# triangle on the bottom), format the fields so we get a space for
nils
# in the array, and join all the array rows together with new lines
def to_s
@fractal.reverse.map do |row|
row.map{|char| "%1s" % char}.join("")
end.join("\n")
end

private

# the height of the fractal can be calculated using the sum
# below
def get_height level
(1..level).inject(1){|sum,i| sum+3**(i-1)}
end

# this method tells us which direction to turn after drawing
# character i. if i%5 is 0..3, we make our standard move, dictated
# by the shape of the fractal, every time. if i%5 is 4, we make a
# move that is resursively defined by the fractal, hence we recal
# get_dir after dividing i by 5.
# cc - counter-clockwise
# c - clockwise
def get_dir i
if i%5 == 4
get_dir(i/5)
elsif i%5 == 0 || i%5 == 3
:cc
elsif i%5 == 1 || i%5 == 2
:c
end
end

# here we define the direction that results when rotating
# from the current direction either clockwise or counter-clockwise
dir == :cc ? :w : :e
dir == :cc ? :e : :w
dir == :cc ? :n : :s
dir == :cc ? :s : :n
end
end

# builds the fractal, given a level
def build_fractal level
x,y = 0,0

# build a 2D array initialized to the correct height. i represents
the
# index of the current character we are drawing.
(0...5**level).inject(Array.new(get_height(level)){[]}) do
|fractal,i|
# store character in array based on heading, then update
# x y coordinates
fractal[y][x] = "|"
x += 1
y += 1
y -= 1
fractal[y][x] = "|"
x += 1
fractal[y][x] = "_"
x += 1
x -= 2
fractal[y][x] = "_"
x -= 1
end
fractal
end
end
end

# handles IO. the -f flag takes a file name and writes the
# output to a file. if the flag is excluded, the output is
# printed to the console
# Usage:
# ruby fractal.rb 3 -> prints level 3 fractal to the console
# ruby fractal.rb 6 -f level6.txt -> prints level 6 fractal to file
if __FILE__ == \$0
if ARGV == "-f"
file_name = ARGV
File.open(file_name,"w") do |out|
Fractal.new(ARGV.to_i).to_s.each do |line|
out << line
end
end
else
puts Fractal.new(ARGV.to_i)
end
end

--
Posted via http://www.ruby-forum.com/.

```