def calc_triangle(height): if height < SIZE: return utils.triangle(height) count = SIZE total = utils.triangle(SIZE) while height >= count * SIZE: count *= SIZE total *= utils.triangle(SIZE) iterations = height // count return total * utils.triangle(iterations) + calc_triangle(height - count * iterations) * (iterations + 1)
def main():
nearest_count = 0
nearest_area = 0
for x in itertools.count(1):
if utilities.triangle(x) > TARGET:
break
for y in itertools.count(1):
count = utilities.triangle(x) * utilities.triangle(y)
if abs(TARGET - count) < abs(TARGET - nearest_count):
nearest_count = count
nearest_area = x * y
if count > TARGET:
break
return nearest_area
def main():
smallest = 0
utils.linear_congruential(utils.triangle(HEIGHT))
triangle = []
candidates = dict()
index = 1
for i in range(1, HEIGHT + 1):
line = []
for j in range(i):
line.append(utils.linear_con_cache[index])
index += 1
triangle.append(line)
for i in range(len(triangle)):
sums = []
for j in range(i, len(triangle)):
sums.append(0)
for k in range(len(sums)):
sums[k] += triangle[j][i]
val = sums[k]
last_layer = (i - 1, j, k)
if last_layer in candidates:
val += candidates[last_layer]
del candidates[last_layer]
if val < 0:
if k + i < j:
candidates[(i, j, k)] = val
elif val < smallest:
smallest = val
return smallest
def main(): tn = 286 pn = 166 hn = 144 t = utilities.triangle(tn) p = utilities.pentagon(pn) h = utilities.hexagon(hn) while t != p or t != h: if t == min(t, p, h): tn += 1 t = utilities.triangle(tn) elif p == min(t, p, h): pn += 1 p = utilities.pentagon(pn) elif h == min(t, p, h): hn += 1 h = utilities.hexagon(hn) return t
def main():
i = 1
n = 0
divisor_count = 0
while divisor_count <= 500:
divisors = set()
n = utilities.triangle(i)
for j in range(1, round(math.sqrt(n) + 1)):
if n % j == 0:
divisors.add(j)
divisors.add(n // j)
divisor_count = len(divisors)
i = i + 1
return n
def main():
utilities.generate_primes_sieve(1000000)
prime_set = set(utilities.primes)
total = 2
for i in itertools.count(2):
base = utilities.triangle(i - 1) * 6 + 1
for j in range(7):
n = base + 1 + j * i
if j == 6:
n -= 1
if j < 6 and j > 0:
prev_layer = n - (i * j + (i - 1) * (6 - j))
next_layer = n + (i * (6 - j) + (i + 1) * j)
candidates = [
prev_layer, next_layer - 1, next_layer, next_layer + 1
]
elif j == 0:
next_layer = n + i * 6
next_next_layer = n + (i * 2 + 1) * 6
candidates = [
next_layer - 1, next_layer + 1, next_next_layer - 1
]
else: # j == 6
prev_prev_layer = n - (i * 2 - 1) * 6
prev_layer = n - i * 6
next_layer = n + (i + 1) * 6
candidates = [
prev_prev_layer + 1, prev_layer + 1, next_layer - 1
]
count = 0
for candidate in candidates:
if abs(n - candidate) in prime_set:
count += 1
if count == 3:
total += 1
if total == TARGET:
return n
def cuboid_layer(x, y, z, k):
return (x * y * 2) + (y * z * 2) + (x * z * 2) + (x * 4 * (k - 1)) + (
y * 4 * (k - 1)) + (z * 4 *
(k - 1)) + (utilities.triangle(max(0, k - 2)) * 8)