From 1bc9c58e771f48071c0a7a8a4c38cb1144f28448 Mon Sep 17 00:00:00 2001
From: Freddy Pringle <freddyjepringle@gmail.com>
Date: Fri, 9 Oct 2020 16:31:11 +0200
Subject: [PATCH 1/5] Added solution for Project Euler problem 72. Fixes: #2695

---
 project_euler/problem_72/__init__.py |  0
 project_euler/problem_72/sol1.py     | 43 ++++++++++++++++++++++++++++
 2 files changed, 43 insertions(+)
 create mode 100644 project_euler/problem_72/__init__.py
 create mode 100644 project_euler/problem_72/sol1.py

diff --git a/project_euler/problem_72/__init__.py b/project_euler/problem_72/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_72/sol1.py b/project_euler/problem_72/sol1.py
new file mode 100644
index 000000000000..e70c14748cc3
--- /dev/null
+++ b/project_euler/problem_72/sol1.py
@@ -0,0 +1,43 @@
+"""
+Consider the fraction, n/d, where n and d are positive integers. If n<d and HCF(n,d)=1,
+it is called a reduced proper fraction.
+
+If we list the set of reduced proper fractions for d ≤ 8 in ascending order of size,
+we get:
+
+1/8, 1/7, 1/6, 1/5, 1/4, 2/7, 1/3, 3/8, 2/5, 3/7, 1/2,
+4/7, 3/5, 5/8, 2/3, 5/7, 3/4, 4/5, 5/6, 6/7, 7/8
+
+It can be seen that there are 21 elements in this set.
+
+How many elements would be contained in the set of reduced proper fractions
+for d ≤ 1,000,000?
+"""
+
+
+def solution(limit: int = 1000000):
+    """
+    Return the number of reduced proper fractions with denominator less than limit.
+    >>> solution(8)
+    21
+    >>> solution(1000)
+    304191
+    """
+    primes = set(range(3, limit, 2))
+    primes.add(2)
+    for p in range(3, limit, 2):
+        if p not in primes:
+            continue
+        primes.difference_update(set(range(p * p, limit, p)))
+
+    phi = [float(n) for n in range(limit + 1)]
+
+    for p in primes:
+        for n in range(p, limit + 1, p):
+            phi[n] *= 1 - 1 / p
+
+    return int(sum(phi[2:]))
+
+
+if __name__ == "__main__":
+    print(solution())

From b1d2b34dafc9a387c32509d48c82c73af0032c75 Mon Sep 17 00:00:00 2001
From: Freddy Pringle <freddyjepringle@gmail.com>
Date: Thu, 15 Oct 2020 10:44:50 +0200
Subject: [PATCH 2/5] Update type annotations and 0-padding of directory name.
 Reference: #3256

---
 project_euler/{problem_72 => problem_072}/__init__.py | 0
 project_euler/{problem_72 => problem_072}/sol1.py     | 6 ++++--
 2 files changed, 4 insertions(+), 2 deletions(-)
 rename project_euler/{problem_72 => problem_072}/__init__.py (100%)
 rename project_euler/{problem_72 => problem_072}/sol1.py (88%)

diff --git a/project_euler/problem_72/__init__.py b/project_euler/problem_072/__init__.py
similarity index 100%
rename from project_euler/problem_72/__init__.py
rename to project_euler/problem_072/__init__.py
diff --git a/project_euler/problem_72/sol1.py b/project_euler/problem_072/sol1.py
similarity index 88%
rename from project_euler/problem_72/sol1.py
rename to project_euler/problem_072/sol1.py
index e70c14748cc3..08e92c18bb3a 100644
--- a/project_euler/problem_72/sol1.py
+++ b/project_euler/problem_072/sol1.py
@@ -1,4 +1,6 @@
 """
+Project Euler Problem 72: https://projecteuler.net/problem=72
+
 Consider the fraction, n/d, where n and d are positive integers. If n<d and HCF(n,d)=1,
 it is called a reduced proper fraction.
 
@@ -15,7 +17,7 @@
 """
 
 
