Advent of Code

   10 TI$="000000":DIM M$(350):OPEN 2,8,2,"INPUT03,S,R"
   20 PRINT"READ TREE MAP ROW:":H=0
   30 IF ST<>0 THEN 100
   40 INPUT#2,M$(H):H=H+1:PRINT H:PRINT"{UP}";:GOTO 30
  100 CLOSE 2:W=LEN(M$(0)):PRINT"READING TIME: ";TI$
  110 R=1:FOR I=1 TO 5:READ SX,SY:X=0:Y=0:TC=0
  120 PRINT"TREES ON SLOPE";SX;",";SY;"=";
  130 IF Y>=H THEN 170
  140 IF MID$(M$(Y),X+1,1)="#" THEN TC=TC+1
  150 Y=Y+SY:X=X+SX:IF X>=W THEN X=X-W
  160 GOTO 130
  170 PRINT TC:R=R*TC:NEXT:PRINT"PART 2:";R:PRINT"TOTAL TIME:";TI$
 9000 REM SLOPE X/Y PAIRS
 9010 DATA 3,1, 1,1, 5,1, 7,1, 1,2

   10 TI$="000000":CR$=CHR$(13):PN=1:R1=0:R2=0:OPEN 2,8,2,"INPUT04,S,R"
   20 PRINT"CHECK PASSPORTS..."
   50 IF ST<>0 THEN 9999
   60 PRINT PN:PRINT"{UP}";:PN=PN+1
  100 REM READ PASSPORT
  110 BY$="":IY$="":EY$="":HG$="":HC$="":EC$="":PI$="":T$=""
  120 GET#2,C$:IF ST<>0 OR C$=CR$ AND C$=T$ THEN 500
  130 GET#2,C2$:GET#2,C3$:K$=C$+C2$+C3$:GET#2,C$:REM READ KEY, SKIP ":"
  140 V$=""
  150 GET#2,C$
  160 IF C$=" " OR C$=CR$ THEN T$=C$:GOTO 180
  170 V$=V$+C$:GOTO 150
  180 REM PRINT"<"K$"> <"V$">"
  190 IF K$="BYR" THEN BY$=V$:GOTO 280
  200 IF K$="IYR" THEN IY$=V$:GOTO 280
  210 IF K$="EYR" THEN EY$=V$:GOTO 280
  220 IF K$="HGT" THEN HG$=V$:GOTO 280
  230 IF K$="HCL" THEN HC$=V$:GOTO 280
  240 IF K$="ECL" THEN EC$=V$:GOTO 280
  250 IF K$="PID" THEN PI$=V$:GOTO 280
  260 IF K$="CID" THEN 280:REM IGNORE COUNTRY ID
  270 PRINT"ERROR: INVALID KEY FOUND: "K$:END
  280 GOTO 120
  500 REM CHECK IF DATA IS COMPLETE
  510 IF BY$="" OR IY$="" OR EY$="" OR HG$="" THEN 50
  520 IF HC$="" OR EC$="" OR PI$="" THEN 50
  530 R1=R1+1
  600 REM CHECK VALUES
  610 IF LEN(BY$)<>4 OR LEN(IY$)<> 4 OR LEN(EY$)<>4 THEN 50
  620 IF LEN(HC$)<>7 OR LEN(PI$)<>9 THEN 50
  630 V=VAL(BY$):IF V<1920 OR V>2002 THEN 50
  640 V=VAL(IY$):IF V<2010 OR V>2020 THEN 50
  650 V=VAL(EY$):IF V<2020 OR V>2030 THEN 50
  700 U$=RIGHT$(HG$,2):IF U$="CM" THEN A=150:B=193:GOTO 730
  710 IF U$="IN" THEN A=59:B=76:GOTO 730
  720 GOTO 50
  730 V=VAL(LEFT$(HG$,LEN(HG$)-2)):IF V<A OR V>B THEN 50
  800 IF LEFT$(HC$,1)<>"#" THEN 50
  810 FOR I=2 TO LEN(HC$):C$=MID$(HC$,I,1)
  820 IF NOT(C$>="0" AND C$<="9" OR C$>="A" AND C$<="F") THEN 50
  830 NEXT
  900 T=EC$<>"AMB" AND EC$<>"BLU" AND EC$<>"BRN" AND EC$<>"GRY" AND EC$<>"GRN"
  910 IF T AND EC$<>"HZL" AND EC$<>"OTH" THEN 50
 1000 FOR I=1 TO LEN(PI$):C$=MID$(PI$,I,1):IF C$<"0" OR C$>"9" THEN 50
 1010 NEXT
 9000 R2=R2+1:GOTO 50
 9999 CLOSE 2:PRINT"PART 1:"R1:PRINT"PART 2:"R2:PRINT"TIME: "TI$

#!/usr/bin/env python3
import sys

import pytest
from attr import attrib, attrs

EXAMPLE_INPUT = """\
1-3 a: abcde
1-3 b: cdefg
2-9 c: ccccccccc
"""


