Main content

### Course: Computer science theory > Unit 1

Lesson 6: Recursive algorithms- Recursion
- The factorial function
- Challenge: Iterative factorial
- Recursive factorial
- Challenge: Recursive factorial
- Properties of recursive algorithms
- Using recursion to determine whether a word is a palindrome
- Challenge: is a string a palindrome?
- Computing powers of a number
- Challenge: Recursive powers
- Multiple recursion with the Sierpinski gasket
- Improving efficiency of recursive functions
- Project: Recursive art

© 2024 Khan AcademyTerms of usePrivacy PolicyCookie Notice

# Multiple recursion with the Sierpinski gasket

So far, the examples of recursion that we've seen require you to make one recursive call each time. But sometimes you need to make multiple recursive calls. Here's a good example, a mathematical construct that is a fractal known as a

**Sierpinski gasket**:As you can see, it's a collection of little squares drawn in a particular pattern within a square region. Here's how to draw it. Start with the full square region, and divide it into four sections like so:

Take the three squares with an × through them—the top left, top right, and bottom right—and divide them into four sections in the same way:

Keep going. Divide every square with an × into four sections, and place an × in the top left, top right, and bottom right squares, but never the bottom left.

Once the squares get small enough, stop dividing. If you fill in each square with an × and forget about all the other squares, you get the Sierpinski gasket. Here it is once again:

To summarize, here is how to draw a Sierpinski gasket in a square:

- Determine how small the square is. If it's small enough to be a base case, then just fill in the square. You get to pick how small "small enough" is.
- Otherwise, divide the square into upper left, upper right, lower right, and lower left squares. Recursively "solve" three subproblems:
- Draw a Sierpinski gasket in the upper left square.
- Draw a Sierpinski gasket in the upper right square.
- Draw a Sierpinski gasket in the lower right square.

Notice that you need to make not just one but

**three**recursive calls. That is why we consider drawing a Sierpinski gasket to exhibit multiple recursion.You can choose any three of the four squares in which you recursively draw Sierpinski gaskets. The result will just come out rotated by some multiple of 90 degrees from the drawing above. (If you recursively draw Sierpinski gaskets in any other number of the squares, you don't get an interesting result.)

The program below draws a Sierpinski gasket. Try commenting and uncommenting some of the recursive calls to get rotated gaskets:

This content is a collaboration of Dartmouth Computer Science professors Thomas Cormen and Devin Balkcom, plus the Khan Academy computing curriculum team. The content is licensed CC-BY-NC-SA.

## Want to join the conversation?

- How would this look like in code?(24 votes)
- Apparently your question was heeded by the creator of this course. There is now a code window of it in this article.(13 votes)

- Was this section a more recent addition to the chapter? The guidelines in the project appear to be for a completely different project (recursive art). I completed the Sierpinksi Gasket but one of the evaluator's guidelines is that the project should change colour at each level of recursion, which seems pointless considering that nothing gets coloured in until the base case anyway.(9 votes)
- If found the instruction "Try commenting and uncommenting some of the recursive calls to get rotated gaskets" confusing, because you don't get rotated gaskets unless you leave exactly one call commented out and three calls active. So I would rewrite this to say one of the following: "Try commenting and uncommenting some of the recursive calls (including the one that's commented out in the code) to see what happens." Or: "Try changing which one of the four recursive calls is commented out to get gaskets rotated in different orientations."(4 votes)
- Would it be possible to go farther than you showed us and go as far as you would like to, or is there at least a limit to how far you can go?(2 votes)
- Recursion typically uses "stack memory" to hold the state of the variables before each recursive call. So every time a recursive call is made, more of stack memory is used up. With enough recursive calls, you run out of stack memory, which gives you a "stack overflow error". So, if you had infinite memory you could go on for ever, but in reality, you run out of stack memory fairly quickly.(5 votes)

- How would one explain this in a presentation to 8th graders?(3 votes)
- Hello - what is the "main" function here? I don't understand what makes interpreter call the function "draw()" - because there is no invocation, just declaration of draw().(2 votes)
- Roughly, it's working within the "Processing" programming environment. So
`processing.js`

, which you don't see, calls the`draw`

function.

Note: The exact details may be slightly different. But this is, in essence, what is going on.(2 votes)

- this is complete confusing(2 votes)