Imagine you're a real life magician, and can make a copy of yourself. You create your double a step closer to the goal and give him (or her) the same orders as you were given.

Your double does the same to his copy. He's a magician too, you see.

When the final copy finds itself created at the goal, it has nowhere more to go, so it reports back to its creator. Which does the same.

Eventually, you get your answer back – without having moved an inch – and can now create the final result from it, easily. You get to pretend not knowing about all those doubles doing the actual hard work for you. "Hmm," you're saying to yourself, "what if I were one step closer to the goal andalready knewthe result? Wouldn't it beeasyto find the final answerthen?"^{*}

Of course, if you were a double, you'd have to report your findings to your creator.

^{*} and that is the essence of the recursion method of problem solving.

How do I know my procedure is right? If my simple little combination step produces a valid solution, under assumption it produced the correct solution for the smaller case, all I need is to make sure it works for the smallest case – the base case – and then by induction the validity is proven!

Another possibility is divide-and-conquer, where we split our problem in two halves, so will get to the base case much much faster. As long as the combination step is simple (and preserves validity of solution of course), it works. In our magician metaphor, I get to create two copies of myself, and combine their two answers into one when they are finished. Each of them creates two copies of themselves as well, so this creates a branching tree of magicians, instead of a simple line as before.

A good example is the Sierpinski triangle which is a figure that is built from three quarter-sized Sierpinski triangles simply, by stacking them up at their corners.

Each of the three component triangles is built according to the same recipe.

Although it doesn't have the base case, and so the recursion is unbounded (bottomless; infinite), any finite representation of S.T. will presumably draw just a dot in place of the S.T. which is too small (serving as the base case, stopping the recursion).

There's a nice picture of it in the linked Wikipedia article.

Recursively drawing an S.T. without the size limit will never draw anything on screen! For mathematicians recursion may be great, engineers though should be more cautious about it. :)

Switching to corecursion ⁄ iteration (see the linked answer for that), we would first draw the outlines, and the interiors after that; so even without the size limit the picture would appear pretty quickly. The program would then be busy without any noticeable effect, but that's better than the empty screen.

Imagine you're a real life magician, and can make a copy of yourself. You create your double a step closer to the goal and give him (or her)

the same ordersas you were given.Your double does the same to his copy. He's a magician too, you see.

When the final copy finds itself created

at the goal, it has nowhere more to go, so it reports back to its creator. Which does the same.Eventually, you get your answer back –

– and can now create the final result from it, easily. You get to pretend not knowing about all those doubles doing the actual hard work for you.without having moved an inch"Hmm,"you're saying to yourself,"what if I were one step closer to the goal andalready knewthe result? Wouldn't it beeasyto find the final answerthen?"^{*}Of course, if

youwere a double, you'd have to report your findings toyourcreator.More here.

(also, I think I saw this "doubles" creation chain event here, though I'm not entirely sure).

^{*}and that is the essence of the recursion method of problem solving.How do I know my procedure is right? If my simple little combination step produces a valid solution, under assumption it produced the correct solution for the smaller case, all I need is to make sure it works for the smallest case – the base case – and then by

inductionthe validity is proven!Another possibility is divide-and-conquer, where we split our problem in two halves, so will get to the base case much much faster. As long as the combination step is

simple(and preserves validity of solution of course), it works. In our magician metaphor, I get to createtwocopies of myself, and combine their two answers into one when they are finished. Each of them creates two copies of themselves as well, so this creates a branching tree of magicians, instead of a simple line as before.A good example is the Sierpinski triangle which is a figure that is built from

threequarter-sizedSierpinski trianglessimply, by stacking them up at their corners.Each of the three component triangles is built according to

the same recipe.Although it doesn't have the base case, and so the recursion is unbounded (bottomless; infinite), any

finiterepresentation of S.T. will presumably draw just a dot in place of the S.T. which is too small (serving as the base case, stopping the recursion).There's a nice picture of it in the linked Wikipedia article.

Recursively drawing an S.T. without the size limit will never draw anything on screen! For mathematicians recursion may be great, engineers though should be more cautious about it. :)

Switching to

corecursion⁄ iteration (see the linked answer for that), we would first draw the outlines, and the interiors after that; so even without the size limit the picture would appear pretty quickly. The program would then be busy without any noticeable effect, but that's better than the empty screen.