Compare commits
No commits in common. "15b4f24087b9d96e8aed984e690dab63c54284b3" and "e5ba1cc940c90a83aa0e844674f28d753e8d7fc5" have entirely different histories.
15b4f24087
...
e5ba1cc940
130
2022/day17.py
130
2022/day17.py
@ -1,20 +1,136 @@
|
||||
#!/usr/bin/python3
|
||||
"""
|
||||
Jour 17 du défi Advent Of Code pour l'année 2022
|
||||
<!-- NE FONCTIONNE PAS --!>
|
||||
"""
|
||||
import os
|
||||
|
||||
PRINT = True
|
||||
ROCKS = [
|
||||
[
|
||||
["@", "@", "@", "@"]
|
||||
],
|
||||
[
|
||||
[".", "@", "."],
|
||||
["@", "@", "@"],
|
||||
[".", "@", "."]
|
||||
],
|
||||
[
|
||||
[".", ".", "@"],
|
||||
[".", ".", "@"],
|
||||
["@", "@", "@"]
|
||||
],
|
||||
[
|
||||
["@"],
|
||||
["@"],
|
||||
["@"],
|
||||
["@"]
|
||||
],
|
||||
[
|
||||
["@", "@"],
|
||||
["@", "@"],
|
||||
]
|
||||
]
|
||||
|
||||
|
||||
def read_sample():
|
||||
"""récupère les entrées depuis le fichier texte correspondant"""
|
||||
filename = os.path.join(os.path.dirname(__file__ ), "inputs", "day17.txt")
|
||||
with open(filename, 'r') as f:
|
||||
sample = f.read().split('\n')
|
||||
sample = [ i for i in sample if i != '' ]
|
||||
return sample
|
||||
with open('inputs/day17.txt', 'r') as f:
|
||||
return f.read()
|
||||
|
||||
|
||||
def print_puzzle(heights, rock, left_down_corner):
|
||||
if not PRINT:
|
||||
return
|
||||
for i in range(len(rock)):
|
||||
print("|"+"."*left_down_corner[1]+"".join(rock[i])+"."*(7-len(rock[i])-left_down_corner[1])+"|")
|
||||
for i in range(left_down_corner[0]-max(heights)):
|
||||
print("|"+"."*7+"|")
|
||||
for i in range(max(heights)):
|
||||
print("|", end="")
|
||||
for j in range(len(heights)):
|
||||
if heights[j] >= (max(heights)-i):
|
||||
print("#", end="")
|
||||
else:
|
||||
print(".", end="")
|
||||
print("|")
|
||||
print("+"+"-"*7+"+")
|
||||
print()
|
||||
|
||||
|
||||
def gas_jet(direction, pos, rock, largeur):
|
||||
if direction == '>':
|
||||
if pos[1]+max([len(j) for j in rock]) < largeur: #Move
|
||||
pos = (pos[0], pos[1]+1)
|
||||
print("Move right:")
|
||||
else:
|
||||
print("Failed to move right:")
|
||||
else:
|
||||
if pos[1] > 0: #Move
|
||||
pos = (pos[0], pos[1]-1)
|
||||
print("Move left:")
|
||||
else:
|
||||
print("Failed to move left:")
|
||||
return pos
|
||||
|
||||
def part1(sample):
|
||||
"""Partie 1 du défi"""
|
||||
return NotImplementedError
|
||||
largeur = 7
|
||||
heights = [0 for i in range(largeur)]
|
||||
stream_pos = 0
|
||||
for i in range(2022):
|
||||
print(f"rock {i}")
|
||||
rock = ROCKS[(i)%len(ROCKS)]
|
||||
|
||||
left_down_corner = (max(heights)+3, 2)
|
||||
falling = True
|
||||
while falling:
|
||||
|
||||
left_down_corner = gas_jet(sample[stream_pos%len(sample)], left_down_corner, rock, largeur)
|
||||
stream_pos += 1
|
||||
|
||||
print_puzzle(heights, rock, left_down_corner)
|
||||
|
||||
print("falls 1 unit:")
|
||||
left_down_corner = (left_down_corner[0]-1, left_down_corner[1])
|
||||
|
||||
print_puzzle(heights, rock, left_down_corner)
|
||||
# Check si en bas
|
||||
if left_down_corner[0] <= 0:
|
||||
falling = False
|
||||
elif left_down_corner[0] <= max(heights)+1:
|
||||
print("Potentially blocked")
|
||||
for j in range(len(rock[0])):
|
||||
print(f"trying on rock[*][{j}]")
|
||||
if (len(rock)-1) - max([k for k in range(len(rock)) if rock[k][j] != '.']) + left_down_corner[0] == heights[j+left_down_corner[1]]:
|
||||
falling = False
|
||||
print("blocked")
|
||||
break
|
||||
|
||||
|
||||
if falling:
|
||||
print_puzzle(heights, rock, left_down_corner)
|
||||
|
||||
left_down_corner = gas_jet(sample[stream_pos%len(sample)], left_down_corner, rock, largeur)
|
||||
stream_pos += 1
|
||||
|
||||
print_puzzle(heights, rock, left_down_corner)
|
||||
for j in range(len(rock[0])):
|
||||
(len(rock)-1) - max([k for k in range(len(rock)) if rock[k][j] != '.']) + left_down_corner[0]
|
||||
print(j+left_down_corner[1], left_down_corner[0], 1+min([k for k in range(len(rock)) if rock[k][j] != '.']))
|
||||
|
||||
if heights[j+left_down_corner[1]] > left_down_corner[0] + len(rock)-(min([k for k in range(len(rock)) if rock[k][j] != '.'])):
|
||||
print(heights[j+left_down_corner[1]], left_down_corner[0] + len(rock)-(min([k for k in range(len(rock)) if rock[k][j] != '.'])), "Error!")
|
||||
print_puzzle(heights, rock, left_down_corner)
|
||||
print(heights)
|
||||
print(left_down_corner)
|
||||
print(len(rock))
|
||||
print(min([k for k in range(len(rock)) if rock[k][j] != '.']))
|
||||
raise Exception
|
||||
heights[j+left_down_corner[1]] = left_down_corner[0] + len(rock)-(min([k for k in range(len(rock)) if rock[k][j] != '.']))
|
||||
|
||||
print("## ignore rock:")
|
||||
print_puzzle(heights, rock, left_down_corner)
|
||||
return max(heights)
|
||||
|
||||
def part2(sample):
|
||||
"""Partie 2 du défi"""
|
||||
|
||||
@ -3,7 +3,6 @@
|
||||
Jour 08 du défi Advent Of Code pour l'année 2023
|
||||
"""
|
||||
import os
|
||||
import math
|
||||
|
||||
def read_sample():
|
||||
"""récupère les entrées depuis le fichier texte correspondant"""
|
||||
@ -13,6 +12,19 @@ def read_sample():
|
||||
sample = [ i for i in sample if i != '' ]
|
||||
return sample
|
||||
|
||||
def gcd(a, b):
|
||||
while b:
|
||||
a, b = b, a % b
|
||||
return a
|
||||
|
||||
def lcm(a, b):
|
||||
return (a * b) // gcd(a, b)
|
||||
|
||||
def lcm_of_list(numbers):
|
||||
result = 1
|
||||
for num in numbers:
|
||||
result = lcm(result, num)
|
||||
return result
|
||||
|
||||
def parse_sample(sample):
|
||||
instructions = sample[0]
|
||||
@ -22,7 +34,6 @@ def parse_sample(sample):
|
||||
}
|
||||
return instructions, mappings
|
||||
|
||||
|
||||
def number_steps(instructions, mappings, pos, untilZZZ=True):
|
||||
step = 0
|
||||
instr = {
|
||||
@ -33,8 +44,6 @@ def number_steps(instructions, mappings, pos, untilZZZ=True):
|
||||
step += 1
|
||||
return step
|
||||
|
||||
|
||||
|
||||
def part1(sample):
|
||||
"""Partie 1 du défi"""
|
||||
instructions, mappings = parse_sample(sample)
|
||||
@ -45,7 +54,7 @@ def part2(sample):
|
||||
instructions, mappings = parse_sample(sample)
|
||||
a_ending = [i for i in mappings.keys() if i[-1] == 'A']
|
||||
steps = [number_steps(instructions, mappings, i, untilZZZ=False) for i in a_ending]
|
||||
return math.lcm(*steps)
|
||||
return lcm_of_list(steps)
|
||||
|
||||
|
||||
def main():
|
||||
|
||||
@ -3,9 +3,8 @@
|
||||
Jour 12 du défi Advent Of Code pour l'année 2023
|
||||
"""
|
||||
import os
|
||||
from functools import cache
|
||||
|
||||
from aoc_utils import decorators
|
||||
from functools import cache, wraps
|
||||
from time import time
|
||||
|
||||
def read_sample():
|
||||
"""récupère les entrées depuis le fichier texte correspondant"""
|
||||
@ -25,6 +24,18 @@ def parse_sample(sample):
|
||||
return springs, counts
|
||||
|
||||
|
||||
def timing(f):
|
||||
@wraps(f)
|
||||
def wrap(*args, **kw):
|
||||
ts = time()
|
||||
result = f(*args, **kw)
|
||||
te = time()
|
||||
print('> %s: %2.4f sec' % \
|
||||
(f.__name__, te-ts))
|
||||
return result
|
||||
return wrap
|
||||
|
||||
|
||||
def nb_poss(spring, count):
|
||||
def check_new_elem(elem, size, count):
|
||||
if size > len(count):
|
||||
@ -103,7 +114,7 @@ def unfold(springs, counts):
|
||||
counts[i] = counts[i]*5
|
||||
|
||||
|
||||
@decorators.timeit
|
||||
@timing
|
||||
def part1(sample):
|
||||
"""Partie 1 du défi"""
|
||||
springs, counts = parse_sample(sample)
|
||||
@ -114,7 +125,7 @@ def part1(sample):
|
||||
return sum(possibilities)
|
||||
|
||||
|
||||
@decorators.timeit
|
||||
@timing
|
||||
def part2(sample):
|
||||
"""Partie 2 du défi"""
|
||||
springs, counts = parse_sample(sample)
|
||||
|
||||
@ -4,8 +4,6 @@ Jour 18 du défi Advent Of Code pour l'année 2023
|
||||
"""
|
||||
import os
|
||||
|
||||
from aoc_utils import snippets
|
||||
|
||||
directions = {
|
||||
"R": (0, 1),
|
||||
"L": (0, -1),
|
||||
@ -109,6 +107,29 @@ def print_terrain(terrain):
|
||||
print()
|
||||
|
||||
|
||||
def border(data):
|
||||
return(sum((i[1] for i in data)))
|
||||
|
||||
# https://www.tutorialspoint.com/program-to-find-area-of-a-polygon-in-python
|
||||
def getInfo(x1, y1, x2, y2):
|
||||
return x1*y2 - y1*x2
|
||||
|
||||
def solve(data):
|
||||
points = [t[0] for t in data]
|
||||
N = len(points)
|
||||
firstx, firsty = points[0]
|
||||
prevx, prevy = firstx, firsty
|
||||
res = 0
|
||||
|
||||
for i in range(1, N):
|
||||
nextx, nexty = points[i]
|
||||
res = res + getInfo(prevx,prevy,nextx,nexty)
|
||||
prevx = nextx
|
||||
prevy = nexty
|
||||
res = res + getInfo(prevx,prevy,firstx,firsty)
|
||||
return abs(res)/2.0
|
||||
|
||||
|
||||
def part1(sample):
|
||||
"""Partie 1 du défi"""
|
||||
data = parse_sample(sample, new_method=False)
|
||||
@ -119,8 +140,7 @@ def part2(sample):
|
||||
"""Partie 2 du défi"""
|
||||
data = parse_sample(sample, new_method=True)
|
||||
terrain = dig(data, only_edges=True)
|
||||
points = [i[0] for i in terrain]
|
||||
return snippets.area(points)
|
||||
return int(solve(terrain)+border(data)//2 +1)
|
||||
|
||||
|
||||
def main():
|
||||
|
||||
@ -3,8 +3,7 @@
|
||||
Jour 21 du défi Advent Of Code pour l'année 2023
|
||||
"""
|
||||
import os
|
||||
|
||||
from aoc_utils import decorators, snippets
|
||||
from aoc_utils.decorators import timeit
|
||||
|
||||
def read_sample():
|
||||
"""récupère les entrées depuis le fichier texte correspondant"""
|
||||
@ -63,12 +62,24 @@ def do_steps(sample, steps=26501365, ext=False):
|
||||
return pos_ts
|
||||
|
||||
|
||||
@decorators.timeit
|
||||
def lagrange_interpolation(points, x0):
|
||||
result = 0
|
||||
for i in range(len(points)):
|
||||
temp = points[i][1]
|
||||
for j in range(len(points)):
|
||||
if j != i:
|
||||
temp *= (x0 - points[j][0]) / (points[i][0] - points[j][0])
|
||||
|
||||
result += temp
|
||||
|
||||
return int(result)
|
||||
|
||||
@timeit
|
||||
def part1(sample):
|
||||
"""Partie 1 du défi"""
|
||||
return len(do_steps(sample, steps=64, ext=False))
|
||||
|
||||
@decorators.timeit
|
||||
@timeit
|
||||
def part2(sample):
|
||||
"""Partie 2 du défi"""
|
||||
def challenge(steps):
|
||||
@ -82,7 +93,7 @@ def part2(sample):
|
||||
(half_size+size, challenge(half_size+size)),
|
||||
(half_size+2*size, challenge(half_size+2*size))
|
||||
]
|
||||
return snippets.lagrange_interpolation(points, 26501365)
|
||||
return lagrange_interpolation(points, 26501365)
|
||||
|
||||
|
||||
|
||||
|
||||
@ -6,8 +6,6 @@ import os
|
||||
import string
|
||||
import random
|
||||
|
||||
from aoc_utils.intervals import Interval
|
||||
|
||||
def read_sample():
|
||||
"""récupère les entrées depuis le fichier texte correspondant"""
|
||||
filename = os.path.join(os.path.dirname(__file__ ), "inputs", "day22.txt")
|
||||
@ -24,25 +22,37 @@ class Brick:
|
||||
coords = text.split("~")
|
||||
coords = (coords[0].split(','), coords[1].split(','))
|
||||
|
||||
self.x = Interval(int(coords[0][0]), int(coords[1][0]))
|
||||
self.y = Interval(int(coords[0][1]), int(coords[1][1]))
|
||||
self.z = Interval(int(coords[0][2]), int(coords[1][2]))
|
||||
self.x0 = int(coords[0][0])
|
||||
self.y0 = int(coords[0][1])
|
||||
self.z0 = int(coords[0][2])
|
||||
|
||||
self.x1 = int(coords[1][0])
|
||||
self.y1 = int(coords[1][1])
|
||||
self.z1 = int(coords[1][2])
|
||||
|
||||
self.label = random.choice(string.ascii_letters)
|
||||
self.text = text
|
||||
|
||||
def __repr__(self):
|
||||
return f"[{self.label}]{self.x.low},{self.y.low},{self.z.low}~{self.x.up},{self.y.up},{self.z.up}"
|
||||
#return self.text+f"[{self.label}] [h:{self.z.low}]"
|
||||
return f"[{self.label}]{self.x0},{self.y0},{self.z0}~{self.x1},{self.y1},{self.z1}"
|
||||
#return self.text+f"[{self.label}] [h:{self.z0}]"
|
||||
|
||||
def supported_by(self, brick):
|
||||
if brick.z.up == self.z.low-1:
|
||||
if self.x.intersect(brick.x) and self.y.intersect(brick.y):
|
||||
def intersect(interval1, interval2):
|
||||
if interval2[0] > interval1[1] or interval1[0] > interval2[1]:
|
||||
return None
|
||||
new_min = max(interval1[0], interval2[0])
|
||||
new_max = min(interval1[1], interval2[1])
|
||||
return [new_min, new_max]
|
||||
|
||||
if brick.z1 == self.z0-1:
|
||||
if intersect([self.x0, self.x1], [brick.x0, brick.x1]) is not None \
|
||||
and intersect([self.y0, self.y1], [brick.y0, brick.y1]) is not None:
|
||||
return True
|
||||
return False
|
||||
|
||||
def can_fall(self, bricks):
|
||||
if self.z.low == 1:
|
||||
if self.z0 == 1:
|
||||
return False
|
||||
for brick in bricks:
|
||||
if brick != self and self.supported_by(brick):
|
||||
@ -51,20 +61,27 @@ class Brick:
|
||||
|
||||
def copy(self):
|
||||
# Assuming your class has a constructor that accepts the same parameters
|
||||
copie = Brick(f"{self.x.low},{self.y.low},{self.z.low}~{self.x.up},{self.y.up},{self.z.up}")
|
||||
copie = Brick(f"{self.x0},{self.y0},{self.z0}~{self.x1},{self.y1},{self.z1}")
|
||||
copie.label = self.label
|
||||
return copie
|
||||
|
||||
def intersect(interval1, interval2):
|
||||
if interval2[0] > interval1[1] or interval1[0] > interval2[1]:
|
||||
return None
|
||||
new_min = max(interval1[0], interval2[0])
|
||||
new_max = min(interval1[1], interval2[1])
|
||||
return [new_min, new_max]
|
||||
|
||||
|
||||
def print_pile(bricks):
|
||||
def occupied(x, z):
|
||||
for b in bricks:
|
||||
if b.x.low <= x and x <= b.x.up and b.z.low <= z and z <= b.z.up:
|
||||
if b.x0 <= x and x <= b.x1 and b.z0 <= z and z <= b.z1:
|
||||
return b
|
||||
return False
|
||||
|
||||
for z in reversed(range(max((b.z.up for b in bricks))+1)):
|
||||
for x in range(max((b.x.up for b in bricks))+1):
|
||||
for z in reversed(range(max((b.z1 for b in bricks))+1)):
|
||||
for x in range(max((b.x1 for b in bricks))+1):
|
||||
occ = occupied(x, z)
|
||||
if occ:
|
||||
print(occ.label, end="")
|
||||
@ -76,7 +93,7 @@ def print_pile(bricks):
|
||||
def fall(bricks, count="z"):
|
||||
fallen = 0
|
||||
has_fallen = False
|
||||
bricks.sort(key=lambda b: b.z.up)
|
||||
bricks.sort(key=lambda b: b.z1)
|
||||
for brick in bricks:
|
||||
has_fallen = False
|
||||
while brick.can_fall(bricks):
|
||||
@ -84,8 +101,8 @@ def fall(bricks, count="z"):
|
||||
fallen += 1
|
||||
|
||||
has_fallen = True
|
||||
brick.z.low -= 1
|
||||
brick.z.up -= 1
|
||||
brick.z0 -= 1
|
||||
brick.z1 -= 1
|
||||
|
||||
if count != "z" and has_fallen:
|
||||
fallen += 1
|
||||
|
||||
@ -1,92 +0,0 @@
|
||||
#!/usr/bin/python3
|
||||
"""
|
||||
Jour 24 du défi Advent Of Code pour l'année 2023
|
||||
"""
|
||||
import os
|
||||
import z3
|
||||
|
||||
def read_sample():
|
||||
"""récupère les entrées depuis le fichier texte correspondant"""
|
||||
filename = os.path.join(os.path.dirname(__file__ ), "inputs", "day24.txt")
|
||||
with open(filename, 'r') as f:
|
||||
sample = f.read().split('\n')
|
||||
sample = [ i for i in sample if i != '' ]
|
||||
return sample
|
||||
|
||||
class Hailstone:
|
||||
def __init__(self, text):
|
||||
self.px = int(text.split(" @ ")[0].split(", ")[0])
|
||||
self.py = int(text.split(" @ ")[0].split(", ")[1])
|
||||
self.pz = int(text.split(" @ ")[0].split(", ")[2])
|
||||
|
||||
self.dx = int(text.split(" @ ")[1].split(", ")[0])
|
||||
self.dy = int(text.split(" @ ")[1].split(", ")[1])
|
||||
self.dz = int(text.split(" @ ")[1].split(", ")[2])
|
||||
|
||||
def __repr__(self):
|
||||
return f"{self.px}, {self.py}, {self.pz} @ {self.dx}, {self.dy}, {self.dz}"
|
||||
|
||||
|
||||
def intersection(h1, h2):
|
||||
try:
|
||||
# ax+b
|
||||
# cx+d
|
||||
b, a = h1.py - (h1.px/h1.dx)*h1.dy, h1.dy/h1.dx
|
||||
d, c = h2.py - (h2.px/h2.dx)*h2.dy, h2.dy/h2.dx
|
||||
|
||||
x = (d - b) / (a - c)
|
||||
y = a*x+b
|
||||
|
||||
if (x-h1.px)/h1.dx < 0:
|
||||
return None
|
||||
if (x-h2.px)/h2.dx < 0:
|
||||
return None
|
||||
except ZeroDivisionError:
|
||||
return None
|
||||
|
||||
return x, y
|
||||
|
||||
|
||||
|
||||
def part1(sample, left=200000000000000, right=400000000000000):
|
||||
"""Partie 1 du défi"""
|
||||
hailstones = [Hailstone(i) for i in sample]
|
||||
|
||||
count = 0
|
||||
for i in range(len(hailstones)):
|
||||
for j in range(i):
|
||||
res = intersection(hailstones[i], hailstones[j])
|
||||
if res is not None:
|
||||
x, y = res
|
||||
if left <= x and x <= right and left <= y and y <= right:
|
||||
count += 1
|
||||
|
||||
return count
|
||||
|
||||
def part2(sample):
|
||||
"""Partie 2 du défi"""
|
||||
hailstones = [Hailstone(i) for i in sample]
|
||||
|
||||
px, py, pz, dx, dy, dz = z3.Ints("px py pz dx dy dz")
|
||||
collision = [z3.Int("t"+str(i)) for i in range(len(hailstones))]
|
||||
solver = z3.Solver()
|
||||
for i in range(len(hailstones)):
|
||||
h = hailstones[i]
|
||||
solver.add(px + dx*collision[i] == h.px + h.dx*collision[i])
|
||||
solver.add(py + dy*collision[i] == h.py + h.dy*collision[i])
|
||||
solver.add(pz + dz*collision[i] == h.pz + h.dz*collision[i])
|
||||
|
||||
solver.check()
|
||||
|
||||
|
||||
return solver.model().evaluate(px + py + pz)
|
||||
|
||||
|
||||
def main():
|
||||
"""Fonction principale"""
|
||||
sample = read_sample()
|
||||
print(f"part1: {part1(sample)}")
|
||||
print(f"part2: {part2(sample)}")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -1,31 +0,0 @@
|
||||
class Interval:
|
||||
"""Définit des intervalles de $\\mathbb{R}$"""
|
||||
def __init__(self, a: float, b: float) -> None:
|
||||
assert a <= b
|
||||
|
||||
self.low = a
|
||||
self.up = b
|
||||
|
||||
def __repr__(self) -> str:
|
||||
if self.up == self.low:
|
||||
return '{'+str(self.up)+'}'
|
||||
return f"[{self.low}, {self.up}]"
|
||||
|
||||
def __len__(self) -> float:
|
||||
return self.up - self.low
|
||||
|
||||
def __contains__(self, item: float) -> bool:
|
||||
return self.low <= item and item <= self.up
|
||||
|
||||
def __eq__(self, interval):
|
||||
return self.low == interval.low and self.up == interval.up
|
||||
|
||||
def intersect(self, interval) -> bool:
|
||||
return not (interval.low > self.up or self.low > interval.up)
|
||||
|
||||
def intersection(self, interval):
|
||||
if interval.low > self.up or self.low > interval.up:
|
||||
return None
|
||||
new_min = max(self.low, interval.low)
|
||||
new_max = min(self.up, interval.up)
|
||||
return Interval(new_min, new_max)
|
||||
@ -1,48 +0,0 @@
|
||||
from typing import TypeVar
|
||||
|
||||
Nb = TypeVar("Nb", int, float)
|
||||
|
||||
|
||||
def lagrange_interpolation(points: list[tuple[Nb, Nb]], x0: Nb) -> int:
|
||||
result = 0
|
||||
for i in range(len(points)):
|
||||
temp = points[i][1]
|
||||
for j in range(len(points)):
|
||||
if j != i:
|
||||
temp *= (x0 - points[j][0]) / (points[i][0] - points[j][0])
|
||||
|
||||
result += temp
|
||||
|
||||
return int(result)
|
||||
|
||||
|
||||
|
||||
def area(points: list[tuple[Nb, Nb]], count_border: bool=True) -> int:
|
||||
def distance(p1: tuple[Nb, Nb], p2: tuple[Nb, Nb]) -> float:
|
||||
return abs(p1[0]-p2[0]) + abs(p1[1]-p2[1])
|
||||
|
||||
def get_info(x1: Nb, y1: Nb, x2: Nb, y2: Nb) -> Nb:
|
||||
return x1*y2 - y1*x2
|
||||
|
||||
def inner_area() -> float:
|
||||
first_x, first_y = points[0]
|
||||
prev_x, prev_y = first_x, first_y
|
||||
res = 0
|
||||
|
||||
for i in range(len(points)-1):
|
||||
next_x, next_y = points[i+1]
|
||||
res = res + get_info(prev_x, prev_y, next_x, next_y)
|
||||
prev_x = next_x
|
||||
prev_y = next_y
|
||||
res = res + get_info(prev_x, prev_y, first_x, first_y)
|
||||
return abs(res)/2.0
|
||||
|
||||
def border() -> float:
|
||||
distances = [distance(points[i], points[i+1]) for i in range(len(points)-1)]
|
||||
distances.append(distance(points[-1], points[0]))
|
||||
return sum(distances)
|
||||
|
||||
if count_border:
|
||||
return int(inner_area()+border()//2 +1)
|
||||
|
||||
return int(inner_area())
|
||||
Loading…
Reference in New Issue
Block a user