A polygon is a flat shape consisting of straight line segments that are joined to form a closed chain or circuit. A polygon consists of at least three sides and does not self-intersect.
A set $S$ of positive numbers is said to generate a polygon $P$ if: no two sides of $P$ are the same length,
the length of every side of $P$ is in $S$, and
$S$ contains no other value.
For example:
The set $\{3, 4, 5\}$ generates a polygon with sides $3$, $4$, and $5$ (a triangle).
The set $\{6, 9, 11, 24\}$ generates a polygon with sides $6$, $9$, $11$, and $24$ (a quadrilateral).
The sets $\{1, 2, 3\}$ and $\{2, 3, 4, 9\}$ do not generate any polygon at all.
Consider the sequence $s$, defined as follows:$s_1 = 1$, $s_2 = 2$, $s_3 = 3$
$s_n = s_{n-1} + s_{n-3}$ for $n \gt 3$.
Let $U_n$ be the set $\{s_1, s_2, \dots, s_n\}$. For example, $U_{10} = \{1, 2, 3, 4, 6, 9, 13, 19, 28, 41\}$.
Let $f(n)$ be the number of subsets of $U_n$ which generate at least one polygon.
For example, $f(5) = 7$, $f(10) = 501$ and $f(25) = 18635853$.
Find the last $9$ digits of $f(10^{18})$.
To solve this problem, we need to find a way to count the number of subsets of $U_n$ that generate at least one polygon. We can do this by generating all subsets of $U_n$ and checking if each subset satisfies the conditions for generating a polygon.
Here is a Python code implementation to solve this problem:
“`python
def generate_subsets(nums):
subsets = [[]]
for num in nums:
subsets += [subset + [num] for subset in subsets]
return subsets
def is_polygon(subset):
if len(subset) < 3:
return False
subset = sorted(subset)
for i in range(len(subset) - 2):
if subset[i] + subset[i+1] <= subset[i+2]:
return False
return True
def count_polygons(n):
sn = [1, 2, 3]
for i in range(3, n):
sn.append(sn[i-1] + sn[i-3])
un = sn[:n]
subsets = generate_subsets(un)
count = 0
for subset in subsets:
if is_polygon(subset):
count += 1
return count
def last_n_digits(n, digits):
return n % (10**digits)
n = 10**18
f_n = count_polygons(n)
last_9_digits = last_n_digits(f_n, 9)
print(last_9_digits)
```
Explanation:
1. The `generate_subsets` function generates all subsets of a given list of numbers using a recursive approach.
2. The `is_polygon` function checks if a subset satisfies the conditions for generating a polygon. It checks if the subset has at least 3 elements and if no two sides have the same length. It also checks if the triangle inequality holds for all triplets of sides in the subset.
3. The `count_polygons` function generates the sequence `s`, constructs the set `U_n`, generates all subsets of `U_n` using `generate_subsets`, and counts the number of subsets that satisfy the conditions for generating a polygon using `is_polygon`.
4. The `last_n_digits` function takes a number `n` and returns the last `digits` number of digits of `n`.
5. Finally, we calculate `f(n)` by calling `count_polygons(n)`, get the last 9 digits using `last_n_digits`, and print the result.
Note: Since the values involved are large, the above implementation may take a significant amount of time to execute for very large values of `n`. You may need to optimize the code further (e.g., using dynamic programming) if you want to compute larger values.
More Answers:
Least Common Multiple CountAmazing Mazes!
$(\text{prime}-k)$ Factorial