@attrs(frozen=True)
class Policy:
    number_a = attrib()
    number_b = attrib()
    character = attrib()

    @classmethod
    def parse(cls, text):
        numbers_text, space, character = text.strip().partition(" ")
        if not space:
            raise ValueError(f"expected space in {text!r}")
        if len(character) != 1:
            raise ValueError(f"expected a single character, got {character!r}")

        number_a_text, dash, number_b_text = numbers_text.partition("-")
        if not dash:
            raise ValueError(f"expected '-' in {numbers_text!r}")

        return cls(int(number_a_text), int(number_b_text), character)


def check_by_sled_rules(policy, password):
    return (
        policy.number_a <= password.count(policy.character) <= policy.number_b
    )


def check_by_toboggan_rules(policy, password):
    return bool(
        (password[policy.number_a - 1] == policy.character)
        ^ (password[policy.number_b - 1] == policy.character)
    )


def parse_line(line):
    policy_text, colon, password = line.strip().partition(":")
    if not colon:
        raise ValueError(f"expected ':' in {line!r}")
    return Policy.parse(policy_text), password.strip()


def count_valid_passwords(policies_and_passwords, check_function):
    return sum(
        check_function(policy, password)
        for policy, password in policies_and_passwords
    )


def main():
    policies_and_passwords = list(map(parse_line, sys.stdin))
    for check_function in [check_by_sled_rules, check_by_toboggan_rules]:
        print(count_valid_passwords(policies_and_passwords, check_function))


@pytest.mark.parametrize(
    "check_function,policy,password,expected",
    [
        #
        # Part 1
        #
        (check_by_sled_rules, Policy(1, 2, "a"), "abcde", True),
        (check_by_sled_rules, Policy(1, 3, "b"), "cdefg", False),
        (check_by_sled_rules, Policy(2, 9, "c"), "ccccccccc", True),
        #
        # Part 2
        #
        (check_by_toboggan_rules, Policy(1, 2, "a"), "abcde", True),
        (check_by_toboggan_rules, Policy(1, 3, "b"), "cdefg", False),
        (check_by_toboggan_rules, Policy(2, 9, "c"), "ccccccccc", False),
    ],
)
def test_policy_and_password(check_function, policy, password, expected):
    assert check_function(policy, password) == expected


@pytest.mark.parametrize(
    "check_function,expected",
    [(check_by_sled_rules, 2), (check_by_toboggan_rules, 1)],
)
def test_example(check_function, expected):
    assert (
        count_valid_passwords(
            map(parse_line, EXAMPLE_INPUT.splitlines()), check_function
        )
        == expected
    )


if __name__ == "__main__":
    main()

   10 ti$="000000":dim s(1023):pn=1:open 2,8,2,"input05,s,r"
   20 print"scanning boarding passes..."
  100 if st<>0 then close 2:goto 200
  110 print pn:print"{up}";:pn=pn+1:input#2,p$:p=0:for i=1 to 10
  120 p=p*2:c$=mid$(p$,i,1):if c$="B" or c$="R" then p=p+1
  130 next:s(p)=-1:goto 100
  200 rem search last taken seat
  210 for i=1023 to 0 step -1:if s(i) then r1=i:i=0
  220 next
  230 rem search gap
  240 for i=1 to r1-2:if s(i-1) and not s(i) then r2=i:i=1023
  250 next
  260 print"part 1:"r1:print"part 2:"r2:print"time: "ti$

#!/usr/bin/env python3
import sys
from functools import reduce
from operator import mul

from attr import attrib, attrs


EXAMPLE_TREE_MAP = """\
..##.......
#...#...#..
.#....#..#.
..#.#...#.#
.#...##..#.
..#.##.....
.#.#.#....#
.#........#
#.##...#...
#...##....#
.#..#...#.#
""".splitlines()


@attrs(frozen=True)
class Point:
    x = attrib(default=0)
    y = attrib(default=0)

    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)


SLOPES = [Point(3, 1), Point(1, 1), Point(5, 1), Point(7, 1), Point(1, 2)]

TREE = "#"
EMPTY = "."


@attrs(frozen=True)
class TreeMap:
    _rows = attrib()

    def __getitem__(self, coordinate):
        if not 0 <= coordinate.y < self.height:
            raise IndexError(f"{coordinate!r} outside map")

        return self._rows[coordinate.y][coordinate.x % self.width]

    @property
    def width(self):
        return len(self._rows[0])

    @property
    def height(self):
        return len(self._rows)

    def traverse(self, slope):
        position = Point()
        try:
            while True:
                yield self[position]
                position += slope
        except IndexError:
            pass  # Reached the bottom.

    @classmethod
    def from_lines(cls, lines):
        return cls([line.strip() for line in lines])


def count_trees_on_slopes(tree_map, slopes):
    return [
        sum(cell == TREE for cell in tree_map.traverse(slope))
        for slope in slopes
    ]


def main():
    tree_counts = count_trees_on_slopes(TreeMap.from_lines(sys.stdin), SLOPES)
    #
    # Part 1
    #
    print(tree_counts[0])
    #
    # Part 2
    #
    print(reduce(mul, tree_counts, 1))


def test_example():
    assert count_trees_on_slopes(
        TreeMap.from_lines(EXAMPLE_TREE_MAP), SLOPES
    ) == [7, 2, 3, 4, 2]


if __name__ == "__main__":
    main()