Add 2020 spring challenge (migrated from other repo)

This commit is contained in:
Gabriel Augendre 2020-11-12 17:19:59 +01:00
parent 8d2cee5250
commit 49af2f7157
No known key found for this signature in database
GPG key ID: 1E693F4CE4AEE7B4

398
challenges/2020-spring.py Normal file
View file

@ -0,0 +1,398 @@
import json
import math
import random
import sys
from enum import Enum
from typing import List, Set, Iterable, Union, Tuple, Dict
LOGGING = True
ENEMY_SIGHT_DISTANCE = 3
DISTANCE_THRESHOLD_FOR_SPEED = 3
WALL = "#"
PATH = " "
UNKNOWN_PATH = "."
class Type(Enum):
ROCK = "ROCK"
PAPER = "PAPER"
SCISSORS = "SCISSORS"
def __gt__(self, other):
wins_over = {
Type.ROCK: Type.SCISSORS,
Type.SCISSORS: Type.PAPER,
Type.PAPER: Type.ROCK,
}
loser = wins_over[self]
return other is loser
def get_winner(self):
winner_for = {
Type.SCISSORS: Type.ROCK,
Type.PAPER: Type.SCISSORS,
Type.ROCK: Type.PAPER,
}
return winner_for[self]
def log(something, *args, **kwargs):
if LOGGING:
print(something, *args, file=sys.stderr, **kwargs)
class Position:
def __init__(self, x, y):
self.x = x
self.y = y
def distance_to(self, other: "Position") -> int:
return int(math.fabs(self.x - other.x) + math.fabs(self.y - other.y))
def __hash__(self):
return hash((self.x, self.y))
def __eq__(self, other: "Position"):
return self.x == other.x and self.y == other.y
def __str__(self):
return json.dumps(self.to_dict())
def __repr__(self):
return str(self)
def to_dict(self):
return {"x": self.x, "y": self.y}
class Pac(Position):
def __init__(self, line: str):
split = line.split()
self.pac_id = int(split[0])
self.mine = split[1] != "0"
self.type_id = Type[split[4].upper()] # type: Type
self.speed_turns_left = int(split[5])
self.ability_cooldown = int(split[6])
x = int(split[2])
y = int(split[3])
super(Pac, self).__init__(x, y)
def __hash__(self):
return hash((self.pac_id, self.mine))
def __eq__(self, other: "Pac") -> bool:
return (
isinstance(other, Pac)
and self.pac_id == other.pac_id
and self.mine == other.mine
)
def to_dict(self) -> Dict:
dct = super(Pac, self).to_dict()
dct.update({"id": self.pac_id, "mine": self.mine})
return dct
def move_to(self, unit: Position) -> str:
return f"MOVE {self.pac_id} {unit.x} {unit.y}"
def speed(self) -> str:
return f"SPEED {self.pac_id}"
def switch(self, type: Type, comment: str = "") -> str:
return f"SWITCH {self.pac_id} {type.value} {comment}"
def target_type(self, other: "Pac") -> Union[Type, None]:
winner_type = other.type_id.get_winner()
if winner_type is self.type_id:
return None
return winner_type
@property
def can_use_power(self) -> bool:
return self.ability_cooldown <= 1
@property
def is_speeding(self) -> bool:
return self.speed_turns_left > 0
class Pellet(Position):
def __init__(self, line: str):
x, y, value = [int(i) for i in line.split()]
self.value = value
super(Pellet, self).__init__(x, y)
def __hash__(self):
return hash((self.x, self.y, self.value))
def __eq__(self, other: "Pellet"):
return (
isinstance(other, Pellet)
and super(Pellet, self).__eq__(other)
and self.value == other.value
)
def to_dict(self):
dct = super().to_dict()
dct.update({"value": self.value})
return dct
@property
def is_super(self) -> bool:
return self.value > 1
class Grid:
def __init__(self, line: str, process_rows: bool = True):
# Invariants
# width: size of the grid
# height: top left corner is (x=0, y=0)
width, height = [int(i) for i in line.split()]
self.width = width # type: int
self.height = height # type: int
self.map = [] # type: List[List[str]]
if process_rows:
for i in range(self.height):
self.map.append(list(input().replace(PATH, UNKNOWN_PATH)))
# Variants
self.pacs = set() # type: Set[Pac]
self.pellets = set() # type: Set[Pellet]
self.previous_pacs = set()
@property
def my_pacs(self) -> Iterable[Pac]:
return filter(lambda pac: pac.mine, self.pacs)
@property
def enemy_pacs(self) -> Iterable[Pac]:
return filter(lambda pac: not pac.mine, self.pacs)
def pac_at_position(self, x, y, enemy_filter=None) -> Union[Pac, None]:
if enemy_filter is True:
pacs = self.enemy_pacs
elif enemy_filter is False:
pacs = self.my_pacs
else:
pacs = self.pacs
x = x % self.width
y = y % self.height
for pac in pacs:
if pac.x == x and pac.y == y:
return pac
def new_turn(self):
self.previous_pacs = self.pacs
self.pacs = set()
self.pellets = set()
def add_pellet(self, line: str) -> Pellet:
pellet = Pellet(line)
self.set_map_at_coordinates(pellet, str(pellet.value))
self.pellets.add(pellet)
return pellet
def add_pac(self, line: str) -> Pac:
pac = Pac(line)
self.pacs.add(pac)
return pac
def get_random_position(self) -> Position:
return Position(
random.randint(0, self.width - 1), random.randint(0, self.height - 1)
)
def get_closest_unknown(self, me: Pac) -> Union[Position, None]:
closest = None
for y, row in enumerate(self.map):
for x, cell in enumerate(row):
if cell != UNKNOWN_PATH:
continue
pos = Position(x, y)
if not closest or me.distance_to(pos) < me.distance_to(closest):
closest = pos
return closest
def get_action(
self, me: Pac, already_targeted: Set[Position]
) -> Tuple[str, Union[Position, None]]:
enemy = self.closest_enemy_in_sight(me)
if me.can_use_power and enemy:
new_type = me.target_type(enemy)
if new_type:
return (
me.switch(new_type, f"switching to {new_type.value} for {enemy}"),
None,
)
if enemy and me.type_id > enemy.type_id:
return me.move_to(enemy), enemy
target = self.find_target(me, already_targeted)
if me.can_use_power:
return me.speed(), None
return me.move_to(target), target
def find_target(self, me: Pac, already_targeted: Set[Position]) -> Position:
rnd = self.get_random_position()
default = self.get_closest_unknown(me)
same_position = False
min_dist = 2 if me.is_speeding else 1
for pac in self.previous_pacs:
if pac == me and pac.x == me.x and pac.y == me.y:
same_position = True
break
if same_position:
return default or rnd
closest_pellet_distance = math.inf
closest_pellet = None
closest_super_pellet_distance = math.inf
closest_super_pellet = None
fallback_pellet = None
for pellet in self.pellets:
if pellet in already_targeted:
continue
distance = me.distance_to(pellet)
if pellet.is_super:
if distance < closest_super_pellet_distance:
closest_super_pellet_distance = distance
closest_super_pellet = pellet
else:
if min_dist <= distance < closest_pellet_distance:
closest_pellet_distance = distance
closest_pellet = pellet
elif distance < closest_pellet_distance:
fallback_pellet = pellet
if (
fallback_pellet
and closest_pellet
and math.fabs(
me.distance_to(fallback_pellet) - me.distance_to(closest_pellet)
)
> 3
):
closest_pellet = fallback_pellet
log(me.pac_id, closest_super_pellet, closest_pellet, default)
return (
closest_super_pellet or closest_pellet or fallback_pellet or default or rnd
)
def get_map_at_coordinates(self, x: int, y: int) -> str:
x = x % self.width
y = y % self.height
return self.map[y][x]
def set_map_at_coordinates(self, position: Position, value: str):
x = position.x % self.width
y = position.y % self.height
self.map[y][x] = value
def closest_enemy_in_sight(self, me: Pac) -> Union[Pac, None]:
try_right, try_left, try_up, try_down = True, True, True, True
closest_enemy = None
self.set_map_at_coordinates(me, PATH)
for i in range(1, max(self.height, self.width)):
if try_right:
x = me.x + i
y = me.y
cell = self.get_map_at_coordinates(x, y)
if cell == WALL:
try_right = False
elif cell == UNKNOWN_PATH:
self.set_map_at_coordinates(Position(x, y), PATH)
pac_at_position = self.pac_at_position(x, y, enemy_filter=True)
if (
pac_at_position
and me.distance_to(pac_at_position) <= ENEMY_SIGHT_DISTANCE
and not closest_enemy
):
closest_enemy = pac_at_position
if try_left:
x = me.x - i
y = me.y
cell = self.get_map_at_coordinates(x, y)
if cell == WALL:
try_left = False
elif cell == UNKNOWN_PATH:
self.set_map_at_coordinates(Position(x, y), PATH)
pac_at_position = self.pac_at_position(x, y, enemy_filter=True)
if (
pac_at_position
and me.distance_to(pac_at_position) <= ENEMY_SIGHT_DISTANCE
and not closest_enemy
):
closest_enemy = pac_at_position
if try_up:
x = me.x
y = me.y - i
cell = self.get_map_at_coordinates(x, y)
if cell == WALL:
try_up = False
elif cell == UNKNOWN_PATH:
self.set_map_at_coordinates(Position(x, y), PATH)
pac_at_position = self.pac_at_position(x, y, enemy_filter=True)
if (
pac_at_position
and me.distance_to(pac_at_position) <= ENEMY_SIGHT_DISTANCE
and not closest_enemy
):
closest_enemy = pac_at_position
if try_down:
x = me.x
y = me.y + i
cell = self.get_map_at_coordinates(x, y)
if cell == WALL:
try_down = False
elif cell == UNKNOWN_PATH:
self.set_map_at_coordinates(Position(x, y), PATH)
pac_at_position = self.pac_at_position(x, y, enemy_filter=True)
if (
pac_at_position
and me.distance_to(pac_at_position) <= ENEMY_SIGHT_DISTANCE
and not closest_enemy
):
closest_enemy = pac_at_position
return closest_enemy
def main():
grid = Grid(input())
# game loop
while True:
grid.new_turn()
my_score, opponent_score = [int(i) for i in input().split()] # type: int, int
visible_pac_count = int(input()) # type: int
for i in range(visible_pac_count):
grid.add_pac(input())
visible_pellet_count = int(input()) # type: int
for _ in range(visible_pellet_count):
grid.add_pellet(input())
output = []
targets = set()
for pac in grid.my_pacs:
action, target = grid.get_action(pac, targets)
output.append(action)
targets.add(target)
print(" | ".join(output))
if __name__ == "__main__":
main()