Project Euler with Befunge
Problem 091: Right triangles with integer coordinates
P(x1, y1) and
Q(x2, y2) are plotted at integer co-ordinates and are joined to the origin,
O(0,0), to form
There are exactly fourteen triangles containing a right angle that can be formed when each co-ordinate lies between 0 and 2 inclusive; that is,
0 <= x1, y1, x2, y2 <= 2.
0 <= x1, y1, x2, y2 <= 50, how many right triangles can be formed?
X XXXX >$41p#^_31g311g:**+.@>$p v1+
^ >51g#^ #:1# - #1:#g5#11#4 ^# _^1
^3_^#! +`g11g16`*:g14*-\g16:g15< p<
This was mostly a mathematical problem.
Lets go step by step through my solution:
We have a triangle with three corners,
Q(q_x, q_y) and
P(p_x, p_y), where
O = (0,0).
We can quickly see that there are three types of solutions, triangles where O has the right angle,
triangles where Q has the right angle and triangles where P has the right angle.
The amount of triangles in group two (angle at Q) and group three (angle at P) are identical (!)
Because for every triangle in group two there is a triangle in group three which has the points P and Q mirrored at the vertical Axis
So when we have a triangle
O(0, 0); Q1(q1_x, q1_y); P(p1_x, p1_y) the corresponding mirrored triangle is
q2_x = q1_y q2_y = q1_x p2_x = p1_y p2_y = p1_x
These two groups (two and three) are also mutually exclusive, because if
Q1 == P2 and
Q2 == P1 then the vectors
OQ would have equal length and
the only possible right angle could be at point O (and not at P or Q).
Now that we have proven that
count(group_2) == count(group_3) we only have to find that triangle count and the amount of triangles in group one.
First group one:
To have an right angle at the zero point
O(0, 0) both other points have to lie on an axis.
We say point Q lies on the x-axis and point P on the Y-axis. All combinations lead to valid and unique triangles, the only disallowed point is the origin
So we have
SIZE possible positions on the x-axis and
SIZE possible positions on the y-axis. This leads to
SIZE * SIZE different unique triangles:
count(group_1) = SIZE * SIZE
Now group 2/3
Because we need to define a bit of semantics we say our point Q is the lower-right point of the triangle (and P is the upper left),
similar to the project-euler example image. Also we want our right angle to be at point Q (between the vectors OP and PQ).
First we can look at the trivial triangles, the ones where Q lies on the x-axis and P has the same x-coordinate as Q.
These triangles all have an right angle at Q and are valid solutions. And because there are
SIZE possible positions for Q (all x-axis positions except
and for each of these there are
SIZE possible positions for P (all points on the same x-value as Q, except
y = 0)
SIZE*SIZE trivial triangles with an right angle at Q.
count(group_2_triv) = count(group_3_triv) = SIZE * SIZE
For the remaining triangle we can finally - kind of - start programming.
We go through all remaining points (q_x, q_y) where
q_x > 0 && q_y > 0 (because the axis are already covered by our trivial cases).
For every point (that we assume is Q) we calculate the vector OQ:
oq_x = q_x - 0 // trivial, yeah i know. In the final program this is all optimized away oq_y = q_y - 0
And we calculate the direction of the vector QP (under the assumption that Q has a right angle and thus OQ and QP form a right angle). This is simply the vector OQ rotate by 90° CW:
v_qp_x = -oq_y; v_qp_y = oq_x;
Now we search for integer solutions of
P = Q + n * v_QP. Each solution, that also falls in our SIZE bounds is a valid triangle.
To find these we go through all the possible y locations out point P can have.
It is not possible that one p_y value responds to multiple p_x values, because then QP would be horizontal
and these triangles are already acknowledged in our trivial cases of group_2 / group_3.
So for each (possibly valid) p_y value we can calculate the corresponding p_x value:
p_y = q_y + n * v_qp_y n = (p_y - q_y) / v_qp_y p_x = q_x + n * v_qp_x = q_x + ((p_y - q_y) / v_qp_y) * v_qp_x = q_x + ((p_y - q_y) * v_qp_x / v_qp_y)
First we want to test if
(p_y - q_y) * v_qp_x is a multiple of
If this were not the case than p_x is not an integer and this is not an integer solution
(then we would simply continue with the next y value until y > SIZE and we have reached our limit).
But if P(p_x, p_y) has two integer components we only need to test if p_x is greater than zero
(because otherwise the triangle would be out of our defined bounds) and then we can increment out triangle counter.
Be aware that we have in this step practically found two unique triangles, this one and its mirrored counter part (see explanation at the beginning).
Now we continue our looping, first until we have tested all possible p_y values (until p_y grows greater than our bounds, SIZE)
and then until we have tested all valid points for Q.
In the end we only have to add our values together and we have our result:
result = c_group_1 + 2 * c_group_23 c_group_23 = c_group_23_triv + c_group_23_nontriv
This is one of the problems that translate really well into befunge, because there are no big data structures and not even a lot of calculations. Most of the work is done before we start to write code and the challenge is finding the correct approach.
After note: I really want a price or something for the compression of this program. Everything is crunched into a 36x5 rectangle and there are nearly no unused codepoints...
|Interpreter steps:||3 072 923|
|Execution time (BefunExec):||343ms (8.96 MHz)|
|Program size:||36 x 5 (fully conform befunge-93)|