main.main() - Code Metrics - Inspection of ":sparkles: Add solution for part 2" - Sigmanificient/aoc - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 950843...c77b04 )

by Yohann

created 2022-12-02 12:58 UTC

main.main() A

↳ Parent: main

Complexity

Conditions

Size

Total Lines	10
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	7
dl	0
loc	10
rs	10
c	0
b	0
f	0
cc	1
nop	0

from __future__ import annotations

import pathlib
from enum import IntEnum
from typing import Tuple, List, Dict

WIN_SCORE = 6
DRAW_SCORE = 3


class PlayMove(IntEnum):
    ROCK = 1
    PAPER = 2
    SCISSORS = 3

    @property
    def win(self) -> PlayMove:
        return PlayMove((self + 1) % 4 or 1)

    @property
    def lose(self) -> PlayMove:
        return PlayMove((self - 1) or 3)


class Target(IntEnum):
    LOSE = 1
    DRAW = 2
    WIN = 3

    def score_from_enemy(self, enemy: PlayMove) -> int:
        if self == Target.LOSE:
            return enemy.lose

        return (
            enemy.win + WIN_SCORE
            if self == Target.WIN
            else enemy + DRAW_SCORE
        )


TRANSLATION_MAP: Dict[str, PlayMove] = {
    'A': PlayMove.ROCK,
    'B': PlayMove.PAPER,
    'C': PlayMove.SCISSORS,

    'X': PlayMove.ROCK,
    'Y': PlayMove.PAPER,
    'Z': PlayMove.SCISSORS,
}


def get_part_one_score(moves: List[Tuple[PlayMove, ...]]) -> int:
    return sum(
        (
            my_move
            + (enemy_move.win == my_move) * WIN_SCORE
            + (my_move == enemy_move) * DRAW_SCORE
        ) for enemy_move, my_move in moves
    )


def get_part_two_score(moves: List[Tuple[PlayMove, ...]]) -> int:
    return sum(
        Target(target).score_from_enemy(enemy_move)
        for enemy_move, target in moves
    )


def main():
    content = pathlib.Path('./input.txt').read_text()

    moves: List[Tuple[PlayMove, ...]] = [
        tuple(map(TRANSLATION_MAP.get, line.split()))
        for line in content.splitlines()
    ]

    print("Part 1:", get_part_one_score(moves))
    print("Part 2:", get_part_two_score(moves))


if __name__ == '__main__':
    main()


1			from __future__ import annotations
2
3			import pathlib
4			from enum import IntEnum
5			from typing import Tuple, List, Dict
6
7			WIN_SCORE = 6
8			DRAW_SCORE = 3
9
10
11			class PlayMove(IntEnum):
12			ROCK = 1
13			PAPER = 2
14			SCISSORS = 3
15
16			@property
17			def win(self) -> PlayMove:
18			return PlayMove((self + 1) % 4 or 1)
19
20			@property
21			def lose(self) -> PlayMove:
22			return PlayMove((self - 1) or 3)
23
24
25			class Target(IntEnum):
26			LOSE = 1
27			DRAW = 2
28			WIN = 3
29
30			def score_from_enemy(self, enemy: PlayMove) -> int:
31			if self == Target.LOSE:
32			return enemy.lose
33
34			return (
35			enemy.win + WIN_SCORE
36			if self == Target.WIN
37			else enemy + DRAW_SCORE
38			)
39
40
41			TRANSLATION_MAP: Dict[str, PlayMove] = {
42			'A': PlayMove.ROCK,
43			'B': PlayMove.PAPER,
44			'C': PlayMove.SCISSORS,
45
46			'X': PlayMove.ROCK,
47			'Y': PlayMove.PAPER,
48			'Z': PlayMove.SCISSORS,
49			}
50
51
52			def get_part_one_score(moves: List[Tuple[PlayMove, ...]]) -> int:
53			return sum(
54			(
55			my_move
56			+ (enemy_move.win == my_move) * WIN_SCORE
57			+ (my_move == enemy_move) * DRAW_SCORE
58			) for enemy_move, my_move in moves
59			)
60
61
62			def get_part_two_score(moves: List[Tuple[PlayMove, ...]]) -> int:
63			return sum(
64			Target(target).score_from_enemy(enemy_move)
65			for enemy_move, target in moves
66			)
67
68
69			def main():
70			content = pathlib.Path('./input.txt').read_text()
71
72			moves: List[Tuple[PlayMove, ...]] = [
73			tuple(map(TRANSLATION_MAP.get, line.split()))
74			for line in content.splitlines()
75			]
76
77			print("Part 1:", get_part_one_score(moves))
78			print("Part 2:", get_part_two_score(moves))
79
80
81			if __name__ == '__main__':
82			main()
83

Sigmanificient / aoc

Push — main ( 950843...c77b04 )

main.main() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like