Question

Write simplistic recursive Java code for Sierpinski

I made a psuedo code tell me if anything wrong with it:

// x - left edge, y - right edge, z - peak, num - number of times the program is supposed to run

public void drawTriangle (int x, int y, int z, int num)

maketriangle(x,y,z); //imaginary method to create triangle using coordinates.

if (num == 0) {

return;

}

else {

int midxy = (y-x)/2;

int midxz = (z-x)/2;

int midyz = (z-y)/2;

drawTriangle(x, midxy, midxz, num);

  drawTriangle(y, midxy, midyz, num);

  drawTriangle(z, midxz, midyz, num);

num--;

}

}

Please note you must find problems in the above simple code that I wrote and also write the code which will take coordinates of 3 points instead of 3 points. The parameters for the method that you write will contain 7 parameters.

Answer 1

Hello, I have answered similar question before. Here is the completed code for drawing sierpinski triangles with 5 levels. You can find the main recursive method to draw sierpinski triangles and find out the working of it (Highlighted in bold text). Comments are included, go through it, learn how things work and let me know if you have any doubts or if you need anything to change. If you are satisfied with the solution, please rate the answer. Thanks

Note: In the question, you mentioned that the method should have 7 parameters. But all I could think of is 5 parameters – 3 Points to denote the coordinates, 1 Graphics object to draw the triangles and 1 integer denoting the number of levels of triangles. If you need to change this, you should provide me info regarding that 7 parameters.

// Sierpinski.java

import java.awt.*;

import javax.swing.JFrame;

import javax.swing.JPanel;

public class Sierpinski extends JFrame {

              public static final int SIZE = 400; // height/width of DrawingPanel

              private JPanel drawPanel; // panel to which the triangles are drawn

              public Sierpinski() {

                           // setting up panel and adding to frame

                           drawPanel = new JPanel();

                           drawPanel.setPreferredSize(new Dimension(SIZE, SIZE));

                           add(drawPanel);

                           setDefaultCloseOperation(EXIT_ON_CLOSE);

                           pack();

                           setVisible(true);

              }

              @Override

              public void paint(Graphics g) {

                           super.paint(g);

                           // getting a graphics object from drawing panel

                           Graphics graphics = drawPanel.getGraphics();

                           // finding the coordinates of top center, bottom left and bottom right

                           Point p1 = new Point(drawPanel.getWidth() / 2, 0);

                           Point p2 = new Point(0, drawPanel.getHeight());

                           Point p3 = new Point(drawPanel.getWidth(), drawPanel.getHeight());

                           // drawing sierpinski triangles with levels = 5

                           drawSierpinski(p1, p2, p3, graphics, 5);

              }

              public static void main(String[] args) {

                           new Sierpinski();

              }

              /*

              * draws a single triangle

              *

              * @ Graphics g graphics object to draw the triangle

              *

              * @ Point p1,p2,p3 - coordinates

              */

              public static void drawTriangle(Point p1, Point p2, Point p3, Graphics g) {

                           /**

                           * creating a polygon with the points and filling it

                           */

                           Polygon p = new Polygon();

                           p.addPoint(p1.x, p1.y);

                           p.addPoint(p2.x, p2.y);

                           p.addPoint(p3.x, p3.y);

                           g.fillPolygon(p);

              }

              /**

              * The actual method that draws a general level-n Sierpinski triangle whose

              * vertices are (p1, p2, p3)

              *

              * @ int n: number of levels

              *

              * @ Graphics g graphics object

              *

              * @ Point p1,p2,p3 coordinates of the triangle

              */

              public static void drawSierpinski(Point p1, Point p2, Point p3, Graphics g,

                                         int n) {

                           if (n == 1) {

                                         // base case: simple triangle

                                         drawTriangle(p1, p2, p3, g);

                           } else {

                                         // get the three middle points between p1 and p2, p1 and p3, p2 and

                                         // p3

                                         Point p4 = new Point((p1.x + p2.x) / 2, (p1.y + p2.y) / 2);

                                         Point p5 = new Point((p2.x + p3.x) / 2, (p2.y + p3.y) / 2);

                                         Point p6 = new Point((p1.x + p3.x) / 2, (p1.y + p3.y) / 2);

                                         // using recursive call to draw three sub-triangles, with one less

                                         // value for n

                                         drawSierpinski(p1, p4, p6, g, n - 1);

                                         drawSierpinski(p4, p2, p5, g, n - 1);

                                         drawSierpinski(p6, p5, p3, g, n - 1);

                           }

              }

}

/*OUTPUT*/