-def solution(limit: int = 1000000):
+def solution(limit: int = 1000000) -> int:
     """
     Return the number of reduced proper fractions with denominator less than limit.
     >>> solution(8)
@@ -40,4 +42,4 @@ def solution(limit: int = 1000000):
 
 
 if __name__ == "__main__":
-    print(solution())
+    print(f"{solution() = }")

From 6d2846ae500adcf797d93a5e6bd4a492f7511dad Mon Sep 17 00:00:00 2001
From: Freddy Pringle <freddyjepringle@gmail.com>
Date: Thu, 15 Oct 2020 13:07:50 +0200
Subject: [PATCH 3/5] Rename sol1.py to sol2.py

---
 project_euler/problem_072/{sol1.py => sol2.py} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename project_euler/problem_072/{sol1.py => sol2.py} (100%)

diff --git a/project_euler/problem_072/sol1.py b/project_euler/problem_072/sol2.py
similarity index 100%
rename from project_euler/problem_072/sol1.py
rename to project_euler/problem_072/sol2.py

From cc76559ff1576af22799297e182c88f67dbf47fb Mon Sep 17 00:00:00 2001
From: Freddy Pringle <freddyjepringle@gmail.com>
Date: Thu, 15 Oct 2020 13:13:51 +0200
Subject: [PATCH 4/5] Added newline at the end of sol2.py

---
 project_euler/problem_072/sol2.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project_euler/problem_072/sol2.py b/project_euler/problem_072/sol2.py
index 45457941c756..08e92c18bb3a 100644
--- a/project_euler/problem_072/sol2.py
+++ b/project_euler/problem_072/sol2.py
@@ -42,4 +42,4 @@ def solution(limit: int = 1000000) -> int:
 
 
 if __name__ == "__main__":
-    print(f"{solution() = }")
\ No newline at end of file
+    print(f"{solution() = }")

From 2a93dfbf3d47c8bb512218fef0b99480b4904aa4 Mon Sep 17 00:00:00 2001
From: Freddy Pringle <freddyjepringle@gmail.com>
Date: Fri, 16 Oct 2020 11:35:04 +0200
Subject: [PATCH 5/5] Revert sol1.py

---
 project_euler/problem_072/sol1.py | 46 +++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 project_euler/problem_072/sol1.py

diff --git a/project_euler/problem_072/sol1.py b/project_euler/problem_072/sol1.py
new file mode 100644
index 000000000000..846396ab0f9c
--- /dev/null
+++ b/project_euler/problem_072/sol1.py
@@ -0,0 +1,46 @@
+"""
+Problem 72 Counting fractions: https://projecteuler.net/problem=72
+
+Description:
+
+Consider the fraction, n/d, where n and d are positive integers. If n<d and HCF(n,d)=1,
+it is called a reduced proper fraction.
+If we list the set of reduced proper fractions for d ≤ 8 in ascending order of size, we
+get: 1/8, 1/7, 1/6, 1/5, 1/4, 2/7, 1/3, 3/8, 2/5, 3/7, 1/2, 4/7, 3/5, 5/8, 2/3, 5/7,
+3/4, 4/5, 5/6, 6/7, 7/8
+It can be seen that there are 21 elements in this set.
+How many elements would be contained in the set of reduced proper fractions for
+d ≤ 1,000,000?
+
+Solution:
+
+Number of numbers between 1 and n that are coprime to n is given by the Euler's Totient
+function, phi(n). So, the answer is simply the sum of phi(n) for 2 <= n <= 1,000,000
+Sum of phi(d), for all d|n = n. This result can be used to find phi(n) using a sieve.
+
+Time: 3.5 sec
+"""
+
+
+def solution(limit: int = 1_000_000) -> int:
+    """
+    Returns an integer, the solution to the problem
+    >>> solution(10)
+    31
+    >>> solution(100)
+    3043
+    >>> solution(1_000)
+    304191
+    """
+
+    phi = [i - 1 for i in range(limit + 1)]
+
+    for i in range(2, limit + 1):
+        for j in range(2 * i, limit + 1, i):
+            phi[j] -= phi[i]
+
+    return sum(phi[2 : limit + 1])
+
+
+if __name__ == "__main__":
+    print(solution())