LTD Puzzle 2: Regular Pentagon

[AlexCuse]

Given a grid co-ordinate (x,y) as the centre point of a regular pentagon, and the sum of the length of the sides, return the co-ordinates of each point as: "Top", "MidLeft", "MidRight", "BottomLeft", "BottomRight" and the distance from the centre to each of the points.

This should work for any possible position of the centre point, and any length of the sides.

• All Sides are equal length in a Regular Pentagon
• x = horizontal scale, y=vertical
• scale increments can be anything you wish.. mm, cm, inches, feet, etc (doesn't matter) - though only whole units can be used

For added points, make it work for any regular polygon (and even further added points for calculating the area)

<courtesy of damber, its' not my wacky spelling />

[Emtucifor]

tsqlLine number Off | Show | Select all

1. IF OBJECT_ID('CalculatePolygon', 'P') IS not null DROP PROCEDURE CalculatePolygon
2. GO
3. CREATE PROCEDURE CalculatePolygon
4.     @Points SMALLINT,
5.     @Perimeter SMALLINT,
6.     @X DECIMAL(30, 27),
7.     @Y DECIMAL(30, 27)
8. AS
9. DECLARE
10.     @BaseAngle DECIMAL(30, 27),
11.     @Angle DECIMAL(30, 27),
12.     @Outside DECIMAL(30, 27),
13.     @PI DECIMAL(30, 27),
14.     @PointName VARCHAR(20)
15.  
16. DECLARE @NamedPoints TABLE (
17.     Point SMALLINT,
18.     PointName VARCHAR(20)
19. )
20.  
21. SET NOCOUNT ON
22.  
23. INSERT @NamedPoints
24. SELECT Point, PointName FROM (
25.     SELECT Points = 5, * FROM (SELECT 5, 'Top' UNION ALL SELECT 4, 'MidLeft' UNION ALL SELECT 3, 'BottomLeft'
26.         UNION ALL SELECT 2, 'BottomRight' UNION ALL SELECT 1, 'MidRight') X (Point, PointName)
27.     UNION ALL SELECT 4, * FROM (SELECT 4, 'Top' UNION ALL SELECT 3, 'Left' UNION ALL SELECT 2, 'Bottom'
28.         UNION ALL SELECT 1, 'Right') X (Point, PointName)
29.     UNION ALL SELECT 3, * FROM (SELECT 3, 'Top' UNION ALL SELECT 2, 'Left' UNION ALL SELECT 1, 'Right') X (Point, PointName)
30. ) Y
31. WHERE Points = @Points
32.  
33. SET @PI = 3.141592653589793238462643383279503
34. SET @BaseAngle = 2 * @PI / @Points
35. SET @Outside = 1.0 * @Perimeter / @Points
36. SET @Angle = @BaseAngle / 2 + @PI
37.  
38. SET @Y = @Y + @Outside / 2 / SIN(@BaseAngle / 2)
39. PRINT 'Radius Length: ' + CONVERT(VARCHAR(41), @Outside / 2 / SIN(@BaseAngle / 2))
40. PRINT 'Area of polygon: ' + CONVERT(VARCHAR(41), @Outside * @Outside / 4 / TAN(@BaseAngle / 2) * @Points)
41. WHILE 1 = 1 BEGIN
42.     SET @PointName = (SELECT PointName FROM @NamedPoints WHERE Point = @Points)
43.     PRINT COALESCE(@PointName, 'X, Y') + ':' + CHAR(9) + CONVERT(VARCHAR(41), @X) + CHAR(9) + CONVERT(VARCHAR(41), @Y)
44.  
45.     SET @X = @X + COS(@Angle) * @Outside
46.     SET @Y = @Y + SIN(@Angle) * @Outside
47.     SET @Angle = @Angle + @BaseAngle
48.     IF @Points = 1 BREAK
49.     SET @Points = @Points - 1
50. END
51. GO
52. EXEC CalculatePolygon 5, 100, 10, 10

Code is hidden, SHOW

P.S. I'm not sure what "only whole units can be used" means. Please clarify and I will correct, probably by multiplying to get rid of any decimal point.

[damber]

Erik - don't worry about the whole numbers thing, it was initially intended to keep things simple, but as the puzzle scope changed it doesn't really make sense to keep it in, so I've edited it out.

[gmmastros]

VB6 Solution:

vbLine number Off | Show | Select all

1. Angle = 2 * PI / iPointCount
2.     R = (TotalLength / iPointCount) / (2 * Sin(Angle / 2))
3.     ReDim Points(iPointCount - 1)
4.  
5.     For i = LBound(Points) To UBound(Points)
6.         Points(i).X = R * Sin(Angle * i)
7.         Points(i).Y = R * Cos(Angle * i)
8.     Next

Code is hidden, SHOW

Download sample application: Polygon Points

[SQLDenis]

P.S. I'm not sure what "only whole units can be used" means. Please clarify and I will correct, probably by multiplying to get rid of any decimal point.

I don't know how many decimal points you need but sql server has a pi function built in

tsqlLine number Off | Hide | Select all

1. SELECT PI()

[Emtucifor]

George,

I think you've been doing polygon math FAR too long for me to compete with. Good work.

I was thinking last night that my code is flawed because it can accumulate errors as it goes. I was thinking about the problem incorrectly. I should have calculated each point from the center as you did. Then half my variables could be disposed of...

[AlexCuse]

Now that I think about it, You missed one thing George:

Given a grid co-ordinate (x,y) as the centre point of a regular pentagon

Shouldn't be too tough though.

Its' not going to win any shortest code contests because I created my own types and enabled them convert between each other, but here goes (anything to liven this thread up a bit). C# on the console

csharpLine number Off | Show | Select all

1. using System;
2. using System.Collections.Generic;
3. using System.Text;
4.  
5. namespace RegularPolygon
6. {
7.     class Program
8.     {
9.         static void Main(string[] args)
10.         {
11.             int numsides;
12.             double perimeter, centerX, centerY, offsetAngle;
13.  
14.             Console.Write("Please Enter # of sides: ");
15.  
16.             while (!int.TryParse(Console.ReadLine(), out numsides))
17.                 Console.WriteLine("You can only have a numeric number of sides");
18.  
19.             Console.Write("Please Enter perimeter: ");
20.  
21.             while (!double.TryParse(Console.ReadLine(), out perimeter))
22.                 Console.WriteLine("This too must be numeric");
23.  
24.             Console.Write("Please Enter center X value: ");
25.  
26.             while (!double.TryParse(Console.ReadLine(), out centerX))
27.                 Console.WriteLine("This too must be numeric");
28.  
29.             Console.Write("Please Enter center Y value: ");
30.  
31.             while (!double.TryParse(Console.ReadLine(), out centerY))
32.                 Console.WriteLine("This too must be numeric");
33.  
34.             Console.Write("Please Enter rotation to apply:");
35.             while(!double.TryParse(Console.ReadLine(), out offsetAngle))
36.                 Console.WriteLine("This too must be numeric");
37.  
38.  
39.             //calculate the radius from outer side length and inner angle
40.             double sideLength = perimeter/numsides;
41.             double radius = (sideLength/2) / Math.Sin(Math.PI / numsides);
42.  
43.             //create regular polygon
44.             RegularPolygon p5 = new RegularPolygon(centerX, centerY, radius, numsides, offsetAngle);
45.  
46.             //show points
47.             int icnt = 0;
48.             foreach (CartesianPoint p in p5.OuterPoints)
49.             {
50.                 Console.WriteLine("Point #{2}: x={0}, y={1}", new object[] { Math.Round(p.X, 2), Math.Round(p.Y, 2), icnt + 1 });
51.                 icnt++;
52.             }
53.  
54.             //show perimeter, area
55.             Console.WriteLine("Perimeter is {0}, area is {1}", new object[] { p5.Perimeter, p5.Area });
56.         }
57.  
58.         public struct CartesianPoint
59.         {
60.             private double _x, _y;
61.  
62.             public CartesianPoint(double x, double y)
63.             {
64.                 _x = x; _y = y;
65.             }
66.  
67.             public double X
68.             {
69.                 get { return _x; }
70.                 set { _x = value; }
71.             }
72.             public double Y
73.             {
74.                 get { return _y; }
75.                 set { _y = value; }
76.             }
77.  
78.             public static CartesianPoint operator +(CartesianPoint sPoint, CartesianPoint diff)
79.             {
80.                 //use this to re-center the polygon (since polar coordinates can only be converted to points centered around 0,0)
81.                 return new CartesianPoint(sPoint.X + diff.X, sPoint.Y + diff.Y);
82.             }
83.  
84.             public static CartesianPoint operator -(CartesianPoint sPoint, CartesianPoint centerPoint)
85.             {
86.                 //adjust the point so that it is centered at 0,0 and can easily be converted to Polar Coordinates
87.                 return new CartesianPoint(sPoint.X - centerPoint.X, sPoint.Y - centerPoint.Y);
88.             }
89.  
90.             public PolarPoint ToPolar()
91.             {
92.                 double radius = Math.Sqrt(_x * _x + _y * _y);
93.  
94.                 double theta = 0; // for compiler's sake
95.  
96.                 if (_x > 0 && _y >= 0)
97.                     theta = Math.Atan(_y / _x);
98.                 else if (_x > 0 && _y < 0)
99.                     theta = Math.Atan(_y / _x) + 2 * Math.PI;
100.                 else if (_x < 0)
101.                     theta = Math.Atan(_y / _x) + Math.PI;
102.                 else if (_x == 0 && _y > 0)
103.                     theta = Math.PI / 2;
104.                 else if (_x == 0 && _y < 0)
105.                     theta = (3 * Math.PI) / 2;
106.  
107.                 return new PolarPoint(radius, theta);
108.             }
109.         }
110.  
111.         public struct PolarPoint
112.         {
113.             private double _radius, _theta;
114.  
115.             public PolarPoint(double radius, double theta)
116.             {
117.                 _radius = radius;
118.                 _theta = theta;
119.             }
120.  
121.             public double Radius
122.             {
123.                 get { return _radius; }
124.                 set { _radius = value; }
125.             }
126.             public double Theta
127.             {
128.                 get { return _theta; }
129.                 set { _theta = value; }
130.             }
131.  
132.             public CartesianPoint ToCartesian()
133.             {
134.                 return new CartesianPoint(_radius * Math.Cos(_theta), _radius * Math.Sin(_theta));
135.             }
136.         }
137.  
138.         public class RegularPolygon
139.         {
140.             private CartesianPoint _centerPoint;
141.             private double _radius;
142.             private int _numSides;
143.             private double _offsetDegrees;
144.             private double _thetaInterval;
145.             private const double _degreesPerRadian = 57.2957795;
146.             private List<CartesianPoint> _outerPoints = new List<CartesianPoint>();
147.  
148.             public RegularPolygon(double radius, int numSides)
149.             {
150.                 _centerPoint = new CartesianPoint(0, 0);
151.                 _thetaInterval = (2 * Math.PI) / numSides;
152.                 _numSides = numSides;
153.                 _radius = radius;
154.                 _offsetDegrees = 0;
155.  
156.                 IdentifyPoints();
157.             }
158.  
159.             public RegularPolygon(double x, double y, double radius, int numSides)
160.             {
161.                 _centerPoint = new CartesianPoint(x, y);
162.                 _thetaInterval = (2 * Math.PI) / numSides;
163.                 _numSides = numSides;
164.                 _radius = radius;
165.                 _offsetDegrees = 0;
166.  
167.                 IdentifyPoints();
168.             }
169.  
170.             public RegularPolygon(double x, double y, double radius, int numSides, double offsetDegrees)
171.             {
172.                 _centerPoint = new CartesianPoint(x, y);
173.                 _thetaInterval = (2 * Math.PI) / numSides;
174.                 _numSides = numSides;
175.                 _radius = radius;
176.                 _offsetDegrees = offsetDegrees / _degreesPerRadian;
177.  
178.                 IdentifyPoints();
179.             }
180.  
181.             public List<CartesianPoint> OuterPoints
182.             {
183.                 get { return _outerPoints; }
184.             }
185.  
186.             public double Radius
187.             {
188.                 get { return _radius; }
189.             }
190.  
191.             public double Perimeter
192.             {
193.                 get { return _numSides * SideLength; }
194.             }
195.  
196.             public double SideLength
197.             {
198.                 get { return 2 * (Math.Sin(_thetaInterval / 2) * _radius); }
199.             }
200.  
201.  
202.             public double Area
203.             {
204.                 get
205.                 {
206.                     //first get the bisector of the side (height of the triangle)
207.                     double height = Math.Sqrt(Math.Pow(_radius, 2) - (Math.Pow(SideLength / 2, 2)));
208.  
209.                     //use 1/2 (base  * height) to get the area for each triangle, multiply by _numSides
210.                     return _numSides * ((SideLength * height) / 2);
211.                 }
212.             }
213.  
214.             public CartesianPoint CenterPoint
215.             {
216.                 get { return _centerPoint; }
217.                 set { _centerPoint = value; IdentifyPoints(); }
218.             }
219.  
220.             private void IdentifyPoints()
221.             {
222.                 _outerPoints.Clear();
223.  
224.                 for (int i = 0; i < _numSides; i++)
225.                 {
226.                     _outerPoints.Add(_centerPoint + new PolarPoint(_radius, (i * _thetaInterval) + _offsetDegrees).ToCartesian());
227.                 }
228.             }
229.         }
230.     }
231. }

Code is hidden, SHOW

[Emtucifor]

I don't know how many decimal points you need but sql server has a pi function built in

tsqlLine number Off | Hide | Select all

1. SELECT PI()

I know THAT.

1. The Pi() function is very slow.
2. The Pi() function only gives 16 decimal places.
3. The Pi() function's 16th digit is wrong. Not just rounded incorrectly, but wrong any way you look at it.

That's why I didn't use it. Plus, I have Pi memorized to 58 decimal places so typing it out is extremely easy and convenient for me.

[damber]

OK, here's mine (ASP.NET / C#):

csharpLine number Off | Show | Select all

1. using System;
2.  
3. public partial class _Default : System.Web.UI.Page
4. {
5.     protected void Page_Load(object sender, EventArgs e)
6.     {
7.                
8.                 RegularPolygon p = new RegularPolygon(5, new coord(10, 10), 20d, 0d);
9.  
10.                 Response.Write("Area: " + Math.Round(p.Area, 2).ToString() + " <br/>");
11.                 Response.Write("Side Length: " + Math.Round(p.SideLength, 2).ToString() + " <br/>");
12.                 Response.Write("Centre Point: x=" + p.CentrePoint.X.ToString() + ", y=" + p.CentrePoint.Y.ToString() + " <br/>");
13.                 Response.Write("Offset Rotation: " + Math.Round(p.Rotation, 2).ToString() + "&deg; <br/>");
14.                 Response.Write("Point Radial: " + Math.Round(p.PointRadial, 2).ToString() + " (Furthest Distance of the outside edge from the centre)<br/>");
15.                 Response.Write("Bisector Radial: " + Math.Round(p.BisectorRadial, 2).ToString() + " (Nearest Distance of the outside edge from the centre)<br/>");
16.                 Response.Write("Centre Angle: " + Math.Round(p.CentreAngle, 2).ToString() + "&deg; (Angle between each 'segment' at the centre point)<br/>");
17.                 Response.Write("Outer Angle: " + Math.Round(p.OuterAngle, 2).ToString() + "&deg; (Angle between the sides)<br/><br /><hr/><br/>");
18.                 for (int i = 0; i < p.Points.Length; i++)
19.                 {
20.                         Response.Write("Point " + i.ToString() + ": x=" + Math.Round(p.Points[i].X, 1).ToString()
21.                                 + " , y=" + Math.Round(p.Points[i].Y, 1).ToString() + " , " + p.Points[i].Angle.ToString()
22.                                 + "&deg;  || Polar: (" + Math.Round(p.Points[i].Radial, 1).ToString() + ","
23.                                 + p.Points[i].Azimuth.ToString() + "&deg;) <br/>");
24.                 }
25.     }
26. }
27.  
28. public class RegularPolygon
29. {
30.     private coord[] _points;
31.     private Double _sideLength;
32.     private Double _centreAngle;
33.     private Double _outerAngle;
34.     private coord _centrePoint;
35.     private Double _area;
36.     private Double _bisectorRadial;
37.     private Double _pointRadial;
38.     private const int FULL_CIRCLE_DEGREES = 360;
39.     private const int FULL_TRIANGLE_DEGREES = 180;
40.     private Double _rotation = 0d;
41.  
42.     public RegularPolygon(int numberOfSides, coord centrePoint, Double perimLength, Double rotation)
43.     {
44.         _centrePoint = centrePoint;
45.         _points = new coord[numberOfSides];
46.         _sideLength = perimLength/numberOfSides;
47.         _centreAngle = FULL_CIRCLE_DEGREES / numberOfSides;
48.         _outerAngle = FULL_TRIANGLE_DEGREES - _centreAngle; //angle between two sides of the polygon
49.         _pointRadial = (_sideLength / 2) / Math.Sin((_centreAngle / 2) * (Math.PI / 180));  // distance of each point from the centre
50.         _bisectorRadial = (_sideLength / 2) / Math.Tan((_centreAngle / 2) * (Math.PI / 180));
51.         _area = (_bisectorRadial * (_sideLength / 2)) * _points.Length;
52.         _rotation = rotation % _centreAngle;
53.  
54.         calculatePoints();
55.     }
56.  
57.         public RegularPolygon(int numberOfSides, coord centrePoint, Double perimLength)
58.                 : this(numberOfSides, centrePoint, perimLength, 0d)
59.         { }
60.  
61.     private void calculatePoints()
62.     {
63.                 Double currRotation = _rotation;
64.  
65.                 for (int i = 0; i < _points.Length;i++)
66.                 {
67.                         currRotation = _rotation + (_centreAngle * i);
68.                         _points[i].Radial = _pointRadial;
69.                         _points[i].Angle = currRotation;
70.                         _points[i].Azimuth = ConvertAngleToAzimuth(currRotation);
71.                        
72.                         Double radianRotation = _rotation * (Math.PI / 180d);
73.  
74.                         _points[i].X = _centrePoint.X + _pointRadial * Math.Sin(radianRotation + (((2 * Math.PI) / _points.Length) * i) );
75.                         _points[i].Y = _centrePoint.Y + _pointRadial * Math.Cos(radianRotation + (((2 * Math.PI) / _points.Length) * i) );
76.  
77.                 }
78.     }
79.  
80.         private Double ConvertAngleToAzimuth(Double angle) { return ((360 - angle) + 90) % 360; }
81.  
82.         public Double Area { get { return _area; } }
83.         public Double SideLength { get { return _sideLength; } }
84.         public Double PointRadial { get { return _pointRadial; } }
85.         public Double BisectorRadial { get { return _bisectorRadial; } }
86.         public Double CentreAngle { get { return _centreAngle; } }
87.         public Double OuterAngle { get { return _outerAngle; } }
88.         public coord CentrePoint { get { return _centrePoint; } }
89.         public Double Rotation { get { return _rotation; } }
90.         public coord[] Points { get { return _points; } }
91.  
92. }
93.  
94. public struct coord
95. {
96.         public coord(Double XCoord, Double YCoord)
97.     {
98.         X = XCoord;
99.         Y = YCoord;
100.                 Radial = 0;
101.                 Angle = 0;
102.                 Azimuth = 0;
103.     }
104.     public Double X;
105.         public Double Y;
106.         public Double Radial;
107.         public Double Angle;
108.         public Double Azimuth;
109. }

Code is hidden, SHOW

I tested it as the codebehind of an aspx page, but you can easily change to run in the console etc.

It will accept any coordinate for the centre point, number of sides/points, a positive length for the sides and an offset rotation in degrees from north (so you can rotate the polygon).

It will return all the points with Cartesian X, Y and Polar Coordinates as well as the Area, distance from the centre to the edge at the furthest and nearest point and the relevant angles.

[SQLDenis]

Plus, I have Pi memorized to 58 decimal places so typing it out is extremely easy and convenient for me.

PFFFtttttt, I expected you to have a MotherOfAllValuesOrFunctions table so that you don't have to type it in


BTW, do you know that I have stuff like this "select dateadd(mm, datediff(mm, 0, getdate())-11, 0)" in notes in outlook

[gmmastros]

Now that I think about it, You missed one thing George:

Given a grid co-ordinate (x,y) as the centre point of a regular pentagon

Shouldn't be too tough though.

Yes Alex. It's not that tough. In fact....

vbLine number Off | Show | Select all

1. Angle = 2 * PI / iPointCount
2.     R = (TotalLength / iPointCount) / (2 * Sin(Angle / 2))
3.     ReDim Points(iPointCount - 1)
4.  
5.     For i = LBound(Points) To UBound(Points)
6.         Points(i).X = CenterX + R * Sin(Angle * i)
7.         Points(i).Y = CenterY + R * Cos(Angle * i)
8.     Next

Code is hidden, SHOW

[reshefm]

Ruby...

rubyLine number Off | Show | Select all

1. class Vector
2.  
3.   def initialize(x,y,length,angle)
4.     @x=x
5.     @y=y
6.     @length=length
7.     @angle=angle
8.   end
9.  
10.   def calc_end_point()
11.     end_y = @length * Math.sin(@angle) + @x
12.     end_x = @length * Math.cos(@angle) + @y
13.     return roundf(end_x, 3), roundf(end_y, 3)
14.   end
15.  
16.   private
17.     def roundf(float, places) # This method is from the book "The Ruby Way"
18.       temp = float.to_s.length
19.       sprintf("%#{temp}.#{places}f",float).to_f
20.     end
21.  
22. end
23.  
24. def polygon_calc(x,y,perimeter, num_of_sides=5)
25.  
26.   angle_jump = (2*Math::PI)/num_of_sides
27.   side_length = perimeter/num_of_sides
28.  
29.   start_angle = Math::PI/2
30.  
31.   vector_length = (side_length/2)/Math.sin(angle_jump/2)
32.    
33.   points = []
34.  
35.   num_of_sides.times do |i|
36.     points << Vector.new(x, y, vector_length, start_angle+(angle_jump*i)).calc_end_point
37.   end
38.  
39.   return points
40. end
41.  
42.  
43. puts polygon_calc(0, 0, 200)

Code is hidden, SHOW

[damber]

There are 2 types of winner - a "People's Champion" (the one with the most rating points across all their posts) and the LTD Admin's Champion (selected with our special formula....honest...well, maybe it's just the ones that the admins thought were particularly good )

So...

People's Champion: joint winners - AlexCuse and gmmastros both scoring 10 points each

LTD Admin's Champion: reshefm - for posting a nice ruby solution


Congratulations to all.. and good luck on next weeks puzzle