P165: Added Java and Python solutions.

Readme: Updated Java SE version requirement from 7 to 8; updated solution count and copyright year.

Author: nayuki

Answers.txt

@@ -148,6 +148,7 @@ Problem 155: 3857447
 Problem 160: 16576
 Problem 162: 3D58725572C62302
 Problem 164: 378158756814587
+Problem 165: 2868868
 Problem 166: 7130034
 Problem 169: 178653872807
 Problem 171: 142989277

Readme.markdown

@@ -5,15 +5,15 @@ A collection of Nayuki's program code to solve over 200 Project Euler math probl
 
 Every solved problem has a program written in Java and usually Python. Some solutions also have Mathematica and Haskell programs. Some solution programs include a detailed mathematical explanation/proof in the comments to justify the code's logic.
 
-All problems from #1 to #100 have a Java and Python program, and problems #1 to #50 have a Mathematica program. This package contains at least 200 solutions in Java, at least 200 in Python, at least 125 in Mathematica, and at least 95 in Haskell.
+All problems from #1 to #100 have a Java and Python program, and problems #1 to #50 have a Mathematica program. This package contains at least 205 solutions in Java, at least 200 in Python, at least 125 in Mathematica, and at least 95 in Haskell.
 
-Java solutions require JDK 7+. Python solutions are tested to work on CPython 3.4.3. Mathematica solutions are tested to work on Mathematica 5.1.
+Java solutions require JDK 8+. Python solutions are tested to work on CPython 3.4.3. Mathematica solutions are tested to work on Mathematica 5.1.
 
 Home page with background info, table of solutions, benchmark timings, and more: [https://www.nayuki.io/page/project-euler-solutions](https://www.nayuki.io/page/project-euler-solutions)
 
 ----
 
-Copyright © 2020 Project Nayuki. All rights reserved. No warranty.
+Copyright © 2021 Project Nayuki. All rights reserved. No warranty.
 
 This code is provided for reference only. You may republish any of this code verbatim with author and URL info intact.
 

java/EulerTest.java

@@ -155,6 +155,7 @@ public final class EulerTest {
 	@Test public void testP160() { assertEquals("16576"                   , new p160().run()); }
 	@Test public void testP162() { assertEquals("3D58725572C62302"        , new p162().run()); }
 	@Test public void testP164() { assertEquals("378158756814587"         , new p164().run()); }
+	@Test public void testP165() { assertEquals("2868868"                 , new p165().run()); }
 	@Test public void testP166() { assertEquals("7130034"                 , new p166().run()); }
 	@Test public void testP169() { assertEquals("178653872807"            , new p169().run()); }
 	@Test public void testP171() { assertEquals("142989277"               , new p171().run()); }

java/p165.java

@@ -0,0 +1,143 @@
+/* 
+ * Solution to Project Euler problem 165
+ * Copyright (c) Project Nayuki. All rights reserved.
+ * 
+ * https://www.nayuki.io/page/project-euler-solutions
+ * https://github.com/nayuki/Project-Euler-solutions
+ */
+
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+
+
+public final class p165 implements EulerSolution {
+	
+	public static void main(String[] args) {
+		System.out.println(new p165().run());
+	}
+	
+	
+	private static final int NUM_LINE_SEGMENTS = 5000;
+	
+	
+	public String run() {
+		BbsRandom rand = new BbsRandom();
+		List<LineSegment> lines = new ArrayList<>();
+		for (int i = 0; i < NUM_LINE_SEGMENTS; i++)
+			lines.add(new LineSegment(rand));
+		
+		Set<Point> trueIntersections = new HashSet<>();
+		Fraction FRAC_ONE = new Fraction(bi(1));
+		for (int i = 0; i < lines.size(); i++) {
+			LineSegment seg0 = lines.get(i);
+			for (int j = i + 1; j < lines.size(); j++) {
+				LineSegment seg1 = lines.get(j);
+				
+				int x0 = seg0.x0, y0 = seg0.y0;
+				int x1 = seg0.x1, y1 = seg0.y1;
+				int x2 = seg1.x0, y2 = seg1.y0;
+				int x3 = seg1.x1, y3 = seg1.y1;
+				
+				// https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection#Given_two_points_on_each_line_segment
+				int denom = (x0 - x1) * (y2 - y3) - (x2 - x3) * (y0 - y1);
+				if (denom == 0) {
+					// There is no unique intersection point between the two infinite lines. This is equivalent to
+					// {one or both line segments being just a point, or both line segments being parallel
+					// (regardless of whether or not they lie on the same infinite line)}.
+					continue;
+				}
+				int numer0 = (x0 - x2) * (y2 - y3) - (x2 - x3) * (y0 - y2);
+				int numer1 = (x1 - x0) * (y0 - y2) - (x0 - x2) * (y1 - y0);
+				
+				Fraction t0 = new Fraction(bi(numer0), bi(denom));
+				Fraction t1 = new Fraction(bi(numer1), bi(denom));
+				if (Fraction.ZERO.compareTo(t0) < 0 && t0.compareTo(FRAC_ONE) < 0 &&
+						Fraction.ZERO.compareTo(t1) < 0 && t1.compareTo(FRAC_ONE) < 0) {
+					Point p = new Point(
+						frac(x0).add(t0.multiply(frac(x1 - x0))),
+						frac(y0).add(t0.multiply(frac(y1 - y0))));
+					trueIntersections.add(p);
+				}
+			}
+		}
+		return Integer.toString(trueIntersections.size());
+	}
+	
+	
+	private static Fraction frac(int x) {
+		return new Fraction(bi(x));
+	}
+	
+	
+	private static BigInteger bi(int x) {
+		return BigInteger.valueOf(x);
+	}
+	
+	
+	
+	// Blum Blum Shub generator
+	private static final class BbsRandom {
+		
+		private int state = 290797;
+		
+		
+		public int next() {
+			state = (int)((long)state * state % 50515093);
+			return state % 500;
+		}
+		
+	}
+	
+	
+	
+	private static final class LineSegment {
+		
+		public final int x0, y0, x1, y1;
+		
+		
+		public LineSegment(BbsRandom r) {
+			x0 = r.next();
+			y0 = r.next();
+			x1 = r.next();
+			y1 = r.next();
+		}
+		
+	}
+	
+	
+	
+	private static final class Point {
+		
+		private final int xNumer, xDenom, yNumer, yDenom;
+		
+		
+		public Point(Fraction x, Fraction y) {
+			xNumer = x.numerator  .intValueExact();
+			xDenom = x.denominator.intValueExact();
+			yNumer = y.numerator  .intValueExact();
+			yDenom = y.denominator.intValueExact();
+		}
+		
+		
+		public boolean equals(Object obj) {
+			if (!(obj instanceof Point))
+				return false;
+			Point other = (Point)obj;
+			return xNumer == other.xNumer
+			    && xDenom == other.xDenom
+			    && yNumer == other.yNumer
+			    && yDenom == other.yDenom;
+		}
+		
+		
+		public int hashCode() {
+			return Objects.hash(xNumer, xDenom, yNumer, yDenom);
+		}
+		
+	}
+	
+}

python/eulertest.py

@@ -179,6 +179,7 @@ def main():
 	160: "16576",
 	162: "3D58725572C62302",
 	164: "378158756814587",
+	165: "2868868",
 	166: "7130034",
 	169: "178653872807",
 	171: "142989277",

python/p165.py

@@ -0,0 +1,71 @@
+# 
+# Solution to Project Euler problem 165
+# Copyright (c) Project Nayuki. All rights reserved.
+# 
+# https://www.nayuki.io/page/project-euler-solutions
+# https://github.com/nayuki/Project-Euler-solutions
+# 
+
+import fractions
+
+
+def compute():
+	rand = BbsRandom()
+	lines = [LineSegment(rand) for _ in range(NUM_LINE_SEGMENTS)]
+	
+	trueintersections = set()
+	for (i, seg0) in enumerate(lines):
+		for seg1 in lines[i + 1 : ]:
+			x0 = seg0.x0;  y0 = seg0.y0
+			x1 = seg0.x1;  y1 = seg0.y1
+			x2 = seg1.x0;  y2 = seg1.y0
+			x3 = seg1.x1;  y3 = seg1.y1
+			
+			# https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection#Given_two_points_on_each_line_segment
+			denom = (x0 - x1) * (y2 - y3) - (x2 - x3) * (y0 - y1)
+			if denom == 0:
+				# There is no unique intersection point between the two infinite lines. This is equivalent to
+				# {one or both line segments being just a point, or both line segments being parallel
+				# (regardless of whether or not they lie on the same infinite line)}.
+				continue
+			numer0 = (x0 - x2) * (y2 - y3) - (x2 - x3) * (y0 - y2)
+			numer1 = (x1 - x0) * (y0 - y2) - (x0 - x2) * (y1 - y0)
+			
+			t0 = fractions.Fraction(numer0, denom)
+			t1 = fractions.Fraction(numer1, denom)
+			if 0 < t0 < 1 and 0 < t1 < 1:
+				trueintersections.add((x0 + t0 * (x1 - x0), y0 + t0 * (y1 - y0)))
+	
+	return str(len(trueintersections))
+
+
+NUM_LINE_SEGMENTS = 5000
+
+
+
+# Blum Blum Shub generator
+class BbsRandom:
+	
+	def __init__(self):
+		self.state = 290797
+	
+	
+	def next(self):
+		self.state *= self.state
+		self.state %= 50515093
+		return self.state % 500
+
+
+
+class LineSegment:
+	
+	def __init__(self, r):
+		self.x0 = r.next()
+		self.y0 = r.next()
+		self.x1 = r.next()
+		self.y1 = r.next()
+
+
+
+if __name__ == "__main__":
+	print(compute())