Pentagram

A pentagram is a star polygon, consisting of a central pentagon of which each side forms the base of an isosceles triangle.

The vertex of each triangle, a point of the star, is 36 degrees.

The task: draw (or print) a regular pentagram, in any orientation. Use a different color (or token) for stroke and fill, and background.

For the fill it should be assumed that all points inside the triangles and the pentagon are inside the pentagram.

J

Probably the simplest approach is:

This will give a pentagram with a blue border and a white interior.

Java

Works with: Java version 8

<lang java>import java.awt.*; import java.awt.geom.Path2D; import javax.swing.*;

public class Pentagram extends JPanel {

   final double degrees144 = Math.toRadians(144);

   public static void main(String[] args) {
       SwingUtilities.invokeLater(() -> {
           JFrame f = new JFrame();
           f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
           f.setTitle("Pentagram");
           f.setResizable(false);
           f.add(new Pentagram(), BorderLayout.CENTER);
           f.pack();
           f.setLocationRelativeTo(null);
           f.setVisible(true);
       });
   }

   public Pentagram() {
       setPreferredSize(new Dimension(640, 640));
       setBackground(Color.white);
   }

   private void drawPentagram(Graphics2D g, int len, int x1, int y1) {
       double angle = 0;

       for (int i = 0; i < 5; i++) {
           int x2 = x1 + (int) (Math.cos(angle) * len);
           int y2 = y1 + (int) (Math.sin(-angle) * len);
           g.drawLine(x1, y1, x2, y2);
           x1 = x2;
           y1 = y2;
           angle -= degrees144;
       }
   }

   private void fillPentagram(Graphics2D g, int len, int x, int y) {
       double angle = 0;

       Path2D.Float p = new Path2D.Float();
       p.moveTo(x, y);

       for (int i = 0; i < 10; i++) {

           x = x + (int) (Math.cos(angle) * len);
           y = y + (int) (Math.sin(-angle) * len);
           p.lineTo(x, y);

           angle += (i % 2 == 0 ? 0.5 : -1) * degrees144;
       }

       p.closePath();
       g.fill(p);
   }

   @Override
   public void paintComponent(Graphics gg) {
       super.paintComponent(gg);
       Graphics2D g = (Graphics2D) gg;

       g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
               RenderingHints.VALUE_ANTIALIAS_ON);

       g.setStroke(new BasicStroke(5, BasicStroke.CAP_ROUND, 0));

       g.setColor(new Color(0xFFD700)); // gold
       fillPentagram(g, 190, 72, 250);

       g.setColor(Color.darkGray);
       drawPentagram(g, 500, 70, 250);
   }

}</lang>

PostScript

<lang postscript>%!PS-Adobe-3.0 EPSF %%BoundingBox: 0 0 200 600

/n 5 def % 5-star; can be set to other odd numbers

/s { gsave } def /r { grestore } def /g { .7 setgray } def /t { 100 exch translate } def /p { 180 90 n div sub rotate 0 0 moveto n { 0 160 rlineto 180 180 n div sub rotate } repeat closepath } def

s 570 t p s g eofill r stroke r % even-odd fill s 370 t p s g fill r stroke r % non-zero fill s 170 t p s 2 setlinewidth stroke r g fill r % non-zero, but hide inner strokes

%%EOF</lang>

Tcl

This implementation draws a simple pentagon on a Canvas widget. <lang Tcl> package require Tk set pi [expr 4*atan(1)]

pack [canvas .c] -expand yes -fill both ;# create the canvas

update ;# draw everything so the dimensions are accurate

set w [winfo width .c] ;# calculate appropriate dimensions set h [winfo height .c] set r [expr {min($w,$h) * 0.45}]

set points [lmap n {0 1 2 3 4 5} {

   set n [expr {$n * 2}]
   set y [expr {sin($pi * 2 * $n / 5) * $r + $h / 2}]
   set x [expr {cos($pi * 2 * $n / 5) * $r + $w / 2}]
   list $x $y

}] set points [concat {*}$points] ;# flatten the list

puts [.c create line $points]

a fun reader exercise is to make the shape respond to mouse events, or animate it!

</lang>

Racket

<lang racket>#lang racket (require 2htdp/image)

(overlay

(star-polygon 100 5 2 "outline" (make-pen "blue" 4 "solid" "round" "round"))
(star-polygon 100 5 2 "solid" "cyan"))</lang>