diff --git a/.aoc_tiles/tiles/2019/01.png b/.aoc_tiles/tiles/2019/01.png new file mode 100644 index 0000000..3146660 Binary files /dev/null and b/.aoc_tiles/tiles/2019/01.png differ diff --git a/.aoc_tiles/tiles/2019/02.png b/.aoc_tiles/tiles/2019/02.png new file mode 100644 index 0000000..83042da Binary files /dev/null and b/.aoc_tiles/tiles/2019/02.png differ diff --git a/.aoc_tiles/tiles/2019/03.png b/.aoc_tiles/tiles/2019/03.png new file mode 100644 index 0000000..a6fba94 Binary files /dev/null and b/.aoc_tiles/tiles/2019/03.png differ diff --git a/.aoc_tiles/tiles/2019/04.png b/.aoc_tiles/tiles/2019/04.png new file mode 100644 index 0000000..0c27c9e Binary files /dev/null and b/.aoc_tiles/tiles/2019/04.png differ diff --git a/.aoc_tiles/tiles/2019/05.png b/.aoc_tiles/tiles/2019/05.png new file mode 100644 index 0000000..892cc0b Binary files /dev/null and b/.aoc_tiles/tiles/2019/05.png differ diff --git a/.aoc_tiles/tiles/2020/01.png b/.aoc_tiles/tiles/2020/01.png new file mode 100644 index 0000000..5b25cbb Binary files /dev/null and b/.aoc_tiles/tiles/2020/01.png differ diff --git a/.aoc_tiles/tiles/2020/02.png b/.aoc_tiles/tiles/2020/02.png new file mode 100644 index 0000000..60343fe Binary files /dev/null and b/.aoc_tiles/tiles/2020/02.png differ diff --git a/.aoc_tiles/tiles/2020/03.png b/.aoc_tiles/tiles/2020/03.png new file mode 100644 index 0000000..88d167b Binary files /dev/null and b/.aoc_tiles/tiles/2020/03.png differ diff --git a/.aoc_tiles/tiles/2020/04.png b/.aoc_tiles/tiles/2020/04.png new file mode 100644 index 0000000..fac621d Binary files /dev/null and b/.aoc_tiles/tiles/2020/04.png differ diff --git a/.aoc_tiles/tiles/2020/05.png b/.aoc_tiles/tiles/2020/05.png new file mode 100644 index 0000000..064c662 Binary files /dev/null and b/.aoc_tiles/tiles/2020/05.png differ diff --git a/.aoc_tiles/tiles/2020/06.png b/.aoc_tiles/tiles/2020/06.png new file mode 100644 index 0000000..e9c8203 Binary files /dev/null and b/.aoc_tiles/tiles/2020/06.png differ diff --git a/.aoc_tiles/tiles/2020/07.png b/.aoc_tiles/tiles/2020/07.png new file mode 100644 index 0000000..2421127 Binary files /dev/null and b/.aoc_tiles/tiles/2020/07.png differ diff --git a/.aoc_tiles/tiles/2020/08.png b/.aoc_tiles/tiles/2020/08.png new file mode 100644 index 0000000..cad8059 Binary files /dev/null and b/.aoc_tiles/tiles/2020/08.png differ diff --git a/.aoc_tiles/tiles/2020/09.png b/.aoc_tiles/tiles/2020/09.png new file mode 100644 index 0000000..02d3f3d Binary files /dev/null and b/.aoc_tiles/tiles/2020/09.png differ diff --git a/.aoc_tiles/tiles/2020/10.png b/.aoc_tiles/tiles/2020/10.png new file mode 100644 index 0000000..b8be27b Binary files /dev/null and b/.aoc_tiles/tiles/2020/10.png differ diff --git a/.aoc_tiles/tiles/2020/11.png b/.aoc_tiles/tiles/2020/11.png new file mode 100644 index 0000000..5c0471a Binary files /dev/null and b/.aoc_tiles/tiles/2020/11.png differ diff --git a/.aoc_tiles/tiles/2020/12.png b/.aoc_tiles/tiles/2020/12.png new file mode 100644 index 0000000..93b7331 Binary files /dev/null and b/.aoc_tiles/tiles/2020/12.png differ diff --git a/.aoc_tiles/tiles/2020/13.png b/.aoc_tiles/tiles/2020/13.png new file mode 100644 index 0000000..667d709 Binary files /dev/null and b/.aoc_tiles/tiles/2020/13.png differ diff --git a/.aoc_tiles/tiles/2020/14.png b/.aoc_tiles/tiles/2020/14.png new file mode 100644 index 0000000..8b9a82c Binary files /dev/null and b/.aoc_tiles/tiles/2020/14.png differ diff --git a/.aoc_tiles/tiles/2020/15.png b/.aoc_tiles/tiles/2020/15.png new file mode 100644 index 0000000..7816ef5 Binary files /dev/null and b/.aoc_tiles/tiles/2020/15.png differ diff --git a/.aoc_tiles/tiles/2020/16.png b/.aoc_tiles/tiles/2020/16.png new file mode 100644 index 0000000..04d4ba4 Binary files /dev/null and b/.aoc_tiles/tiles/2020/16.png differ diff --git a/.aoc_tiles/tiles/2020/17.png b/.aoc_tiles/tiles/2020/17.png new file mode 100644 index 0000000..5aa45aa Binary files /dev/null and b/.aoc_tiles/tiles/2020/17.png differ diff --git a/.aoc_tiles/tiles/2020/18.png b/.aoc_tiles/tiles/2020/18.png new file mode 100644 index 0000000..0cd5779 Binary files /dev/null and b/.aoc_tiles/tiles/2020/18.png differ diff --git a/.aoc_tiles/tiles/2020/19.png b/.aoc_tiles/tiles/2020/19.png new file mode 100644 index 0000000..e5f7a86 Binary files /dev/null and b/.aoc_tiles/tiles/2020/19.png differ diff --git a/.aoc_tiles/tiles/2020/20.png b/.aoc_tiles/tiles/2020/20.png new file mode 100644 index 0000000..0c716bf Binary files /dev/null and b/.aoc_tiles/tiles/2020/20.png differ diff --git a/.aoc_tiles/tiles/2020/21.png b/.aoc_tiles/tiles/2020/21.png new file mode 100644 index 0000000..c28eeb7 Binary files /dev/null and b/.aoc_tiles/tiles/2020/21.png differ diff --git a/.aoc_tiles/tiles/2020/22.png b/.aoc_tiles/tiles/2020/22.png new file mode 100644 index 0000000..5604d51 Binary files /dev/null and b/.aoc_tiles/tiles/2020/22.png differ diff --git a/.aoc_tiles/tiles/2020/23.png b/.aoc_tiles/tiles/2020/23.png new file mode 100644 index 0000000..f84a91a Binary files /dev/null and b/.aoc_tiles/tiles/2020/23.png differ diff --git a/.aoc_tiles/tiles/2020/24.png b/.aoc_tiles/tiles/2020/24.png new file mode 100644 index 0000000..840685e Binary files /dev/null and b/.aoc_tiles/tiles/2020/24.png differ diff --git a/.aoc_tiles/tiles/2020/25.png b/.aoc_tiles/tiles/2020/25.png new file mode 100644 index 0000000..bce6e94 Binary files /dev/null and b/.aoc_tiles/tiles/2020/25.png differ diff --git a/.aoc_tiles/tiles/2021/01.png b/.aoc_tiles/tiles/2021/01.png new file mode 100644 index 0000000..8e0f7de Binary files /dev/null and b/.aoc_tiles/tiles/2021/01.png differ diff --git a/AoCTiles/examples/basic.png b/.aoc_tiles/tiles/2021/02.png similarity index 100% rename from AoCTiles/examples/basic.png rename to .aoc_tiles/tiles/2021/02.png diff --git a/.aoc_tiles/tiles/2021/03.png b/.aoc_tiles/tiles/2021/03.png new file mode 100644 index 0000000..7ad9878 Binary files /dev/null and b/.aoc_tiles/tiles/2021/03.png differ diff --git a/.aoc_tiles/tiles/2021/04.png b/.aoc_tiles/tiles/2021/04.png new file mode 100644 index 0000000..9e8ff7b Binary files /dev/null and b/.aoc_tiles/tiles/2021/04.png differ diff --git a/.aoc_tiles/tiles/2021/05.png b/.aoc_tiles/tiles/2021/05.png new file mode 100644 index 0000000..46df117 Binary files /dev/null and b/.aoc_tiles/tiles/2021/05.png differ diff --git a/.aoc_tiles/tiles/2021/06.png b/.aoc_tiles/tiles/2021/06.png new file mode 100644 index 0000000..fe99590 Binary files /dev/null and b/.aoc_tiles/tiles/2021/06.png differ diff --git a/.aoc_tiles/tiles/2021/07.png b/.aoc_tiles/tiles/2021/07.png new file mode 100644 index 0000000..b491cf1 Binary files /dev/null and b/.aoc_tiles/tiles/2021/07.png differ diff --git a/.aoc_tiles/tiles/2021/08.png b/.aoc_tiles/tiles/2021/08.png new file mode 100644 index 0000000..a82a4c6 Binary files /dev/null and b/.aoc_tiles/tiles/2021/08.png differ diff --git a/.aoc_tiles/tiles/2021/09.png b/.aoc_tiles/tiles/2021/09.png new file mode 100644 index 0000000..a4a2e85 Binary files /dev/null and b/.aoc_tiles/tiles/2021/09.png differ diff --git a/.aoc_tiles/tiles/2021/10.png b/.aoc_tiles/tiles/2021/10.png new file mode 100644 index 0000000..96a98f7 Binary files /dev/null and b/.aoc_tiles/tiles/2021/10.png differ diff --git a/.aoc_tiles/tiles/2021/11.png b/.aoc_tiles/tiles/2021/11.png new file mode 100644 index 0000000..df47e05 Binary files /dev/null and b/.aoc_tiles/tiles/2021/11.png differ diff --git a/.aoc_tiles/tiles/2021/12.png b/.aoc_tiles/tiles/2021/12.png new file mode 100644 index 0000000..847d59b Binary files /dev/null and b/.aoc_tiles/tiles/2021/12.png differ diff --git a/.aoc_tiles/tiles/2021/13.png b/.aoc_tiles/tiles/2021/13.png new file mode 100644 index 0000000..57c4a0e Binary files /dev/null and b/.aoc_tiles/tiles/2021/13.png differ diff --git a/.aoc_tiles/tiles/2021/14.png b/.aoc_tiles/tiles/2021/14.png new file mode 100644 index 0000000..dd5bec7 Binary files /dev/null and b/.aoc_tiles/tiles/2021/14.png differ diff --git a/.aoc_tiles/tiles/2021/15.png b/.aoc_tiles/tiles/2021/15.png new file mode 100644 index 0000000..7f7a050 Binary files /dev/null and b/.aoc_tiles/tiles/2021/15.png differ diff --git a/.aoc_tiles/tiles/2021/16.png b/.aoc_tiles/tiles/2021/16.png new file mode 100644 index 0000000..976a388 Binary files /dev/null and b/.aoc_tiles/tiles/2021/16.png differ diff --git a/.aoc_tiles/tiles/2021/17.png b/.aoc_tiles/tiles/2021/17.png new file mode 100644 index 0000000..3964e34 Binary files /dev/null and b/.aoc_tiles/tiles/2021/17.png differ diff --git a/.aoc_tiles/tiles/2021/18.png b/.aoc_tiles/tiles/2021/18.png new file mode 100644 index 0000000..f42e976 Binary files /dev/null and b/.aoc_tiles/tiles/2021/18.png differ diff --git a/.aoc_tiles/tiles/2021/19.png b/.aoc_tiles/tiles/2021/19.png new file mode 100644 index 0000000..21ffca2 Binary files /dev/null and b/.aoc_tiles/tiles/2021/19.png differ diff --git a/.aoc_tiles/tiles/2021/20.png b/.aoc_tiles/tiles/2021/20.png new file mode 100644 index 0000000..02d9784 Binary files /dev/null and b/.aoc_tiles/tiles/2021/20.png differ diff --git a/.aoc_tiles/tiles/2021/21.png b/.aoc_tiles/tiles/2021/21.png new file mode 100644 index 0000000..96776ad Binary files /dev/null and b/.aoc_tiles/tiles/2021/21.png differ diff --git a/.aoc_tiles/tiles/2021/22.png b/.aoc_tiles/tiles/2021/22.png new file mode 100644 index 0000000..db4e6cc Binary files /dev/null and b/.aoc_tiles/tiles/2021/22.png differ diff --git a/.aoc_tiles/tiles/2021/23.png b/.aoc_tiles/tiles/2021/23.png new file mode 100644 index 0000000..aa9ef4c Binary files /dev/null and b/.aoc_tiles/tiles/2021/23.png differ diff --git a/.aoc_tiles/tiles/2021/24.png b/.aoc_tiles/tiles/2021/24.png new file mode 100644 index 0000000..4992254 Binary files /dev/null and b/.aoc_tiles/tiles/2021/24.png differ diff --git a/.aoc_tiles/tiles/2021/25.png b/.aoc_tiles/tiles/2021/25.png new file mode 100644 index 0000000..99ce1d9 Binary files /dev/null and b/.aoc_tiles/tiles/2021/25.png differ diff --git a/.aoc_tiles/tiles/2022/01.png b/.aoc_tiles/tiles/2022/01.png new file mode 100644 index 0000000..4024410 Binary files /dev/null and b/.aoc_tiles/tiles/2022/01.png differ diff --git a/.aoc_tiles/tiles/2022/02.png b/.aoc_tiles/tiles/2022/02.png new file mode 100644 index 0000000..ee10e77 Binary files /dev/null and b/.aoc_tiles/tiles/2022/02.png differ diff --git a/.aoc_tiles/tiles/2022/03.png b/.aoc_tiles/tiles/2022/03.png new file mode 100644 index 0000000..f36b1a8 Binary files /dev/null and b/.aoc_tiles/tiles/2022/03.png differ diff --git a/.aoc_tiles/tiles/2022/04.png b/.aoc_tiles/tiles/2022/04.png new file mode 100644 index 0000000..612aaba Binary files /dev/null and b/.aoc_tiles/tiles/2022/04.png differ diff --git a/.aoc_tiles/tiles/2022/05.png b/.aoc_tiles/tiles/2022/05.png new file mode 100644 index 0000000..809bb8e Binary files /dev/null and b/.aoc_tiles/tiles/2022/05.png differ diff --git a/.aoc_tiles/tiles/2022/06.png b/.aoc_tiles/tiles/2022/06.png new file mode 100644 index 0000000..703590a Binary files /dev/null and b/.aoc_tiles/tiles/2022/06.png differ diff --git a/.aoc_tiles/tiles/2022/07.png b/.aoc_tiles/tiles/2022/07.png new file mode 100644 index 0000000..066934d Binary files /dev/null and b/.aoc_tiles/tiles/2022/07.png differ diff --git a/.aoc_tiles/tiles/2022/08.png b/.aoc_tiles/tiles/2022/08.png new file mode 100644 index 0000000..286afb3 Binary files /dev/null and b/.aoc_tiles/tiles/2022/08.png differ diff --git a/.aoc_tiles/tiles/2022/09.png b/.aoc_tiles/tiles/2022/09.png new file mode 100644 index 0000000..b02492e Binary files /dev/null and b/.aoc_tiles/tiles/2022/09.png differ diff --git a/.aoc_tiles/tiles/2022/10.png b/.aoc_tiles/tiles/2022/10.png new file mode 100644 index 0000000..2132b21 Binary files /dev/null and b/.aoc_tiles/tiles/2022/10.png differ diff --git a/.aoc_tiles/tiles/2022/11.png b/.aoc_tiles/tiles/2022/11.png new file mode 100644 index 0000000..1bdfaaa Binary files /dev/null and b/.aoc_tiles/tiles/2022/11.png differ diff --git a/.aoc_tiles/tiles/2022/12.png b/.aoc_tiles/tiles/2022/12.png new file mode 100644 index 0000000..b694244 Binary files /dev/null and b/.aoc_tiles/tiles/2022/12.png differ diff --git a/.aoc_tiles/tiles/2022/13.png b/.aoc_tiles/tiles/2022/13.png new file mode 100644 index 0000000..2ff728e Binary files /dev/null and b/.aoc_tiles/tiles/2022/13.png differ diff --git a/.aoc_tiles/tiles/2022/14.png b/.aoc_tiles/tiles/2022/14.png new file mode 100644 index 0000000..0a52874 Binary files /dev/null and b/.aoc_tiles/tiles/2022/14.png differ diff --git a/.aoc_tiles/tiles/2022/15.png b/.aoc_tiles/tiles/2022/15.png new file mode 100644 index 0000000..e9fb998 Binary files /dev/null and b/.aoc_tiles/tiles/2022/15.png differ diff --git a/.aoc_tiles/tiles/2022/16.png b/.aoc_tiles/tiles/2022/16.png new file mode 100644 index 0000000..38c6a94 Binary files /dev/null and b/.aoc_tiles/tiles/2022/16.png differ diff --git a/.aoc_tiles/tiles/2022/17.png b/.aoc_tiles/tiles/2022/17.png new file mode 100644 index 0000000..d9bdbc6 Binary files /dev/null and b/.aoc_tiles/tiles/2022/17.png differ diff --git a/.aoc_tiles/tiles/2022/18.png b/.aoc_tiles/tiles/2022/18.png new file mode 100644 index 0000000..6705e02 Binary files /dev/null and b/.aoc_tiles/tiles/2022/18.png differ diff --git a/.aoc_tiles/tiles/2022/19.png b/.aoc_tiles/tiles/2022/19.png new file mode 100644 index 0000000..cd25e37 Binary files /dev/null and b/.aoc_tiles/tiles/2022/19.png differ diff --git a/.aoc_tiles/tiles/2022/20.png b/.aoc_tiles/tiles/2022/20.png new file mode 100644 index 0000000..e175778 Binary files /dev/null and b/.aoc_tiles/tiles/2022/20.png differ diff --git a/.aoc_tiles/tiles/2022/21.png b/.aoc_tiles/tiles/2022/21.png new file mode 100644 index 0000000..f8e6df0 Binary files /dev/null and b/.aoc_tiles/tiles/2022/21.png differ diff --git a/.aoc_tiles/tiles/2022/22.png b/.aoc_tiles/tiles/2022/22.png new file mode 100644 index 0000000..6786f93 Binary files /dev/null and b/.aoc_tiles/tiles/2022/22.png differ diff --git a/.aoc_tiles/tiles/2022/23.png b/.aoc_tiles/tiles/2022/23.png new file mode 100644 index 0000000..f84dab8 Binary files /dev/null and b/.aoc_tiles/tiles/2022/23.png differ diff --git a/.aoc_tiles/tiles/2022/24.png b/.aoc_tiles/tiles/2022/24.png new file mode 100644 index 0000000..be664db Binary files /dev/null and b/.aoc_tiles/tiles/2022/24.png differ diff --git a/.aoc_tiles/tiles/2022/25.png b/.aoc_tiles/tiles/2022/25.png new file mode 100644 index 0000000..bb15a9a Binary files /dev/null and b/.aoc_tiles/tiles/2022/25.png differ diff --git a/.aoc_tiles/tiles/2023/01.png b/.aoc_tiles/tiles/2023/01.png new file mode 100644 index 0000000..2080879 Binary files /dev/null and b/.aoc_tiles/tiles/2023/01.png differ diff --git a/.aoc_tiles/tiles/2023/02.png b/.aoc_tiles/tiles/2023/02.png new file mode 100644 index 0000000..03e9863 Binary files /dev/null and b/.aoc_tiles/tiles/2023/02.png differ diff --git a/.aoc_tiles/tiles/2023/03.png b/.aoc_tiles/tiles/2023/03.png new file mode 100644 index 0000000..98d58db Binary files /dev/null and b/.aoc_tiles/tiles/2023/03.png differ diff --git a/.aoc_tiles/tiles/2023/04.png b/.aoc_tiles/tiles/2023/04.png new file mode 100644 index 0000000..5183cfa Binary files /dev/null and b/.aoc_tiles/tiles/2023/04.png differ diff --git a/.aoc_tiles/tiles/2023/05.png b/.aoc_tiles/tiles/2023/05.png new file mode 100644 index 0000000..2f0f0b5 Binary files /dev/null and b/.aoc_tiles/tiles/2023/05.png differ diff --git a/.aoc_tiles/tiles/2023/06.png b/.aoc_tiles/tiles/2023/06.png new file mode 100644 index 0000000..3a3f28c Binary files /dev/null and b/.aoc_tiles/tiles/2023/06.png differ diff --git a/.aoc_tiles/tiles/2023/07.png b/.aoc_tiles/tiles/2023/07.png new file mode 100644 index 0000000..848932b Binary files /dev/null and b/.aoc_tiles/tiles/2023/07.png differ diff --git a/.aoc_tiles/tiles/2023/08.png b/.aoc_tiles/tiles/2023/08.png new file mode 100644 index 0000000..6e198cf Binary files /dev/null and b/.aoc_tiles/tiles/2023/08.png differ diff --git a/.aoc_tiles/tiles/2023/09.png b/.aoc_tiles/tiles/2023/09.png new file mode 100644 index 0000000..b5011bf Binary files /dev/null and b/.aoc_tiles/tiles/2023/09.png differ diff --git a/.aoc_tiles/tiles/2023/10.png b/.aoc_tiles/tiles/2023/10.png new file mode 100644 index 0000000..c6d5cf7 Binary files /dev/null and b/.aoc_tiles/tiles/2023/10.png differ diff --git a/.aoc_tiles/tiles/2023/11.png b/.aoc_tiles/tiles/2023/11.png new file mode 100644 index 0000000..33a7af6 Binary files /dev/null and b/.aoc_tiles/tiles/2023/11.png differ diff --git a/.aoc_tiles/tiles/2023/12.png b/.aoc_tiles/tiles/2023/12.png new file mode 100644 index 0000000..88ca7d9 Binary files /dev/null and b/.aoc_tiles/tiles/2023/12.png differ diff --git a/.aoc_tiles/tiles/2023/13.png b/.aoc_tiles/tiles/2023/13.png new file mode 100644 index 0000000..a1c316c Binary files /dev/null and b/.aoc_tiles/tiles/2023/13.png differ diff --git a/.aoc_tiles/tiles/2023/14.png b/.aoc_tiles/tiles/2023/14.png new file mode 100644 index 0000000..78705b8 Binary files /dev/null and b/.aoc_tiles/tiles/2023/14.png differ diff --git a/.aoc_tiles/tiles/2023/15.png b/.aoc_tiles/tiles/2023/15.png new file mode 100644 index 0000000..88bf5c0 Binary files /dev/null and b/.aoc_tiles/tiles/2023/15.png differ diff --git a/.aoc_tiles/tiles/2023/16.png b/.aoc_tiles/tiles/2023/16.png new file mode 100644 index 0000000..86cf251 Binary files /dev/null and b/.aoc_tiles/tiles/2023/16.png differ diff --git a/.aoc_tiles/tiles/2023/17.png b/.aoc_tiles/tiles/2023/17.png new file mode 100644 index 0000000..61509c4 Binary files /dev/null and b/.aoc_tiles/tiles/2023/17.png differ diff --git a/.aoc_tiles/tiles/2023/18.png b/.aoc_tiles/tiles/2023/18.png new file mode 100644 index 0000000..d8b9026 Binary files /dev/null and b/.aoc_tiles/tiles/2023/18.png differ diff --git a/.aoc_tiles/tiles/2023/19.png b/.aoc_tiles/tiles/2023/19.png new file mode 100644 index 0000000..e860181 Binary files /dev/null and b/.aoc_tiles/tiles/2023/19.png differ diff --git a/.aoc_tiles/tiles/2023/20.png b/.aoc_tiles/tiles/2023/20.png new file mode 100644 index 0000000..ea6cff4 Binary files /dev/null and b/.aoc_tiles/tiles/2023/20.png differ diff --git a/.aoc_tiles/tiles/2023/21.png b/.aoc_tiles/tiles/2023/21.png new file mode 100644 index 0000000..6130ada Binary files /dev/null and b/.aoc_tiles/tiles/2023/21.png differ diff --git a/.aoc_tiles/tiles/2023/22.png b/.aoc_tiles/tiles/2023/22.png new file mode 100644 index 0000000..d055d78 Binary files /dev/null and b/.aoc_tiles/tiles/2023/22.png differ diff --git a/.aoc_tiles/tiles/2023/23.png b/.aoc_tiles/tiles/2023/23.png new file mode 100644 index 0000000..cfb2fbf Binary files /dev/null and b/.aoc_tiles/tiles/2023/23.png differ diff --git a/.aoc_tiles/tiles/2023/24.png b/.aoc_tiles/tiles/2023/24.png new file mode 100644 index 0000000..9e76897 Binary files /dev/null and b/.aoc_tiles/tiles/2023/24.png differ diff --git a/.aoc_tiles/tiles/2023/25.png b/.aoc_tiles/tiles/2023/25.png new file mode 100644 index 0000000..dc263df Binary files /dev/null and b/.aoc_tiles/tiles/2023/25.png differ diff --git a/.aoc_tiles/tiles/2024/01.png b/.aoc_tiles/tiles/2024/01.png new file mode 100644 index 0000000..0e821fd Binary files /dev/null and b/.aoc_tiles/tiles/2024/01.png differ diff --git a/.aoc_tiles/tiles/2024/02.png b/.aoc_tiles/tiles/2024/02.png new file mode 100644 index 0000000..a8a0147 Binary files /dev/null and b/.aoc_tiles/tiles/2024/02.png differ diff --git a/.aoc_tiles/tiles/2024/03.png b/.aoc_tiles/tiles/2024/03.png new file mode 100644 index 0000000..7c12d67 Binary files /dev/null and b/.aoc_tiles/tiles/2024/03.png differ diff --git a/.aoc_tiles/tiles/2024/04.png b/.aoc_tiles/tiles/2024/04.png new file mode 100644 index 0000000..c80854f Binary files /dev/null and b/.aoc_tiles/tiles/2024/04.png differ diff --git a/.aoc_tiles/tiles/2024/05.png b/.aoc_tiles/tiles/2024/05.png new file mode 100644 index 0000000..e8cbf00 Binary files /dev/null and b/.aoc_tiles/tiles/2024/05.png differ diff --git a/.aoc_tiles/tiles/2024/06.png b/.aoc_tiles/tiles/2024/06.png new file mode 100644 index 0000000..d1731d6 Binary files /dev/null and b/.aoc_tiles/tiles/2024/06.png differ diff --git a/.aoc_tiles/tiles/2024/07.png b/.aoc_tiles/tiles/2024/07.png new file mode 100644 index 0000000..a1bd4e6 Binary files /dev/null and b/.aoc_tiles/tiles/2024/07.png differ diff --git a/.aoc_tiles/tiles/2024/08.png b/.aoc_tiles/tiles/2024/08.png new file mode 100644 index 0000000..4e2089f Binary files /dev/null and b/.aoc_tiles/tiles/2024/08.png differ diff --git a/.aoc_tiles/tiles/2024/09.png b/.aoc_tiles/tiles/2024/09.png new file mode 100644 index 0000000..9dbb11b Binary files /dev/null and b/.aoc_tiles/tiles/2024/09.png differ diff --git a/.aoc_tiles/tiles/2024/10.png b/.aoc_tiles/tiles/2024/10.png new file mode 100644 index 0000000..63fca2f Binary files /dev/null and b/.aoc_tiles/tiles/2024/10.png differ diff --git a/.aoc_tiles/tiles/2024/11.png b/.aoc_tiles/tiles/2024/11.png new file mode 100644 index 0000000..99fd549 Binary files /dev/null and b/.aoc_tiles/tiles/2024/11.png differ diff --git a/.aoc_tiles/tiles/2024/12.png b/.aoc_tiles/tiles/2024/12.png new file mode 100644 index 0000000..2265331 Binary files /dev/null and b/.aoc_tiles/tiles/2024/12.png differ diff --git a/.aoc_tiles/tiles/2024/13.png b/.aoc_tiles/tiles/2024/13.png new file mode 100644 index 0000000..bb9eddd Binary files /dev/null and b/.aoc_tiles/tiles/2024/13.png differ diff --git a/.aoc_tiles/tiles/2024/14.png b/.aoc_tiles/tiles/2024/14.png new file mode 100644 index 0000000..5d16359 Binary files /dev/null and b/.aoc_tiles/tiles/2024/14.png differ diff --git a/.aoc_tiles/tiles/2024/15.png b/.aoc_tiles/tiles/2024/15.png new file mode 100644 index 0000000..c54e5ad Binary files /dev/null and b/.aoc_tiles/tiles/2024/15.png differ diff --git a/.aoc_tiles/tiles/2024/16.png b/.aoc_tiles/tiles/2024/16.png new file mode 100644 index 0000000..4b9ccca Binary files /dev/null and b/.aoc_tiles/tiles/2024/16.png differ diff --git a/.aoc_tiles/tiles/2024/17.png b/.aoc_tiles/tiles/2024/17.png new file mode 100644 index 0000000..4e38d2e Binary files /dev/null and b/.aoc_tiles/tiles/2024/17.png differ diff --git a/.aoc_tiles/tiles/2024/18.png b/.aoc_tiles/tiles/2024/18.png new file mode 100644 index 0000000..5983ae6 Binary files /dev/null and b/.aoc_tiles/tiles/2024/18.png differ diff --git a/.aoc_tiles/tiles/2024/19.png b/.aoc_tiles/tiles/2024/19.png new file mode 100644 index 0000000..2d37a46 Binary files /dev/null and b/.aoc_tiles/tiles/2024/19.png differ diff --git a/.aoc_tiles/tiles/2024/20.png b/.aoc_tiles/tiles/2024/20.png new file mode 100644 index 0000000..4ea62c5 Binary files /dev/null and b/.aoc_tiles/tiles/2024/20.png differ diff --git a/.aoc_tiles/tiles/2024/21.png b/.aoc_tiles/tiles/2024/21.png new file mode 100644 index 0000000..181daf8 Binary files /dev/null and b/.aoc_tiles/tiles/2024/21.png differ diff --git a/.aoc_tiles/tiles/2024/22.png b/.aoc_tiles/tiles/2024/22.png new file mode 100644 index 0000000..8e52f04 Binary files /dev/null and b/.aoc_tiles/tiles/2024/22.png differ diff --git a/.aoc_tiles/tiles/2024/23.png b/.aoc_tiles/tiles/2024/23.png new file mode 100644 index 0000000..a3be5cd Binary files /dev/null and b/.aoc_tiles/tiles/2024/23.png differ diff --git a/.aoc_tiles/tiles/2024/24.png b/.aoc_tiles/tiles/2024/24.png new file mode 100644 index 0000000..4bc1e17 Binary files /dev/null and b/.aoc_tiles/tiles/2024/24.png differ diff --git a/.aoc_tiles/tiles/2024/25.png b/.aoc_tiles/tiles/2024/25.png new file mode 100644 index 0000000..6958d22 Binary files /dev/null and b/.aoc_tiles/tiles/2024/25.png differ diff --git a/.gitignore b/.gitignore index 2842530..a89d375 100644 --- a/.gitignore +++ b/.gitignore @@ -1,8 +1,18 @@ 2021/3/3golfed.py *run -session.cookie .apl.history .idea AoCTiles/.aoc_tiles_cache *.class META-INF +*.jar +target +session.cookie + +*.in +*.ans + +.aoc_tiles/* +!.aoc_tiles/tiles/ + + diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 97b41bd..4b77607 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,8 +1,11 @@ repos: - - repo: local + - repo: https://github.com/LiquidFun/aoc_tiles + rev: 0.6.3 hooks: - - id: create-day-tiles - name: create-day-tiles - entry: python3 AoCTiles/create_aoc_tiles.py - language: system + - id: aoc-tiles + args: + - --language-sorting=jl,kt,py,rs + - --exclude-patterns=2021/*/*.apl,2021/*/*.py,2021/*/*.cpp,2023/*/*.rs + - --auto-add-tiles-to-git=amend + - --count-as-solved-when=on_leaderboard diff --git a/2019/01/01.ml b/2019/01/01.ml new file mode 100644 index 0000000..28accf3 --- /dev/null +++ b/2019/01/01.ml @@ -0,0 +1,14 @@ +let fuel x = x / 3 - 2;; +let rec fuel_of_fuel x = if x < 0 then 0 else x + (x |> fuel |> fuel_of_fuel);; + +let rec collect_nums acc = + try + let line = input_line stdin in + collect_nums ((line |> int_of_string |> fuel) :: acc) + with End_of_file -> + List.rev acc + +let () = + let lines = collect_nums [] in + List.fold_left ( + ) 0 lines |> Printf.printf "%d\n"; + List.fold_left ( + ) 0 (List.map fuel_of_fuel lines) |> print_int \ No newline at end of file diff --git a/2019/02/02.ml b/2019/02/02.ml new file mode 100644 index 0000000..375b617 --- /dev/null +++ b/2019/02/02.ml @@ -0,0 +1,19 @@ +let rec process nums i = + match nums.(i) with + | 1 -> nums.(nums.(i+3)) <- nums.(nums.(i+1)) + nums.(nums.(i+2)); process nums (i+4) + | 2 -> nums.(nums.(i+3)) <- nums.(nums.(i+1)) * nums.(nums.(i+2)); process nums (i+4) + | _ -> nums.(0) + +let with_a_b nums n = + let memory = Array.copy nums in + memory.(1) <- n / 100; + memory.(2) <- n mod 100; + process memory 0 + +let find_part2 nums = + List.init 10000 Fun.id |> List.find (fun x -> (with_a_b nums x) == 19690720) + +let () = + let nums = input_line stdin |> String.split_on_char ',' |> List.map int_of_string |> Array.of_list in + with_a_b nums 1202 |> Printf.printf "%d\n"; + find_part2 nums |> print_int \ No newline at end of file diff --git a/2019/03/03.ml b/2019/03/03.ml new file mode 100644 index 0000000..b64dc11 --- /dev/null +++ b/2019/03/03.ml @@ -0,0 +1,37 @@ +module TupleSet = Set.Make(struct + type t = int * int + let compare = compare +end) + +let to_tup dir = let num = String.sub dir 1 (String.length dir - 1) |> int_of_string in + let xy = match String.get dir 0 with + | 'U' -> (0, 1) + | 'D' -> (0, -1) + | 'R' -> (1, 0) + | _ -> (-1, 0) in + List.init num (fun _ -> xy) + + +let rec scan sx sy = function + | [] -> [] + | (x, y) :: rest -> (sx+x, sy+y) :: scan (sx+x) (sy+y) rest + + +let read_line stdin = + input_line stdin |> String.split_on_char ',' |> List.concat_map to_tup |> scan 0 0 |> TupleSet.of_list + + + (* List.iter (fun (a, b) -> Printf.printf("%d,%d -> ") a b) dirs *) + +let () = + let d1 = read_line stdin in + let d2 = read_line stdin in + (* TupleSet.inter d1 d2 |> TupleSet.iter (fun (a,b) -> Printf.printf "%d,%d -> " a b); *) + (* TupleSet.inter d1 d2 |> TupleSet.to_list |> List.map (fun (a,b) -> abs(a) + abs(b)) |> List.iter (fun b -> Printf.printf "%d -> " b); *) + TupleSet.inter d1 d2 |> TupleSet.to_list |> List.map (fun (a,b) -> abs(a) + abs(b)) |> List.fold_left min max_int |> Printf.printf "%d\n"; + (* Printf.printf "\n%d\n" (TupleSet.to_list d1 |> List.length); *) + (* Printf.printf "\n%d\n" (TupleSet.to_list d2 |> List.length); *) + (* List.iter (fun (a, b) -> Printf.printf("%d,%d -> ") a b) d1; *) + (* let shared = List.filter (fun x -> List.exists (fun a -> a == x) d1) d2 in *) + (* let num = List.map (fun (a, b) -> a+b) shared |> List.fold_left max min_int in *) + (* Printf.printf "%d " num; *) diff --git a/2020/01/01.rs b/2020/01/01.rs new file mode 100644 index 0000000..4d2638c --- /dev/null +++ b/2020/01/01.rs @@ -0,0 +1,12 @@ +use std::io::stdin; +use itertools::iproduct; + +fn main() { + let nums: Vec = stdin().lines().map(|a| a.unwrap().parse().unwrap()).collect(); + iproduct!(&nums, &nums) + .find(|(&a, &b)| a+b == 2020) + .map(|(&a, &b)| println!("{}", a*b)); + iproduct!(&nums, &nums, &nums) + .find(|(&a, &b, &c)| a+b+c == 2020) + .map(|(&a, &b, &c)| println!("{}", a*b*c)); +} \ No newline at end of file diff --git a/2020/01/input.ans b/2020/01/input.ans new file mode 100644 index 0000000..ab928a1 --- /dev/null +++ b/2020/01/input.ans @@ -0,0 +1,2 @@ +964875 +158661360 diff --git a/2020/02/02.rs b/2020/02/02.rs new file mode 100644 index 0000000..c3c1846 --- /dev/null +++ b/2020/02/02.rs @@ -0,0 +1,38 @@ +use itertools::Itertools; +use std::io::stdin; + +struct PasswordPhilosophy { + range: std::ops::RangeInclusive, + letter: char, + string: String, +} + +fn parse_password_philosophies() -> Vec { + let lines = stdin().lines().filter_map(Result::ok).collect_vec(); + lines.iter() + .map(|line| line.split(|c| "- :".contains(c)).next_tuple().unwrap()) + .map(|(a, b, letter, _, string)| { + PasswordPhilosophy { + range: a.parse().unwrap()..=b.parse().unwrap(), + letter: letter.chars().next().unwrap(), + string: string.to_owned(), + } + }) + .collect() +} + +fn main() { + let philosophies = parse_password_philosophies(); + println!("{}", philosophies.iter().filter(|p| p.range.contains(&p.string.matches(p.letter).count())).count()); + + let sum2 = philosophies + .iter() + .filter(|p| { + let is_first = p.string.chars().nth((p.range.start() - 1) as usize).unwrap() == p.letter; + let is_second = p.string.chars().nth((p.range.end() - 1) as usize).unwrap() == p.letter; + is_first != is_second + }) + .count(); + + println!("{}", sum2); +} \ No newline at end of file diff --git a/2020/02/input.ans b/2020/02/input.ans new file mode 100644 index 0000000..b41c15e --- /dev/null +++ b/2020/02/input.ans @@ -0,0 +1,2 @@ +666 +670 \ No newline at end of file diff --git a/2020/03/03.rs b/2020/03/03.rs new file mode 100644 index 0000000..6bbc1a1 --- /dev/null +++ b/2020/03/03.rs @@ -0,0 +1,20 @@ +use std::io::stdin; + +fn solve(map: &Vec, dy: usize, dx: usize) -> usize { + let mut x = 0; + let mut count = 0; + for y in (0..map.len()).step_by(dy) { + count += (map[y].get(x..=x).unwrap() == "#") as usize; + x = (x+dx) % map[0].len(); + } + count +} + +fn main() { + let map = stdin().lines().filter_map(Result::ok).collect(); + println!("{}", solve(&map, 1, 3)); + let ans2: usize = [(1, 1), (1, 3), (1, 5), (1, 7), (2, 1)].iter() + .map(|(y, x)| solve(&map, *y, *x)) + .product(); + println!("{}", ans2); +} \ No newline at end of file diff --git a/2020/04/04.rs b/2020/04/04.rs new file mode 100644 index 0000000..1e70856 --- /dev/null +++ b/2020/04/04.rs @@ -0,0 +1,29 @@ +use std::{io::stdin, collections::HashMap}; + +use itertools::Itertools; +use regex::Regex; + +fn valid_p1(map: &HashMap<&str, &str>) -> bool { + "byr iyr eyr hgt hcl ecl pid".split(" ").all(|req| map.contains_key(&req)) +} + +fn valid_p2(map: &HashMap<&str, &str>) -> bool { + valid_p1(map) + && (1920..=2002).contains(&map["byr"].parse().unwrap()) + && (2010..=2020).contains(&map["iyr"].parse().unwrap()) + && (2020..=2030).contains(&map["eyr"].parse().unwrap()) + && Regex::new(r"^((1[5-8]\d|19[0123])cm|(59|6\d|7[0-6])in)$").unwrap().is_match(map["hgt"]) + && Regex::new(r"^#[0-9a-f]{6}$").unwrap().is_match(map["hcl"]) + && Regex::new(r"^\d{9}$").unwrap().is_match(map["pid"]) + && "amb blu brn gry grn hzl oth".split(" ").contains(&map["ecl"]) +} + +fn main() { + let input = stdin().lines().filter_map(Result::ok).join(" "); + let passports: Vec> = input + .split(" ") + .map(|line| line.split(" ").map(|e| e.split_once(":").unwrap()).collect()) + .collect(); + println!("{}", passports.iter().filter(|h| valid_p1(h)).count()); + println!("{}", passports.iter().filter(|h| valid_p2(h)).count()); +} \ No newline at end of file diff --git a/2020/05/05.rs b/2020/05/05.rs new file mode 100644 index 0000000..99e8404 --- /dev/null +++ b/2020/05/05.rs @@ -0,0 +1,17 @@ +use std::io::stdin; + +use itertools::Itertools; + +fn as_binary(s: &str) -> i32 { + s.char_indices().fold(0, |acc, (i, c)| acc + (1<<(9-i)) * ("BR".contains(c) as i32)) +} + +fn main() { + let nums: Vec = stdin().lines().map(|l| as_binary(&l.unwrap())).collect(); + println!("{:?}", nums.iter().max().unwrap()); + nums.iter() + .sorted() + .tuple_windows() + .find(|(&a, &b)| b-a == 2) + .map(|(&a, _)| println!("{}", a+1)); +} diff --git a/2020/06/06.rs b/2020/06/06.rs new file mode 100644 index 0000000..30a3b15 --- /dev/null +++ b/2020/06/06.rs @@ -0,0 +1,19 @@ +use std::{io::stdin, collections::HashSet}; + +fn main() { + let sets = stdin().lines() + .map(|l| l.unwrap().chars().collect::>()) + .collect::>(); + let groups = sets + .split(|set| set.is_empty()) + .collect::>(); + + let p1: usize = groups.iter() + .map(|s| s.iter().fold(s[0].clone(), |acc, curr| acc.union(curr).cloned().collect())) + .fold(0, |acc, l| acc+l.len()); + let p2: usize = groups.iter() + .map(|s| s.iter().fold(s[0].clone(), |acc, curr| acc.intersection(curr).cloned().collect())) + .fold(0, |acc, l| acc+l.len()); + + println!("{}\n{}", p1, p2); +} \ No newline at end of file diff --git a/2020/07/07.rs b/2020/07/07.rs new file mode 100644 index 0000000..603cdc4 --- /dev/null +++ b/2020/07/07.rs @@ -0,0 +1,26 @@ +use std::{io::stdin, collections::HashMap}; +use regex::Regex; + +fn contains_shiny_gold(map: &HashMap<&str, Vec<[&str; 2]>>, key: &str) -> bool { + if key == "shiny gold" { return true } + map[key].iter().any(|[_, name]| contains_shiny_gold(map, name)) +} + +fn count_bags(map: &HashMap<&str, Vec<[&str; 2]>>, key: &str) -> usize { + map[key].iter() + .map(|[num, name]| num.parse::().unwrap()*count_bags(map, name)) + .sum::() + 1 +} + +fn main() { + let pat = Regex::new(r"(^|\d) ?(\w+ \w+)").unwrap(); + let lines = stdin().lines().filter_map(Result::ok).collect::>(); + let map = lines.iter() + .map(|s| pat.captures_iter(&s).map(|c| c.extract::<2>()).collect::>()) + .map(|m| (m[0].0, m.iter().skip(1).map(|s| s.1).collect::>())) + .collect::>(); + + let p1 = map.iter().filter(|(key, _)| contains_shiny_gold(&map, key)).count(); + let p2: usize = count_bags(&map, "shiny gold"); + println!("{}\n{}", p1-1, p2-1); +} \ No newline at end of file diff --git a/2020/08/08.rs b/2020/08/08.rs new file mode 100644 index 0000000..90e45fb --- /dev/null +++ b/2020/08/08.rs @@ -0,0 +1,47 @@ +use std::{io::stdin, collections::HashSet}; + +fn terminates(inst: &Vec<(&str, i32)>) -> Result { + let mut visited = HashSet::new(); + let mut i: i32 = 0; + let mut acc = 0; + loop { + let (op, num) = inst[i as usize]; + match op { + "acc" => { acc += num; i += 1 }, + "nop" => i += 1, + "jmp" => i += num, + _ => panic!(), + } + if visited.contains(&i) { + return Err(acc); + } + if !(0..inst.len() as i32).contains(&i) { + return Ok(acc); + } + visited.insert(i); + } +} + +fn swap(op: &str) -> &str { + match op { + "nop" => "jmp", + "jmp" => "nop", + o => o, + } +} + +fn main() { + let lines = stdin().lines().filter_map(Result::ok).collect::>(); + let mut inst = lines.iter() + .map(|line| line.split_once(" ").unwrap()) + .map(|(op, num)| (op, num.parse::().unwrap())) + .collect::>(); + println!("{:?}", terminates(&inst).unwrap_err()); + for i in 0..inst.len() { + inst[i].0 = swap(inst[i].0); + if let Ok(res) = terminates(&inst) { + println!("{:?}", res); + } + inst[i].0 = swap(inst[i].0); + } +} \ No newline at end of file diff --git a/2020/09/09.rs b/2020/09/09.rs new file mode 100644 index 0000000..69d4266 --- /dev/null +++ b/2020/09/09.rs @@ -0,0 +1,21 @@ +use std::io::stdin; + +fn main() { + let nums: Vec = stdin().lines().map(|line| line.unwrap().parse().unwrap()).collect(); + let target_num = nums + .windows(26) + .find(|vec| !vec.iter().take(25).any(|n| vec.contains(&(vec[25]-n)))) + .unwrap()[25]; + + let mut max = (0, 0); + for i in 0..nums.len() { + let mut sum = 0; + for j in i..nums.len() { + sum += nums[j]; + if sum == target_num && j-i > max.0 { + max = (j-i, nums[i..=j].iter().min().unwrap() + nums[i..=j].iter().max().unwrap()); + } + } + } + println!("{}\n{}", target_num, max.1); +} \ No newline at end of file diff --git a/2020/10/10.rs b/2020/10/10.rs new file mode 100644 index 0000000..aed02db --- /dev/null +++ b/2020/10/10.rs @@ -0,0 +1,12 @@ +use std::io::stdin; +use itertools::Itertools; + +fn main() { + let mut nums: Vec = stdin().lines().map(|line| line.unwrap().parse().unwrap()).collect(); + nums.extend([0, *nums.iter().max().unwrap()+3]); + let diffs: Vec<_> = nums.iter().sorted().tuple_windows().map(|(a,b)|b-a).collect(); + let counts = diffs.iter().counts(); + let lookup = [1, 1, 2, 4, 7]; + let p2: i64 = diffs .split(|&n| n == 3) .map(|vec| lookup[vec.len()]) .product(); + println!("{}\n{}", counts[&1]*counts[&3], p2); +} \ No newline at end of file diff --git a/2020/11/11.rs b/2020/11/11.rs new file mode 100644 index 0000000..7f808cd --- /dev/null +++ b/2020/11/11.rs @@ -0,0 +1,51 @@ +use std::{io::stdin, collections::HashSet}; +use itertools::{iproduct, Itertools}; + +const DIRS: [(i32, i32); 8] = [(0, 1), (1, 0), (-1, 0), (0, -1), (-1, -1), (-1, 1), (1, -1), (1, 1)]; + +fn solve(lines: &Vec>, is_part2: bool) { + + let seats: Vec<_> = iproduct!(0..lines.len(), 0..lines[0].len()) + .filter(|(y, x)| lines[*y][*x] == 'L') + .map(|(y, x)| (y as i32, x as i32)) + .collect(); + + // let is_seat = |y, x| seats.contains(x) + + let mut taken = HashSet::new(); + let s = lines.len() as i32; + loop { + let mut new_taken = HashSet::new(); + for seat in &seats { + let mut adj = DIRS.iter() + .filter(|&(y, x)| taken.contains(&(seat.0+y, seat.1+x))) + .count(); + if is_part2 { + adj = DIRS.iter() + .map(|&(y, x)| (y, x, (1..s).find(|m| seats.contains(&(seat.0+y*m, seat.1+x*m))).unwrap_or(1))) + .filter(|&(y, x, m)| taken.contains(&(seat.0+y*m, seat.1+x*m))) + .count(); + } + match adj { + 0 => new_taken.insert(seat), + 4 if !is_part2 => false, + 5..=8 => false, + _ if taken.contains(seat) => new_taken.insert(seat), + _ => false, + }; + } + if taken.len() == new_taken.len() { + break + } + taken = new_taken; + } + println!("{:?}", taken.len()); +} + +fn main() { + let lines: Vec> = stdin().lines() + .map(|line| line.unwrap().trim().chars().collect_vec()) + .collect(); + solve(&lines, false); + solve(&lines, true); +} \ No newline at end of file diff --git a/2020/12/12.rs b/2020/12/12.rs new file mode 100644 index 0000000..bf4b3f4 --- /dev/null +++ b/2020/12/12.rs @@ -0,0 +1,47 @@ +use std::io::stdin; + +const DIRS: [(i32, i32); 4] = [(0, 1), (1, 0), (0, -1), (-1, 0)]; + +fn part1(actions: &Vec<(String, i32)>) -> i32 { + let (mut y, mut x, mut dir) = (0, 0, 0); + for (action, num) in actions { + match action.as_str() { + "N" => y -= num, + "S" => y += num, + "W" => x -= num, + "E" => x += num, + "F" => {y += DIRS[dir as usize].0 * num; x += DIRS[dir as usize].1 * num }, + "R" => dir = (dir + num / 90 + 4) % 4, + "L" => dir = (dir - num / 90 + 4) % 4, + _ => panic!(), + } + } + y.abs() + x.abs() +} + +fn part2(actions: &Vec<(String, i32)>) -> i32 { + let (mut y, mut x) = (0, 0); + let (mut wpy, mut wpx) = (-1, 10); + for (action, num) in actions { + match (action.as_str(), num) { + ("N", _) => wpy -= num, + ("S", _) => wpy += num, + ("W", _) => wpx -= num, + ("E", _) => wpx += num, + ("F", _) => {y += wpy * num; x += wpx * num }, + ("R", 90) | ("L", 270) => {(wpy, wpx) = (wpx, -wpy)}, + ("R", 270) | ("L", 90) => {(wpy, wpx) = (-wpx, wpy)}, + ("R", 180) | ("L", 180) => {(wpy, wpx) = (-wpy, -wpx)}, + _ => panic!(), + } + } + y.abs() + x.abs() +} + +fn main() { + let actions: Vec<(String, i32)> = stdin().lines() + .filter_map(Result::ok) + .map(|l| (l[0..1].to_owned(), l[1..l.len()].parse().unwrap())) + .collect(); + println!("{}\n{}", part1(&actions), part2(&actions)); +} \ No newline at end of file diff --git a/2020/13/13.rs b/2020/13/13.rs new file mode 100644 index 0000000..dbec655 --- /dev/null +++ b/2020/13/13.rs @@ -0,0 +1,43 @@ +use std::io::stdin; + +fn mod_inv(a: i64, module: i64) -> i64 { + let mut mn = (module, a); + let mut xy = (0, 1); + + while mn.1 != 0 { + xy = (xy.1, xy.0 - (mn.0 / mn.1) * xy.1); + mn = (mn.1, mn.0 % mn.1); + } + while xy.0 < 0 { + xy.0 += module; + } + xy.0 +} + +fn chinese_remainder_theorem(pairs: &Vec<(i64, i64)>) -> i64 { + let prod: i64 = pairs.iter().map(|t| t.1).product(); + let mut sum = 0; + for (s, x) in pairs { + let p = prod / x; + let residue = (x - s) % x; + sum += residue * mod_inv(p, *x) * p; + } + sum % prod +} + +fn main() { + let lines = stdin().lines().filter_map(Result::ok).collect::>(); + + let time: i32 = lines.first().unwrap().parse().unwrap(); + lines[1].split(",") + .filter_map(|s| s.parse().ok()) + .map(|t: i32| (t - time % t, t)) + .min() + .map(|(b, t)| println!("{}", b*t)); + + let pairs = lines[1].split(",") + .enumerate() + .filter_map(|(i, s)| s.parse().ok().map(|n| (i as i64, n))) + .collect::>(); + println!("{:?}", chinese_remainder_theorem(&pairs)); +} \ No newline at end of file diff --git a/2020/14/14.rs b/2020/14/14.rs new file mode 100644 index 0000000..046673a --- /dev/null +++ b/2020/14/14.rs @@ -0,0 +1,62 @@ +use std::{collections::HashMap, io::stdin}; + +use itertools::Itertools; + +fn mask_value(mask: &str, value: &str) -> i64 { + let bin = format!("{:036b}", value.parse::().unwrap()); + let masked = mask + .chars() + .zip(bin.chars()) + .map(|(m, b)| if m == 'X' { b } else { m }) + .join(""); + i64::from_str_radix(&masked, 2).unwrap() +} + +fn mask_address(mask: &str, addr: &str) -> Vec { + let bin = format!("{:036b}", addr.parse::().unwrap()); + let x_ids: Vec = mask + .char_indices() + .filter(|t| t.1 == 'X') + .map(|t| 1 << (35-t.0)) + .collect(); + + let masked = mask + .chars() + .zip(bin.chars()) + .map(|(m, b)| match m { '0' => b, '1' => '1', _ => '0' }) + .join(""); + let num = i64::from_str_radix(&masked, 2).unwrap(); + + (0..=x_ids.len()) + .flat_map(|k| { + x_ids + .iter() + .combinations(k) + .map(|comb| num + comb.iter().fold(0, |a, &b| a + b)) + }) + .collect() +} + +fn main() { + let lines: Vec<_> = stdin().lines().filter_map(Result::ok).collect(); + let mut memory1 = HashMap::new(); + let mut memory2 = HashMap::new(); + let mut mask = ""; + for line in &lines { + if line.starts_with("mask") { + mask = &line[7..line.len()]; + } else { + let (addr, val) = line + .strip_prefix("mem[") + .unwrap() + .split_once("] = ") + .unwrap(); + memory1.insert(addr, mask_value(mask, val)); + for address in mask_address(mask, addr) { + memory2.insert(address, val.parse().unwrap()); + } + } + } + println!("{:?}", memory1.values().sum::()); + println!("{:?}", memory2.values().sum::()); +} \ No newline at end of file diff --git a/2020/15/15.rs b/2020/15/15.rs new file mode 100644 index 0000000..cae6efb --- /dev/null +++ b/2020/15/15.rs @@ -0,0 +1,12 @@ +use std::{io::stdin, collections::HashMap}; + +fn main() { + let line = stdin().lines().last().unwrap().unwrap(); + let mut lookup: HashMap<_, _> = line.split(",").map(|n| n.parse().unwrap()).zip(1..).collect(); + let mut last = 0; + for i in lookup.len()+1..30_000_000 { + last = i - lookup.insert(last, i).unwrap_or(i); + if i == 2019 { println!("{}", last); } + } + println!("{}", last); +} diff --git a/2020/16/16.rs b/2020/16/16.rs new file mode 100644 index 0000000..52ba470 --- /dev/null +++ b/2020/16/16.rs @@ -0,0 +1,68 @@ +use std::{collections::HashSet, io::stdin}; + +use hopcroft_karp::matching; +use itertools::Itertools; +use regex::Regex; + +fn main() { + let raw_input = stdin().lines().filter_map(Result::ok).join("\n"); + let input = raw_input.split("\n\n").collect_vec(); + let pattern = Regex::new(r"\d+").unwrap(); + let mut sum = 0; + + let ranges = input + .get(0) + .unwrap() + .lines() + .map(|line| { + pattern + .find_iter(line) + .map(|a| a.as_str().parse::().unwrap()) + .tuples() + .map(|(a, b, c, d)| (a..=b, c..=d)) + .next() + .unwrap() + }) + .collect_vec(); + + let mut allowed: HashSet<(usize, usize)> = (0..ranges.len()) + .cartesian_product(20..ranges.len() + 20) + .collect(); + + for nearby in input.get(2).unwrap().split("\n").skip(1) { + for (i, num) in nearby + .split(",") + .map(|n| n.parse::().unwrap()) + .enumerate() + { + let invalid = ranges + .iter() + .map(|(r1, r2)| r1.contains(&num) || r2.contains(&num)) + .all(|n| n == false); + if invalid { + sum += num; + } else { + ranges + .iter() + .enumerate() + .filter(|(_, (r1, r2))| !(r1.contains(&num) || r2.contains(&num))) + .for_each(|(j, _)| { + allowed.remove(&(j, i + 20)); + }); + } + } + } + println!("{:?}", sum); + + let mine = pattern.find_iter(input.get(1).unwrap()) + .map(|a| a.as_str().parse::().unwrap()) + .collect_vec(); + + matching(&allowed.into_iter().collect_vec()) + .iter() + .sorted() + .take(6) + .map(|(_, b)| mine[b - 20]) + .reduce(|acc, x| acc * x) + .map(|a| println!("{:?}", a)); +} diff --git a/2020/17/17.rs b/2020/17/17.rs new file mode 100644 index 0000000..6218e25 --- /dev/null +++ b/2020/17/17.rs @@ -0,0 +1,57 @@ +use std::{collections::HashSet, io::stdin}; + +use itertools::{iproduct, Itertools}; + +fn adjacent(p: &Vec) -> HashSet> { + let r = [-1, 0, 1]; + + match p.len() { + 3 => iproduct!(r, r, r) + .map(|(dx, dy, dz)| vec![p[0] + dx, p[1] + dy, p[2] + dz]) + .collect(), + 4 => iproduct!(r, r, r, r) + .map(|(dx, dy, dz, dw)| vec![p[0] + dx, p[1] + dy, p[2] + dz, p[3] + dw]) + .collect(), + _ => HashSet::new(), + } +} + +fn solve(initial_active: HashSet>) { + let mut active = initial_active; + for _ in 0..6 { + let mut new_active = HashSet::new(); + let mut inactive = HashSet::new(); + for xyz in active.iter() { + let adj = adjacent(xyz); + inactive.extend(adj.difference(&active).cloned()); + if (3..=4).contains(&adj.intersection(&active).count()) { + new_active.insert(xyz.to_vec()); + } + } + for xyz in inactive.iter() { + if adjacent(xyz).intersection(&active).count() == 3 { + new_active.insert(xyz.to_vec()); + } + } + active = new_active; + } + println!("{:?}", active.len()); +} + +fn main() { + let active = stdin() + .lines() + .enumerate() + .map(|(y, line)| { + line.unwrap() + .chars() + .enumerate() + .filter(|(_, c)| *c == '#') + .map(|(x, _)| vec![y as i32, x as i32, 0]) + .collect_vec() + }) + .flatten() + .collect::>(); + solve(active.clone()); + solve(active.iter().map(|v| v.iter().cloned().chain(vec![4]).collect()).collect()); +} \ No newline at end of file diff --git a/2020/18/18.rs b/2020/18/18.rs new file mode 100644 index 0000000..6736e7a --- /dev/null +++ b/2020/18/18.rs @@ -0,0 +1,35 @@ +use std::io::stdin; + +fn eval(line: &str, plus_precedence: i32) -> i64 { + let mut nums = Vec::new(); + let mut operators = Vec::new(); + let precedence = |c| match c { '+' => plus_precedence, '*' => 1, _ => 0 }; + + for c in line.chars().chain(")".chars()) { + match c { + '0'..='9' => nums.push(c.to_digit(10).unwrap() as i64), + '(' | '+' | '*' | ')' => { + while !operators.is_empty() && c != '(' { + let op = operators.pop().unwrap(); + if op == '(' && c == ')' { break } + if precedence(op) < precedence(c) { + operators.push(op); + break; + } + let func = match op { '*' => |(a, b)| a * b, _ => |(a, b)| a + b }; + let value = nums.pop().zip(nums.pop()).map(func).unwrap(); + nums.push(value); + } + if c != ')' { operators.push(c); } + }, + _ => continue, + } + } + *nums.get(0).unwrap() +} + +fn main() { + let lines: Vec = stdin() .lines().filter_map(Result::ok).collect(); + println!("{}", lines.iter().map(|l| eval(&l, 1)).sum::()); + println!("{}", lines.iter().map(|l| eval(&l, 2)).sum::()); +} \ No newline at end of file diff --git a/2020/19/19.rs b/2020/19/19.rs new file mode 100644 index 0000000..8b20f47 --- /dev/null +++ b/2020/19/19.rs @@ -0,0 +1,54 @@ +use std::{collections::HashMap, io::stdin}; + +use itertools::Itertools; +use regex::Regex; + +fn resolve( + curr: &str, + rules: &HashMap>>, + resolved: &mut HashMap, +) -> String { + if let Some(value) = resolved.get(curr) { + return value.to_string(); + } + let rule = rules.get(curr).unwrap(); + let pattern = rule + .iter() + .map(|v| v.iter().map(|s| resolve(s, rules, resolved)).join("")) + .join("|"); + let pat = format!("({pattern})"); + resolved.insert(curr.to_owned(), pat.clone()); + + return pat; +} + +fn main() { + let lines = stdin().lines().filter_map(Result::ok).join("\n"); + + let (rules_str, messages) = lines.split("\n\n").next_tuple().unwrap(); + let mut rules = HashMap::new(); + for rule in rules_str.lines() { + let (index, sub) = rule.split(":").next_tuple().unwrap(); + rules.insert( + index.to_owned(), + sub.split("|") + .map(|nums| nums.trim().split(" ").map(|v| v.to_owned()).collect_vec()) + .collect_vec(), + ); + } + let mut resolved: HashMap = rules + .iter() + .map(|(k, v)| (k, v.first().unwrap().first().unwrap())) + .filter(|(_, s)| s.contains('"')) + .map(|(&ref k, v)| (k.to_owned(), v.trim_matches('"').to_owned())) + .collect(); + + let p42 = resolve("42", &rules, &mut resolved); + let p31 = resolve("31", &rules, &mut resolved); + let regex1 = Regex::new(&format!("^{p42}{p42}{p31}$")).unwrap(); + println!("{}", messages.lines().filter(|l| regex1.is_match(l)).count()); + + let pattern2 = (1..6).map(|i| format!("({p42}+{p42}{{{i}}}{p31}{{{i}}})")).join("|"); + let regex2 = Regex::new(&format!("^({pattern2})$")).unwrap(); + println!("{}", messages.lines().filter(|l| regex2.is_match(l)).count()); +} \ No newline at end of file diff --git a/2020/20/20.rs b/2020/20/20.rs new file mode 100644 index 0000000..89dfb6f --- /dev/null +++ b/2020/20/20.rs @@ -0,0 +1,114 @@ +use std::{collections::{HashMap, HashSet}, io::stdin}; + +use itertools::Itertools; +use regex::Regex; + +#[derive(Clone, Debug, PartialEq, Eq)] +struct Tile { + id: usize, + rows: Vec, +} + +impl Tile { + fn new(id: usize, lines: Vec<&str>) -> Tile { + Tile { id: id, rows: lines.iter().map(|s| usize::from_str_radix(s, 2).unwrap()).collect_vec() } + } + + fn flipped(&self) -> Tile { + let a = self.rows.iter().map(|i| format!("{i:010b}").chars().rev().join("")).collect_vec(); + Tile::new(self.id, a.iter().map(|i| i.as_str()).collect_vec()) + } + + fn rotated(&self) -> Tile { + Tile { + id: self.id, + rows: (0..10).map(|i| (0..10).map(|j| (self.rows.get(9-j).unwrap() & (1< Tile { + Tile { + id: self.id, + rows: self.rows.iter().skip(1).take(8).map(|n| (n - (n & (1<<9))) >> 1).collect() + } + } + + fn top(&self) -> usize { *self.rows.first().unwrap() } + fn bot(&self) -> usize { *self.rows.last().unwrap() } + fn left(&self) -> usize { self.rotated().bot() } + fn right(&self) -> usize { self.rotated().top() } + + fn variations(&self) -> Vec { + let mut tiles = Vec::new(); + let mut tile = self.clone(); + (0..4).for_each(|_| { tile = tile.rotated(); tiles.push(tile.clone()); tiles.push(tile.flipped()) }); + tiles + } + + fn top_edges(&self) -> HashMap { + self.variations().iter().map(|tile| (tile.top(), tile.clone())).collect() + } +} + +fn solve(corner: &Tile, all_tiles: &Vec) -> usize { + let size = (0..).find(|i| i*i == all_tiles.len() / 8).unwrap(); + + let mut leftmost = corner.rotated().rotated().flipped(); + let mut used = HashSet::new(); + let mut field: Vec = Vec::new(); + + for y in 0..size { + let mut current = all_tiles.iter().filter(|t| !used.contains(&t.id)).find(|tile| tile.top() == leftmost.bot()).unwrap().clone(); + leftmost = current.clone(); + used.insert(current.id); + current.inner().rows.iter().for_each(|n| field.push(format!("{n:08b}"))); + for _ in 1..size { + current = all_tiles.iter().filter(|t| !used.contains(&t.id)).find(|tile| tile.left() == current.right()).unwrap().clone(); + used.insert(current.id); + + for (row, num) in current.inner().rows.iter().enumerate() { + field.get_mut(y*8+row).unwrap().extend(format!("{num:08b}").chars()); + } + } + } + let dragon1 = Regex::new(r"..................1.").unwrap(); + let dragon2 = Regex::new(r"1....11....11....111").unwrap(); + let dragon3 = Regex::new(r".1..1..1..1..1..1...").unwrap(); + let mut dragons = 0; + for (a, b, c) in field.iter().tuple_windows() { + for i in 0..a.len() { + if dragon1.is_match(&a.chars().skip(i).take(20).join("")) + && dragon2.is_match(&b.chars().skip(i).take(20).join("")) + && dragon3.is_match(&c.chars().skip(i).take(20).join("")) { + dragons += 15; + } + } + } + field.join("").matches("1").count() - dragons +} + +fn main() { + let input = stdin().lines().filter_map(Result::ok).join("\n").replace(".", "0").replace("#", "1"); + let blocks = input.split("\n\n").collect_vec(); + + let mut all_tiles = Vec::new(); + let mut edges: HashMap> = HashMap::new(); + + for block in blocks { + let num: usize = block.lines().next().unwrap().trim_matches(['T', 'i', 'l', 'e', ' ', ':']).parse().unwrap(); + let tile = Tile::new(num, block.lines().skip(1).collect()); + all_tiles.extend(tile.variations()); + + for (edge, _) in tile.top_edges() { + edges.entry(edge).or_insert_with(HashSet::new).insert(num); + } + } + + let corners = all_tiles.iter() + .filter(|t| edges.get(&t.top()).unwrap().len() == 1) + .filter(|t| edges.get(&t.left()).unwrap().len() == 1) + .collect_vec(); + + println!("{}", corners.iter().map(|tile| tile.id).unique().reduce(|acc, a| acc * a).unwrap()); + println!("{}", corners.iter().map(|corner| solve(corner, &all_tiles)).min().unwrap()); +} \ No newline at end of file diff --git a/2020/21/21.rs b/2020/21/21.rs new file mode 100644 index 0000000..dc16eeb --- /dev/null +++ b/2020/21/21.rs @@ -0,0 +1,33 @@ +use std::{collections::{HashMap, HashSet}, io::stdin}; +use itertools::Itertools; + +fn main() { + let lines = stdin().lines().filter_map(Result::ok).collect_vec(); + + let mut all: Vec<&str> = Vec::new(); + let mut possible = HashMap::new(); + + for line in &lines { + let (left, right) = line.split_once(" (contains ").unwrap(); + let ingredients: HashSet<&str> = left.split(" ").collect(); + let allergens = right.trim_matches(')').split(", ").collect_vec(); + all.extend(&ingredients); + + for allergen in allergens { + possible.entry(allergen) + .or_insert(ingredients.clone()) + .retain(|k| ingredients.contains(k)) + } + } + println!("{}", all.iter().filter(|k| !possible.values().flatten().contains(k)).count()); + + let mut pairings: HashMap<&str, &str> = HashMap::new(); + while possible.len() != pairings.len() { + possible.iter() + .filter(|(_, v)| v.len() == 1) + .for_each(|(k, v)| { pairings.insert(k, v.iter().next().unwrap()); }); + possible.values_mut() + .for_each(|v| v.retain(|a| !pairings.values().contains(a))) + } + println!("{}", pairings.iter().sorted().map(|(_, b)| b).join(",")); +} \ No newline at end of file diff --git a/2020/22/22.rs b/2020/22/22.rs new file mode 100644 index 0000000..097977a --- /dev/null +++ b/2020/22/22.rs @@ -0,0 +1,31 @@ +use std::{collections::{HashSet, VecDeque}, io::stdin}; + +fn solve(mut player1: VecDeque, mut player2: VecDeque, part2: bool) -> bool { + let is_first = player1.len() == player2.len(); + let mut cache = HashSet::new(); + while !player1.is_empty() && !player2.is_empty() { + if !cache.insert((player1.clone(), player2.clone())) { return true; } + let p1 = player1.pop_front().unwrap(); + let p2 = player2.pop_front().unwrap(); + let mut p1wins = p1 > p2; + if part2 && player1.len() >= p1 && player2.len() >= p2 { + p1wins = solve(player1.iter().take(p1).copied().collect(), player2.iter().take(p2).copied().collect(), true) + } + if p1wins { + player1.extend([p1, p2]) + } else { + player2.extend([p2, p1]) + } + } + if is_first { + println!("{:?}", player1.iter().chain(player2.iter()).rev().zip(1..).fold(0, |acc, (i, v)| acc+i*v)); + } + player2.is_empty() +} + +fn main() { + let mut player1: VecDeque = stdin().lines().map(|l| l.unwrap().parse()).filter_map(Result::ok).collect(); + let player2 = player1.split_off(player1.len() / 2); + solve(player1.clone(), player2.clone(), false); + solve(player1, player2, true); +} \ No newline at end of file diff --git a/2020/23/23.rs b/2020/23/23.rs new file mode 100644 index 0000000..12d22bd --- /dev/null +++ b/2020/23/23.rs @@ -0,0 +1,41 @@ +use std::io::stdin; + +use itertools::Itertools; + +fn solve(initial: Vec, steps: i32) -> Vec { + let mut cups = initial.iter().zip(initial.iter().cycle().skip(1)).sorted().map(|a| a.1).copied().collect_vec(); + cups.insert(0, 0); + let mut curr = initial[0]; + let max = initial.len(); + + for _ in 0..steps { + let first = cups[curr]; + let second = cups[first]; + let third = cups[second]; + + let mut dest = curr; + while [curr, first, second, third].contains(&dest) { dest = (dest + max - 2) % max + 1 } + + cups[curr] = cups[third]; + cups[third] = cups[dest]; + cups[dest] = first; + + curr = cups[curr]; + } + + let mut sorted = Vec::new(); + curr = 1; + for _ in 0..max { + sorted.push(curr); + curr = cups[curr]; + } + sorted +} + +fn main() { + let cups = stdin().lines().next().unwrap().unwrap().chars().map(|c| c.to_digit(10).unwrap() as usize).collect_vec(); + println!("{}", solve(cups.clone(), 100).iter().skip(1).join("")); + + let p2 = cups.into_iter().chain(10..=1_000_000).collect(); + println!("{}", solve(p2, 10_000_000).into_iter().skip(1).take(2).reduce(|acc, a| acc * a).unwrap()); +} \ No newline at end of file diff --git a/2020/24/24.rs b/2020/24/24.rs new file mode 100644 index 0000000..3cbb768 --- /dev/null +++ b/2020/24/24.rs @@ -0,0 +1,33 @@ +use std::{collections::HashSet, io::stdin}; + +use regex::Regex; + +fn adjacent((x, y): &(i32, i32)) -> impl Iterator { + [(x-2, *y), (x+2, *y), (x+1, y+1), (x+1, y-1), (x-1, y-1), (x-1, y+1)].into_iter() +} + +fn main() { + let pat = Regex::new("e|ne|nw|w|sw|se").unwrap(); + let mut tiles = HashSet::new(); + + for line in stdin().lines().filter_map(Result::ok) { + let (mut x, mut y) = (0, 0); + for dir in pat.find_iter(&line).map(|m| m.as_str()) { + x += (dir.contains('e') as i32 * 4 - 2) / dir.len() as i32; + y += dir.contains('n') as i32 - dir.contains('s') as i32; + } + if !tiles.remove(&(x, y)) { + tiles.insert((x, y)); + } + } + println!("{}", tiles.len()); + + for _ in 0..100 { + tiles = tiles.iter() + .flat_map(adjacent) + .filter(|t| (1 + !tiles.contains(t) as usize..=2) + .contains(&adjacent(t).filter(|a| tiles.contains(a)).count())) + .collect(); + } + println!("{}", tiles.len()); +} diff --git a/2020/25/25.rs b/2020/25/25.rs new file mode 100644 index 0000000..6741ed2 --- /dev/null +++ b/2020/25/25.rs @@ -0,0 +1,9 @@ +use std::io::stdin; +use itertools::Itertools; + +fn main() { + let (card, door) = stdin().lines().map(|n| n.unwrap().parse()).filter_map(Result::ok).next_tuple().unwrap(); + let mut value: usize = 1; + let card_loop = (0..).map(|_| { value = value * 7 % 20201227; value }).take_while(|v| *v != card).count() + 1; + println!("{}", (0..card_loop).fold(1, |acc, _| acc * door % 20201227)); +} \ No newline at end of file diff --git a/2020/Cargo.lock b/2020/Cargo.lock new file mode 100644 index 0000000..1b3be23 --- /dev/null +++ b/2020/Cargo.lock @@ -0,0 +1,95 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "aho-corasick" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" +dependencies = [ + "memchr", +] + +[[package]] +name = "aoc2020" +version = "0.1.0" +dependencies = [ + "hopcroft-karp", + "itertools", + "regex", +] + +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + +[[package]] +name = "either" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0" + +[[package]] +name = "fxhash" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c" +dependencies = [ + "byteorder", +] + +[[package]] +name = "hopcroft-karp" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a72f3d9ba936766ff5d1c23504b6da754e4eb882e36f390e57a257214cb2762e" +dependencies = [ + "fxhash", +] + +[[package]] +name = "itertools" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569" +dependencies = [ + "either", +] + +[[package]] +name = "memchr" +version = "2.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" + +[[package]] +name = "regex" +version = "1.10.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4219d74c6b67a3654a9fbebc4b419e22126d13d2f3c4a07ee0cb61ff79a79619" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b" diff --git a/2020/Cargo.toml b/2020/Cargo.toml new file mode 100644 index 0000000..6cd3638 --- /dev/null +++ b/2020/Cargo.toml @@ -0,0 +1,115 @@ +[package] +name = "aoc2020" +version = "0.1.0" +edition = "2021" + +[profile.release] +codegen-units = 1 +lto = "fat" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +regex = "1.10.2" +itertools = "0.12.0" +hopcroft-karp = "0.2.1" + +[[bin]] +name = "01" +path = "01/01.rs" + +[[bin]] +name = "02" +path = "02/02.rs" + +[[bin]] +name = "03" +path = "03/03.rs" + +[[bin]] +name = "04" +path = "04/04.rs" + +[[bin]] +name = "05" +path = "05/05.rs" + +[[bin]] +name = "06" +path = "06/06.rs" + +[[bin]] +name = "07" +path = "07/07.rs" + +[[bin]] +name = "08" +path = "08/08.rs" + +[[bin]] +name = "09" +path = "09/09.rs" + +[[bin]] +name = "10" +path = "10/10.rs" + +[[bin]] +name = "11" +path = "11/11.rs" + +[[bin]] +name = "12" +path = "12/12.rs" + +[[bin]] +name = "13" +path = "13/13.rs" + +[[bin]] +name = "14" +path = "14/14.rs" + +[[bin]] +name = "15" +path = "15/15.rs" + +[[bin]] +name = "16" +path = "16/16.rs" + +[[bin]] +name = "17" +path = "17/17.rs" + +[[bin]] +name = "18" +path = "18/18.rs" + +[[bin]] +name = "19" +path = "19/19.rs" + +[[bin]] +name = "20" +path = "20/20.rs" + +[[bin]] +name = "21" +path = "21/21.rs" + +[[bin]] +name = "22" +path = "22/22.rs" + +[[bin]] +name = "23" +path = "23/23.rs" + +[[bin]] +name = "24" +path = "24/24.rs" + +[[bin]] +name = "25" +path = "25/25.rs" diff --git a/2020/benchmark.sh b/2020/benchmark.sh new file mode 100644 index 0000000..134b8ad --- /dev/null +++ b/2020/benchmark.sh @@ -0,0 +1,2 @@ +for dir in {0,1,2}*; do cargo build --release --bin $dir; done +for dir in {0,1,2}*; do hyperfine -N --min-runs 1 --warmup 3 --input $dir/input.in ./target/release/$dir; done diff --git a/2021/01/input.in b/2021/01/input.in deleted file mode 100644 index 7e216a8..0000000 --- a/2021/01/input.in +++ /dev/null @@ -1,2000 +0,0 @@ -191 -185 -188 -189 -204 -213 -215 -227 -222 -221 -236 -235 -236 -232 -224 -228 -234 -226 -227 -228 -230 -232 -234 -213 -197 -198 -210 -238 -248 -261 -263 -265 -262 -295 -296 -311 -330 -333 -337 -344 -345 -356 -359 -360 -364 -367 -383 -386 -387 -391 -424 -426 -428 -440 -442 -446 -450 -423 -428 -423 -425 -445 -429 -436 -465 -456 -463 -461 -463 -483 -484 -500 -517 -525 -529 -527 -530 -535 -566 -578 -582 -587 -604 -613 -614 -609 -611 -619 -623 -627 -621 -622 -626 -644 -646 -655 -657 -659 -661 -671 -673 -668 -673 -676 -682 -683 -678 -679 -682 -681 -684 -686 -690 -693 -698 -700 -702 -707 -708 -732 -733 -734 -743 -745 -776 -794 -804 -784 -790 -813 -856 -855 -859 -850 -851 -886 -885 -888 -889 -883 -885 -920 -919 -917 -915 -918 -909 -910 -924 -925 -932 -933 -935 -966 -970 -971 -974 -958 -959 -961 -959 -964 -969 -970 -973 -972 -976 -998 -1009 -1010 -1011 -1046 -1047 -1040 -1041 -1056 -1062 -1061 -1062 -1077 -1078 -1080 -1082 -1094 -1096 -1097 -1103 -1128 -1125 -1167 -1176 -1175 -1173 -1183 -1182 -1183 -1188 -1202 -1204 -1205 -1206 -1207 -1212 -1235 -1236 -1256 -1268 -1270 -1276 -1281 -1283 -1276 -1287 -1292 -1295 -1291 -1297 -1298 -1301 -1312 -1316 -1333 -1327 -1340 -1338 -1348 -1364 -1381 -1382 -1383 -1394 -1385 -1388 -1387 -1388 -1394 -1398 -1400 -1397 -1399 -1401 -1408 -1410 -1420 -1421 -1434 -1433 -1436 -1456 -1455 -1479 -1482 -1483 -1522 -1526 -1527 -1542 -1543 -1544 -1548 -1557 -1571 -1574 -1580 -1579 -1602 -1618 -1605 -1608 -1612 -1622 -1625 -1626 -1633 -1648 -1641 -1643 -1650 -1652 -1659 -1678 -1681 -1688 -1692 -1702 -1686 -1688 -1685 -1684 -1674 -1694 -1696 -1695 -1720 -1729 -1736 -1762 -1763 -1767 -1780 -1789 -1796 -1798 -1799 -1800 -1808 -1800 -1805 -1848 -1849 -1867 -1888 -1902 -1903 -1920 -1923 -1926 -1930 -1933 -1925 -1906 -1878 -1898 -1899 -1930 -1936 -1948 -1974 -1983 -1984 -1986 -1983 -1984 -1987 -1985 -1988 -1992 -2005 -2009 -2013 -2025 -2033 -2043 -2046 -2030 -2014 -2009 -2011 -2013 -2043 -2049 -2053 -2065 -2070 -2079 -2080 -2090 -2092 -2102 -2116 -2138 -2140 -2141 -2143 -2149 -2152 -2153 -2154 -2170 -2194 -2192 -2216 -2231 -2246 -2261 -2268 -2269 -2252 -2260 -2264 -2274 -2289 -2293 -2296 -2297 -2300 -2305 -2334 -2329 -2353 -2357 -2359 -2364 -2374 -2377 -2364 -2365 -2366 -2360 -2362 -2360 -2361 -2367 -2357 -2362 -2376 -2379 -2380 -2381 -2401 -2436 -2435 -2439 -2446 -2454 -2456 -2459 -2492 -2493 -2514 -2519 -2524 -2529 -2530 -2535 -2548 -2549 -2551 -2548 -2553 -2552 -2556 -2563 -2570 -2603 -2616 -2617 -2623 -2630 -2631 -2641 -2645 -2660 -2662 -2663 -2664 -2662 -2668 -2673 -2677 -2687 -2688 -2699 -2698 -2691 -2695 -2696 -2710 -2711 -2717 -2722 -2723 -2747 -2746 -2754 -2753 -2752 -2771 -2773 -2774 -2777 -2789 -2790 -2805 -2807 -2818 -2817 -2825 -2818 -2828 -2833 -2834 -2837 -2839 -2854 -2856 -2858 -2859 -2863 -2880 -2882 -2884 -2887 -2888 -2889 -2902 -2911 -2917 -2936 -2938 -2940 -2943 -2944 -2943 -2947 -2954 -2956 -2957 -2959 -2957 -2958 -2959 -2956 -2959 -2960 -2969 -2974 -2979 -2983 -2985 -2986 -2992 -2993 -2995 -3025 -3037 -3036 -3037 -3038 -3040 -3043 -3049 -3058 -3071 -3072 -3080 -3083 -3081 -3090 -3091 -3070 -3076 -3079 -3083 -3084 -3086 -3101 -3114 -3106 -3107 -3137 -3138 -3139 -3137 -3133 -3137 -3102 -3108 -3109 -3124 -3130 -3138 -3149 -3150 -3160 -3171 -3191 -3190 -3200 -3205 -3229 -3235 -3237 -3238 -3239 -3243 -3244 -3245 -3246 -3250 -3265 -3268 -3269 -3271 -3279 -3278 -3279 -3280 -3281 -3290 -3295 -3296 -3300 -3303 -3304 -3305 -3308 -3325 -3313 -3326 -3327 -3335 -3336 -3337 -3335 -3361 -3378 -3374 -3378 -3387 -3406 -3416 -3418 -3438 -3454 -3460 -3475 -3476 -3477 -3471 -3476 -3477 -3486 -3487 -3500 -3502 -3503 -3530 -3531 -3530 -3556 -3563 -3564 -3565 -3566 -3580 -3587 -3591 -3598 -3599 -3612 -3613 -3624 -3623 -3631 -3660 -3661 -3662 -3668 -3671 -3672 -3674 -3683 -3684 -3693 -3694 -3700 -3696 -3699 -3705 -3706 -3710 -3717 -3731 -3734 -3729 -3735 -3736 -3739 -3749 -3734 -3739 -3742 -3753 -3756 -3757 -3775 -3777 -3774 -3780 -3785 -3786 -3790 -3792 -3796 -3798 -3802 -3817 -3818 -3815 -3822 -3824 -3849 -3856 -3871 -3845 -3847 -3849 -3851 -3853 -3884 -3885 -3887 -3889 -3891 -3894 -3895 -3900 -3918 -3935 -3936 -3941 -3945 -3936 -3942 -3945 -3942 -3943 -3965 -3974 -3976 -3979 -3975 -3976 -3980 -3993 -3992 -3991 -3999 -4000 -3996 -4019 -4028 -4029 -4031 -4053 -4054 -4080 -4087 -4089 -4088 -4098 -4100 -4103 -4104 -4112 -4125 -4145 -4148 -4152 -4153 -4158 -4162 -4165 -4177 -4184 -4203 -4205 -4206 -4207 -4211 -4215 -4221 -4240 -4247 -4253 -4261 -4262 -4265 -4269 -4273 -4274 -4258 -4260 -4264 -4282 -4299 -4313 -4284 -4287 -4289 -4290 -4293 -4295 -4297 -4296 -4310 -4314 -4313 -4327 -4329 -4330 -4328 -4338 -4347 -4368 -4371 -4373 -4379 -4388 -4392 -4396 -4393 -4394 -4393 -4397 -4406 -4409 -4410 -4414 -4437 -4436 -4428 -4429 -4434 -4426 -4427 -4428 -4445 -4447 -4467 -4471 -4470 -4472 -4485 -4487 -4493 -4495 -4491 -4497 -4500 -4506 -4507 -4508 -4511 -4518 -4519 -4523 -4520 -4523 -4540 -4541 -4548 -4549 -4550 -4551 -4560 -4570 -4586 -4575 -4581 -4585 -4586 -4591 -4601 -4595 -4597 -4601 -4613 -4615 -4617 -4619 -4604 -4609 -4610 -4616 -4640 -4666 -4676 -4677 -4678 -4709 -4704 -4719 -4727 -4729 -4730 -4747 -4753 -4755 -4768 -4770 -4772 -4777 -4781 -4811 -4814 -4843 -4844 -4846 -4850 -4862 -4863 -4868 -4869 -4870 -4871 -4874 -4881 -4882 -4878 -4887 -4895 -4898 -4910 -4920 -4908 -4910 -4909 -4914 -4916 -4922 -4914 -4918 -4926 -4949 -4952 -4953 -4955 -4956 -4959 -4985 -4986 -4990 -4992 -5028 -5029 -5032 -5030 -5037 -5038 -5047 -5053 -5054 -5059 -5057 -5059 -5062 -5067 -5085 -5086 -5090 -5084 -5077 -5078 -5081 -5091 -5094 -5096 -5095 -5097 -5103 -5118 -5144 -5146 -5153 -5160 -5169 -5173 -5174 -5175 -5184 -5187 -5195 -5196 -5216 -5225 -5238 -5239 -5232 -5235 -5237 -5242 -5244 -5247 -5254 -5262 -5271 -5281 -5287 -5288 -5260 -5264 -5282 -5295 -5301 -5304 -5310 -5295 -5296 -5297 -5298 -5303 -5304 -5305 -5277 -5278 -5289 -5295 -5290 -5297 -5299 -5320 -5328 -5341 -5347 -5356 -5361 -5364 -5365 -5378 -5379 -5377 -5378 -5367 -5380 -5381 -5387 -5385 -5390 -5391 -5392 -5415 -5422 -5423 -5425 -5439 -5441 -5448 -5455 -5470 -5477 -5482 -5488 -5489 -5492 -5501 -5499 -5496 -5499 -5533 -5552 -5562 -5563 -5565 -5566 -5572 -5571 -5581 -5583 -5589 -5594 -5593 -5596 -5602 -5606 -5629 -5643 -5644 -5652 -5673 -5676 -5680 -5676 -5681 -5696 -5703 -5698 -5718 -5720 -5733 -5736 -5741 -5766 -5771 -5786 -5787 -5793 -5790 -5786 -5804 -5805 -5808 -5809 -5816 -5810 -5811 -5818 -5829 -5836 -5839 -5824 -5839 -5843 -5845 -5849 -5853 -5856 -5861 -5873 -5894 -5895 -5896 -5897 -5898 -5899 -5900 -5913 -5917 -5918 -5923 -5924 -5934 -5935 -5952 -5965 -5963 -5958 -5961 -5975 -5988 -5989 -5996 -5997 -6008 -6011 -6023 -6024 -6033 -6048 -6050 -6051 -6049 -6048 -6043 -6048 -6051 -6055 -6081 -6084 -6087 -6093 -6092 -6090 -6078 -6079 -6103 -6092 -6094 -6099 -6100 -6116 -6123 -6129 -6127 -6138 -6139 -6141 -6143 -6146 -6147 -6159 -6162 -6163 -6177 -6179 -6183 -6187 -6188 -6194 -6198 -6213 -6237 -6267 -6282 -6288 -6292 -6297 -6310 -6323 -6325 -6324 -6347 -6349 -6350 -6353 -6363 -6376 -6384 -6394 -6397 -6401 -6402 -6399 -6415 -6416 -6421 -6422 -6423 -6420 -6445 -6446 -6449 -6451 -6457 -6460 -6461 -6467 -6468 -6473 -6474 -6517 -6522 -6519 -6515 -6532 -6533 -6535 -6530 -6532 -6522 -6548 -6549 -6565 -6568 -6579 -6556 -6563 -6565 -6572 -6576 -6578 -6601 -6608 -6611 -6612 -6626 -6619 -6651 -6657 -6658 -6666 -6665 -6660 -6682 -6704 -6705 -6711 -6708 -6716 -6720 -6725 -6727 -6729 -6733 -6734 -6737 -6736 -6741 -6742 -6743 -6750 -6756 -6757 -6758 -6755 -6774 -6773 -6774 -6780 -6781 -6790 -6791 -6800 -6812 -6815 -6817 -6827 -6826 -6832 -6833 -6834 -6833 -6822 -6825 -6829 -6836 -6840 -6846 -6850 -6861 -6868 -6869 -6872 -6879 -6882 -6884 -6907 -6917 -6930 -6924 -6934 -6931 -6918 -6924 -6928 -6934 -6935 -6936 -6953 -6955 -6964 -6987 -6999 -7009 -7042 -7048 -7027 -7054 -7053 -7072 -7073 -7055 -7056 -7057 -7079 -7080 -7084 -7095 -7108 -7107 -7109 -7111 -7134 -7135 -7137 -7138 -7145 -7151 -7161 -7172 -7179 -7183 -7189 -7188 -7189 -7195 -7202 -7236 -7241 -7250 -7277 -7295 -7297 -7294 -7298 -7297 -7301 -7289 -7291 -7276 -7293 -7295 -7311 -7318 -7341 -7378 -7398 -7408 -7409 -7412 -7409 -7413 -7397 -7399 -7423 -7424 -7423 -7426 -7418 -7414 -7409 -7412 -7425 -7426 -7433 -7439 -7448 -7462 -7466 -7467 -7468 -7477 -7480 -7481 -7498 -7499 -7501 -7507 -7527 -7535 -7548 -7551 -7552 -7555 -7561 -7554 -7559 -7560 -7587 -7590 -7596 -7620 -7628 -7645 -7646 -7652 -7653 -7654 -7663 -7670 -7678 -7683 -7686 -7687 -7683 -7692 -7691 -7687 -7688 -7691 -7699 -7698 -7725 -7733 -7734 -7736 -7740 -7751 -7744 -7724 -7719 -7729 -7731 -7746 -7747 -7749 -7722 -7725 -7730 -7735 -7737 -7738 -7739 -7724 -7721 -7724 -7736 -7727 -7730 -7731 -7732 -7736 -7737 -7768 -7787 -7797 -7807 -7815 -7819 -7825 -7852 -7856 -7862 -7869 -7881 -7882 -7885 -7888 -7892 -7889 -7893 -7895 -7896 -7901 -7919 -7921 -7932 -7933 -7964 -7979 -7990 -7991 -7994 -7997 -8011 -8005 -8006 -8014 -8047 -8049 -8064 -8065 -8046 -8047 -8079 -8081 -8082 -8083 -8055 -8052 -8056 -8063 -8064 -8066 -8053 -8067 -8072 -8073 -8077 -8079 -8081 -8076 -8083 -8086 -8098 -8100 -8109 -8107 -8124 -8125 -8126 -8127 -8145 -8146 -8152 -8175 -8176 -8177 -8182 -8193 -8195 -8197 -8199 -8203 -8204 -8213 -8217 -8237 -8240 -8239 -8230 -8237 -8245 -8259 -8264 -8272 -8288 -8285 -8286 -8300 -8301 -8304 -8305 -8327 -8326 -8327 -8341 -8343 -8356 -8357 -8358 -8367 -8374 -8375 -8391 -8392 -8393 -8394 -8399 -8405 -8402 -8404 -8435 -8444 -8484 -8481 -8490 -8492 -8493 -8494 -8503 -8506 -8516 -8515 -8516 -8504 -8508 -8513 -8529 -8542 -8545 -8541 -8546 -8549 -8570 -8552 -8553 -8581 -8578 -8585 -8593 -8596 -8605 -8606 -8608 -8616 -8627 -8628 -8627 -8639 -8644 -8645 -8626 -8633 -8635 -8636 -8640 -8645 -8655 -8673 -8693 -8694 -8695 -8696 -8695 -8714 -8716 -8742 -8739 -8735 -8740 -8763 -8762 -8771 -8772 -8777 -8776 -8787 -8788 -8795 -8796 -8777 -8782 -8783 -8794 -8800 -8810 -8827 -8828 -8833 -8829 -8841 -8862 -8865 -8867 -8869 -8895 -8899 -8901 -8904 -8908 -8909 -8927 -8928 -8930 -8931 -8935 -8945 -8946 -8950 -8954 -8957 -8959 -8949 -8961 -8976 -8980 -8986 -8988 -8992 -9003 -9008 -9009 -9029 -9050 -9051 -9054 -9055 -9068 -9054 -9071 -9082 -9087 -9089 -9112 -9113 -9127 -9126 -9125 -9129 -9138 -9140 -9145 -9149 -9151 -9179 -9185 -9187 -9188 -9189 -9186 -9190 -9207 -9208 -9209 -9221 -9228 -9252 -9254 -9264 -9267 -9276 -9287 -9293 -9292 -9260 -9261 -9260 -9265 -9266 -9285 -9287 -9289 -9290 -9291 -9292 -9293 -9295 -9313 -9314 -9291 -9282 -9304 -9315 -9316 -9317 -9327 -9345 -9350 -9352 -9356 -9366 -9367 -9400 -9407 -9408 -9415 -9418 -9419 -9432 -9441 -9442 -9439 -9440 -9451 -9455 -9464 -9472 -9479 -9481 -9490 -9514 -9527 -9546 -9552 -9556 -9570 -9582 -9584 -9592 -9597 -9602 -9618 -9619 -9622 -9639 -9645 -9648 -9643 -9647 -9648 -9650 -9641 -9665 -9678 -9681 -9682 -9683 -9692 -9703 -9704 -9702 -9704 -9712 -9726 -9731 -9732 -9733 -9744 -9745 -9757 -9755 -9763 -9764 -9766 -9768 -9782 -9780 -9781 -9783 -9786 -9803 -9804 -9821 -9822 -9840 -9841 -9843 -9839 -9840 -9846 -9856 -9859 -9863 -9862 -9864 -9865 -9866 -9870 -9878 -9877 -9894 -9896 -9937 -9938 -9943 -9944 -9943 -9952 -9962 -9983 -9985 -9984 -9992 -10002 -10003 -10041 -10040 -10041 -10040 -10042 -10029 -10034 -10033 -10034 -10052 -10053 -10062 -10055 -10056 -10057 -10069 -10073 -10067 -10070 -10065 -10064 -10069 -10071 -10092 -10069 -10070 -10080 -10095 -10099 -10100 -10101 -10099 -10115 -10116 -10117 -10122 -10124 -10129 -10096 -10101 -10106 -10099 -10102 -10143 -10144 -10145 -10146 -10148 -10149 -10150 -10160 -10132 -10137 -10177 -10181 -10178 -10183 -10189 -10191 -10192 -10194 -10203 -10199 -10207 -10218 -10223 -10224 -10225 -10245 -10239 -10247 -10252 -10250 -10254 -10255 -10256 -10279 -10280 -10292 -10293 -10300 -10310 -10312 -10321 -10324 -10326 -10330 -10329 -10328 -10329 -10333 -10355 -10354 -10349 -10352 -10357 -10369 -10386 -10387 -10402 -10406 -10407 -10404 -10405 -10407 -10408 -10412 -10413 -10417 -10420 -10412 -10426 -10427 -10424 -10433 -10434 -10435 -10456 -10472 -10492 -10494 -10508 -10510 -10511 -10512 -10513 -10514 -10507 -10510 -10511 -10515 -10525 -10526 diff --git a/2021/02/input.in b/2021/02/input.in deleted file mode 100644 index b3a0ece..0000000 --- a/2021/02/input.in +++ /dev/null @@ -1,1000 +0,0 @@ -forward 9 -down 3 -down 8 -forward 2 -up 3 -forward 5 -up 8 -down 2 -down 5 -up 7 -down 9 -forward 4 -up 5 -down 9 -forward 2 -forward 2 -forward 8 -down 6 -forward 2 -up 9 -up 5 -down 2 -forward 5 -down 8 -forward 3 -up 4 -forward 5 -forward 7 -down 8 -down 6 -up 7 -down 3 -forward 4 -up 8 -down 5 -down 3 -down 6 -down 8 -forward 1 -forward 9 -forward 4 -up 7 -down 4 -forward 7 -forward 3 -forward 9 -down 1 -down 3 -up 9 -down 3 -forward 9 -up 6 -up 9 -down 8 -up 3 -down 1 -up 8 -down 8 -down 2 -down 4 -down 4 -up 3 -down 6 -down 1 -down 3 -forward 1 -up 5 -forward 5 -forward 8 -down 2 -forward 6 -forward 2 -up 7 -forward 6 -down 8 -forward 6 -forward 5 -up 9 -forward 5 -up 5 -forward 9 -down 2 -down 4 -down 3 -down 8 -forward 9 -forward 6 -forward 2 -up 7 -down 7 -up 3 -forward 4 -forward 5 -down 7 -forward 5 -up 9 -forward 6 -forward 6 -forward 1 -down 6 -forward 9 -up 2 -down 7 -down 8 -down 6 -up 5 -down 8 -down 8 -forward 7 -down 6 -up 5 -down 9 -down 3 -forward 2 -down 4 -forward 8 -down 5 -up 5 -forward 7 -up 2 -up 2 -down 4 -forward 4 -down 5 -up 8 -down 2 -forward 4 -down 9 -forward 8 -down 5 -down 6 -down 7 -up 7 -up 5 -up 7 -forward 7 -forward 8 -down 2 -forward 3 -down 2 -down 7 -down 4 -down 2 -forward 3 -forward 5 -down 3 -down 7 -up 7 -down 7 -up 5 -forward 1 -down 8 -down 2 -up 4 -up 5 -down 8 -forward 9 -down 3 -down 9 -forward 8 -forward 1 -forward 1 -down 2 -up 9 -down 2 -up 8 -down 6 -up 8 -forward 7 -down 5 -forward 7 -down 8 -forward 8 -down 7 -up 9 -up 2 -up 6 -down 5 -down 9 -forward 2 -up 3 -down 4 -up 5 -up 4 -down 9 -forward 7 -forward 7 -down 3 -forward 4 -forward 9 -up 8 -forward 3 -down 1 -forward 2 -down 7 -down 3 -down 7 -down 7 -forward 8 -forward 4 -forward 7 -up 1 -down 4 -up 9 -down 2 -down 1 -forward 6 -down 3 -forward 7 -forward 8 -up 9 -up 2 -up 2 -forward 7 -up 2 -up 5 -forward 5 -down 3 -forward 8 -forward 1 -up 4 -down 6 -down 5 -forward 4 -up 9 -forward 8 -up 4 -down 8 -down 3 -down 3 -down 7 -forward 2 -forward 4 -down 9 -down 7 -down 2 -up 3 -up 3 -forward 8 -forward 7 -forward 8 -down 5 -up 5 -forward 3 -forward 6 -up 7 -up 1 -forward 2 -forward 5 -down 5 -forward 8 -down 2 -down 4 -forward 2 -down 7 -down 3 -down 5 -forward 9 -down 7 -down 8 -up 1 -up 2 -down 8 -forward 7 -forward 8 -down 8 -forward 5 -up 7 -forward 3 -up 2 -down 7 -forward 1 -down 2 -up 7 -up 4 -down 2 -forward 1 -up 5 -forward 2 -up 2 -forward 3 -forward 9 -forward 2 -forward 8 -forward 2 -up 7 -down 8 -down 7 -forward 2 -forward 7 -down 1 -forward 2 -up 1 -up 6 -down 3 -down 6 -forward 7 -down 4 -forward 5 -forward 6 -up 3 -forward 3 -down 6 -forward 8 -up 8 -forward 4 -down 3 -forward 3 -down 4 -down 7 -forward 9 -forward 2 -up 2 -forward 8 -down 6 -forward 6 -down 9 -down 9 -forward 8 -down 1 -forward 9 -down 1 -down 6 -down 8 -down 5 -down 5 -forward 3 -forward 3 -down 2 -down 5 -forward 9 -down 2 -down 8 -down 3 -forward 9 -up 2 -down 4 -down 9 -forward 9 -forward 1 -forward 5 -up 9 -down 1 -down 6 -forward 6 -forward 5 -forward 8 -down 2 -forward 8 -down 4 -down 2 -down 6 -down 6 -up 3 -up 8 -forward 1 -down 1 -up 8 -down 3 -down 4 -up 9 -up 1 -down 7 -down 7 -up 1 -up 2 -forward 5 -up 8 -forward 2 -down 3 -forward 1 -up 5 -forward 6 -forward 2 -down 6 -up 2 -forward 2 -forward 1 -down 3 -forward 4 -up 8 -forward 5 -down 4 -forward 2 -down 8 -down 7 -up 7 -down 8 -forward 1 -down 4 -up 9 -down 6 -up 6 -up 6 -down 2 -forward 1 -forward 8 -down 6 -up 3 -down 7 -forward 9 -up 1 -up 4 -forward 7 -down 7 -forward 1 -down 6 -down 4 -down 7 -down 8 -down 8 -forward 4 -down 6 -down 6 -down 5 -forward 6 -up 9 -up 3 -down 4 -forward 8 -down 7 -forward 6 -up 3 -forward 1 -forward 1 -down 8 -forward 7 -forward 4 -forward 6 -up 1 -forward 7 -up 8 -forward 2 -forward 6 -forward 8 -down 9 -down 8 -up 9 -up 4 -up 2 -forward 2 -forward 8 -up 2 -forward 3 -forward 2 -up 2 -up 5 -up 8 -forward 4 -forward 8 -forward 3 -up 5 -down 1 -forward 2 -down 7 -down 8 -forward 3 -up 1 -forward 5 -forward 7 -forward 9 -up 7 -forward 4 -down 4 -up 2 -forward 4 -forward 5 -forward 3 -up 9 -forward 6 -forward 8 -down 9 -down 1 -forward 1 -down 5 -down 2 -forward 9 -down 2 -up 9 -down 1 -forward 5 -forward 8 -up 2 -forward 6 -down 4 -down 9 -forward 4 -forward 1 -down 3 -down 3 -up 5 -forward 5 -down 6 -forward 3 -down 2 -forward 8 -down 7 -down 2 -down 1 -forward 2 -up 5 -forward 9 -forward 3 -forward 5 -down 4 -up 7 -forward 6 -down 3 -forward 1 -forward 7 -forward 1 -up 4 -down 2 -down 7 -up 9 -forward 9 -down 8 -down 1 -up 2 -down 3 -forward 7 -down 8 -down 5 -down 5 -up 8 -forward 1 -down 5 -forward 8 -up 7 -down 1 -forward 9 -down 4 -forward 8 -forward 5 -forward 7 -forward 8 -forward 3 -up 9 -forward 3 -down 7 -down 5 -up 8 -forward 3 -up 6 -forward 8 -up 3 -down 5 -forward 5 -forward 6 -forward 4 -forward 3 -forward 8 -up 9 -forward 2 -down 6 -down 4 -down 5 -forward 7 -down 2 -up 5 -forward 2 -forward 5 -down 9 -forward 8 -down 8 -forward 6 -down 9 -down 7 -up 9 -forward 3 -forward 3 -up 5 -down 2 -forward 5 -down 6 -down 6 -down 2 -down 3 -down 4 -forward 7 -up 1 -down 7 -forward 7 -up 1 -forward 3 -up 6 -down 7 -down 5 -forward 9 -forward 2 -down 5 -forward 9 -down 5 -forward 9 -forward 1 -down 4 -forward 9 -down 5 -forward 8 -down 6 -down 4 -down 5 -forward 9 -down 1 -forward 6 -forward 9 -down 1 -down 1 -up 2 -forward 5 -forward 3 -down 4 -up 8 -forward 8 -down 2 -forward 3 -forward 1 -down 7 -forward 6 -forward 5 -up 7 -up 8 -down 5 -up 3 -down 8 -forward 6 -forward 5 -forward 6 -up 1 -up 8 -up 7 -down 5 -forward 3 -forward 9 -up 9 -up 4 -up 7 -up 8 -forward 7 -forward 3 -forward 9 -down 7 -forward 3 -down 6 -forward 9 -down 1 -forward 3 -down 1 -forward 8 -forward 7 -down 2 -forward 1 -forward 6 -forward 7 -down 3 -down 2 -down 1 -forward 7 -forward 4 -down 6 -up 4 -forward 4 -forward 9 -forward 3 -down 1 -up 2 -down 3 -down 5 -forward 7 -forward 5 -up 1 -down 2 -down 3 -down 8 -forward 1 -down 4 -forward 5 -down 5 -up 6 -down 6 -down 8 -forward 1 -forward 9 -up 5 -forward 2 -down 9 -down 5 -down 1 -down 4 -down 9 -down 8 -forward 2 -forward 4 -up 2 -forward 3 -down 8 -down 5 -up 5 -forward 8 -up 2 -down 8 -up 3 -forward 7 -down 7 -forward 8 -down 7 -down 3 -up 6 -forward 5 -up 4 -up 5 -forward 9 -forward 6 -down 9 -forward 5 -down 5 -down 3 -forward 2 -down 1 -up 9 -up 8 -down 6 -down 1 -forward 9 -forward 4 -forward 2 -up 1 -forward 5 -forward 9 -up 5 -forward 8 -forward 4 -down 4 -down 4 -down 2 -forward 1 -forward 7 -down 9 -forward 4 -down 5 -down 4 -down 7 -down 2 -forward 9 -down 3 -forward 6 -forward 3 -down 9 -down 3 -down 4 -down 9 -down 9 -up 6 -down 5 -up 4 -down 1 -down 1 -forward 9 -forward 7 -down 9 -forward 4 -down 8 -down 7 -forward 7 -forward 4 -up 2 -up 5 -forward 2 -forward 7 -down 1 -forward 6 -forward 6 -forward 3 -forward 8 -down 2 -up 2 -forward 7 -up 5 -down 1 -down 5 -forward 8 -down 6 -forward 8 -down 5 -down 4 -down 6 -forward 5 -down 1 -forward 9 -forward 8 -up 5 -down 6 -forward 5 -up 5 -down 4 -forward 1 -down 2 -down 5 -down 3 -forward 2 -down 9 -forward 1 -forward 1 -forward 1 -forward 8 -forward 2 -down 8 -down 6 -up 1 -forward 6 -down 3 -down 4 -up 9 -down 3 -down 3 -up 7 -down 4 -forward 4 -forward 9 -down 3 -down 8 -forward 5 -down 3 -down 6 -down 7 -forward 1 -up 2 -forward 8 -down 1 -down 4 -up 9 -forward 9 -up 4 -up 2 -forward 3 -forward 4 -down 2 -down 2 -down 6 -forward 6 -forward 8 -down 6 -up 6 -down 5 -forward 1 -down 4 -up 9 -forward 1 -forward 3 -down 1 -down 4 -up 6 -forward 5 -forward 6 -up 9 -up 9 -down 2 -up 6 -forward 1 -forward 2 -forward 3 -forward 3 -forward 6 -up 2 -down 8 -down 9 -forward 7 -up 1 -up 3 -down 2 -forward 3 -down 8 -forward 9 -down 3 -forward 6 -up 2 -forward 7 -down 2 -forward 5 -down 4 -down 2 -up 8 -forward 3 -forward 5 -forward 9 -forward 5 -forward 3 -up 9 -down 7 -forward 4 -forward 2 -forward 7 -down 5 -up 6 -up 6 -forward 8 -down 2 -forward 1 -up 1 -up 9 -up 8 -up 3 -up 4 -down 2 -up 7 -down 4 -up 5 -down 1 -up 9 -down 5 -down 9 -down 4 -up 2 -down 8 -up 2 -up 7 -up 9 -forward 4 -forward 2 -forward 1 -forward 6 -forward 8 -up 5 -forward 5 -forward 5 -down 4 -up 6 -forward 3 -down 9 -down 7 -forward 4 -down 3 -up 1 -forward 4 -down 2 -down 6 -up 3 -up 1 -down 9 -down 7 -down 9 -forward 3 -forward 8 -down 8 -up 7 -up 6 -down 2 -down 9 -down 1 -down 9 -forward 6 -up 4 -down 3 -forward 5 -up 3 -up 9 -up 8 -forward 6 -down 8 -forward 6 -forward 6 -forward 5 -up 4 -down 4 -up 6 -up 4 -forward 2 -down 5 -forward 9 -up 7 -up 6 -down 4 -forward 7 -forward 6 -up 2 -down 8 -down 6 -forward 5 -up 2 -forward 5 -forward 1 -up 9 -down 8 -forward 7 -up 4 -forward 8 -down 4 -forward 3 -forward 3 -down 9 -forward 4 -forward 9 -up 8 -forward 7 -forward 3 -forward 9 -forward 4 -up 3 -forward 2 -forward 7 diff --git a/2021/03/input.in b/2021/03/input.in deleted file mode 100644 index 7ab3dcf..0000000 --- a/2021/03/input.in +++ /dev/null @@ -1,1000 +0,0 @@ -111110110111 -110011001101 -110100000011 -100011000101 -110010010000 -100110100101 -111000010101 -011110011001 -111001110111 -101001101001 -110001011001 -110110110100 -101010101100 -011010010010 -101101110000 -011101000111 -100100100100 -100101001111 -010101101011 -101101000001 -111111000100 -010110001000 -001111010010 -100010000100 -000110011001 -001111001000 -011101101111 -011001100101 -001001011111 -100011110001 -110010111000 -000101000010 -000011010100 -010011111000 -010101101100 -111110110101 -100011100100 -000100010010 -000111110111 -010110000111 -110110010101 -000011001011 -001100000101 -100010101100 -101000111001 -000010100100 -000011000001 -010100011101 -101110111001 -110001101101 -100000101111 -010000100101 -110001110110 -111101011101 -100100000101 -110011101110 -100001011001 -101011111000 -011101110000 -100100011101 -101010110011 -010010101100 -100010010101 -010000001001 -011100001000 -111011000000 -000101111001 -111001101001 -111111101111 -010000110001 -000011011101 -001010011001 -010010100110 -100011100011 -101010000010 -100111001011 -010000010011 -110111110110 -010111011110 -101101000010 -011011011010 -101000100000 -011001110011 -011001010010 -100101110010 -011011001010 -001010101101 -011101010011 -111101101011 -100011101010 -101101010110 -000010100011 -010100101000 -001000100101 -101111011010 -011110011011 -101000010001 -110001011100 -001010001010 -011010001100 -100000100100 -010110110111 -111010000001 -111111010010 -010111001010 -111000010110 -111110010011 -110001100000 -000111010101 -010001000101 -001100100011 -110010000011 -101100001011 -100100011110 -101110010001 -101001100010 -011001111001 -011000000101 -111100101011 -000101011011 -111110001000 -010111110101 -101010101110 -001110110111 -110000110110 -110001000011 -000010000110 -100100100011 -010101110111 -110000101001 -101100001110 -101101001001 -100011001101 -111010101100 -011100111001 -011001111010 -000010111101 -110010000010 -001111111100 -001011001000 -001110110001 -101100011100 -101011000110 -101010010110 -011000101011 -111101000110 -110011010011 -110000011001 -011000101110 -000001111001 -111011011001 -010111111010 -010011000110 -000101111100 -111101101001 -101001111001 -010000011001 -111111100111 -010101101000 -000100110010 -000101100010 -011001000010 -100010000000 -111100001100 -101110110011 -001100101001 -111001000001 -110101111111 -000100110001 -101000001011 -100110001000 -101001000111 -011010100001 -011001101111 -000111111011 -001111000100 -001001000101 -110010001011 -010110010110 -111000101110 -100100001001 -100101011010 -111111110101 -111100010010 -101110111101 -010100011011 -001101111001 -010010100111 -101111010000 -000011111101 -101110011101 -111000011111 -001000000100 -100011001010 -101111101000 -001110010001 -100110111011 -101011110000 -110111001111 -001000010010 -101011111111 -100111111111 -001011010100 -110100111111 -111001010110 -101001110001 -101010111110 -010100011010 -100000000001 -000010010101 -010010101010 -011101001011 -110101010110 -001110000000 -010111111101 -011101110101 -001010110010 -001111101111 -100011110110 -101100110100 -111010111010 -001110000011 -111101111110 -001111100110 -000010010110 -111110011011 -111110011000 -001001111101 -000011110110 -001000101010 -000110101111 -010010111100 -100010101000 -000111010000 -110000001001 -000101111011 -100100101000 -101001110000 -110001001010 -110011000001 -111010100110 -000000100011 -111000111010 -100100111000 -100010010100 -111011110100 -001001001011 -000010110001 -000000101110 -010010101011 -000100101000 -011000000100 -110111110111 -111100001011 -001000000011 -101010011010 -110110011010 -000011000101 -110110110001 -000111010011 -011010111101 -000101011110 -110111111111 -111010101110 -001101000011 -101100000101 -010001111001 -101001010100 -010111100010 -011100101100 -001100110111 -000101010000 -000001110100 -100101001010 -000010110000 -011101110110 -000000110000 -001001000110 -100000111000 -011101111101 -111011001010 -100010001100 -001100000001 -101100111011 -100010011110 -011011111010 -001000000110 -010001001111 -010101010110 -000100000000 -000110111000 -001010011111 -010000001111 -111001000111 -010001100101 -100011011000 -111111000001 -111010111110 -000011010101 -001000101100 -001000110101 -111101101100 -000011100100 -010110111111 -101010001000 -010001111011 -101110000111 -000111010111 -011011111100 -010100000011 -100010111001 -110100110001 -100001100111 -110000101011 -001000101011 -101100101000 -001001010100 -011000111111 -111000001010 -111100101000 -010100110100 -000011010001 -110001100110 -110101111101 -101010100000 -101110111110 -110101011001 -111101111001 -100111101110 -010011101000 -100000001010 -000100100101 -010000000000 -100000010110 -110100011000 -101100101010 -011000001111 -001111110111 -011010011010 -001100010001 -110000101111 -011101111010 -110010010110 -001110101010 -000100111010 -011100000001 -011011110010 -001000001101 -111110111011 -110100110100 -010111011000 -110111101111 -010110000010 -111011011010 -000001001100 -010010111101 -001110111010 -010100000010 -111000110110 -110001111101 -100110000001 -100001011111 -010110110100 -011000111000 -110101001101 -100010000010 -010010000110 -111111011111 -101111000011 -101010010101 -000000010001 -000010001010 -101111000010 -010001000001 -100110011011 -010111100000 -101111000101 -101111001110 -011010110010 -000101101110 -111000011010 -011101101001 -001010101110 -111101101110 -000001110111 -001111001001 -110010101111 -010111001110 -101001001010 -011110001000 -110111011010 -010001010010 -001101001000 -001110100001 -010011110110 -110010110101 -110000011101 -111011101111 -000000001100 -101010111111 -011110010011 -001101011111 -100000100101 -011010100111 -011010110000 -000100010001 -011111001101 -111110010111 -110001001101 -101111011000 -111010100000 -111001111001 -110000010111 -010010110110 -110110010000 -100101101010 -101010000000 -100010010001 -010110000110 -000000011000 -001011111110 -010000010111 -001001011110 -010100000100 -011011010110 -110010100000 -110001010101 -000110010111 -101001100000 -101111001000 -010100110110 -100101011110 -111010010001 -110101101011 -111111011101 -010000101111 -011100000000 -010011111110 -110000111111 -001110001101 -101001001011 -111011010001 -011101101100 -110010001111 -100100100110 -100011000011 -000010111000 -111101001000 -100001101111 -001011011001 -111101011011 -111110010100 -100000011110 -100110001011 -111100011001 -111111110000 -100100111001 -010001111110 -100110110010 -000000001101 -011110110100 -111011000101 -101001000101 -110010101001 -110011110111 -000010010011 -010011010010 -110101100000 -111000000010 -010100100000 -110000111010 -011101110111 -010011010100 -000110101001 -000110011100 -101000000101 -101101110111 -010101100110 -000001111000 -110100111100 -001101010010 -110111111011 -010010001101 -001111000011 -101111011110 -010110101011 -110011100011 -101000000000 -011000001000 -101101100111 -000100111011 -101101000111 -110001000111 -001010100011 -001011101101 -000110011010 -101011100000 -111110100001 -111110000010 -001111100101 -011011011101 -000111100001 -101001100101 -110000100100 -111000111011 -101011001110 -100111100011 -000100100000 -000111001110 -001000011001 -001101100101 -111000001110 -011011110101 -010001011100 -000000110100 -011010001111 -000011100111 -001100111101 -110010110011 -000100010111 -100000010001 -000001100000 -111101000100 -110100101010 -011010110011 -010101000010 -101100111100 -100001101001 -001011101111 -110100010001 -011001001001 -110010100010 -001000110001 -100111011110 -100111110011 -100101111010 -100000110011 -111000111110 -111111011010 -011010111011 -001101001011 -001110101100 -010110111101 -001101110111 -000010101101 -110110101001 -101001000010 -001101100111 -100111011000 -001101101110 -110001111001 -101111100000 -000110001110 -111001111100 -110101011110 -000001010010 -100001011101 -001110000101 -011000110110 -000000111100 -010100100110 -000110001001 -010011111101 -101010000111 -001001111011 -101101010111 -111101100011 -111001111110 -000010111100 -110000101000 -011100100010 -101100111010 -010001010101 -001010011100 -011001011000 -001111001011 -100100110111 -001001111100 -110010001110 -101010000110 -011000111011 -010001011110 -100011000010 -110100101111 -101111110110 -111000110000 -100100110011 -110110001111 -100000111100 -011001000000 -110000000110 -100011101011 -000000110011 -111101101000 -111010000110 -101111011001 -011011010011 -111001010011 -100111010001 -011000010110 -111110110011 -100010101111 -101111100100 -010000111000 -000011111011 -011111001001 -000001110001 -000001001111 -110000110111 -100110100000 -101100011110 -000110111101 -011000001010 -010011100011 -111111011000 -000000000001 -011110000101 -011001001000 -001010111010 -111011000111 -010111010110 -011011110111 -000011111001 -001101110001 -100110010000 -010100011111 -101100111110 -110100011001 -101011100001 -110101011111 -111111001110 -010011110101 -010101000011 -010011110000 -101110110001 -000100001111 -110011011000 -111100110000 -111110110110 -110111010100 -110011110001 -100100101011 -000101001010 -111110001001 -001100110010 -101011100101 -101110101101 -001000101110 -100110001001 -011001111000 -111111000010 -011001110111 -110100001000 -101101101000 -110010011011 -111111010001 -101001110010 -101010001110 -100101000000 -100001011100 -011011000101 -001001001001 -010110000011 -010111110111 -000000111011 -110110011100 -110000110011 -011110101000 -110110110110 -001101000100 -101110101011 -101101001110 -000110100110 -001100101110 -011010011001 -011111001111 -010010000001 -111110101001 -111000000101 -001010000110 -000100111110 -000001101101 -111010100001 -010110111010 -110000010001 -010001101011 -110000010010 -000001011011 -111001011000 -011000001101 -101101110001 -100000101110 -000010110100 -100001111001 -100010110110 -101011111001 -111101011010 -110100000100 -101111000100 -101101110011 -000011110011 -110000010101 -011000110011 -001100010110 -100101011101 -000100101011 -101011111101 -111000111100 -001000011011 -101000001010 -010001001000 -110111110001 -101010010111 -101100100010 -010001000100 -000110100010 -011111010000 -000110100001 -010010001001 -001001010001 -111010111100 -101110001101 -101011111011 -011101010101 -110010100001 -110101110110 -111000111000 -110111010010 -110101010111 -010101101010 -110101010010 -000000101011 -111101000001 -100011001110 -111110000011 -100111000100 -010010011101 -010100000111 -001111111110 -011001100001 -101000101000 -001111111010 -110001101011 -110110010111 -010110111100 -110100010111 -110101110001 -010011100111 -100101011011 -110111111100 -010011111100 -010000100111 -010111101110 -101010010100 -111001011101 -101111110101 -001101110011 -110111101110 -110100001010 -000111101001 -011111001010 -110110000000 -100110010111 -000101001111 -011001010011 -000000110001 -110110101000 -101001010000 -000010010010 -000011001111 -011010100110 -010101011011 -100100111011 -011110010110 -100001010001 -111010111101 -110100011011 -011101010001 -110011111011 -101100110101 -100001001101 -011111111111 -111111100100 -111100111101 -111011010110 -100101101100 -001011111101 -100101110111 -001100100010 -001011100010 -101010100111 -010111110011 -011111011011 -100011110100 -011011001111 -000101101111 -010011010111 -011001111101 -101101101101 -000010100101 -110101100110 -100101001000 -111110101000 -100101101011 -010101101101 -010001101000 -010111100110 -010111010100 -101110010000 -010010011100 -011001110000 -111010110001 -100000000000 -101111101100 -000100011100 -011010100011 -101111010010 -010000111010 -100100100000 -000111101100 -001000010110 -010011011000 -001101000010 -001000001110 -011011011000 -111110000000 -010100101010 -111111101100 -001101001110 -011001001101 -100100110100 -000010011001 -010000111110 -101111110100 -001100101100 -011111010111 -100010010010 -011001010001 -111011001000 -011011010100 -000101011101 -010001110000 -001000011000 -100111010111 -000001010101 -010100111010 -001000000010 -001100011011 -101110001011 -010000001110 -001011011101 -000100100001 -001010010001 -110100101001 -000011110101 -010110111011 -011010101100 -101110011110 -100001001010 -111100101111 -011010001101 -001111111000 -000011000111 -001100010011 -101001111101 -111000011000 -110111110011 -110110100011 -011110001010 -001111011110 -000101000001 -101101011110 -110000111101 -101011100011 -111011111100 -010011111010 -010101011000 -111110111101 -111011000110 -111011010000 -110001111110 -011110101101 -010010010000 -011011100011 -001100111110 -100101010100 -010010100001 -111100011010 -000010110011 -100000011100 -011111111010 -111111111010 -000110000011 -011001111100 -100100010001 -110111001011 -100101010010 -010110100110 -111011100000 -100100100010 -110111000010 -100001011010 -000110010010 -010000011111 -010001110100 -011001010111 -110111100100 -001011100100 -110001111011 -011011001000 -101110010101 -101001010101 -111100000000 -100110010010 -110010111100 -101110111100 -111001100110 -100111101100 -111011111010 -111000100011 -001001100011 -011110111000 -000111101010 -011011110001 -011111101100 -110111001010 -101111111010 -001010010011 -100101111110 -011011100010 -100111101101 -000010110111 -101010000011 -001100111001 -001101011001 -110010011000 -101100101100 -111000000111 -111110011111 -101010110010 -010011001110 -111101001001 -001011001001 -100111011111 -110100001111 -001111001100 -110101100001 -011001100000 -001100101000 -111111111111 -100110000000 -000100000011 -110001001111 -101000111110 -101111100101 -101000110100 -110100111000 -100010011000 -110011100010 -101010110100 -110000100010 -010100000000 -111011111011 -001110000111 -000110110010 -010010001000 -110110011110 -001111111101 -100100001111 -100110110100 -011110000111 -111101010011 -011000100000 -001011010010 -011001111111 -110010011101 -000001000110 -101011010001 -101101011111 -011101001111 -011010000011 -011010001010 -000010011101 -010010110011 -111100111010 -111011010101 -111110101010 -010000100011 -011000100101 -010010110000 -010100110001 -111110110000 -100010001000 -000011100011 -100000111101 -111001010101 -100000100001 -001011111000 -111100000001 -110001111010 diff --git a/2021/04/input.in b/2021/04/input.in deleted file mode 100644 index 5c0109d..0000000 --- a/2021/04/input.in +++ /dev/null @@ -1,601 +0,0 @@ -23,91,18,32,73,14,20,4,10,55,40,29,13,25,48,65,2,80,22,16,93,85,66,21,9,36,47,72,88,58,5,42,53,69,52,8,54,63,76,12,6,99,35,95,82,49,41,17,62,34,51,77,94,7,28,71,92,74,46,79,26,19,97,86,87,37,57,64,1,30,11,96,70,44,83,0,56,90,59,78,61,98,89,43,3,84,67,38,68,27,81,39,15,50,60,24,45,75,33,31 - -67 97 50 51 1 -47 15 77 31 66 -24 14 55 70 52 -76 46 19 32 73 -34 22 54 75 17 - -44 11 97 50 71 -66 7 24 9 67 -88 39 82 93 57 -77 5 6 58 51 -85 61 65 70 23 - -72 74 58 71 41 - 4 57 45 89 67 -78 55 66 28 48 -82 61 87 85 84 -96 8 94 76 97 - -25 33 45 16 68 -60 27 22 13 29 -92 95 93 50 36 -43 1 66 51 99 -85 14 20 52 58 - -65 47 18 50 90 -44 25 11 70 81 -86 36 45 10 85 -43 89 74 0 14 -97 59 32 91 5 - -64 19 39 69 90 -41 5 59 37 42 -75 95 58 89 92 -20 3 85 48 71 -31 94 11 18 70 - -30 17 56 54 79 -63 12 51 57 5 -95 16 98 75 69 -80 87 71 39 48 -66 14 99 42 31 - -27 35 46 69 50 - 3 16 84 39 42 -19 22 34 80 72 -40 54 66 30 10 -12 67 36 9 74 - -39 47 61 3 35 -15 33 45 79 58 -96 53 20 80 19 -75 85 73 6 64 -43 88 72 69 37 - -52 68 12 23 59 -79 32 37 87 69 -48 31 4 36 51 -77 2 92 67 8 -13 88 93 98 20 - -12 54 34 13 27 -79 85 62 76 71 -52 84 65 93 66 -40 89 73 95 74 -29 70 32 11 41 - -54 56 53 55 78 -21 85 43 75 79 -62 66 14 84 2 -32 13 83 38 7 -15 71 81 63 49 - -83 7 51 49 50 -89 59 9 72 80 -99 41 65 13 64 -74 95 75 54 90 -53 79 58 40 5 - -36 16 46 71 87 -73 13 84 3 38 -69 88 85 28 68 -63 94 0 86 1 -49 44 65 39 15 - -55 27 91 44 39 - 6 75 14 22 99 -38 89 92 42 11 -20 60 3 70 15 - 5 19 78 88 81 - -16 90 29 52 86 -60 61 96 47 91 -19 59 10 14 4 -18 35 50 20 25 -56 2 99 63 72 - -66 54 87 7 98 -55 45 62 38 99 -13 23 76 30 3 -75 68 5 51 46 - 0 60 71 70 41 - -22 77 65 72 27 -88 9 25 44 0 -61 6 46 41 26 -74 78 20 86 87 -70 81 4 5 48 - -41 51 8 64 50 -96 40 45 85 53 -18 86 24 29 27 -90 11 39 82 88 -12 56 54 87 59 - -90 79 64 77 78 -97 12 72 27 86 -32 56 33 18 46 -95 5 51 6 80 -34 38 42 35 52 - -66 10 82 90 19 -38 69 71 77 72 -61 9 98 86 93 -56 7 88 28 47 -22 96 21 52 64 - -91 82 25 93 69 -95 79 84 35 90 -48 0 28 41 83 -23 55 88 71 65 -97 19 67 31 59 - -47 60 65 11 85 -97 36 64 96 70 -82 84 76 89 44 -67 26 28 21 41 -63 54 94 10 34 - -24 19 78 4 69 -52 38 7 58 21 -20 23 10 91 42 -44 36 25 45 49 -94 51 98 99 27 - -67 25 54 28 71 - 9 14 89 91 46 -65 1 55 88 19 -59 45 26 84 73 -83 62 50 42 97 - -58 51 29 60 94 -34 79 39 19 91 - 9 81 93 35 70 - 4 23 80 33 75 -73 69 7 49 59 - -44 83 20 24 56 -41 50 77 55 10 -79 49 67 99 16 -36 57 33 15 98 -40 76 4 53 39 - -59 92 67 6 80 -64 90 15 40 7 -36 96 62 25 32 -44 91 52 43 19 - 5 2 51 88 87 - - 4 97 70 78 59 -90 43 62 50 41 -61 64 2 91 49 -19 82 85 30 73 -15 51 36 11 34 - -97 7 86 64 40 -15 46 84 0 58 -54 87 73 93 20 -48 94 32 4 77 -13 85 72 50 36 - -68 54 94 71 83 -81 53 33 12 58 -22 67 52 21 25 -79 90 59 92 41 -29 11 76 98 85 - -10 25 64 3 83 -21 87 97 78 7 -44 71 48 22 74 -80 72 90 29 63 - 1 24 32 84 13 - -25 28 19 65 24 -98 32 4 6 99 - 7 0 27 37 35 -72 11 1 76 73 -49 85 83 93 14 - -78 91 50 45 29 -35 27 18 48 87 - 3 56 60 99 64 -84 61 15 77 40 -58 39 19 0 92 - -98 38 88 43 39 -48 93 4 52 66 -57 99 83 55 25 -91 35 42 12 23 -40 15 81 94 77 - -85 28 95 76 78 -39 66 18 47 49 -32 77 34 12 58 -69 15 45 6 41 - 3 51 25 40 63 - -58 97 10 5 57 -47 86 24 78 98 -89 25 39 73 83 -11 15 99 68 66 -84 70 61 76 30 - -67 40 29 75 90 -71 31 41 37 52 -61 0 86 84 94 -25 96 9 21 6 -39 62 14 1 81 - -15 65 47 63 94 -82 21 32 38 67 -12 20 30 91 68 -16 79 4 28 45 - 1 70 84 49 78 - -80 21 39 92 71 -48 8 87 0 38 -74 4 52 23 98 -53 89 61 30 46 -29 10 64 49 5 - -40 2 62 39 51 - 4 24 19 73 75 -86 14 97 91 11 -43 7 77 71 28 -32 63 6 20 8 - -90 57 28 47 23 -10 41 77 52 31 -45 18 55 80 49 -76 50 16 96 81 -91 75 93 68 58 - -63 87 12 16 60 -36 52 94 39 91 -67 56 24 18 26 -73 80 46 1 84 -30 74 6 61 75 - -98 32 56 51 44 -58 78 71 74 26 -55 45 83 10 30 -54 47 93 62 23 -15 67 53 21 49 - -59 93 49 65 42 - 9 74 58 52 18 - 1 47 71 25 68 -45 92 67 60 73 -97 63 61 34 36 - -73 74 6 68 40 -76 85 1 26 91 -90 94 39 92 17 -80 51 20 77 67 -54 88 21 57 83 - -14 52 70 30 32 -60 69 75 10 24 -65 40 72 71 58 -80 73 84 96 4 -62 9 28 41 36 - -56 2 83 9 50 -75 42 5 3 72 -73 28 34 76 38 -49 33 30 80 46 -37 77 55 45 74 - -40 69 31 88 8 -58 27 78 26 95 -73 86 1 34 79 -12 83 2 75 92 - 0 48 63 17 65 - - 3 87 59 76 24 -90 10 44 28 21 -83 19 77 86 51 -81 88 42 94 15 -27 78 92 34 30 - -44 23 83 22 87 -75 53 91 93 89 -88 40 56 46 37 - 0 4 80 24 7 -97 72 96 12 68 - -40 45 61 84 31 -85 12 27 82 50 - 4 49 33 6 44 -51 36 15 0 14 -68 77 64 11 79 - -31 79 50 63 59 -13 4 6 54 7 -86 30 41 68 34 -16 35 48 11 70 -84 8 81 65 74 - -75 33 21 60 57 - 7 86 82 18 68 -40 91 0 28 38 -90 36 92 94 55 -95 88 85 62 25 - - 7 5 75 36 74 -40 37 58 92 93 -46 68 24 98 34 -32 88 67 62 53 -83 84 90 31 63 - -17 24 25 93 37 -16 36 59 81 41 -99 51 12 77 98 -80 32 28 18 39 -44 85 38 64 73 - -83 18 86 33 61 -21 88 94 62 67 -40 25 97 27 73 -71 90 63 87 6 -16 7 36 92 69 - -69 67 35 24 84 -79 44 66 37 75 - 0 73 53 80 15 -74 20 32 12 60 -36 22 29 85 82 - -49 72 69 33 10 -45 81 43 0 22 -12 76 5 29 52 -82 40 42 63 85 - 1 34 32 66 15 - -82 41 16 67 23 -30 84 25 88 48 -75 71 43 0 2 -35 3 68 26 50 -64 24 8 89 98 - -61 23 63 51 46 -21 59 99 97 91 -60 34 42 26 31 -12 64 38 96 24 - 5 13 90 37 94 - -97 0 20 61 96 -92 39 43 57 64 -87 52 16 85 45 -60 41 86 6 53 -75 10 24 21 37 - -37 92 1 46 51 -33 5 88 47 19 - 0 35 2 69 72 -67 56 49 20 63 -25 7 41 65 91 - -17 69 67 77 23 -16 79 81 51 57 -12 59 49 76 91 - 1 55 41 87 38 -85 98 37 71 5 - -90 11 18 59 31 -61 1 28 2 27 -98 56 95 63 93 -24 83 36 85 72 -64 97 69 20 10 - -80 58 95 5 74 - 6 20 13 59 63 - 8 62 55 53 41 -48 70 28 10 47 -18 4 76 45 34 - -39 30 64 24 14 -42 6 0 33 57 -35 7 68 62 32 -70 65 44 82 31 -98 93 50 53 61 - -14 9 98 70 45 -27 86 6 21 76 -56 19 26 28 43 -78 87 58 89 97 -72 49 54 67 8 - -21 22 51 62 59 -38 64 30 40 94 -56 57 28 19 17 -50 32 83 97 48 -41 54 75 66 5 - - 4 21 16 91 75 -17 87 68 38 66 -92 11 39 31 45 -58 41 96 85 98 -99 44 86 15 26 - -76 61 82 96 49 -98 10 93 22 56 -66 78 21 73 67 - 3 39 15 85 87 -48 91 45 70 53 - -17 6 8 46 30 -81 53 76 21 63 -20 47 75 67 59 -69 58 5 62 92 - 7 9 93 43 70 - -17 50 24 71 28 -30 31 37 48 80 -34 62 19 57 41 -88 49 51 93 98 -87 78 55 94 46 - -93 87 54 64 29 -81 66 35 43 25 -74 86 95 2 92 -42 94 45 51 17 -23 28 16 37 80 - -68 15 25 10 32 -60 51 45 38 4 -64 47 50 12 14 -86 61 31 67 2 -18 28 55 59 87 - -95 84 19 48 0 -12 22 97 6 89 -93 70 71 35 88 -49 18 37 58 36 -43 63 23 68 17 - -29 15 91 37 45 - 3 98 33 73 39 -31 13 94 90 96 -81 87 78 93 42 -69 75 14 2 27 - -80 30 69 34 1 -59 23 20 85 31 -48 71 16 96 92 -66 99 39 53 52 -91 67 70 77 19 - -90 16 52 74 2 -41 39 95 59 1 -46 84 64 93 14 -92 48 25 28 98 -94 81 20 27 32 - -22 89 48 77 37 -54 59 30 71 38 -80 53 3 27 32 -25 23 35 79 91 -15 29 7 93 9 - -60 38 37 5 96 -51 77 28 63 80 -45 67 87 20 34 -56 26 61 85 82 -19 71 27 41 54 - -27 71 18 16 40 -88 3 61 74 52 -80 44 34 10 36 -15 2 1 4 11 -84 50 72 39 89 - -42 74 45 1 35 - 0 63 38 12 85 -18 2 13 87 30 -44 67 68 41 70 -47 82 98 48 69 - -34 78 38 27 9 -91 47 69 51 73 -67 59 45 15 21 -30 24 89 5 2 -36 22 87 68 76 - -18 68 58 95 29 -72 24 70 47 79 -35 63 20 71 93 -60 59 34 49 81 -22 98 57 53 76 - -46 40 82 45 0 - 2 22 28 38 97 -11 16 78 95 86 -80 85 83 17 67 -63 1 26 25 64 - -49 81 31 9 60 -33 15 29 38 66 -90 43 2 39 89 -24 40 63 36 91 -45 68 62 87 12 - -36 54 76 33 9 -60 7 25 96 61 -17 4 1 62 31 -93 83 79 30 73 -88 75 13 6 24 - -47 96 5 82 34 -76 67 30 15 2 -52 43 16 92 77 -58 13 18 78 84 -39 41 74 46 91 - -15 45 99 42 5 -41 61 58 14 55 -24 76 46 91 78 -52 56 81 92 59 - 4 0 63 95 29 - -75 53 8 76 33 -82 60 7 32 97 -90 40 56 51 1 -15 48 4 41 71 -13 69 46 65 52 - -77 93 27 42 20 - 0 68 31 51 52 - 3 83 56 4 38 -54 65 86 72 16 -35 34 2 99 64 - - 0 47 54 49 73 -11 61 18 69 16 -75 90 3 65 93 -22 57 84 96 8 -92 4 5 2 35 - -91 23 41 85 88 -68 28 9 70 74 -51 71 42 79 7 -61 77 57 82 18 -16 4 32 80 38 - -99 87 92 63 24 -51 64 22 9 94 -48 5 7 83 19 -11 27 46 2 17 -33 60 36 30 32 - -91 20 80 10 81 -55 78 8 67 7 -37 76 31 16 49 -30 33 63 68 28 -50 35 40 74 77 - -27 39 23 34 94 -51 18 60 8 98 -28 75 4 85 12 -96 2 15 29 88 -46 35 32 79 50 - -91 62 4 40 11 -92 47 56 5 3 -85 75 55 8 12 -25 48 13 31 21 -46 54 95 26 80 - - 5 54 87 34 3 -96 12 67 6 14 - 1 43 92 35 49 -31 72 65 85 2 -75 81 26 28 4 - -81 38 3 64 71 -69 53 19 1 67 -17 63 73 10 85 -37 15 91 20 62 - 0 35 47 8 43 diff --git a/2021/05/input.in b/2021/05/input.in deleted file mode 100644 index d7b445a..0000000 --- a/2021/05/input.in +++ /dev/null @@ -1,500 +0,0 @@ -593,10 -> 593,98 -777,236 -> 964,236 -650,575 -> 476,575 -120,612 -> 715,17 -508,707 -> 508,89 -98,834 -> 751,834 -623,554 -> 623,701 -929,976 -> 62,109 -368,893 -> 330,931 -495,335 -> 40,335 -44,704 -> 423,704 -683,711 -> 683,487 -26,940 -> 833,133 -961,183 -> 454,183 -301,306 -> 301,935 -973,822 -> 398,822 -639,911 -> 515,911 -861,180 -> 184,857 -31,97 -> 857,923 -966,376 -> 966,114 -881,485 -> 881,377 -930,98 -> 110,918 -841,889 -> 841,35 -512,261 -> 880,261 -48,533 -> 48,674 -207,226 -> 52,226 -823,952 -> 177,306 -331,566 -> 423,566 -422,418 -> 422,130 -699,517 -> 699,567 -757,784 -> 241,784 -508,445 -> 560,393 -866,275 -> 435,706 -74,41 -> 74,258 -386,369 -> 334,317 -240,94 -> 240,969 -851,197 -> 577,197 -28,906 -> 741,193 -286,227 -> 286,293 -849,800 -> 849,665 -736,307 -> 336,307 -69,701 -> 494,276 -421,823 -> 96,823 -121,626 -> 121,393 -318,351 -> 194,351 -670,671 -> 439,671 -603,914 -> 603,272 -61,507 -> 61,889 -266,39 -> 157,39 -543,664 -> 869,664 -382,709 -> 884,709 -499,80 -> 548,80 -489,79 -> 878,79 -695,86 -> 644,86 -987,585 -> 987,557 -287,67 -> 551,67 -975,983 -> 35,43 -707,351 -> 232,351 -529,175 -> 852,175 -32,811 -> 604,811 -106,153 -> 815,153 -195,268 -> 509,582 -50,922 -> 312,922 -220,500 -> 872,500 -473,33 -> 569,33 -858,847 -> 162,151 -937,947 -> 26,36 -726,435 -> 402,435 -686,601 -> 474,813 -764,880 -> 84,200 -850,950 -> 850,464 -413,620 -> 413,285 -893,560 -> 229,560 -149,100 -> 149,901 -358,613 -> 243,613 -202,445 -> 202,411 -127,153 -> 513,539 -147,846 -> 53,940 -139,920 -> 679,380 -913,953 -> 913,735 -339,466 -> 339,177 -113,882 -> 647,882 -18,880 -> 134,880 -897,152 -> 897,428 -473,511 -> 636,511 -880,370 -> 358,370 -400,244 -> 721,244 -419,987 -> 120,688 -872,224 -> 481,224 -335,302 -> 730,302 -961,324 -> 961,157 -769,301 -> 959,301 -829,124 -> 144,124 -523,372 -> 985,372 -520,33 -> 520,685 -554,644 -> 808,898 -82,676 -> 870,676 -303,612 -> 303,705 -338,40 -> 338,939 -836,47 -> 72,811 -371,751 -> 575,955 -929,505 -> 929,324 -273,181 -> 275,183 -347,595 -> 347,463 -95,629 -> 95,606 -809,188 -> 126,871 -857,924 -> 145,212 -668,277 -> 668,63 -700,904 -> 700,45 -814,899 -> 22,899 -205,98 -> 714,607 -943,28 -> 40,931 -282,620 -> 773,129 -424,803 -> 285,803 -688,329 -> 299,329 -146,628 -> 34,628 -573,417 -> 164,826 -292,232 -> 412,112 -412,508 -> 145,508 -632,648 -> 632,92 -885,904 -> 885,513 -295,981 -> 132,818 -134,681 -> 41,681 -810,531 -> 959,531 -188,590 -> 188,215 -960,795 -> 189,24 -729,211 -> 729,833 -214,817 -> 845,817 -196,609 -> 584,609 -384,908 -> 384,101 -770,907 -> 770,530 -451,469 -> 451,812 -571,261 -> 834,261 -799,436 -> 799,983 -248,105 -> 248,879 -783,906 -> 783,903 -955,670 -> 790,670 -723,750 -> 723,429 -572,427 -> 546,427 -610,341 -> 527,341 -925,426 -> 816,317 -151,403 -> 151,684 -408,969 -> 408,369 -276,425 -> 276,75 -186,86 -> 186,758 -412,420 -> 412,531 -361,60 -> 976,60 -787,649 -> 667,769 -45,866 -> 91,866 -319,963 -> 51,963 -112,866 -> 112,747 -291,475 -> 504,475 -175,116 -> 357,116 -968,961 -> 968,213 -13,12 -> 987,986 -640,728 -> 767,728 -981,505 -> 246,505 -864,981 -> 128,981 -91,66 -> 931,906 -798,116 -> 91,823 -552,74 -> 88,538 -620,872 -> 232,872 -45,229 -> 658,229 -413,75 -> 413,436 -815,257 -> 815,686 -989,22 -> 36,975 -178,904 -> 233,849 -635,128 -> 635,96 -640,820 -> 640,313 -890,787 -> 167,64 -221,22 -> 826,22 -914,132 -> 60,986 -848,31 -> 392,487 -105,969 -> 858,969 -903,868 -> 143,108 -38,941 -> 621,358 -171,340 -> 14,497 -286,460 -> 81,255 -726,688 -> 857,819 -494,689 -> 510,689 -517,913 -> 598,913 -932,66 -> 932,431 -977,982 -> 18,23 -95,101 -> 95,278 -574,467 -> 349,467 -63,803 -> 63,882 -838,874 -> 255,874 -900,752 -> 181,33 -102,897 -> 989,10 -374,439 -> 374,277 -513,504 -> 513,885 -814,932 -> 814,407 -824,656 -> 959,521 -415,570 -> 616,570 -577,880 -> 577,181 -287,524 -> 986,524 -955,665 -> 323,665 -556,365 -> 263,658 -154,226 -> 886,226 -803,750 -> 866,750 -558,725 -> 558,395 -941,115 -> 941,150 -180,410 -> 180,874 -458,753 -> 112,753 -199,253 -> 363,253 -423,650 -> 22,650 -892,851 -> 279,238 -611,109 -> 611,198 -983,344 -> 339,988 -299,47 -> 299,934 -435,652 -> 700,387 -186,775 -> 677,284 -136,576 -> 136,368 -818,744 -> 305,744 -767,171 -> 767,431 -930,842 -> 259,171 -342,831 -> 342,601 -193,672 -> 46,525 -925,164 -> 528,164 -725,92 -> 617,200 -67,729 -> 67,739 -547,153 -> 547,245 -763,434 -> 763,509 -314,888 -> 357,888 -72,645 -> 491,645 -92,67 -> 240,67 -827,936 -> 788,897 -852,378 -> 77,378 -448,337 -> 668,337 -846,739 -> 499,739 -465,691 -> 315,541 -716,163 -> 18,861 -78,965 -> 983,60 -114,952 -> 820,246 -950,351 -> 419,882 -266,36 -> 266,482 -773,841 -> 773,66 -742,198 -> 742,46 -417,512 -> 304,625 -900,277 -> 900,338 -983,431 -> 473,941 -986,282 -> 734,30 -742,19 -> 769,19 -952,320 -> 948,324 -92,590 -> 548,590 -107,39 -> 107,696 -603,749 -> 603,26 -55,282 -> 888,282 -670,848 -> 985,533 -981,982 -> 92,93 -147,428 -> 649,930 -773,737 -> 821,785 -791,576 -> 791,852 -327,672 -> 530,469 -847,122 -> 381,122 -419,493 -> 498,572 -879,842 -> 879,239 -267,717 -> 267,869 -142,449 -> 174,417 -342,718 -> 342,397 -603,207 -> 314,207 -612,648 -> 735,771 -37,10 -> 971,944 -891,716 -> 891,86 -252,217 -> 662,627 -185,165 -> 941,921 -854,717 -> 676,717 -158,791 -> 336,791 -762,226 -> 98,890 -73,189 -> 92,189 -649,511 -> 253,115 -719,456 -> 514,251 -605,286 -> 325,286 -454,609 -> 454,489 -374,541 -> 783,541 -599,177 -> 94,682 -600,384 -> 32,384 -810,933 -> 39,162 -780,871 -> 409,871 -24,639 -> 24,316 -454,80 -> 454,95 -556,541 -> 907,541 -627,295 -> 750,295 -245,71 -> 214,102 -725,445 -> 614,445 -779,538 -> 779,390 -746,667 -> 351,272 -117,776 -> 117,660 -498,495 -> 88,905 -697,721 -> 697,919 -580,314 -> 580,166 -22,656 -> 641,37 -413,433 -> 44,802 -182,305 -> 805,928 -739,277 -> 739,499 -172,210 -> 172,259 -894,576 -> 894,322 -265,263 -> 265,437 -430,228 -> 780,578 -464,531 -> 798,531 -713,63 -> 668,63 -918,831 -> 256,169 -414,375 -> 467,375 -440,32 -> 391,32 -439,806 -> 955,806 -335,820 -> 335,279 -727,458 -> 422,458 -312,274 -> 619,581 -136,724 -> 538,322 -589,680 -> 589,850 -335,648 -> 232,545 -499,216 -> 405,216 -942,710 -> 942,455 -969,556 -> 721,556 -756,552 -> 756,902 -98,870 -> 445,870 -476,833 -> 476,269 -820,127 -> 407,127 -337,519 -> 714,519 -756,95 -> 11,840 -317,339 -> 317,286 -353,86 -> 43,86 -93,950 -> 938,105 -705,509 -> 705,319 -244,879 -> 721,402 -434,794 -> 711,517 -272,381 -> 431,381 -652,104 -> 652,587 -850,866 -> 34,50 -645,902 -> 79,336 -701,39 -> 701,295 -492,793 -> 95,396 -352,554 -> 395,554 -123,405 -> 322,206 -941,745 -> 716,520 -450,512 -> 569,631 -42,25 -> 817,800 -909,387 -> 909,863 -919,934 -> 919,546 -439,881 -> 569,881 -167,866 -> 167,669 -242,264 -> 242,694 -981,786 -> 228,33 -452,434 -> 452,660 -22,26 -> 22,29 -26,155 -> 677,806 -801,627 -> 313,627 -657,135 -> 657,270 -872,875 -> 440,443 -636,248 -> 636,338 -776,51 -> 93,51 -498,600 -> 894,600 -263,984 -> 263,807 -416,390 -> 899,873 -269,137 -> 976,137 -752,12 -> 752,617 -55,925 -> 548,925 -856,551 -> 771,551 -653,93 -> 653,587 -403,286 -> 403,417 -895,706 -> 221,32 -139,822 -> 139,928 -696,194 -> 696,143 -270,678 -> 710,678 -879,353 -> 879,360 -949,712 -> 752,712 -665,661 -> 817,661 -462,952 -> 980,434 -692,766 -> 692,478 -157,117 -> 144,117 -438,701 -> 408,701 -401,703 -> 401,724 -876,831 -> 108,63 -749,892 -> 832,892 -455,124 -> 455,776 -551,222 -> 551,372 -533,80 -> 726,80 -342,740 -> 56,740 -793,370 -> 34,370 -949,614 -> 949,623 -610,287 -> 610,760 -978,834 -> 85,834 -644,894 -> 644,341 -35,887 -> 176,887 -168,958 -> 964,162 -341,886 -> 341,470 -417,845 -> 417,702 -338,347 -> 304,313 -651,10 -> 72,10 -853,160 -> 853,85 -381,568 -> 436,623 -794,437 -> 250,437 -861,72 -> 206,72 -807,813 -> 807,827 -820,502 -> 820,329 -547,508 -> 547,773 -160,129 -> 160,175 -756,468 -> 756,80 -442,661 -> 405,661 -304,817 -> 304,765 -99,42 -> 957,900 -212,110 -> 854,752 -44,620 -> 661,620 -212,311 -> 784,883 -329,671 -> 329,908 -86,359 -> 553,826 -257,799 -> 934,122 -409,663 -> 409,367 -528,623 -> 593,688 -957,525 -> 544,938 -846,766 -> 113,33 -176,680 -> 176,102 -167,287 -> 167,929 -932,870 -> 834,968 -86,774 -> 49,774 -745,231 -> 70,906 -435,760 -> 138,463 -776,810 -> 625,810 -928,930 -> 76,78 -602,24 -> 602,688 -394,424 -> 65,424 -946,966 -> 93,113 -494,39 -> 951,39 -607,699 -> 832,699 -13,403 -> 391,403 -726,475 -> 726,29 -828,625 -> 836,617 -396,770 -> 167,770 -28,546 -> 374,200 -56,113 -> 837,894 -290,589 -> 740,139 -930,805 -> 296,171 -646,895 -> 49,895 -111,15 -> 111,497 -11,274 -> 570,833 -257,624 -> 603,624 -63,844 -> 666,844 -846,661 -> 846,464 -431,72 -> 431,674 -726,674 -> 726,40 -286,660 -> 286,909 -847,222 -> 847,861 -325,896 -> 325,416 -793,953 -> 365,953 -987,956 -> 62,31 -845,853 -> 363,371 -79,782 -> 506,782 -424,21 -> 424,369 -938,162 -> 177,923 -86,193 -> 799,906 -320,164 -> 320,654 -840,306 -> 840,711 -852,736 -> 852,690 -876,966 -> 143,233 -787,926 -> 38,177 -374,112 -> 340,112 -132,541 -> 740,541 -29,28 -> 968,967 -916,212 -> 170,958 -371,553 -> 521,403 -88,796 -> 870,796 -656,367 -> 71,367 -785,166 -> 785,427 -320,30 -> 320,549 -909,527 -> 816,620 -832,965 -> 302,965 -672,259 -> 80,259 -578,513 -> 578,243 -975,561 -> 537,123 -135,330 -> 188,330 -501,695 -> 501,573 -717,230 -> 878,230 -854,501 -> 27,501 -705,885 -> 950,885 -704,338 -> 704,630 -477,485 -> 864,485 -901,42 -> 305,638 -660,540 -> 660,546 -555,79 -> 190,79 -226,126 -> 800,700 -575,908 -> 944,908 -94,478 -> 94,746 -461,425 -> 929,893 -861,429 -> 451,19 -832,825 -> 179,172 -186,133 -> 298,133 -684,270 -> 558,270 -786,872 -> 125,872 -649,178 -> 649,595 -893,738 -> 412,257 -760,854 -> 901,713 -16,914 -> 866,64 -935,928 -> 266,259 -323,229 -> 32,229 -608,828 -> 608,49 -715,892 -> 74,251 -787,187 -> 787,903 -405,793 -> 405,183 -232,704 -> 232,389 -130,706 -> 130,657 diff --git a/2021/06/input.in b/2021/06/input.in deleted file mode 100644 index 403b184..0000000 --- a/2021/06/input.in +++ /dev/null @@ -1 +0,0 @@ -3,4,1,1,5,1,3,1,1,3,5,1,1,5,3,2,4,2,2,2,1,1,1,1,5,1,1,1,1,1,3,1,1,5,4,1,1,1,4,1,1,1,1,2,3,2,5,1,5,1,2,1,1,1,4,1,1,1,1,3,1,1,3,1,1,1,1,1,1,2,3,4,2,1,3,1,1,2,1,1,2,1,5,2,1,1,1,1,1,1,4,1,1,1,1,5,1,4,1,1,1,3,3,1,3,1,3,1,4,1,1,1,1,1,4,5,1,1,3,2,2,5,5,4,3,1,2,1,1,1,4,1,3,4,1,1,1,1,2,1,1,3,2,1,1,1,1,1,4,1,1,1,4,4,5,2,1,1,1,1,1,2,4,2,1,1,1,2,1,1,2,1,5,1,5,2,5,5,1,1,3,1,4,1,1,1,1,1,1,1,4,1,1,4,1,1,1,1,1,2,1,2,1,1,1,5,1,1,3,5,1,1,5,5,3,5,3,4,1,1,1,3,1,1,3,1,1,1,1,1,1,5,1,3,1,5,1,1,4,1,3,1,1,1,2,1,1,1,2,1,5,1,1,1,1,4,1,3,2,3,4,1,3,5,3,4,1,4,4,4,1,3,2,4,1,4,1,1,2,1,3,1,5,5,1,5,1,1,1,5,2,1,2,3,1,4,3,3,4,3 diff --git a/2021/07/input.in b/2021/07/input.in deleted file mode 100644 index 84d7622..0000000 --- a/2021/07/input.in +++ /dev/null @@ -1 +0,0 @@ -1101,1,29,67,1102,0,1,65,1008,65,35,66,1005,66,28,1,67,65,20,4,0,1001,65,1,65,1106,0,8,99,35,67,101,99,105,32,110,39,101,115,116,32,112,97,115,32,117,110,101,32,105,110,116,99,111,100,101,32,112,114,111,103,114,97,109,10,1304,510,261,432,1,767,525,1663,1598,125,84,924,216,1049,365,4,21,226,131,178,666,1134,58,839,1065,670,419,11,297,28,80,258,811,659,1288,21,17,436,1184,823,667,7,499,249,406,157,112,715,220,93,710,148,152,1192,15,493,1551,473,760,503,177,124,123,236,848,221,658,771,347,23,264,739,1583,747,17,336,998,159,679,119,2,160,412,873,1480,337,92,369,136,3,188,683,496,214,131,330,493,649,136,503,249,342,240,728,494,150,25,146,95,1328,401,580,743,385,85,1011,466,36,228,1394,77,1009,46,751,782,1501,464,1046,4,317,1566,1661,822,107,487,208,727,53,55,355,370,1319,16,18,965,1582,190,38,386,169,766,111,262,229,248,318,368,70,18,302,87,218,404,265,2,109,62,557,714,1174,429,1082,786,37,470,195,408,598,935,1224,11,83,318,475,354,342,699,209,372,942,801,30,1065,4,110,969,449,266,50,314,771,890,314,394,316,211,1238,84,574,120,698,1382,1039,670,121,281,241,491,742,802,194,41,573,473,824,1283,59,371,1167,32,1645,115,58,845,11,408,1284,414,1618,240,364,991,111,517,146,256,616,968,130,98,414,13,152,332,96,816,366,214,69,1072,1225,98,122,554,236,14,499,89,793,119,945,511,476,112,1201,501,9,23,517,277,283,1600,581,290,248,472,38,144,178,645,477,1016,139,123,4,671,370,1025,290,20,1680,856,212,44,93,656,1163,384,852,461,1248,79,341,1125,812,746,511,1461,420,1070,22,126,274,1698,526,949,20,865,66,1244,157,275,670,384,1142,696,43,74,344,893,237,327,135,272,690,1032,395,1,16,521,1573,304,512,466,243,171,913,323,325,82,16,462,457,1609,24,98,22,528,158,79,1012,60,146,58,504,503,1,42,78,164,3,439,653,217,251,94,584,333,435,254,170,1213,671,548,799,332,434,487,61,710,136,551,556,722,316,365,1403,115,104,597,137,881,577,1334,41,649,177,196,434,191,101,248,14,71,1053,44,1074,51,607,65,161,922,235,132,247,1412,500,1409,15,86,72,327,878,507,1379,454,109,1250,184,19,284,1057,353,476,807,577,305,466,40,136,16,883,516,253,150,125,49,102,404,1606,518,94,1042,204,443,444,22,1197,168,766,1466,1053,695,565,77,406,694,102,84,414,686,800,157,7,516,440,139,1538,144,1327,851,1526,69,315,1078,678,247,1579,100,254,947,758,603,44,535,1242,1117,1119,645,203,97,88,437,886,408,566,351,36,0,461,1098,415,1381,1217,1763,202,1106,466,30,237,757,313,390,38,344,1254,1275,343,278,1064,1116,70,279,276,214,1153,306,67,488,683,432,53,128,91,1082,403,117,1169,568,60,578,475,657,43,509,434,128,1115,872,333,73,954,789,590,185,1305,352,574,266,1634,731,156,562,247,356,743,689,298,637,1125,590,761,123,1508,33,0,558,146,888,236,668,53,94,619,591,422,44,1114,1284,806,39,816,47,59,76,1090,1102,7,1307,676,1161,473,376,175,224,431,284,875,86,28,99,700,459,204,673,1001,31,302,291,386,259,4,181,1048,274,1661,347,614,760,187,1118,196,1076,219,1194,226,909,189,208,265,601,503,693,213,16,63,25,108,133,979,56,195,250,294,920,231,435,1004,352,469,55,1374,605,72,714,534,504,1411,128,724,1216,7,317,948,285,668,320,97,316,298,145,605,40,486,324,399,336,612,386,328,631,44,366,103,109,219,530,39,654,341,132,1090,50,15,654,801,791,169,746,1512,660,383,67,762,46,236,184,51,1051,1161,347,673,554,523,3,463,31,132,258,413,18,293,986,699,608,289,175,70,217,136,857,473,585,14,636,189,119,128,129,358,560,580,425,236,1194,1182,213,79,36,162,200,179,170,892,1398,336,1073,76,798,231,58,216,1134,175,392,688,342,28,300,672,1160,501,44,79,357,1411,856,27,471,600,303,35,546,1466,74,359,234,1200,657,224,431,802,0,584,784,1245,15,776,28,1464,191,275,639,569,179,908,173,1041,630,907,1520,248,1,34,596,53,44,9,782,777,295,818,1295,1115,468,34,530,349,271,99,344,923,733,124,170,208,20,744,530,582,35,58,938,721,253,934,326,528,722,123,0,623,382,889,929,454,457,1024,43,293,521,548,291,654,506,307,1031,1,390,321,727,937,1000,57,52,136,69,920,19,269,950,578,119,207,14,244,274,171,971,548,335,748,553,196,531 diff --git a/2021/08/input.in b/2021/08/input.in deleted file mode 100644 index a5bf9d9..0000000 --- a/2021/08/input.in +++ /dev/null @@ -1,200 +0,0 @@ -badc bd dbeaf cfdbge dfb cfbdea efbag edcfgab dcafe degfca | eacfd acdfbe cbdegf fcbaedg -cd fdbac egcfab gbadcfe cfgdeb cbadfe deca cdf dfabg abefc | dcf cfbad gbafced fcd -cg agecfb cbg eabgfdc egdc fdgba bafecd cbdfe bfcdeg cfgdb | efdcb adcfeb fbdcg gbc -bfceg gfadb dbcfgea bgaef efad abe bcdgfa ea fbdgea agecbd | eadf ceadbg abfge fecdbga -gdcafe eacb adc gbfda afdceb edgbcf badfc ecgbafd ac fdbce | ebfcd cefdab bdfgeca egbdacf -aefbgd fbdc fbecg egdcb edcbag bf gcefa fbedcg bagfced fbg | afgce cfbd bdcf geafdbc -ebgacd edacg gcdeaf cabfg dbc bd cdbgaef ebad fecgbd acbgd | dgbac db caegbdf gcbfa -defbga gead ge efagcb gdafbc cegbdfa egf bfdce bgdef dgabf | gef eg bfcdag ge -bae adcgfbe cdfeag ab dcgeb bfdage agecb cagfe abcf bfcaeg | bae aeb agfceb afceg -ae adefcb gaceb gadceb edag efadcgb badgc cfgbe cadbfg cea | ceabgd fbeacdg aged aged -aegbdc dbegfac gcbaf df febd egdafc deabg gdf gdfeab adfbg | bcdegaf dfeb bcegad df -aegcdfb becdaf gdecf ag fag dcfgba badg fcbad cdgaf acefgb | abcdf cefdab ga ga -gbcfad cefadg cegad aefdb gedacb gcfe fc cfbgead cfade caf | degac egcf geacfbd afc -bcfad afcdbe fd ecfba cfd afde cfeabg gcbfed dacbg fdgabec | cafbged edfa fcd dabgc -afdc adbfe bgecfad ecagdb dbcafe dfe fd agbfe bdace gdbfec | fadbe efbdgc fadbe edcba -bdface geba ecbdag acegd afcdg ge eadbc bfecgda edg fgbdce | eg abge fadgceb abge -fagbde fcegbd gec efcdg fdgbe ebfcag gc adcfe cgdb cagbdfe | defcg cbgdfea gcbd ecfgd -acfbg debgf gfcdba edcbfa fbdag fgbeca cfbagde gadc da bda | dacg acbgf cedfgab caefdgb -ca dfegca edcbgf gfcde aedbg gfdeacb dcbfea facg dgcea ace | fedcg fdagec cea ac -acdf gcfde debcga ecbgaf cf ebgdf bagfdce cedag cef gedafc | dgcbea fc dcgeaf cdaeg -ebagf cabgfed ed cbgad afcbge afdbge edg eagbd cedgfb aefd | fcgdbe de cgbeaf ed -fbcdeag cafbd fgcbea fdgacb daecfb cg gca defga gbdc fdcga | abfcged agc acfgd cbfaeg -dacfe ed ebdcag gcadfe dfbcaeg dce dfeg fbcadg bfeca acdfg | fcbdga gcbade aegdcf fbcgda -cfdegb cbef fgdec gdfbca gdecbfa egfdca bc gbc cbegd aedgb | befc bc abegd ebcdfga -agcefdb fdbg bf bdafe gdebaf eafdg acdbe gcebaf bef edcfga | bf fdbg efdab gefda -gcb bdcgef dcbfg bg edbg facegb cbedf edgafbc dfgca edacbf | gb cdebfa deagfcb bg -eafbg gfad afegbd caefbg befdgc ebagd gd bdg cfbdage acdeb | gd geafb cabed dbg -bcedfg dc dgc aedfbcg acgbed bgfead gedbf bfdcg cedf facbg | gabfed cdebag dafegb cd -fa adbceg afecd cafdbge eacgfb daegcf aef bcdfe fdga daceg | acedf afe fae afdg -cdfaeg agcfb bcdgea dcafeb cef fabec ef dfgcbae defb eabcd | gdabce fdeb ebdf ecf -cdefg ceafg gebfd cdg dc efbcdg cdgbea cfedbga cbfd fdagbe | fbcd afdgbe fabedg dcfb -cdafgb egdb fecgabd cbfdg fcbedg feb acefg begcf be dacebf | be be ebfdca abgfcd -eafgcd facegb acb cdbfaeg fagec dgcabe baefd cgbf cb afecb | bcafeg fcgb gfdeac eagcf -ecgdfb deb edfgab eb faedcg agfed bfaed dbacf gbae efgdcba | fabde eb ecdgfb eabg -aefbg bdegfa gacdb gefc fbc fc bfdcae gefbac cbfag dbgefac | ecfg fc cfge efgcdab -gcfbed gcbae dcaef cbegad bdag bgeacf adefgcb deg adgec gd | agcbde bgad gdbfec gcfabe -dfacb egbcda dac agdcfb fecab adecfgb bgadf cd fgeabd cgfd | gabfdec acd dc dc -bfecg dcgeab af gadf aedbg caefdbg bgfade bafeg abf eabdcf | ebcfg gafd ebacfd fgbdace -ge fdeab gcebfda fadcg fgead abcdef eag ebdgfa acgbef dgeb | cdagf cfdgbae fdeab eag -dba dgfceb fbcegad bagde bcdeag bcedg bdafce agfbe ad cgad | bdcafe agdc ebdcg cdga -edfg fedac fbegcad acgfe fabcd ead bgefac de daecgf bcaged | bafcd ade bacefg fdbac -gdecbf edabc ef fcgead fcadg bdcfga fec ceadf dgaefbc agfe | faedgc ef gabfcd fe -deafg eb egbaf cadegf fcdeab degb bcgaf bfe bfcdega gefdba | abgfe eb gfdaeb efdcga -fabcd beadf efabgc fc cafdgb gcfd adfcgeb abgdce cfb dgcba | dcgf bdcgaef gdcf cfdg -ebac acedf ceadfb cfe dbcgaf ec efcgdab degaf abfcd edgbcf | ce edgaf dgbceaf fce -ecbag fg gacdfe edafgcb cgefa eacdfb deafc bdagcf gcf dgef | fged gedf cefdga cabge -dgebc bcg cg gdeabf cgfeba gdfc gefbdc adbec bdefg fgcdbae | begdf cfgd eadbc gbfde -aefdb ecgb dgaeb agdbce ega fgdacb bcadg cbdeafg ge edacfg | age fcbdaeg gea bcfegda -cdeabg fcgda bdagc acfb dfa af cdeabfg efdgab fbcgda decgf | bcagd cfba gedfc af -ceadb caebgfd bdfaeg cbgaf ge ega gadcbf gfce ebgcfa gebca | aecdb febgcad bgcaf fadcgbe -daegb gfdae ceagfd bgfade feagcb fbgd bg cbagdfe ebdac ebg | gefbacd dbgf geb adgbfe -ecadfg acdfb aefgc ecbfdag dce cfbega fcdae edga gbecdf ed | fcdba ced egfcba dega -defgbc cgdea efag fdbcgae acbdf gcdaeb fe dfcega efc defca | fage fec dcafeg ecagfdb -bg dbcafg gdafecb dgfcae defcg gebd cefgb bgfecd fbaec fbg | gbf dfgec bedg cfdgae -ebgda ebd adce cdgaeb edfcgb bcagd agdcebf ed agbef gcbfda | efagb gbefa dbcfgae eadc -ebcfdg dbe de cdabgf fgdab dgae aecbf abfgced edbaf eagdfb | bface cdafebg gadcefb fedab -agc dabcge agbcd cabe dbagf cfgeadb gecafd gbcdfe ac gbced | cbegd beac dgbce ac -fdagb bdeacf fga eagd gcfdb gecafb ga feabd abfgde dcbfega | bdafe abgcfe gbecfad abdgefc -fbecd dbaef bdgc debafgc daecgf ebfcgd ebc abegfc bc gfced | fadecbg cb cdgeaf bfade -fagbe aebfgcd gef bgadf cbagfd deafbg cfdeag ge begd beafc | bcfadeg edbgaf fcgaed ge -gabfc gabde fbdga bfegca agfbcd df cdfagbe dcfg caefbd dbf | decfagb bdf gfcd fd -bdafeg gf gbadf gefb cgefda daecbfg bacfed cdagb fdg fdaeb | daegcf eagdfb adgcb bagfed -dafegb efdac bda fgedbac egfcdb bgfa fbaed bgdef debagc ba | ba bgcead bad ab -cfged cbegdf cb ecgdb adefbcg fdcabg cdb cdagef efbc gedab | bc gdebcf gecdb bagdcf -fbegcd gcedba eba acegf dbfa efbgd ebfadg ab fgceadb bgfea | fgbae gbedcf degfb agdebc -ceadf fdacbe ef edgafb dfe bgaedc cadfg bcef cfebgad ecabd | cafde fabedc debac eacfd -cd dgafe cbgfae decfg cfebg cfd gdbc febgdc fbegacd fceadb | dc beagfc aebcfg gcfeabd -adcefbg caefgb bafd dface bdcfe cegbd fbe gdfcae dceabf fb | efb ebcgd gbdcaef fb -fbdg gebac degbfc gd dfeagbc decfb gcd dafgce faecbd bdgec | gfdcae gfdb dg afgdce -fb fgedca fbe gfcde gcbfde dbceaf bgeca eafbdcg dgfb fbegc | fbe cbdegf bfe gedfc -acfbe fcbaged bgdcf cabgfd ag cagd fcbga bcfegd gfa eadbfg | afgcb gbdecf efdbcg fag -fbegc dgca dfc fagbedc bfadcg dc ebdfca fadbg cgbfd gfdbae | dabefg egdbaf gaebdf dc -cdbgf bdfaeg ca fgcab dgacfbe feac facgbe ebgcad bca gfbea | dafbeg cab cdagbe debfga -gfbe ebcfag bcedaf be egfac fegdca gebca eab cbgad gfacdbe | dabcgef bcagfed gcfea bea -bdefacg fbgedc efdagb beg geabf eg dafbce dage gfabc eabdf | gead gcafb ecfdab egfbdac -gd gfecbd dacefb dgbf cdegf acfge agbfced becdf aedbgc gdc | gdcef cgbead gd gefacbd -cgbfea cafed dbgefac gacb bc afbge fdabge efbac bcfgde cbe | gbac fcdbge agcb aecgdfb -abgefc cfeba gcdba fgdcea gf fcbgaed eadfcb gbfe fga bacgf | efcba fabecd dgcbfae eagcfd -gcdbfe fdec gcfdb bdfeg de efgba cbgdafe afgcbd cgdbea ged | cedgbf fced agfcdeb cgfbed -dbacfge cafdb gbcfea aegc afbec ea bae bgcedf befgc edgafb | dfgeabc bfgcde faceb fbecag -bfcgad bfegd fg dcgeb egaf bfedcag efabdc dfegba gfb abefd | gf abdgcf dcbfag fgb -degab dgebac bfdeacg cadeb fbdeac bag debgf cgda abgecf ga | dceba fdbeg edbac dbacfge -abdef gcbead bgce cgdab deg dgcbfa aedbg fbacdge eadcfg ge | cgfdba gcafde agfcedb fdacbge -defabg cabdg gcfed cabe gbeacd fgadbc eb geb aedcfgb bdgce | eb dbegc dfecg dbecag -egdabcf edcgb bcedgf cgb bgfe fcgabd bg acgfed cbaed dfegc | cgb gbc egcfad degbc -fe agebdc gfbead fcdea abecgfd bafcde beacd cbef def cgfad | dabgfe fde adfcg bfgead -ba fcabed bad dgacf dfgecab dcgba gdecb bdgcfa abgf caegfd | gdecb dgcfba gcdafe afbedgc -bdgef cdbgfa acbed gedcfb efdgba cg abcgedf cgb cgdbe cfeg | edabc ebdca edbcg ecgf -edfba bcfgead cbged defbcg ag gfadce gcaebd edabg cabg dga | fedagc bcag bdegc gaebfdc -edab fed egcfb ecgbfad fegbd fagdcb degcaf afgebd gabdf ed | def gdefb fgedb edcagf -fc ebfgda ebcfd cabed gcadbf baecfdg cgfe fdc egdfb gdecbf | defbg aecbfdg cadbegf adgfbe -bgdfc fgc fdegb dgecfb fcabd egbafdc gc dgce gabefc gedbfa | fbdgce gc dbfegca cg -bgedc ged gdfcea dcefb cdabg bgfe defbgc bdecaf dcgbfae ge | badefc gbfe cbegd fdagbce -cdefga cgdafeb cbe becdg gdefc cfbg cfdbeg cb febdac edgba | edbgcf abecfd ebgfcd fgbc -de aegcf agedcb afegbdc edbf fbdga facgdb gdaef dbaegf dea | cdabgf ead afgbcd edbf -cfagde eagfbc cbegf cg fcaegdb ebgfd gcf dafebc efabc acbg | bacfe fgc gcf cg -gadfce fbcaeg bdag eba bedcgfa dcfbe ab ebdgca ceagd ecabd | eabdc badec cdaeg dagb -aedb ebcagf fdeac be bdgfc eafbdc abcfegd aefgcd feb ecdfb | fecbd adeb be bfe -dg fgdecb dfecb fdcgeba gedcb gceab fdge cgd cgdbfa baedcf | ecbgd cagfdeb dcbfeg gd -fgcead bfdcag gecdf dfeacb dce aged gcbfe dcfgeab ed fgcda | cfegd de gcafd gefdc -dbec eafbdg dafegc eac gbacf decagb bcgae bdgea gbcefad ce | becag edgab cbadgfe edbc -gefcab agbdc febd bcegd de ecbfg afgdce ebafgdc dfebgc egd | de gdecfba edbf cdegb -abdcefg fbdega dcfag bd fegba badgec fgadb edbf fgaceb bdg | acdfg fagbce adcfg abgfd -ag agdb bfeag fbgdace bcfeda dgafeb egafdc begfc dfeba eag | ecbfg agbd dabg bfeacd -dagc dae fdaec edcafg fbadeg cgefa abcgef ad dfecb fdgcbae | eda eagcbf agfec debfc -ead beafd dfagb faceb bfedca facegd aefcbg cbed ed gfcbaed | abgdf eda agbfce ead -afdgb eabcgf dfgbe fecdgba dagceb gfa cafgdb af cdfa abdcg | abdfg dceagb decfagb fagcedb -dbcfga cb acb gcbafde fcbg egbfda dceaf gbfda dcfba cdbgae | fcadgb cdefgba agbfd cgfb -gceb fcgba cefdba caebfdg egfadb eagfcb cb beafg acb gfacd | abcedf bca gfcda bcge -eabdc caebf ad dgabcef fcaedg cfegba deacbf dabf dca begdc | dbgce dbfa fgebadc acedb -fbgce ec gcea dafcgeb fgbed fec adgbcf abcfeg fcbga cfbade | cbdfag ebgfc fgcbe agbfdc -afcg afebcg becgf fgadeb bdgaefc fa afe acedb abecf gdfebc | fgecb eacdfgb ceabf cgfa -fb gadeb aegdfb abgfe fab dfgb adfecbg bcaegd ebdafc cafeg | becdfga bf fbadec bgfd -ab dgafe fdaeb adb agcedf ecbfd agfb caedgb bdfage egfabdc | fedbc dfecag afdcge becfd -bgedf dgecfb fae gbaec fa cedafg dcabfge gedfab gafbe fbda | fcgdea geadcfb efbdg fa -cgfaed fdebg fcgabd fcegb bd dfaeg gfbeda fgdceba edba dgb | db ebcgf fgcbe edgfa -fgc egcafb dcgb fagdb bedafgc cdbgaf fedac cg gacfd dfbage | febgad cgfaeb fadbg gc -fdaebcg deabgc bfdeg dfcaeg efcgd cdaf cfbeag fcg cf cgeda | bgefcad bgdfe dafc ebagfc -egcfad dbecf cbgf fbe aecbd bcfdge dfbgea aebgdcf ecfdg fb | cgfb gecfd gefacdb fbcg -cdb adcf gbcdae bdceaf dfaeb cdfeb febgc fgedba cd cgdafeb | eadfb fcgeb cbedga bdacge -gd dacg gbdafc gfbdc bdegaf fbgca cbgdefa cbafge edfcb dfg | gbcafd dgac dgcafb cbfgae -cbf dafeb fbceag bc egbdfc edbgafc fbced ecdfg cdgb gdafec | bcf dbfea ebagcf gadfcbe -dcebgf eagfc aebfcd edcbg baefgdc fd cdefg dgaebc fde bfgd | ebagfcd acgefdb fagec gbdaec -afgdc bagec bdfg fb ecgdbfa fab dfecga bcgadf dcafbe bgafc | afgced fb dcafg feabcd -gef febag ebagc egcfbd fg cafg abfde abcfge afcgebd ebcgda | egf gaebf dfeba gadbce -ag cdeafg gdbfce daceb acgf efgbda adg cegda gaedbfc efcgd | debac eadbc bgaecdf cgbaedf -acefdbg debgac ecdgf ead facebg eafgb ad fedbga bfda eafgd | adbf eagfd eabcfgd ecagfb -cd bafegc fgcaed fcaeg dgc fdcag agdbf fedc gbadce egdabcf | fedbcga bgafd fcde cfed -decg egf ecgbfa degfa edbagfc dgcabf cdfag eg fcaedg faebd | gcadef efadg egf eg -feacbg cgfadbe efb efbga dfagb eb aefgc bgec cgedaf dcebfa | eb be be fbe -begc eacfdb dfacg agcfe ce eagbf eac eafdgb aefbcg dfgaecb | ce ce ce gbce -dfeagb dgaeb dbagefc gbcfae degf decba cbgdfa bgfda eg gae | ge agfdcbe bdace fdeg -cgdab cegdbf cfbad bg aegb caedfg eacgbfd dgb dgaec gdbaec | gbea eacgd gb cgaebd -ag ecdgbaf edcba eagcd aeg gcfa dfcgae egcdf gfdeba fcgbde | fgeadb dacge fdagceb egafbd -fdbgec bge fdacbe bfdga edfgb cbgaed gefc cefdb ge baegdfc | ebfgd gbe begdf eg -cedafb gdab fgced cabdf fgbaecd dcbgf gb bgc gabfdc ebfgca | bcadgf cbfda cdgfab agdb -fdcbg bgface ecdabf ad fgcbaed gcefad dac efgac cfagd daeg | dcfabge edga ad gcfea -bce gaecdb aefc bedfgca acbfge aebgf fbceg defgba dgfcb ce | ceaf ce bfgce ce -gefadc gefadb agd ebfcdag dbeg dfagb abfed gafcb dg adbcef | fbgad bged gd cfebda -dcfge egdbf adcgf bafecgd ecd gdfeac bdecaf ec cfgdab cage | acge dacgf facdg cgea -bagdec gecdfba gdabe deb eabc be acdgfe afgdb deagc gdecfb | aebgd cgdea adbge eabc -gebca bedgaf ac gcbeaf bcagedf bafge egcfda bedgc cabf cea | ecbdg efcgab ebagc bgadfec -edacbg gcfad efdabg bc cgfdbae bdc cfedab efbc beadf fadbc | dbc fcbe fbedacg cabfd -adfgce acgfb bgfadc dgbca fc gfc fgacdbe fagbe bcdf ebagcd | cbagdfe gfc fgbac cgbaed -gdbfec bea acdb ba bcged edabgc gcfaebd afebcg gedba gdeaf | ba fgcebd efgda gadfecb -gd gcda bgd gafbcde bdcfag bcgdf cedfb bgefda eacfbg cfbga | fgcab fdgcba bgacf bfedga -fgcadeb abdgc gce bagec fcbea ge aebcgd gead cedfgb bagdfc | gbdace baefc fdcagb cdgab -fbca aedfcg eagcbd fadbec bdgef fec cf bgcfade dbcef cbade | fgedb bgefadc fc cf -dbgfa feca gfbced cf abfgce fcb cafbg eabgc acdbge edafcbg | abgdf dbcgef geabfc fcb -dbaf fag bdfgea ecbgfa dgbfe fa edacg agcfdbe cefdbg fdgea | fgbaed cdegbf dacfbge gdcfbe -abc acefbd gacedbf gbcde dgabf ca fgcedb cega dgbca cgeadb | ca bcged abgfd bca -ceabgd cgfeb ea aedf gcbdfa cadbf acdfeb abfec eac dgcefba | cgdbafe cea adfe aec -dbcfgae agebc ebgd cebdfa ebacdg deagc be fdecga gbacf bce | deagcb agecdf caefdg cegad -dcaeg gea gdaf befgac cefgd facbdeg dcgbfe ga dagfec adecb | gadf gaedc age cabedgf -bead dagfbe gda bagfec ad egfba ecgfad fdcgb ecfabdg dfgab | agefdc dga bgfea dafcgbe -abcgd gecbfda cegd badfge bcaed fcaeb ed adcgfb gcabed edb | acefb acbgde deb ed -cgefdab dgbcfe gbe beca be fdecga bgcafe bfgda abgfe fgace | bfgda eb gbe bdgaf -age cefbadg bcfea cdagbe begca ag gedfca cbfdeg ebcgd dbga | efbac ega fecab dgba -cgedf fc defbgc cdf fceb dgebf bafgdce eadbgf ecgad gcfadb | cf deabgfc efgdbc fgbcda -bdgeacf bagdef gb becg bcfage cafbg bga fdbac caefdg eafcg | bcedafg cbeg bg gb -dfceb gcdab ecbad gfbdea eab gcbeda bgcdeaf ea abfgdc cgea | baedc egca dgacbe cedfb -gdaeb dgfbc cefg fe cfbgaed gdfeb fadcbg defgcb abcdfe dfe | gdcfba eagdb fe cfeg -abfcedg afgcde acgfd ae bdecga efbcd dea fdgabc feacd gfae | afdcge gaef aefgcd geacfd -beadfg cfdgb fdb agfcbde db abcgfd ecdgf cbagf bafgce bdca | efgcd dcefg cdgfe bd -fagbe fedbcag afbgcd agdfbe age adgcbe ea fead egbcf abgdf | gae cbegf afgdb ea -badfcg fagdc gaf fedcgba dagb acefd dbgcf cgfdbe ag gbecfa | ag bagd bdfgca fbadgc -cfebg gc fcbea dcbafe gbc gcedafb cegdba cagf fbgde baecgf | cg agcf befgc bgc -fegb ecdaf ecb gacefdb eb gdacbf cdegba abgfc afceb acegfb | ebafgcd afdgceb ebc be -adgb cgbae bg abecdg gcefa ecbad dbgfec gbe cbfdega baecfd | badg badg dbag aegbc -ab bfa gbedcaf adbgfe bfecg acefb fgdcae bcad fceda ebafdc | gebdaf edcfag ab ba -ceadbg cd gfdeca ebgfd gdfec dce fegbca ecfag fadc gdeabfc | gfaec gface fdac ecadgf -fbagd egdafb bdg adcefg gbfac daegbcf eadgf bd bfde dgceab | dbfe bd agfde agdef -ebg bgdfe acebdg dcfage abfdge agefd dgbcf eb bdfegac afbe | cdfbg aefb dcagef edfga -bfcd efc bfdcge gbdec bagfe agdceb cf dacgbef bfgec eadgfc | cfe dcbf cgebdf dbecag -cda cefdbg fgeca fdgbeca acgdf bdcgf da deafcb fbgcad bdga | afgbcd cfega gbfcda gdebcf -dcaf cagfb gdacb bgdfca fgaecb ebdag cd fdgcbae dbc bcfegd | cfdegb dc abcgd cbfedag -gabedc dgfab ecdfbg adegf afbc dbagc bacedgf bf fdb fdcbag | cfedgb dgcfab gbfcead dcbga -bcagde efd bgfcd fdecb aefb fe dcfbae gacfebd caebd afecgd | ebcdf afeb ef befa -abfc gcdaef agecdfb cb gacedb cgb gcbdf bdgfac gedfb gcdaf | gfceda bc bdfgaec bdgef -geabc gcebad cgbeaf begdcf gfabe fe bfgda gfe afce ebcfagd | febgac fcea fbcged baecgd -aedfb gbfe acbgde fe fcedgba aef fcadge bacdf fegdab ebdga | fcgdeba afdeb ef fae -gbcfd adfgcb gba dgcbafe agbfde ag cfag fecdbg gbdac edcab | fgcbd bgcad agb bdefga -agfde efgcba gaefc bdcfeg cfe bafc bgcedaf egbac agcedb cf | gebacf ecgafb gfceab cefag -febdc begcd ecgbdf dbacfe bdfagc adgec gbd gb afbdceg gefb | dbg gacbfd egcdfb gfebcd -decfbg dagfb afcgbd gdcfb cbaedf caefgdb da gdca gafeb abd | adbgcef dgafb abd cfbgeda -begcfd bgeaf dcfaeb cadfeg gcdb cadbgfe cg ecfbd cfbge cgf | cg gfc gdcb gcf -ecagdf dfcebg fgbea bg cbeadgf egb ebcafg edfab gbca fegac | bafeg aebfd gcab fbecdag -dgacf abfecg fcgadeb cgd gdbace cgbfa egfda dbfc cdbfga dc | cfbd gabdce dbgcaf egfda -afedcgb afge bfead gf gdfbe fgabed dgcbe dfceab dgf fabgdc | feag cdabef bgdacf gfea -adebgc de bfgacde beafdg egabc egcabf deg cead cbdeg dcgfb | ed eabdgf eadc dbafge -fcdbgae gbacf ebgdfc bcadeg bdgea fagdbe gce aecgb acde ce | cge ecg cabeg efdcgba -aefgcb fedagcb cefbdg ef dcbeg bacdge fegd edbfc fabdc cef | ecbgfd gdef bacdeg bcdeg -geadc gecfad gfcadb eg agdcf bgafce gdef acdbe gea dabegcf | ecfbag gebcaf baecd dfeg -cdeba bd aegcd bfadec ecfab bafd agbfce bfdcge bdc cgebdfa | abcfe agdce db adecg -fbadg faedgc bgdac bcegd bcadge agc gdefcb cbae gdfbace ca | defgcb ceagbd bdgca afedcg -acgfd cbdage agcbd dfa edcfg fa dbcfeag fabc dbaefg gdbcfa | af gedabfc af ebgdfac -dafgbc dfegc dc cgfae cgeafd cdf cagefb ceda bfged fdegcba | aecd cade deac fbged -cbegda dgfeb gefcb aefbgc fdgceb agdfe dgb bd fdbc bdgfaec | dcgbeaf db gfbed efdag -aefbd cdbeagf gd fdgc fgcdab afbcg bdg egfabc bfgad aebgcd | gdfc gadcfeb cfgd fgacb -eb gcbaed aeb fgdecba begd eagdc cadfb eabdc cfgade gacfeb | egdca dcbea bdfcgea be diff --git a/2021/09/input.in b/2021/09/input.in deleted file mode 100644 index 2858d84..0000000 --- a/2021/09/input.in +++ /dev/null @@ -1,100 +0,0 @@ -9987653234589654549865432101235789979765459832101234567943986543101239874321012932397319985214896543 -9898541015678943239876973876545699868954398765212345678932399654592345965432129891985498764323789432 -9765432126789654123998765987897789759893219894333656789543498986989957898543498789976579895454678943 -9879656737899797434589986798998897646789398989454789898959987899876899987654989678899699976565789656 -8998767945678996545678997999569965435678987678967897947898765698765678998799878466798989988676898777 -7679898998799987676789398998439876323999876567898976736569894329954569789987964345987878999788999888 -5569959349898799787892139987321987549898765456789765623478989497542345699876543239876567898999998999 -4398943245999659898993045996210499698759876345678954212349876989321234589876455123954453567899987897 -6997832134678945959889159895432349999898763234567894303456965878943445678954321019843212456789976995 -9876543265789434345678999789943498899987654126898985424579854567894578789986532129654325677899854789 -9987654378894321256789987687894997789976543245789876539798768978965989897898763298767534798998765699 -9998867459943210167899976576789876678898674689894988798999899989876999976987654349879545899999876789 -8989978967894345234989895434598985568789788799933299987988989999987899895498765767989656987899987890 -7679989878965976349876789323987654345699899899321012976567678998998998789329876878998767896789899951 -6567895999876765498765678912396543236899956978932129854323567897899989698934998989679878945698789543 -4367896989989896989824567893459874345789543569549299765434579945799877567895789997543989432397678954 -6456789678998989873213678994598765456795432678998989879765678936998765456789896789732394321234589899 -7867894569987678965302759789679876567894321799997878998976789029876744348978945699901298636346698778 -8998923459876567973212345698789997678965433899876768987897899998765432124567934989893397545458975667 -9769212598765459895463456789894398789877549998765656346789998769876545635688949879799498656867894356 -9854324987654346789654577899943239899988698999854341247898987653987678986799198765678999987978965457 -9985459876532235678968688987652124989998796598763210123567897632598789987891019654569998798989976768 -9876598754321014567999799999873015678999987679874331234898998543469893498989198543456989659497899879 -4987999865432323456789899998754123789687798798765765345789239754567912989678976432345678943236910989 -3999998978543476567896978899875234896545679969896889656890198765678909876549876321234567894345899894 -9899987987654587678965356789986346789639889345987992987999349989999999995434965430999698995456789763 -8789995398765698789643235894398956998798999239899893998978969999898989984329876999878989976568997654 -7679876219876789896542129901239899889897778998765789879569998998787878965510999876567678987879998795 -6569997901989891987843458913498788778976667897654678965456987997676567894323987955476567898989989989 -5498789892399932398954567894987654567895456789642567894235695987543478999499876545313456789899876567 -6987678789999543459987678959876543679932378996543456965123984399864569998989985432101239898798765456 -9876546679898954567999789546987621767891567789654587893239973298765678987879876543212345995697654367 -9965434569767895978999893234598832348932345698765698954398764569976789656568987654323476789987743256 -8954323698956789899998942195679953567893478999876799965499865678989896543459999866455678999976551045 -6561012987545698788987893989998769878987567896987899896989987889298985432198754986566789678985432136 -7432123498699987667896789878899989989987679975699989689678998994367965321096563497678994567986544357 -6543434679987893459945698766789994597899789654599876575569899765459876432985432398989323456987655456 -7654545689876789967897987655679913456789898765989975433456789876767989949874321019998910127898767667 -8965656798765667898998986543489894768998999899879874321387899989898998899865432125987891238989898798 -9878969899874356789999997432356789899567899999867965434458989999999987678976743434976989349876999899 -4989878998543235678989854321247895912456789998759876545789678949899998789987854589865878998785679978 -3497989987654146789679765432346954323457991987643987856894589439789769893498767679764567987654598767 -2356799998763259895434996566459899496567890987732298997893499998698954902999898798943458976543987656 -1345998759998768999323987878698798989698999896521019498902578896587893219899999987654569998651098945 -2349887646789878998909998989789657478989298765432329399312456789476789399789999898765878979732129857 -3498765434899989987898999999896545365679109876543498989423969893345995987678989769876989569843598767 -4599894323987899876667899899987621234568914997656987878944878932239894598547568978989895479955679878 -5689989210196998765456789789876210145679323498979766567895989210198795987832456899998794398766789989 -6799878923965449887567895698765421234789459989898753456789994345989689976541368954989689239877899999 -7899769999874335998789989899876532365678998876789866567899985459878599987430267893976578999988998989 -8998958989910126999895678916998645466989897665789877689939876598766469898521256799865456789799987879 -9987847768921237899934689105679656567898786544598999994324987987654349765432345987674347889659876567 -9876426457892357998925693223998769779987654323987887889212998998743234978545469876544235678998765458 -8765212346895468987998789339899878989876543105986455678929899999832123987676569998432123789989896345 -9893101287896778956789895498799989294987654219875334599998798987654016898987978987654234599868987456 -7654242398969889545678976987689990123499864329883223678998657998762145679398989398766345678956897678 -8765357899954995434569989876578921934987986598761019999999736799763234789239799219875458789345999789 -9876459987899894323678998875467899895976797987652128789989945689654756894345678998986567891239899899 -9987699896798789434789897654323456789985698976543234567968896798765897895656799997897678910198776999 -8998988765667678945896789876212345699996789987654345678959789989878998976767899976798989321987665678 -7999876554354588996945679877103456789869899898765458789345678969989329987878999865659796499895434789 -6789987432143456789439998765213467899953998769896569994234569658991012998989998764546679987654323890 -5679896541012345799598789874327878969892987654987678996545678967989129879099876543234567899795434891 -4598765432123569898987678985456789459789898743498789989756789879878998765146998732125698901989545789 -3759986543234678987656589876769898698657789992109899978997894998767899943237984321016989992978956897 -2349898757655989898743456989899999998745678989234998868789923499656798895349875432234678989867897896 -3498769898767995679754687894999899899987789878976987654689934987543236789767976543345689876546789965 -5957656999898994889898798943499789789998898769897998743476899876432125698978989954496898765435789954 -9843545989919989998989899954987679678969987658789876532545899976521034567899999795987999876323567893 -8732135678909878967879999899995564599357897645679987621236798765432145678978988689999899943213679954 -7643014789998765456568998788994323788969919876798768730345679896543267989569876578998798654323789875 -8654123898999654345457897656789515677896323987898654321656789987655358993459875467987698765434892996 -8766234567898743212345789534994323456965434598989765442767895698767467892398764345696549876545993989 -9874345678999832101234679423989434699799565989679877653458954349878878921987653234986539987656789878 -9965657899298743212345894212878945987678976976547989765669765689989989439876543123497698998767899764 -9876798921019654323456982104567899866567899867435699878878998799997699545998653234598987899889998943 -3989899892198767434569877323456998753467997654526789989989219989876578976789854447679996867995387891 -1298956789299878565678965434567897542346789643214567999894329878964347897899965557798765456894216789 -0987645898989989678789876545878965321578998759323456999765498767894256798949876678987654345892105899 -2698766987678997989898987856989954320789869898937599878978987856943145789432988989998743236789324678 -3499989898598965397997698967898765434899754997999987567899876645894235699921299096999984345679434567 -9988998765467893236789579989999887545678975986878976458998765434689346789890932125789965456796545678 -8976899754359992125679456799999999698789876795467891367999986323478956896799843234699878767899696899 -7895789973298989014568967898989439899994987984356910179898797212667897975689754348789989878998789999 -6434890989987878923699878987678921999893499878268899298789598601457898954579765678895699989349899678 -5423921298756867895789999896569890198789989862156788965678987542356789343467999789934989993210998569 -8737893989943458976799998765476789987679876545034567894589999753478993212979878992129878994921987678 -9656794979899569987999899654345679876543987632123478943499898764589432109898769994939769789892998989 -8767999868767989799898698765476789999432499843234569654986789878997643498789356989898654698789899194 -9879898657657895698795439876987899987654678954545678999875688989019759569653239876789543987698789012 -6998775432348894239679921997898978998767989876789789789654567899998967898764699865678952986567678929 -5987654321256789197598799998929867899898999987899897698973456789787978979978989976789769878454567898 -4598763210368898986487678999213456789949989998921954567892567998656899754989978987899879764323678986 -3459875391239897697396568789428589890129878999530123678943688974545799843499867898963989875214567895 -2345965485446797543212345678937678932398767985432654789764569763234899754998756789642199932108678914 -1459879876568999852101267899548789654987659876543465999875678954356999879877645678921019853219989103 -2345989987879998763254345678959898767899536987754576789986789765456895998763234599934329764324598912 -3589996598989899854395456789967999878998745699865679896597897987587894309854123578896449895434567893 -4678965409599798765986577899878986999899656789986789965498986987698963219767012456789567976545998954 -5789654312345679876897689910989754346798787891099899876899765698999654397654323767897689987656899865 diff --git a/2021/10/input.in b/2021/10/input.in deleted file mode 100644 index 6b75869..0000000 --- a/2021/10/input.in +++ /dev/null @@ -1,90 +0,0 @@ -({[[{{({<<<<(<{}()><()[]>)[([]{}){<>[]}]><[{<>()}{<><>}]<(()[])([]<>)>>>){<([(())<()<>>][{{}{}}[(){ -({{<{<<(([({<[[]()]<()<>>>{(()())(<>())}}[{[(){}]}(<{}[]>[<>])])<[[[{}()](<>{})]]<<{{}()}[<>]>[({})[{}()]]>> -<[<{{<<{[{{([(())<{}{}>][{<><>}(<><>)])}}]((<(<{[]<>}>(<()()>[[]()]))>))}([(<<({[]()})>(({[][]}([]{})){(()() -({<{{{{<<{([{[<>()][<>()]}[((){})([]())]])[[<[()()]<()<>>>[{<>()}{(){}}]][[{<>{}}[{}[]]][([]())[{}() -[((<[[{<[<{[<[<>[]]<(){}>><(()[])(()())>]((<<>{}>[<><>]){[()<>]{{}<>}})}>]<<[<[<()()>](({}{})( -[{{([([[<([[<[()()][()<>]>][<<{}{}>[<>{}]>(((){}){[][]})]][<[<()()><{}()>](<<><>><[]{}>)><<<<>()><{}<>>>(([]( -<{[{(<{<[[{{{[[]{}]<{}<>>>{{{}()}<[]<>>}}([(()[])]{[{}<>][<>()]})}((<(<>{})<<>[]>>[[{}[]][{}{}]]) -[<[<(<{[<([({(<>())[{}()]}[[<><>]])]){<{(((){})[{}<>])<<<>[]>(()[])>}(<([]{})<<>[]>><[{}<>][{}()]>)><<({( -(([{[<[{{[<[{{{}{}}<[]{}>}[[{}{}]{(){}}]][(<{}()>([][])){<<><>>({}[])}]>[(<(<>{})<<>{}>><{(){}}[ -<<[{[{[(<(<({{[]{}}[<>]])[{{[]{}}{[]()}}(<<>{}>[<>{}])]>{{(<{}[]>[{}[]])<{[]{}}<[]<>>>}{<{{}[]}([]( -({<<<[[({(<{{<{}()><()<>>}[{[]{}}<[]<>>]}>[<({<>{}}[[]<>])(<(){}>{[]<>})>[[(()()}(<>[])][(<><>)<{} -[(<[{[[(<{({<[[]<>]><<()[]>[{}()]>}([{<>}<[]<>>]({{}()}<{}{}>])){({(()[])([][])}<<{}{}>({}{}) -{(<<<(([[((<(<()<>>{(){}}){{{}[]}{{}()}}><(({}){<>()})<((){})({}())>>))][[{[<[<>[]]{(){}}>]( -{[<((<[[[<<[[<{}<>>{[]()}]<[{}<>][[]{}]>]{<<{}>[()[]]>{[<><>][<>]}}>{{{{{}()}}[{[]<>}<<><>>]}}>]< -([(<[[<({{[([{[]()}{<>()}]{[()<>]<<>{}>})({{()()]([]<>)})]{<((<>())[[][]])[[()<>][<>[]]]>}}}{{[[(<<><>> -<({{({<([[({<{[][]}[{}[]]>}([(<>[])((){})]([[]<>]([]{}))))}({{<<[][]>[()()]>[<()[]>{<>{}}]}[{[{}{}] -<<<[<<(<(<{{[[()()]{[][]>]<<[]()><[]<>>>}[{(<>()){<><>}}[<()<>>[[]<>]]]}>{(<(<<>>[<><>])([ -[[{({[<{(([<<[<>()](<><>)>{({}<>)(()[])}>{(({}<>){{}<>})}]([<[()[]]>><[(<>[])[<>()]]>)))[{{(({ -[<[<[{{[{{(([{()[]}{<><>}]<[{}()]({}{})>)([{()<>}{[][]}]({<><>}([]<>))))<<{<{}{}]}<(<>())([] -([(<{<{([<[((<()<>>{[][]}))([<<><>><[]{}>]({()[]}(<>())))]([<[[]<>](())><[(){}]{()[]}>]{[[[] -[{[{({{[[(([[<{}()]{{}{}}]]){([([][])([]<>)]<[()<>](<>())>){[<(){}>[<>()]]{[{}<>][{}<>]}}})(<[<{()()}([]<>) -(({<[<[<{({[(<[]<>>{(){}})[<[][]>([]{})]]{<<<>{}>(()<>)>[[()[]]}}})}{<<<((()<>)[{}{}]){<<>{}>[<>()]}><< -<[{[<[([[{{<{(<><>)[{}[]]}<<<>{}><{}()>>>}}{<<(({}[])([]{})}{(<>{}){[]<>}}>((([]<>)<{}()>){{{}<>}})><<<< -[<[([[{({(<<<(<>())>(([]())[<>{}])><<<[]()>[()<>]><(<>){<>{}>>>><({[[]{}]<{}[]>}([<>{}][{}<> -{(<[<<(<[({(({[]()}<[]{}>)({[]<>}{<><>})){<(()[]){[][]}>([()]<<>()>)}}{{((<>())[()]){[{}<>]<<> -(<{{<(({{{<[[([]()>]<{<>()}[{}{}]>]>[([[()<>](<>())][{<>{}}<[][]>])<[<()[]>]({()[]}[[]()])>]}}}))>[[< -((({{<[{[((<(<[][]>([]())){[()<>][{}{}]}>){<{{<><>}<<><>>}<([]<>)>>{([{}()][()[]])}})<[<{{<>}[[][]]}[[()[]] -([<((<(<{<{{[<[]<>>{(){}}](<{}[]>(()[]))}}>}>)<{([{<<{()()}{()[]}>[{{}()}({}[])]><[[{}[]](<>())]{[()( -<<[<<(({({((([[][]]<[]{}>)<({}<>){()()}>)[<[{}<>][[]()]>{<[]()><<>>}])})}{(([[[<[][]><[]{}>](<{}[]>{ -<<[(<<(((<([[{()()}<(){}>]({()<>}[()<>])][{((){})(<><>)}{<<>[]>({}{})}]){(<{()[]}[<>()]>)<({<><>}){[ -{(<[{([<(<[(({<>()})<[{}<>]{()<>}>)(([<>()]{[][]}))]{[<{[]{}}>[(()<>)])(<({}{})><[{}<>]{<><>}>) -{((<{[<{{[[{(<<>[]>{{}[]})}{[({}<>)[<>[]]]}]]<[[[[()]{{}<>)]{({}()){[][]}}]<[{<><>}<[][]>]((<> -{(<({[<<<(<<{[{}{}]}([[]()]({}[]))>(({<>()}<[]>)<{{}()}{{}{}}>}>)(<{{[()[]]{()}}(<<>()>{[]<>})}>)>[([[<{< -(<<[<<[(([[{({()}[<>[]])}][<(<[][]>{(){}})>(<<{}{}>{{}[]}>[({}<>)<<>[]>])]]))]((({[{{<[]{}>{{}()}}[([][])({}< -(({{<({<{{(<<{<>{}}{()[]}><[(){}][()[]]>><[<<>[]>{{}}](<()[]>{[]{}})>)}<{<([()<>]{<>{}})[([ -(<<[<{<{{<(({({}())([]{})}<({}())>)[[({}{})[<>()]]]>{{<{{}{}}<{}()>>(({}{})[{}{}])}}>({({<< -[[{([{<<<{<({[()[]][{}()]})>[{[({}{})[()()]](<<>()><<>[]>)}<(<<><>><[]{}>)<(<><>)<[]()>>>]}>>>}])}({(<<[[ -(<{(<<({[[{({{{}{}}[<>()>}[[<><>]])}]<{(<{()<>}{[]()}>[([][])[{}[]]])<[[<>][(){}]]{<[][]>([]{})}>}[((<<><> -<(({[(<<[<[[{{()()}(<>())}(<[][]><<><>>)]][[(<[]>[<>[]])([[]{}]{<>()})]{{[[]{}](<>[])}({()()}([]()))}]>]({({ -<<([<(((<{{[(<<>()>(()[])){{[]<>}<[]{}>}]<{[<>()][(){}]}>}<<[<{}<>>]>{([<><>]{<><>}){{{}[] -(([{[[[<{[{[[[()()]<()>]<[{}{}][(){}]>]}]}{[<{{[()<>][()[]]}}[{{()()}}[[<>[]][{}()]]])<<({<>()}<{}()>)>({([ -{[(<{{({[{{[{([]>({}<>)}<<{}[]>>][[{(){}}[<><>]]{<(){}>({}())}]}}[{([({}()){()[]}]{({})<[]<>>})[[[[]<>]]([<> -(([{[({{<([[([[]{}]<()[]>)(<<>>[<>[]])]{[{()()}<{}{}>](<{}()>([]{})>}])<[<{{<>{}}}<[<>[]]>>{[{[] -{({<<({<<<<{(([]()))(<<>()>)}({<()<>>{{}{}}})>[{[(<>)]{<[][]>[{}()]}}]>({[[[{}[]]({}[])]]})>>{{ -[(<[<((<[(([((<><>)([]{})){([][])[()()]}]<{{{}{}}{(){}}}>)<{{({}{})<()>}({()()}[[]{}])}<[[<>()]{()<>}>({<>} -<{{[(({{<((<({[]{}}(()()))[[{}{}]{{}<>}]>[([<>[]>(()<>))]))[[([{<><>}<<>[]>][[()<>]([][])]){<((){}){{}[ -((<[({<<({{[<[(){}](<><>)>[{[][]}[{}[]]]]}<([(<><>){[]{}}])([[()()]<()[]>])>}(([[[[]()]{{}{}}]{[{}<>]{() -(({{[<<<[[{<<[<><>]<{}<>>>[<<>()>(<>{})]>}<{(<()()><{}()>)<([]())[<>{}]>}>]]<<{([(<>{})[<>()]]{{[]()}{()( -<[{{{<<<[{[{<[()[]]({}[])>}[{({}{}){<>[]}}{<<>[]>[{}[]]}]]<[<({}{})>(([]())<{}{}>)]{([{}[]]([]<>) -{<<<[[(([{{[[(()<>)<()()>]][[{{}[]}[()()]]]}<<{[{}()]<{}[]>}[{()[]}<[]<>>]>>}]))][{(<[(<[<<><>>(()())]<({}{ -(<<<{{(<{[[[[(()())<<>[]>]<[[][]]>]((<{}<>><[][]>)[([]())[()()]])]([(<{}>(()[]))<([]()){[]{}}>]))}>)}({ -({<(({{{<{{[{<()<>>[<>[]]}([[]()][()()])]{([()<>]({}())){{{}()>{[]<>}}}}}>}<[{[<[<{}()>[{}{}]]<<()()><()( -<[{<<<([{<[{{<[][]><[]{}>}{[{}]{{}}}}<<{()[]}([]{})>([{}[])(()()))>][<[{[][]}{(){}}]{[()[] -{<[{{[<([[[[<{()[]}[<>()]>{<<>[]>{{}()}}]<({[]{}}{()<>}){{()[]}(<>{})}>]({[<()[]]([]{})][<<>()>(<><>)]}<< -({{[(([<[<[[{(()[])}{(()[])[()()]}]{[(<><>){<>{}}]<<[]<>><<><>>>}]>]<[(([<<>[]>]))]<((<{{}{}}{(){}}> -({[[(({[[<(<({<>{}})[([]<>)([]{})]>[<([][])<{}{}>>(<()()>)]){<[[<>()]{[]{}}]({{}{}}([]()))>}>]]}<{<{ -[[{([<({[[[<<<[]{}>({}())>([{}<>][<><>])>{<(()<>)<<><>>>{[<>{}]{[]{}}}}]{{((()[]))[({}[])<[]{}>]}[({<>{} -([[(([<[<([(<(<>()){{}{}>><<<>[]>[{}<>]>)<(<[]()>[()[]])>])>(<{([{[][]}<<>()>]<[<>[]]>)(<<{ -([{({<<<<[[({[[]<>]({}<>)}[({}[])(<>{})])][<{((){}){[]()}}<[{}[]]<[]{}>>>(<<()[]><{}<>>]{[<><>][{}<>]} -<<<<{{({<{{[([<>()][[][]]){{[]{}}<{}()>}][(<[]{}>[{}<>]>[{<>[]}((){})]]}}(<<<{[]{}}{{}}><([]{})({}<>)>>({(( -[[<<{<{<(<{({{{}[]}}((<>)(<>[]))){{{[]()}<()()>}[{<>()}<[]{}>]}}{[{({}{})<{}[]>}({<>[]}{[]<>})]{([{} -{{{[{[([[{{[{<{}>({}<>)}[([][]){<><>}]]([{{}[]}])}[<[[[]()]]{[[]{}]}>{<{<>()}>}]}]{[{[[[<>{}]{[]}](( -(<[[<<<({[[{{[<>[]]<(){}>}}<({<><>}{<>{}}){((){})([]<>)}>](<[[{}[]][[]]][{{}<>}[{}{}}]>((([][])[()()]){<() -{([((<{{{[[<<{()()}<[])>[{<>()}<()()>]>]((<[{}<>]<{}()>>{{{}<>}(()())}){{<()[]>(<><>)}{[[]()](<>())}})]} -{{<<<<({[<{<([{}<>]([][]))<<{}[]>([]{})>><[{<>()}{[]()}](<(){}><[]()>)>}<[<<[][]>({}())>(<[] -{[<[[((<({<<[<{}<>><{}()>]><<<{}<>>{<>}>{{{}[]){()<>}}>>([[{[][]}(()[])](({}[]){{}{}})])}<<({(<> -[[[<([[([<[{[{()[]}{{}[]}][(()()){[]{}}]}{{{<><>}{[][]}}{<{}<>]({}())}}]>[[<[{()<>}<{}{}>]<{[]()}({}<>)>>{<< -({[{<[[[([[((({}<>)((){})){({}{}){{}()}})[[(()())<{}[]>]]>[[[<{}()>]<[[]]<()[]>>][<(()<>){[]()} -[[<[{[<<<<{{({[]<>}({}[]))[<<><>>([]{})]}[<{<><>}<[]{}>><([]())[()<>]>]}<([{<><>}<()()>]<[(){}]({})> -[{(<<{{((({[<{<>[]}>](<[[]]({}[])>(<{}{}>{()()}))}<([({}<>)<{}()>]({[][]}({}())))>)<{{((<><> -{{((<(<[[<<(<([]()){()<>}><[()()]{[]{}}>)[[({}{})({}{})]<<{}{}><[][]>>]>[(<(())[<>[]]>)<<[<>() -[{([({<<{<<[{<[]>({}{})}((<>[])<<><>>)][<([])><{[]<>}<[]{}>>]><{({<>()}<<>[]>)}>>(([[({}{})[()[]]] -<{([({{{{(([{<[]()>(<>())}{{{}{}}{{}()}}]<{<{}()>[()<>]}({()[]}{<><>})>)<((<<>()>{<>{}}))({([]<>)[{}{}]}<([] -<{<[(<<({<(([(<><>)([]())]){{<<>()>}(<{}{}>{<>[]})})[{[{()<>}[<>[]]]([()()]{{}})}{([<>()]<[]()>)<[<>[]]{{}() -<{<{[[({<[[([[{}<>][{}<>]][(<>[]){()[]}])<([()[]])[<()<>>[{}()]]>}{[{[{}[]]<[]<>>}[(<>[])<()()>]]([< -[<{(<{<(([{[<<()()><()[]>>{({}{})<[][]>}]<(<(){}>)>}[<<<[]()>>[({}<>)([]())>><<((){}){<><> -[[[(((<({[([[<<>()>]{(<><>)<[]<>>}]([<[]()>{()()}]{[{}()]{<>}}))[[([<><>](<>[]))({<>()})]]](<(([[] -<{({(([{<[(<{{[]()}}>({[{}{}]{[]{}}}[{()}(<>{})>))]<(([[()][[][]]])<<<{}<>><(){}>>>)({<(<>{})>(([]())({}<>)) -<([([[[<([(<(([]<>)){[[]()][()]}>{[{<>()}([]{})]{([]<>)({}[])>})]<[<({(){}}(()<>)){{{}()}<[]{}>}><[[<>{}] -([(<[({<<(<{{(()<>)<(){}>}{<{}{}>}}>[<<(<>())<{}[]>><[<>()][<><>]>><<([]{}){[]()}>>])<[<{<[]()>[[]{}]}{([])<( -(<<{[<[(<(<<[<(){}>[[]{}]][({}())<[]{}>]>>{[<(<>())<{}()>>][<{{}<>}<[][]>><[<>()](()())>]}]>{({[<<[]() -[([<<<([<<[{{<()()><{}()>}{<[]{}>}}]{[{[[]()]}]({<(){}>(()[])})}>(<{{<<>{}>{()()}}<(()[])[[]()]>}(<<(){}>{ -<(<([((<((({(((){})]{{{}}<{}>}}<<(()())({}())>((<>[])([]()))>)){{[<((){})<<><>>>]}})><<[<[({[]{}}(<><>)){(< -<{[<[[({<[<<{(<>[])[()[]]}{<<>>(()[])}><[{(){}}[<>()]][{[][]}(()<>)]>>{<<(<>[])[[]()]>{{<>()}<{} -<<({[({{[([{[<[]><<>[]>]}<{{{}[]][()<>]}{{()[]}[{}<>]}>])]}<<{([{(<>[]){{}<>}}]([[<>()][()<>]]))({(<{ -(<{{{[[([<[{{{[]<>}[()<>]}<<<>()>>}[((()[]){()[]})]]>{{([([][])])<([<><>]{()<>})(<<>{}><<>{}>)>}{<<<[] -[[([<([[<[<{({()<>}{[]{}}){[{}[]][<>[]]}}>]>]{{({(([{}[]]({}{})){[<>{}]{{}<>}})<((<>()))[{[]{}}]>}(((( -({[<<[[[{{{[<<[]>([]<>)>(([]<>)<[]{}>)][<<{}[]>({}{})>]}([[<{}{}>[()[]]]((()<>)[<>[]])]{([()<>]{[][]}){{<>< -{<[{({[<({({[{{}[]}[[]{}]]({{}{}}([]()))}[(<()<>>{[]{}}){<[]{}>[()]}])}<({<{[]()}({}[])>[(()){<>()}]} -[([{{(([[{<[{(()())[{}[]]}<<<>><{}[]>>]{[{[]()}[[]<>]](<{}{}>[()()})}>}[([(<{}<>><{}<>>)(<<>{}>([]{}))]({([]{ diff --git a/2021/11/input.in b/2021/11/input.in deleted file mode 100644 index b6997c3..0000000 --- a/2021/11/input.in +++ /dev/null @@ -1,10 +0,0 @@ -2682551651 -3223134263 -5848471412 -7438334862 -8731321573 -6415233574 -5564726843 -6683456445 -8582346112 -4617588236 diff --git a/2021/12/input.in b/2021/12/input.in deleted file mode 100644 index 98d5a8e..0000000 --- a/2021/12/input.in +++ /dev/null @@ -1,25 +0,0 @@ -DA-xn -KD-ut -gx-ll -dj-PW -xn-dj -ll-ut -xn-gx -dg-ak -DA-start -ut-gx -YM-ll -dj-DA -ll-xn -dj-YM -start-PW -dj-start -PW-gx -YM-gx -xn-ak -PW-ak -xn-PW -YM-end -end-ll -ak-end -ak-DA diff --git a/2021/13/input.in b/2021/13/input.in deleted file mode 100644 index b56a02e..0000000 --- a/2021/13/input.in +++ /dev/null @@ -1,929 +0,0 @@ -1236,308 -296,291 -26,378 -391,705 -1272,434 -1221,595 -653,476 -1274,52 -97,54 -1295,690 -716,396 -522,739 -783,485 -1227,171 -159,463 -152,241 -611,892 -373,459 -912,10 -601,614 -1091,148 -391,637 -326,649 -561,436 -309,413 -1268,610 -237,411 -348,668 -745,259 -1255,350 -484,287 -402,306 -234,110 -430,60 -566,854 -830,689 -353,637 -156,516 -1200,254 -237,259 -574,438 -565,859 -1064,579 -248,350 -1076,802 -773,683 -1141,578 -1057,371 -1250,892 -764,619 -1160,345 -883,254 -1242,401 -1129,287 -1186,136 -1190,162 -932,52 -961,175 -157,540 -229,502 -1014,298 -326,425 -1298,57 -745,812 -987,207 -296,674 -94,834 -338,548 -856,842 -1250,722 -534,150 -1139,444 -78,96 -604,52 -485,764 -875,604 -1096,78 -1063,507 -1136,379 -452,588 -348,317 -1082,219 -1088,733 -619,306 -745,859 -1195,351 -912,894 -120,162 -1034,52 -1119,283 -694,534 -246,803 -316,570 -214,856 -150,113 -714,77 -744,40 -1110,842 -594,396 -912,690 -810,159 -440,822 -321,54 -432,861 -1190,380 -132,58 -323,207 -1123,595 -340,340 -1288,49 -127,485 -110,254 -1279,518 -657,448 -701,723 -109,619 -1155,114 -576,126 -170,327 -1010,250 -624,627 -1087,665 -1058,26 -888,549 -1258,701 -724,661 -865,204 -442,117 -703,95 -197,256 -750,711 -954,855 -1302,607 -1113,227 -150,666 -537,409 -524,605 -1136,827 -338,346 -1096,596 -574,787 -545,278 -1131,159 -1002,432 -353,298 -1134,228 -1091,66 -716,172 -1191,836 -1091,336 -642,101 -1072,292 -1047,189 -132,715 -853,3 -35,812 -898,666 -1250,577 -202,728 -16,175 -853,891 -117,623 -119,388 -537,623 -673,562 -952,855 -266,172 -966,495 -393,764 -812,791 -272,602 -545,275 -673,145 -745,595 -1009,639 -176,890 -1001,413 -852,345 -320,471 -422,661 -547,77 -1290,577 -246,315 -164,95 -219,596 -1042,77 -1258,641 -537,211 -534,723 -1289,735 -490,52 -104,189 -1295,103 -1091,784 -1186,318 -288,491 -136,121 -590,283 -1123,483 -676,317 -110,192 -653,782 -156,513 -574,14 -6,471 -1062,350 -1217,458 -1235,539 -293,567 -1283,59 -686,155 -202,754 -827,733 -323,655 -1072,723 -305,425 -768,368 -1277,32 -52,701 -1086,813 -875,290 -1052,493 -12,389 -811,285 -358,338 -273,843 -169,316 -113,49 -413,551 -706,233 -637,775 -176,4 -430,50 -880,50 -201,590 -1096,410 -619,540 -1274,842 -472,375 -780,318 -929,51 -422,549 -38,460 -818,315 -775,254 -227,618 -977,802 -1211,640 -530,12 -919,705 -209,836 -855,540 -929,359 -1096,298 -425,189 -878,861 -985,670 -750,101 -1156,735 -1275,812 -830,343 -94,263 -1193,354 -729,147 -296,596 -537,683 -191,283 -989,502 -228,891 -586,849 -952,338 -1108,883 -1280,556 -1210,462 -775,640 -416,238 -17,593 -1119,723 -1226,218 -907,763 -1099,679 -780,128 -308,407 -381,107 -1134,890 -708,192 -1310,350 -982,320 -1297,684 -580,28 -576,574 -274,416 -535,506 -682,826 -691,540 -1044,717 -773,409 -719,282 -517,830 -766,702 -932,842 -344,838 -825,130 -1134,605 -82,1 -480,689 -522,491 -214,618 -929,56 -902,91 -917,278 -818,799 -1257,723 -483,385 -937,843 -758,172 -80,803 -146,507 -176,325 -467,287 -852,793 -1195,543 -246,539 -80,8 -780,459 -686,892 -1298,289 -185,175 -400,882 -247,507 -976,607 -206,408 -669,460 -171,444 -1084,189 -1113,172 -537,872 -972,548 -252,26 -1290,541 -301,333 -276,374 -348,765 -1101,46 -1201,171 -370,527 -908,868 -910,12 -1014,556 -1252,817 -525,274 -1082,667 -1277,215 -528,276 -219,593 -329,446 -21,649 -656,544 -1175,499 -222,733 -353,703 -586,45 -586,717 -1093,171 -852,605 -535,388 -565,35 -1017,567 -1064,315 -242,255 -773,719 -196,112 -1198,374 -460,291 -579,539 -23,707 -118,52 -994,353 -673,640 -510,823 -1026,367 -621,414 -1233,707 -460,332 -638,728 -381,278 -574,456 -616,534 -985,446 -984,68 -565,812 -840,129 -196,101 -995,800 -701,171 -1086,492 -338,93 -320,404 -524,289 -273,555 -12,241 -1203,784 -1114,782 -580,866 -33,455 -498,381 -320,490 -1165,108 -112,618 -875,817 -929,339 -564,263 -541,49 -214,148 -1046,369 -816,768 -1097,14 -1,866 -30,892 -301,639 -1093,392 -306,765 -1037,51 -864,842 -305,175 -52,80 -1139,161 -765,54 -22,49 -181,607 -281,718 -724,401 -704,446 -1125,271 -13,145 -224,728 -749,234 -10,570 -1272,82 -328,425 -478,737 -1125,175 -115,7 -490,767 -1134,569 -689,563 -944,491 -1159,16 -1288,497 -686,267 -775,836 -25,596 -1073,635 -689,396 -999,56 -1118,179 -12,57 -115,543 -1275,588 -1280,2 -47,95 -530,459 -820,127 -1258,640 -956,644 -224,492 -1134,442 -1042,817 -709,168 -1125,63 -1272,883 -909,147 -720,283 -202,588 -170,119 -296,855 -35,588 -1277,563 -107,817 -909,523 -93,10 -976,791 -1274,500 -454,842 -505,434 -724,717 -535,640 -994,93 -400,12 -194,114 -432,33 -373,51 -883,724 -176,228 -884,675 -768,72 -349,229 -271,46 -884,168 -425,502 -12,605 -1252,77 -662,551 -1036,192 -1141,764 -594,562 -805,434 -110,631 -393,278 -982,126 -893,259 -171,733 -1233,259 -537,37 -957,74 -119,836 -408,803 -430,620 -776,171 -132,603 -544,702 -1304,471 -750,681 -820,763 -937,754 -164,842 -803,588 -977,502 -1098,565 -248,544 -562,110 -328,387 -252,588 -1226,676 -1275,540 -724,493 -793,606 -1183,228 -1297,145 -894,866 -1206,637 -537,354 -117,872 -254,12 -673,705 -1250,844 -642,228 -1076,784 -639,782 -1272,31 -996,549 -1029,802 -734,280 -604,681 -406,320 -1034,842 -1017,327 -785,256 -1195,343 -572,1 -1047,364 -1299,128 -743,19 -305,873 -867,663 -555,254 -1171,635 -997,749 -1280,450 -691,843 -309,705 -1174,773 -1101,847 -400,487 -202,870 -529,528 -668,57 -353,820 -214,298 -927,360 -1110,724 -0,203 -745,299 -1292,407 -1158,653 -457,891 -962,317 -546,51 -1298,228 -426,3 -435,66 -478,829 -381,499 -214,822 -300,250 -219,828 -82,768 -485,130 -209,204 -1134,793 -763,393 -1092,661 -545,54 -624,338 -624,556 -156,791 -850,506 -326,835 -1277,414 -2,14 -187,483 -214,746 -1257,168 -864,394 -1193,495 -825,764 -152,653 -469,271 -146,418 -763,77 -858,360 -1113,443 -1228,673 -276,38 -273,275 -637,145 -313,749 -308,487 -197,119 -296,603 -137,64 -63,282 -1263,760 -714,817 -484,42 -422,345 -137,736 -127,676 -1064,803 -880,85 -972,324 -776,408 -720,611 -435,784 -1190,648 -1110,170 -1160,666 -0,691 -984,516 -1221,35 -462,267 -124,318 -431,217 -720,163 -484,159 -736,787 -1310,691 -1037,555 -42,610 -155,733 -1310,842 -1218,784 -1014,220 -440,78 -135,499 -1155,733 -100,462 -1114,549 -536,500 -328,506 -1193,200 -957,298 -200,170 -764,51 -607,95 -537,175 -579,355 -83,723 -371,30 -773,211 -1193,683 -100,432 -219,53 -273,56 -283,30 -264,525 -580,199 -976,9 -567,19 -1250,317 -753,54 -150,381 -957,257 -219,148 -1293,189 -200,724 -438,799 -930,192 -1037,840 -869,880 -994,772 -1265,170 -82,344 -478,65 -328,350 -33,480 -806,333 -349,5 -883,52 -417,35 -251,131 -373,802 -704,222 -1283,835 -880,620 -244,712 -557,54 -1158,515 -1129,254 -58,77 -191,723 -805,460 -885,502 -33,32 -987,655 -669,434 -1298,101 -1161,434 -957,596 -80,886 -156,378 -1140,42 -430,834 -310,495 -1083,618 -136,773 -185,623 -560,681 -917,166 -263,82 -109,616 -89,595 -1086,81 -545,59 -929,395 -654,282 -637,254 -601,107 -522,263 -972,346 -989,54 -1158,689 -33,414 -552,315 -1005,425 -1014,596 -366,491 -1009,561 -1022,491 -258,849 -865,652 -641,658 -949,327 -55,350 -1154,791 -1027,30 -1220,631 -1292,487 -38,11 -1001,271 -435,817 -542,72 -691,218 -353,561 -966,56 -229,189 -402,866 -1102,500 -832,228 -1308,14 -305,623 -738,1 -214,484 -118,842 -224,50 -560,162 -716,780 -580,308 -1101,200 -229,392 -27,835 -570,415 -301,298 -281,802 -1221,588 -706,681 -338,570 -430,477 -783,857 -21,735 -249,828 -609,619 -15,690 -21,383 -197,227 -1250,765 -90,631 -937,170 -1114,112 -536,394 -599,544 -897,551 -793,64 -570,218 -1108,870 -422,213 -1173,606 -775,388 -185,271 -324,574 -552,579 -1192,394 -117,271 -768,36 -252,28 -0,842 -1110,52 -381,838 -1293,705 -373,473 -1289,159 -1198,618 -654,724 -1136,515 -30,450 -755,640 -45,312 -455,794 -619,843 -977,652 -1258,39 -176,569 -691,306 -152,827 -291,218 -473,80 -152,379 -90,263 -109,278 -435,290 -1113,256 -868,117 -176,793 -734,574 -120,380 -52,640 -730,308 -1186,103 -197,891 -427,254 -686,556 -1295,593 -1014,674 -266,450 -1014,338 -940,395 -932,394 -127,228 -937,473 -1309,28 -460,780 -1288,845 -504,289 -1222,656 -345,189 -293,327 -668,228 -1309,418 -746,711 -820,767 -1064,539 -601,168 -104,705 -127,857 -1129,786 -857,590 -607,799 -1054,204 -929,726 -1116,603 -782,276 -989,840 -1141,316 -214,276 -929,278 -855,794 -470,129 -1156,607 -1027,864 -252,238 -1193,623 -1072,171 -540,117 -202,166 -641,460 -17,327 -1,28 -1111,442 -499,733 -581,147 -1195,7 -47,134 -1221,147 -1088,861 -745,306 -18,487 - -fold along x=655 -fold along y=447 -fold along x=327 -fold along y=223 -fold along x=163 -fold along y=111 -fold along x=81 -fold along y=55 -fold along x=40 -fold along y=27 -fold along y=13 -fold along y=6 diff --git a/2021/14/input.in b/2021/14/input.in deleted file mode 100644 index 9131169..0000000 --- a/2021/14/input.in +++ /dev/null @@ -1,102 +0,0 @@ -OKSBBKHFBPVNOBKHBPCO - -CB -> P -VH -> S -CF -> P -OV -> B -CH -> N -PB -> F -KF -> O -BC -> K -FB -> F -SN -> F -FV -> B -PN -> K -SF -> V -FN -> F -SS -> K -VP -> F -VB -> B -OS -> N -HP -> O -NF -> S -SK -> H -OO -> S -PF -> C -CC -> P -BP -> F -OB -> C -CS -> N -BV -> F -VV -> B -HO -> F -KN -> P -VC -> K -KK -> N -BO -> V -NH -> O -HC -> S -SB -> F -NN -> V -OF -> V -FK -> S -OP -> S -NS -> C -HV -> O -PC -> C -FO -> H -OH -> F -BF -> S -SO -> O -HB -> P -NK -> H -NV -> C -NB -> B -FF -> B -BH -> C -SV -> B -BK -> K -NO -> C -VN -> P -FC -> B -PH -> V -HH -> C -VO -> O -SP -> P -VK -> N -CP -> H -SC -> C -KV -> H -CO -> C -OK -> V -ON -> C -KS -> S -NP -> O -CK -> C -BS -> F -VS -> B -KH -> O -KC -> C -KB -> N -OC -> F -PP -> S -HK -> H -BN -> S -KO -> K -NC -> B -PK -> K -CV -> H -PO -> O -BB -> C -HS -> F -SH -> K -CN -> S -HN -> S -KP -> O -FP -> H -HF -> F -PS -> B -FH -> K -PV -> O -FS -> N -VF -> V diff --git a/2021/15/input.in b/2021/15/input.in deleted file mode 100644 index 623713d..0000000 --- a/2021/15/input.in +++ /dev/null @@ -1,100 +0,0 @@ -1762397661132951281872118191829951912248172478339632549455181981251788927258534119468168714528621114 -8319319112748383315492426133271137584941117782129986515332716159745294224193293175158161499293222148 -8266728412139799931643116912557929947663988821211944399124893291926199243572783776173611922147331181 -9768991115438161618229664911612111659721489122113919117417168282889149141331521139589972137335416965 -3171539222181482245864217884221793163933341199835974591512912153611719383822886874252812189119211692 -9813861882122513794416142966122147931711931986114712961595314549632318377591159215157316813144934355 -7249291646824518193378853916825167931368827832213362177131511326161252924118148113122117239516894281 -7619265123128119111958978123298112151893112118796447627993349181166826971622479558261738365928333993 -2172119611123667198988912581135762996771929293568381611622194474422232946596921716259957372123899698 -4352214875122283151191299159125268139125394182223812438129936119129887731491391363987958285611735124 -9392311228738188112389181962964441553298875142992639762857989199385199119362214956984889116161512973 -2892785495413127483914947156452441111911711971248471862338463181961152891293748296521551886171944432 -9771371132754482976691473392179769191511659123186661481992184193199162717851182183975513821945725321 -9218767829493884196118831313927579911256192463613676192213864258491926157791112198274214181147959154 -2792193899714181173347298221195589991167789114137161959778141371252115777986241795181919174317949829 -7619548189922581181859166518531891927419411953133381591936168586775311272448519147149659321171116141 -3711326392171499975162459323581728293983795119922197923141493849921729498132819921129641917259118864 -9662821131571632544219456989289467698811981163262144283931368698226797383923219731421621671825257671 -8926251431913827251411827421261859513843589241938313879248752781892119516839862167961428927931111162 -9696892328613843521773991428165191277894129912138571399131152313611391251983614926952746144321251911 -9335234624983873138234757195373269431811641469169819336189911147917583295479638741437112278149159862 -2111192894139376481161215281139285422974424132138831311924793514959279281114124319742841958641419391 -7621315589183391171215115441519488669384175731591179229641387112121194738813559138294251112341297538 -8831271268391495711587992124119994691138611111165198323212973519468749437821131791997859117239181924 -4811735832189511994318149332378111193361165795554681993992221559549144569162156939979819678945272974 -1524179911227897316229296744618768288496498312432216265311939361711974311645192215436812821129213365 -9411237933162299161925557884812745439884925962585979813832329174935225424534918864159991415748622183 -1969119121165124863159769267319535155153661143981392621984891612819937929929952945517261771543768827 -8117376273619779538922341789922174281183223161181712439119861966423951811953421121216521561271992999 -5911336591183894763911894167932995172998223111199119111393119784189332442198132136931181614895719112 -9144417911989291113272235811667566164454718852785519276832453415115489939413487813914189189111722296 -3172782697359615397137825146724135259786191794785523156861711576611169978989562291681822797597411471 -3691317861982226551781149914227481161871796979945154831871894629422677185511681333724141515124763312 -6152916321893165355934593689222281456739634897387348419961128898831955884712128911284192198313767992 -2123565322186129768844952156135549396186911811173898116782215672225918152219221191893512531731418343 -9148448789413415121188812348651634491941741358988162111713948362231472972523456143118935167366114159 -7215951236798967714143299289482837632184226282821596493275119221115719283519213866698847919639581299 -1211423833873117249111527243314291155181115773173149818592743169151611135262551161178646584474226217 -3141441922169621422636811311228221519329196814132217999729948137477929641724452113233326511319525111 -6353774379142258441594111831969139261677193112616941375776199819687827849195111119561812988217263123 -5155468118892524167244234498923983312939713497637191178858211851911621151598115952188939151571911411 -3264971191887918252178185125131132812346323233298941194625423463868531137179151242921171128214116421 -2192146511349122811114487199149628158792934427223174998915226911885299861741222982117327896189138141 -3817555391414595191215996912159952814172651289927691484296328451126227654144279475752877198439541351 -3272311727962111147114985241973956466428912929211888379341615218161714914831994199497611398384573714 -3276111123319119118182112283823812169388217113736878913512112173157558173223311372394341828193146797 -9581993771117231862931291845155311586313219171988916823938586755181161698523359212217997922756426139 -1918622894641131169621888219818617193839128714861122522312135898994175928269569112793476895471213998 -2271546578513428929848359713361369484681371894466191911128727429149832611914911886812791255753623169 -2686121559311382749993357595341117532442113911695512432717391181456663681541622198894564758175943318 -1337167193589499119223489928689264347326914997916799169553341539117192116458582999194574691292429739 -2987468387842898434761167929526166691242921787821721976164921525555727921546368194597227292929935193 -9856191999892314431796119592565346416369117282381924278686522198989115828829229499191199899942269826 -4159119835291241279424919921752929162954245885262298833199324979522119268319649232728271944228715139 -5247461775789923151611677854751726991193131793119286262144188718119121417814487573868915314322549329 -7661813574189395262215217212114966839939986162219999286758293567396393524675861592534961528693615891 -2965317131929913122722181933419595373832972818598892124999196577426993846517981678984881831197982191 -1972199933158221981388146184292133116193126181146474235137663523168143244565531372633122489398489914 -7423919964326886514368971251639349937192526679938781331813691661562111363176487262313547792297131577 -2917722861145329977821111173291529851591981941395919845218123923234989734132462271549997693877195215 -9221435231914979351891461911284473643411525579889886721158974241328216297819784913121119921737224263 -3566219395561214162477611543497922131799998149212573699224587793287919966791587986252836637192119133 -3812171216111466869119115211112153642718392182973562614919722152728182773759846982213314428821264758 -8991197268386247539851968187713485151115713151193351148119651589416293595167932129989241479124143627 -9211499872118751526793162988158249348518412163571792637591529327473131996812716991116188843973119581 -8614137211759975531382622998957411166491897152241192418281984823628591952239215482182387842813361871 -8251589811136243659161191211583731979325411956771731128239861413269235561218411879942978841232992111 -3111499818132173935199311225353892127596636149897991831955933243981952575199928241632548277891793291 -4431785818236512111396943889611445371331396615433746415529736682113689425795525643888133986439531335 -9995925821921378382129271715156919237821269326578692118275314885169372111849848564112395779671157318 -1987539366619221915184994848732376216442112332812932859164799863358117281128445782941219181486597613 -9734932112213977129169618132588418748257997619225111991282361982189931392696335623148599438162964993 -1268542894811891811752185845917126686731111729151141185841237681314145379626272561327153116697253893 -7961582572112147851139341243998815131115871353869821241569111211311173743737429841517967133645346968 -8131131195643613581916973416327251713377286522581727261974749238538719916249467375251549742638713962 -7977612542191913784424123691995545989898244266289211136997219895141819231944297116814818111569149281 -8761673393124368197342592244518993981872433593118269136396188269295546121117191592992417627132133951 -1651978712438629147262911948236819593481188191673533419875699391719179399418159484312979829643125878 -2848189151727256129221118261999751718212112458891842251928813719141689361121238411237423697529991811 -8528124345999713421922279887245218255633572311333279811971192723411129973962191825312936729635111535 -3126599598725196396213972376977781128199369299181973179226838421144294851141754733382394814127389931 -8323175518498898731893963895816749112329321499182744141129978131811161949947793693914585912629991286 -9231819122963995515633969921861191116511778131324189152432598462571732129799113218113199629285919395 -6356352514912132331995294112175921815291563324826718912431311119817931161152817991628441799761119371 -2968217271711154911627567222991829619422231818535238861182483981925818211613351748667121283417219121 -2986392289931997914122281314222947267925911961565211934849281836413651936112923131496213298332143158 -6587271799388817315278422618122269129966213812991115388711725198517419351365461989269599121323694713 -1116591631891928799281817941339947924114147515129989638958495287291947819549271893749651112813219981 -1143157968584776191444994384614838194823133446488624243151928321519127891988989917891777379611798118 -8399291892169518714793192128111192235991541914834914922688165329289884129349482229926121144924115514 -5668119329997863259888245715692793776372918952839318591392981291144699832866692374222595323233168486 -1216172119823141749353314274825582984999984484435979229912935228419361471926794973175917614844595886 -7499725626525512271213984958599416332619526213119268641699133726257851179181134147793412718614975614 -4288111112156922267983399793396113699811611291414346541972227217218118113671472672112213192111581181 -9411112131817256595664146121293142298999399429821453921188512943862327573213912219625131825813291399 -5429441953242814421419835169719152828451133936519178139114667488425944842768762393235891219691624813 -7199274849564917958467522334719119915121692718981981522289815567155928198869311911982725834726235516 -4851719158713681489832158231939414111984561313913178292865317239795299169256621724995929214446597981 -2895141151816231324862721919961491572329591628247151846125129115212222764271248124311117311343989181 -8573312112116444197131192178856685531315797232771662865695122611599151931945191918296911647973257553 diff --git a/2021/16/input.in b/2021/16/input.in deleted file mode 100644 index 59fd24b..0000000 --- a/2021/16/input.in +++ /dev/null @@ -1 +0,0 @@ -620D79802F60098803B10E20C3C1007A2EC4C84136F0600BCB8AD0066E200CC7D89D0C4401F87104E094FEA82B0726613C6B692400E14A305802D112239802125FB69FF0015095B9D4ADCEE5B6782005301762200628012E006B80162007B01060A0051801E200528014002A118016802003801E2006100460400C1A001AB3DED1A00063D0E25771189394253A6B2671908020394359B6799529E69600A6A6EB5C2D4C4D764F7F8263805531AA5FE8D3AE33BEC6AB148968D7BFEF2FBD204CA3980250A3C01591EF94E5FF6A2698027A0094599AA471F299EA4FBC9E47277149C35C88E4E3B30043B315B675B6B9FBCCEC0017991D690A5A412E011CA8BC08979FD665298B6445402F97089792D48CF589E00A56FFFDA3EF12CBD24FA200C9002190AE3AC293007A0A41784A600C42485F0E6089805D0CE517E3C493DC900180213D1C5F1988D6802D346F33C840A0804CB9FE1CE006E6000844528570A40010E86B09A32200107321A20164F66BAB5244929AD0FCBC65AF3B4893C9D7C46401A64BA4E00437232D6774D6DEA51CE4DA88041DF0042467DCD28B133BE73C733D8CD703EE005CADF7D15200F32C0129EC4E7EB4605D28A52F2C762BEA010C8B94239AAF3C5523CB271802F3CB12EAC0002FC6B8F2600ACBD15780337939531EAD32B5272A63D5A657880353B005A73744F97D3F4AE277A7DA8803C4989DDBA802459D82BCF7E5CC5ED6242013427A167FC00D500010F8F119A1A8803F0C62DC7D200CAA7E1BC40C7401794C766BB3C58A00845691ADEF875894400C0CFA7CD86CF8F98027600ACA12495BF6FFEF20691ADE96692013E27A3DE197802E00085C6E8F30600010882B18A25880352D6D5712AE97E194E4F71D279803000084C688A71F440188FB0FA2A8803D0AE31C1D200DE25F3AAC7F1BA35802B3BE6D9DF369802F1CB401393F2249F918800829A1B40088A54F25330B134950E0 diff --git a/2021/17/input.in b/2021/17/input.in deleted file mode 100644 index 1dbc999..0000000 --- a/2021/17/input.in +++ /dev/null @@ -1 +0,0 @@ -target area: x=96..125, y=-144..-98 diff --git a/2021/18/input.in b/2021/18/input.in deleted file mode 100644 index 2638d04..0000000 --- a/2021/18/input.in +++ /dev/null @@ -1,100 +0,0 @@ -[[[[3,9],[0,5]],[4,6]],3] -[[[8,[3,0]],[[8,4],[9,4]]],[[[0,9],4],[[3,8],2]]] -[3,[3,[[2,8],[1,4]]]] -[8,[[3,6],[[8,9],[4,1]]]] -[[3,[[5,8],[3,3]]],[[[9,3],[6,3]],[[7,0],[8,8]]]] -[[6,[[5,8],7]],[8,[[1,6],7]]] -[[[[8,6],[9,3]],[3,[2,7]]],[[[6,7],[2,8]],[6,7]]] -[[[9,[1,6]],0],[[7,3],[2,4]]] -[[[[4,9],3],6],[[7,5],8]] -[[[[8,3],8],[2,[6,5]]],[[6,[1,9]],[0,2]]] -[[[9,9],[[9,8],1]],[[[7,4],[1,4]],[[1,1],4]]] -[[5,[[8,2],[8,6]]],[9,[7,[8,9]]]] -[[4,6],[8,[3,[1,2]]]] -[[[2,[7,9]],7],[[2,0],[9,2]]] -[[4,9],[[[3,4],[2,9]],5]] -[[[[0,0],[3,7]],[[6,1],8]],[[[4,0],4],8]] -[[4,[[8,9],[2,2]]],[[[1,8],[2,7]],[[6,8],0]]] -[[7,5],[[7,0],1]] -[[[5,[1,0]],1],[[[7,7],[2,2]],[[4,2],8]]] -[[[7,1],[7,3]],[2,0]] -[[[[6,2],3],[3,[5,2]]],[[7,2],[[9,5],[0,1]]]] -[[[[0,3],2],6],9] -[[[9,8],[[7,8],[5,9]]],[[[4,8],[0,2]],[[6,8],[2,3]]]] -[2,[[3,7],9]] -[[[9,9],1],[7,[7,[5,8]]]] -[[8,[1,1]],[8,8]] -[[[[3,3],[1,4]],[[5,3],4]],[5,2]] -[[[[0,9],1],[[3,8],8]],[9,[[8,8],[0,7]]]] -[[[9,4],1],[[9,7],[[6,1],[9,5]]]] -[[[1,[4,0]],9],[[3,7],2]] -[[[5,[0,5]],[5,[9,2]]],[[[2,2],[8,0]],[3,[7,8]]]] -[[[[8,2],3],3],[[[5,4],[0,5]],9]] -[[[3,[6,2]],0],[[[7,3],[6,3]],[[6,3],2]]] -[[6,1],[[[1,2],2],[9,4]]] -[[[1,[9,0]],[[8,2],[4,9]]],[[0,[9,6]],[[0,4],[4,0]]]] -[9,[4,[7,0]]] -[[7,2],[[9,5],8]] -[[6,[[0,6],0]],[[[2,0],[4,1]],[[9,5],4]]] -[[[6,[0,0]],5],[[[5,2],[7,3]],[[2,8],[3,2]]]] -[[[2,7],[[8,2],2]],[[5,[0,6]],[[9,8],[0,4]]]] -[[[8,9],[[4,1],2]],[[[3,4],[4,5]],[[7,4],0]]] -[[5,[2,[2,1]]],[[5,6],[[6,2],[3,0]]]] -[[8,[0,0]],[[6,1],[9,[1,3]]]] -[[[9,[5,8]],5],[[8,[6,6]],[7,5]]] -[3,2] -[[8,[[6,3],[8,4]]],[[2,7],[8,[9,5]]]] -[[[4,[9,1]],[[3,6],[8,8]]],[[[9,0],6],[[3,7],6]]] -[[9,[[4,9],6]],[[8,2],[1,3]]] -[[[2,[4,3]],[[5,6],[7,3]]],7] -[[[[0,1],7],[[9,1],9]],[[[0,1],[6,5]],1]] -[[[7,[5,3]],[[6,6],6]],[[2,7],3]] -[[1,[[5,8],[1,7]]],[[[5,0],[4,7]],[[3,3],[3,7]]]] -[[[[8,8],[2,6]],[1,2]],[[[2,6],4],[1,[1,8]]]] -[5,[[8,[8,2]],0]] -[[6,[[5,9],[8,4]]],[7,[5,9]]] -[[7,3],[[[2,5],4],[[1,1],8]]] -[[[0,1],7],[0,8]] -[[7,[6,6]],[2,9]] -[[[[1,9],1],[[4,8],5]],[[0,[8,3]],[[0,9],[1,5]]]] -[[[0,9],[[6,7],5]],[4,[[1,1],[0,6]]]] -[[[6,1],7],[[[1,4],8],[[9,0],4]]] -[5,[3,[[0,7],[4,9]]]] -[[[[6,0],[1,5]],[[1,5],1]],[[1,[7,1]],[[6,2],7]]] -[[[9,0],8],[[[4,1],[5,4]],[4,[5,1]]]] -[3,[5,9]] -[6,[6,5]] -[[1,[8,0]],[9,0]] -[[[[1,8],3],0],[7,[[0,8],6]]] -[[[[4,2],2],3],[[2,5],[[9,2],4]]] -[[1,[[1,1],[8,4]]],[[[8,1],0],[0,2]]] -[[[[0,7],[8,7]],[9,6]],0] -[[3,7],[[1,[0,9]],[1,[7,6]]]] -[[[[3,5],[4,6]],[[7,1],[8,0]]],6] -[[7,[5,[7,7]]],[4,[5,3]]] -[1,[[[0,0],[4,6]],[7,[1,9]]]] -[[[3,7],[7,[0,6]]],[7,[5,3]]] -[[[[5,3],0],2],[[[2,7],[7,9]],[[1,4],3]]] -[[[[8,3],9],[[8,3],[7,4]]],[[4,[6,0]],[7,[3,7]]]] -[[[6,[5,0]],8],[[[4,5],3],[1,[5,9]]]] -[[7,8],[[6,8],[[8,4],[3,1]]]] -[[[2,7],[6,3]],[[0,0],4]] -[[1,[[6,5],[4,8]]],[[8,[2,7]],[[7,8],[6,8]]]] -[[[2,3],[7,7]],[0,[3,3]]] -[5,[[2,8],[2,[6,9]]]] -[[[[6,3],2],[[2,8],9]],[[[5,6],[8,0]],[[9,3],[5,0]]]] -[[[[6,2],7],[6,1]],[[[5,9],4],4]] -[[[[7,2],[0,4]],[[6,7],7]],[6,[[8,5],[9,0]]]] -[[[[9,6],8],[2,[3,7]]],6] -[[0,[[1,0],4]],[5,[[7,4],[2,4]]]] -[[[[4,4],[4,7]],[[7,4],3]],5] -[[[[8,2],[0,3]],[[7,2],1]],[[7,[1,2]],6]] -[[[3,8],[3,1]],[7,7]] -[[[6,5],[[8,7],4]],3] -[[7,[2,[2,5]]],[9,1]] -[9,2] -[[4,[2,9]],[[4,[2,9]],0]] -[[[0,2],[[2,1],[9,2]]],[[6,[8,2]],[4,[3,8]]]] -[1,[[[2,2],6],[[3,5],6]]] -[[[9,[4,8]],[1,4]],[4,[1,[9,1]]]] -[[[8,0],[[8,4],3]],9] diff --git a/2021/19/input.in b/2021/19/input.in deleted file mode 100644 index b2a1974..0000000 --- a/2021/19/input.in +++ /dev/null @@ -1,777 +0,0 @@ ---- scanner 0 --- -806,301,-633 --501,-417,319 -699,-593,593 -599,-948,-962 -666,506,480 -657,-639,635 --363,523,-711 --689,-409,-863 -523,-841,-961 --466,-444,389 --551,-478,293 -682,294,-783 -637,-604,531 -628,429,346 --557,720,459 -698,394,-619 --727,-433,-850 --299,531,-672 --405,725,448 --418,610,-699 -544,505,321 -12,-5,-66 -534,-850,-930 --659,-479,-863 --481,563,432 - ---- scanner 1 --- --567,723,271 -396,736,775 --333,391,-925 -879,-437,-483 -435,619,-826 -391,674,792 --362,-472,-516 -818,-588,563 --675,800,276 -841,-447,-497 --392,-344,-501 --699,-555,431 -558,488,-853 -97,11,24 -883,-354,-438 --369,353,-837 --400,-372,-455 -777,-696,687 -537,540,-764 -390,680,786 --305,394,-763 -745,-688,659 --52,18,-125 --754,-476,397 --652,-554,484 --503,789,349 - ---- scanner 2 --- -715,-612,-331 -545,344,802 --544,-764,-423 -605,551,-225 --484,815,-437 --501,-701,621 --547,683,-535 -646,-699,-245 -461,319,726 -615,-621,837 -592,631,-352 -674,-712,-435 -12,16,66 --488,446,506 --595,701,-474 --446,-713,708 --514,-703,-390 -583,478,725 -723,-635,930 --382,-674,700 --522,-922,-413 --564,430,668 --640,457,511 --74,-142,125 -599,-785,937 -468,608,-260 - ---- scanner 3 --- -711,-748,-788 --428,630,-632 -590,-772,-913 -605,-418,728 --514,718,-615 --815,-855,649 --541,714,303 -441,331,-954 -109,-112,-17 -846,546,409 --13,1,-175 --481,598,-593 --416,646,368 -860,485,221 --793,-799,727 -592,-779,-647 --648,-558,-530 -414,368,-881 --391,664,243 -645,-341,704 --680,-765,-573 -403,509,-949 --840,-850,672 -466,-343,676 -934,609,281 --674,-569,-489 - ---- scanner 4 --- -428,-524,476 -466,-579,-849 --769,-857,-356 -406,-703,-775 -553,-542,501 -812,511,472 --447,-558,513 --430,-470,599 -705,539,591 --755,469,-592 --696,-820,-329 -865,811,-327 -79,-43,-21 -594,-642,-761 --712,564,-682 -978,793,-405 --693,607,426 --764,-679,-318 -950,755,-407 --740,539,490 -488,-474,626 --408,-590,566 -844,420,607 --770,435,-728 --668,460,484 - ---- scanner 5 --- --770,670,763 -812,733,-782 --382,460,-566 -864,-289,801 -380,-691,-662 --709,738,832 -553,686,617 --386,599,-494 -528,604,507 --495,-654,-628 --352,-408,571 --478,-568,-716 --393,-434,560 -126,151,86 -804,591,-833 -809,-242,852 --748,662,687 -786,-267,857 -413,640,643 -56,-22,-18 --456,-601,-596 --404,652,-635 --436,-402,767 -773,636,-858 -505,-666,-644 -440,-541,-712 - ---- scanner 6 --- -415,738,-730 --509,-231,-485 --566,-398,-446 -895,-614,-866 --673,871,-512 --478,-737,417 -329,617,-773 --435,-703,499 -425,-435,792 -835,-555,-763 -381,-366,613 --2,82,-131 -488,849,633 --547,-310,-637 --436,812,529 --304,875,431 -814,-461,-928 --662,719,-517 -639,762,677 --689,795,-674 -495,666,-823 -421,-468,663 --477,-650,423 -538,758,741 --418,764,468 - ---- scanner 7 --- -816,594,927 -764,-673,507 --700,-812,470 --509,776,-400 --775,-530,-277 --651,-775,612 -474,893,-700 -535,-581,-321 --739,-564,-332 --602,-628,-266 --698,-780,644 -137,144,40 -826,-635,367 --779,893,786 -947,459,955 -562,-418,-377 --572,882,-393 --617,891,703 -462,890,-494 --608,806,812 -898,456,894 --638,796,-428 -856,-752,466 -510,-495,-311 -413,960,-544 -26,4,-20 - ---- scanner 8 --- --2,-27,-81 -279,771,385 --722,552,475 --883,-705,621 -418,-693,422 -673,-491,-462 -527,810,-417 -339,-785,381 --572,-771,-592 --730,327,449 -311,769,559 --538,-703,-736 --860,-496,609 --649,732,-830 --652,793,-712 -510,-464,-406 -561,846,-362 --869,-653,584 -596,-439,-396 -463,673,-351 -456,-755,282 --596,761,-615 -316,722,527 --785,447,522 --561,-867,-645 - ---- scanner 9 --- -534,387,316 -609,-822,763 --598,-439,-626 -478,-699,790 --779,659,516 --722,660,680 --837,742,607 --457,-416,434 -726,-861,-838 --425,588,-715 -41,-108,-42 --447,-378,420 --488,580,-642 -670,-867,-849 -791,664,-548 -796,474,-521 -664,-866,-855 --364,-374,375 --359,597,-749 --698,-512,-722 -564,438,294 -779,574,-496 -530,-720,701 -536,308,410 --706,-480,-750 --74,50,-5 - ---- scanner 10 --- --406,581,-714 -722,-721,317 -802,778,364 --564,849,465 --667,-365,-438 -880,877,-395 --703,-353,-411 -663,-772,352 --459,913,488 -365,-811,-472 --585,-455,-439 --46,127,15 -640,835,-400 -733,886,-350 --476,497,-778 -71,-69,-135 -722,-803,507 -421,-731,-387 --376,-800,384 --365,-867,526 --494,-863,468 -383,-733,-359 -741,836,476 -782,684,432 --479,605,-874 --582,767,515 - ---- scanner 11 --- -402,-784,-886 -783,741,-556 --533,-704,643 -839,727,-764 --821,-388,-547 --465,784,451 -792,715,595 -664,690,666 -316,-559,712 --683,-423,-526 --440,637,393 -431,-649,-791 --363,809,-761 --378,775,-625 -740,735,-794 --75,-30,-32 --745,-486,-533 --525,-622,485 --421,680,-715 -406,-540,884 --491,-643,554 --393,705,457 -452,-813,-891 -65,119,-66 -456,-575,672 -567,766,593 - ---- scanner 12 --- -784,-492,511 --295,-330,781 -884,816,628 --346,698,653 -448,382,-760 --344,-362,747 -933,886,678 --350,-348,824 -872,819,834 -490,-826,-332 -399,385,-821 -811,-655,455 -582,-747,-373 -530,520,-793 --308,-480,-589 --547,403,-234 -520,-709,-233 --587,379,-311 --379,-467,-617 -85,84,166 -836,-569,445 --332,886,592 -69,-48,4 --258,826,716 --330,-440,-596 --726,431,-236 - ---- scanner 13 --- -411,707,-621 --565,830,590 --692,445,-432 --739,-815,-383 -772,-378,-261 -801,-428,-256 -10,48,94 --787,402,-522 -376,845,-600 -474,769,-614 -353,804,492 --747,-716,-353 --584,754,611 --423,-607,800 --508,703,701 -578,-458,360 --753,-759,-591 --821,387,-386 -323,770,583 --649,-602,747 --125,151,-15 -288,802,574 -618,-419,428 --585,-660,787 -637,-407,-356 -496,-530,367 - ---- scanner 14 --- -608,-336,293 -752,444,-774 --502,766,474 --625,793,605 --902,528,-904 -641,-374,-719 --800,421,-990 -714,-534,-743 --890,385,-949 -436,-409,304 --89,60,-6 -644,-470,-827 --641,-686,-497 --457,-846,413 --714,-625,-568 -717,476,-765 --79,-90,-191 -238,703,699 -266,865,702 -687,442,-856 --463,-835,357 -302,777,740 --724,-581,-518 -500,-331,370 --458,-852,419 --604,704,553 - ---- scanner 15 --- -787,-650,573 --404,-560,-455 -336,-785,-518 -797,-689,790 --582,-698,615 --67,-11,29 -785,770,-779 --804,818,-693 --792,863,-836 -520,834,444 -364,-788,-356 -642,895,555 --673,-793,518 -850,688,-777 -775,-644,672 --608,-826,595 --711,854,745 --527,-691,-428 -400,-826,-444 -560,902,483 --861,886,833 --506,-639,-517 -815,679,-745 -78,64,-58 --702,904,-800 --740,856,837 - ---- scanner 16 --- -768,605,-805 --608,844,666 -347,571,569 -848,559,-637 --611,783,784 --475,498,-568 -563,-497,-533 --538,603,-521 -798,-408,758 -810,-356,747 -545,610,547 --699,-816,599 -678,-525,-466 --722,-652,690 -502,545,513 -667,-496,-603 --664,812,569 --688,-720,546 -787,478,-779 -73,9,-106 --400,-445,-655 --79,60,53 --530,378,-495 --391,-602,-630 --377,-654,-667 -742,-408,707 - ---- scanner 17 --- --860,464,581 -404,733,736 -399,-669,688 --865,422,341 -869,842,-527 -747,844,-651 --882,-419,796 -564,-247,-439 -756,692,-561 --513,-525,-716 -69,2,35 -350,-664,708 -601,-364,-349 --896,-492,758 -480,712,717 --493,-654,-688 --84,119,78 --407,-588,-723 --765,-350,735 -531,622,793 --396,458,-416 --329,397,-572 --399,446,-622 --910,413,488 -389,-725,818 -661,-310,-316 - ---- scanner 18 --- --544,-725,396 -699,-488,503 --607,-772,501 -264,447,-773 -310,575,521 --572,460,285 --7,-109,20 --460,-663,-704 --469,-638,-547 -290,458,-950 -598,-690,-598 --599,-798,276 -437,572,427 --393,543,-957 -718,-514,376 --187,20,-25 -779,-656,457 --446,-626,-756 -326,596,469 -363,558,-826 --736,444,385 --722,336,292 -609,-827,-627 -494,-760,-599 --425,608,-859 --394,619,-850 - ---- scanner 19 --- --792,-483,-620 -341,393,-874 --563,907,-919 --868,-534,-710 --931,785,778 -700,-776,776 --913,898,700 -547,396,-886 --195,30,-19 --811,-407,-599 -497,326,-935 --589,-835,513 -486,-759,-640 -559,-844,787 --40,53,-150 -522,514,344 -459,386,256 -452,-872,-490 --656,857,-868 --875,870,698 --555,-850,377 -576,-750,-488 --416,862,-910 -737,-849,749 -583,326,330 --684,-792,423 - ---- scanner 20 --- --407,576,646 -486,697,-523 -544,808,502 --929,-530,-560 -542,-407,-580 --821,-480,-469 --656,426,-554 -585,-321,-701 -405,-675,559 -635,-487,-652 -620,783,586 --661,-416,528 -543,649,624 --442,519,509 --534,496,633 --865,-631,-556 --741,-344,531 -329,670,-599 --183,57,-25 -359,-719,448 --717,444,-506 -320,-770,452 --30,-75,-63 --813,-345,599 -324,681,-447 --619,312,-443 - ---- scanner 21 --- -429,874,443 -614,-831,729 -349,789,387 -807,850,-681 --654,-676,-750 --619,513,-843 --565,-718,-689 --468,-816,659 -427,902,405 --450,736,687 -750,-846,763 --585,768,778 --633,426,-839 --404,-769,591 -536,-388,-434 -704,-788,634 -35,16,-73 --462,-744,738 --555,442,-822 --569,629,659 -705,822,-563 -795,823,-645 --496,-684,-668 --107,41,71 -522,-464,-532 -515,-526,-469 - ---- scanner 22 --- -365,-635,386 -581,917,409 --8,123,57 --370,-536,-733 -528,809,-505 --334,618,-845 -787,-549,-660 --614,794,504 -499,852,407 -590,882,441 --648,-567,444 --322,582,-872 --642,-441,306 -837,-559,-616 --424,700,-844 -406,-725,350 --654,-331,419 --607,731,442 --593,829,366 -78,-10,-96 --377,-454,-889 -636,806,-409 --418,-429,-807 -451,-737,493 -612,879,-569 -858,-476,-721 - ---- scanner 23 --- --851,915,696 -389,-697,-376 -281,-653,-479 -397,601,-595 --534,868,-330 --413,-663,-631 --867,756,662 -376,684,-490 -630,-676,673 -709,-513,622 --540,867,-324 -829,822,386 --8,16,1 -447,611,-551 -814,731,514 -386,-751,-431 -740,-619,672 --807,869,591 --389,-373,604 -714,821,524 --408,-473,-658 --425,-573,-683 --478,862,-341 --397,-581,557 --383,-375,578 - ---- scanner 24 --- -553,-531,-484 -515,901,443 --488,-330,-877 --395,-640,803 --489,-468,-762 -719,-689,477 -666,-610,341 --699,607,-495 --554,-606,819 -676,-504,-338 -628,-731,322 -656,858,-646 -623,896,366 -451,823,377 --579,-458,-862 --626,546,-424 --118,-62,-103 --448,397,430 -729,698,-670 --709,651,-445 --443,380,492 --441,-535,759 --5,84,74 -659,762,-754 -571,-481,-402 --442,386,486 - ---- scanner 25 --- -576,805,-368 --522,908,464 -630,-324,-503 -735,983,767 -601,-613,565 --656,770,-584 --604,-268,-754 -452,655,-375 -659,984,874 -724,952,776 -621,-509,530 -559,-571,519 -560,641,-468 -20,5,45 --746,-231,-803 --510,931,673 --849,-408,723 -592,-458,-580 -7,178,-115 --609,833,-479 --750,-291,753 --682,778,-359 --572,-263,-801 --547,917,621 --709,-370,661 -714,-299,-579 - ---- scanner 26 --- -843,-791,297 -921,-678,279 -755,637,-577 -520,957,655 --471,-436,-492 --449,574,-489 --440,542,-454 -475,-712,-753 --477,590,418 -748,575,-640 -149,105,-164 -566,899,526 -734,499,-542 --767,-755,794 --387,-372,-562 --725,-750,554 --567,641,342 --456,514,399 -463,-739,-789 --358,540,-519 -656,942,621 --495,-276,-565 -841,-763,335 --776,-800,647 -18,47,10 -565,-711,-671 - ---- scanner 27 --- -310,-373,899 --770,469,775 --603,-909,924 -408,454,706 --534,339,-353 -550,-378,857 --826,632,802 --447,-842,863 -527,374,-750 -468,339,-699 -457,-328,908 -769,-365,-709 --500,307,-304 -62,-61,94 -468,529,-781 --689,-909,-341 -807,-337,-711 --836,546,827 -449,498,858 --653,-839,875 --628,-721,-355 --565,-849,-267 -825,-450,-789 -388,386,800 --457,325,-359 diff --git a/2021/20/input.in b/2021/20/input.in deleted file mode 100644 index 574baec..0000000 --- a/2021/20/input.in +++ /dev/null @@ -1,102 +0,0 @@ -##.......#.####..#..#...##.##...#.####.#.##.######...###...#..#####...###...##.###..#...#....#.#....###.#....##..####...##....###....##.#.###..###.#...####.#....#.#.#.####...#...#.#..#....#######......#..#.###.....#.#...#.....##.##.##..#....##.##.####.#..#..#.#...#..########.##.########....##.#...#...#..#..#.#..#..###..#..##.##.#.#.#.##.##..##....#.##.#.#.##.#..#..####..#...####.##..#.....###...##..##..####..#..#...####.##.##.#.##.#....####..####...#.#.#..#.#.##.##.##.###.#......##.#...#.#.##..##.##..###... - -##.##.#.#####..###.######.#.######..##...#.#.##....#..#...#...##.##.#######...###...#..#.##..#.##.## -.###..####..#..#....##..#.#.#.####.##.#.#####.####.#.....#.##.#####.#.....#...##.#.###.......#.##### -..###.#..##.....#.###.#.##..##...##.##..##.###.##.#..#..#....###.##..#...#.#.##...###..##.......#### -.##...#.###...##..#.##..##....#.#.#####.#.#.###..##...#.##.#.....#..#.........#.#.##.#...##.#....### -##..##..#..#.####.#...##....#.......#...#.#.#..##..#.###..#.#.####.#..##..###...####..###...#.....#. -...#..#....##.#..#.#..#...###..#...#.##.##...#...####.#.#.#.###.##.###.####..##.##....#..#.###....## -..#.####.....###......###......##.##.###...##.....#.#..##...###..##..###....##..#.###.####...##.###. -#...##..##.#.#..#.##.##.#.##.....#...##.#...#....#......######.#...###....#....####.#.###.###...#.#. -#..##..###...#.#..##..###..#....##.#.#####.#.##.##.#....###.####.##..#...####..###..###.#...#.#.###. -#.##.#######.###.###..###.......##.##...#...####.##...##..##.###.#..#####.#..###..#......#..#####..# -.#####....#####..#..###.##....##.#....#.#..#...##...#.#.#..####.#.#..##.#....####...#...##..##.#.### -#.##.#..#.#.###.##..#.##.#......###..##.###.#...############.##...##.##..#.#.#.#..#.##..##..#.#..##. -##.#.##.#..##.#....#..#..#.#.##.####....#......###.##.#.##.#.##.#.#..#.#.#...#...##....##.####...#.. -#..##.##.##......##...##..#.######.#.#.##...####.#.....#...#.#..#....#...#.#####.....##.#....##.#.#. -#.#...##.#.#..#.##.##.....###..#.##.#...##.#.......#.######..###########.###.#.#.##...#...#.#.#..### -.##.#..#...#...#.##..###...##########.##.####....##.#.##########.#..#.#.##########....##......#.#.## -#..##.###.#..####....#.###..#.#.###.##.#######.##.#####.#......###.#..#####....##.#...#.#######..... -#.....####........#......#.#.#.##..#.#..#.#.#.#.##..#######...#...###.##..#.#..#...#.#.....##.#.#... -#.#.#.####..##...###.#####.########......#.#.##.##...##.#...#.#.#...#..#..#.....##.....##.#..#.#...# -...#.##.#..###..###.#..##...##.##..#####....###...###.#.#########.#..#...#....##..#.##.#.###.####... -##.#...#..#..#.#..##..#.#######.#.#..###....#....####..##.##..#.##.#.####.##..#####.##.#...#.##..#.# -......#.#.#....#.###....########....##....####..###.##.####.......#.#..###...####..###.####.##..#.#. -#...##.#.###.#.###...#.#..#..#....#....####.###.#.####.#####.#.#...#.#.#.####..#.####.....##.#..#.## -....###..#.##########......##.####..##.####....##.#.####.##..##......##.##..##.####..#####..#.#.##.# -#.#.###.###........#..#.#.##.#..#.###.#.#.##..#.#.#.##.#########..#..#....##..#....#.##...#.##.#..#. -#...#..###.######..#.###.#####....###..#..#...#...###.#.#####.#..##..####..##...#.#.##..###.#....### -###.#..#.##.#.#...#.#.#..#..#...#....#.......###.......#.#.##...#.#.....#...#.....#.#....#####...#.# -..#.......#.#.#.##.....##.####.####...#..##.#.##....#.##.#.#.####..#.#.###.....###..####...##.#.#... -###.####.#####.....#...#.###.#...#.#...###.#....#..#.#######...#####..#....###.....#######..#####.#. -.#####.#.#.#.##..#####.####.#.#.#.#.#...##..##......##..#.###.#..#...#...####...#.#.##....#.####..#. -...#.#.##..#...######.##.#.###..####.....#..##..#.####..#.#.##.##..#.###.###..##...##.#.#.#.#.##.##. -...#...##.#.####.#.#..#..#..#.#.#.#.###.####.#....###...#.....##.###..#..##..##.##.......##.##.##.## -###.##...##.#####.#.#..#.#..#.#..######.#....#..##.######...#..##.#####....#.##..###.##..#.#...#.... -##.....##.#..#####..#...#.#.#####.....#..###.##..#..#..#.#.....#.#..##.#####..##...#.###...##.#.###. -#..#..##..#..#.###.#..#..#.##..#.#####.##.....#.##......#.##.######.##.###.##...#..####...#...##.### -.#.###...####...#....#..##.#.#..##.#.##.###..#..#.##.#########...#.#..#..##...####.#.#.#.##......### -#...#...#.###.##..#..#...#####.#######......##.#.....#.#......#..####..#..##..#.#..#######...#.#..#. -.#####..#..#...#.###...###....#...#..##.###...#.#.#...###.##....#...##...#.#..#..##.###.#.###....##. -#.#.#.#.......##..#.#.#.###..###...##..##..#.####....##.####...#...##..#.#..#.####.######..######... -.#......#.##..#.####.#..#.#.#######.#..###.#..##...#...#..##.###.#..######...#..###########..###.### -...##...#...##.#.##.###..##.####.#.#..#.##.##..##.#.#.....#.##.#...#....#.##.#....#....##.#.#.####.# -.#.#....#.#..#....#..##....#......##.##...###.....#...#.#...#..#..##..##...##.#..#.####..####...#.#. -..##.#...###....#.#.######.#.#....######.......#..#...###.###.##.##.#..#.###.##..#.#.#..###########. -.##.#..#.#.#....#..###.######.#....#########....#...#..##..##...#.#####.###.##.####...#..#..#.#.##.. -####.#..#....##...#...#.#.##.#.#.##.#.#...#...##.....#..##..###.#.#.#.#####......#..#....##..##.##.. -#.#..##.#..##.##.###.###...#....#####.##....#.#..#.#..#####..#.#..###.#..#..#......##.#.##..#.#.#..# -###....#.........#.##.#.##.#.#.###.####.###..#.####.#####.####.....#....#..#...##.##..##.####...#.## -##..###.##.########.#.##.##...#.#..###.##.###.####.###..#..#...#.#.#..##..###.#.#.##...#####.#.#..## -.#####..###..#.#..#....##..###.#.....#...###....#....##..###.##..####.#..#.#......###..#....#...#..# -.......#.##....##..#...##....#..##...#.##.#..##..#..#######..##..#.#....#....#..####.#.#..#.#.#.##.. -....###.#..#..#....#..#..#.##.....#..##..###.#.#.###.##.#..#....####.##.......##.#..#..#....###....# -...####.##.#.########.#.##.##...####.#.###.##..###..##.....##.#...#.........#....##.....#.####.#.##. -#..##....#.##....##..#...#.#.##.####....#......##..##.##.#.#.#.#....#.####..##.#.#..########..#...## -.####.....#..##...#.##..##...#.#..#.#...#####.#...#..##....###.###.#.##.####..#.#.#..#...#..#.#.#... -#.###..#...#.#.##.######....#..#...##..##.###.....##..#.#.#..#.##.#.####..######........##..#.##.... -.###..##....##..#.###.##..#..##.#.#.....#..##.#####.#.#.#....###...###......#.#..#####...##....###.. -.#.........#..##...##.##.##..#...###.#####.#####.#..#....##....##..##...##.#..##.###..##..##........ -.#.##...#..#..#.#####...#..###.###.#.#....######.##....#.####.####...#######.....#.#.#.#.#..#..#...# -..###.##..#....#######.#..##.#.##.###.##.#.#..##..###.#.###.....#..##.##..##.#..##.....#.##.#.#####. -###.....#...###.#....##..##....#..#..###...###..#....###.##.#####.#...#....#.####.###......##..####. -####....###..##.#.#.#..########..####..##.#...........#######.###.#..#.###.##.##.....##.....###.#.#. -#.###.###..#.#.###.....##..###......#....#.#...##.###...###..#..####..#.....#...##..##......#...#.## -.....#.........#...###.####.#...###.###..#.#.##..#.###..##..##..#......#.#######...##.###.#.#.##...# -##.######...#...##......#..#.######.###.#####.....#.#.#...####.#.#...#.###..#.##....#######...#...## -.#..#.........########.##..####.#########..##.....###.##.#.#..#######..#..######..##.#.###.######..# -#.#.#.#.##.#.....##.#.....###...#..##.#.#.###....#.#...##..##.###....###....#.####..###....##.####.. -..#.#...##.#######..#.#...#.##...##.#.###.###.#.#.##.#.##.##..#.##..#.#....#.#.#.####......###...##. -#.#....##.#....#.#.###..##.#.#.#######...#.###.#.#.#....##...##.#.#..#...########.##.###.#.#.#....#. -#.....#....######...###.#.##...#.#..##..#.#.#....###..#......#..#........##.##.#..####.#.#.##.#.#### -#.#..#..#..#.##.#..#.###...##.##....#....###.##.#####..#..##.#.#.#..#.###..##..#####......###.###.## -#.#......#.#.###.#..#...#......#.....#..#..#..#.#.....##.#.##..##.###.#.#..#.#.#....#....#.#....##.. -######.#.##.##.#.#...#.##..#..########.#.####....##.######....##.##.....#.###....####...#.#.##..##.# -..##.###..##.#.##..#..#.######.#.#.#.####.#....##..##..#.#.#....##...###.##..####...#....#######..#. -##.##.#.....###..#####.#.###..#.#.#...##..#.######.#######..#.##.##.##..##...#####...##.##.#.###..## -#.#..##.##....#...##.#..#.#####..##..#..##.#.##.#.##...##.##...##.###........#.############.....#... -...#.####..##.#.#..#.#.#..##...####.#..#.#....##..##..#####.#..#...##.##..###..###..##...##...##...# -#.###..#.....#.#.#######.#..#..##.###..#..#.##.#..####.#...#.####.##.#....##...##..##..##..#..###..# -###..##.###.#...##..##....###..#.#..#.#.##.....#..##.#..##..#.##......#..##..#.#..##..#.####...##.#. -...##...#.#.##.#...###.##....#.#.#.##..#####.#.##.#.##.###..#..#.##.#..###.####.#...#....#.#.#.#.#.# -...#.#...####...#####.....#.#.##.#.#..##.###..#.#..##.###.#.#....#.##..####..#....#.##.###....####.. -...##....##..#.#..#####..#...###..##..#.#..#..###.....##..#..###.#.###....#..#.##.#..###.#....##..## -.#..####.#.#..###.##.#.###.#.###.######.####.#.##....#.#...#.#####..#.##..##......#..#.#.##.##.####. -....##.#.#.....###..##.#..#..#####.####.#.#.##.####..##.##.#.##..#.###.....####.###..#.##..#...#.#.. -#.##.#..#.###.#.###..#.##.##.##.#...#...#.#....#..#.##.#.....#....###.#.###..######......#.###.##.## -#..##.#.#........##.#.###.#.#.#.#..##.##.###.#.###.#....#.##.#####.##..###..###..##.#.....#.#####... -#####.##..#.#.##..#...#...#.#.####.#.#.##.#....#.#..##...#.#.#.#.#..#....##.....#.#..#####..##.##... -.#.##...##.####...#..###.##.#.#....##...#.##.##.#.#..#.#..##..##.###.#.#..#.#..##.#...#..#....#.#..# -######......###.#..#....##.#######...##.####.#....#..####.#..##.#..#..#.######.#.#.######..#.#..##.# -###...#.####.#...#.##.####...#....##.#..#.#..###..#..#....#.###.#.#.#.#...##....#..#..##.#.###....## -.#.##......##..#...##....###...#..###.#.#......##.###.#.###.#..#####..#...###.####.######.###.###..# -###.#.#..##...#..#.#.#....###...##..##.###.#.###.##..####.#.##.####.##..##...#......#######.#..##.## -....##..#.#...##......##.#.#.#.####.#.#......#.#..........#....##...#.##.#.#.###..##.###.####..####. -#......####.#.#####.##.###.##...######..#.#..###.##......###..#..#.#...#.####.#.##...###..#.###..### -.#....###.##.####.##..####..##.##..######.#..#.###.#...##..#####...#..###.#.#.#######.##.####.###.#. -###.#.#.#.###.#.#.###....##.....###.#..##.####..#.##..##.##########.#.#..#..###..##..#.####......### -...##..##..#####.#..#.###..#...####....#..#.####..#...###.##.###.###...#.#..#...#..#.#..###..#....#. -.###.#.#####.#....#..######.####.###..##..###...##...####..#.....##.##.#.....#..###.####.....#.##.## -.#....##.#..##.....###....##.#.#####...#..#..###..#......#.#....#...#.#.#....###...#..####..#.#...#. -#....#..##..##..#.###..#..#.#.....#.#.##.#####..#.#.##...##..##..#.##.##.#..#...#.##.#...#.#.#....## -#.#...#.###..##.##.#########......#.##..###.###...##...#..##...#.#...#..###.#######.#####..#.##.#.#. diff --git a/2021/21/input.in b/2021/21/input.in deleted file mode 100644 index 8fc0831..0000000 --- a/2021/21/input.in +++ /dev/null @@ -1,2 +0,0 @@ -Player 1 starting position: 7 -Player 2 starting position: 4 diff --git a/2021/22/input.in b/2021/22/input.in deleted file mode 100644 index 3ca7e56..0000000 --- a/2021/22/input.in +++ /dev/null @@ -1,420 +0,0 @@ -on x=-45..7,y=-17..27,z=5..49 -on x=-47..6,y=-17..30,z=-24..26 -on x=-41..3,y=-7..39,z=-40..13 -on x=-7..37,y=-13..39,z=-8..42 -on x=-28..25,y=1..47,z=-30..16 -on x=-17..35,y=-41..8,z=-24..28 -on x=-12..40,y=-16..36,z=-9..38 -on x=-42..5,y=-43..5,z=-41..5 -on x=-41..8,y=-19..32,z=-5..48 -on x=-7..45,y=-48..-4,z=-36..18 -off x=-30..-17,y=-18..-5,z=14..31 -on x=-34..11,y=-2..43,z=-40..12 -off x=15..31,y=8..23,z=-25..-14 -on x=1..49,y=-7..39,z=-21..27 -off x=-10..0,y=24..33,z=-25..-8 -on x=-45..1,y=-5..45,z=-20..31 -off x=-45..-28,y=-3..15,z=29..43 -on x=-28..22,y=-13..33,z=-17..31 -off x=40..49,y=9..24,z=-38..-21 -on x=-31..20,y=-21..31,z=-10..40 -on x=58139..70015,y=-49609..-18906,z=19361..36256 -on x=-39287..-12309,y=66131..82072,z=13276..35310 -on x=-38949..-17453,y=-49529..-24823,z=55665..59650 -on x=61392..82266,y=-12404..6500,z=4950..31263 -on x=70741..83016,y=-1541..20873,z=-21674..7357 -on x=-34218..162,y=-70012..-44525,z=42760..66985 -on x=-47728..-21420,y=-1708..17042,z=-84807..-57400 -on x=-69820..-59219,y=43821..69305,z=2296..22054 -on x=46547..61145,y=-50265..-36252,z=19460..47328 -on x=10220..47534,y=56556..93325,z=-2705..20946 -on x=-66580..-44842,y=-59481..-31671,z=18352..40065 -on x=-67971..-41858,y=-15159..3388,z=39731..56500 -on x=-7464..2686,y=69347..76538,z=13667..39722 -on x=-44072..-16433,y=-43849..-30853,z=56335..69595 -on x=-83105..-72178,y=5307..31541,z=-3936..16810 -on x=25464..39638,y=-120..31814,z=-69618..-52103 -on x=-82616..-57987,y=15114..25223,z=-28861..-23141 -on x=-49633..-29006,y=41204..52341,z=-65156..-47964 -on x=41031..61766,y=-76189..-58486,z=9912..27403 -on x=57437..69980,y=12769..38313,z=-43090..-17897 -on x=17604..33962,y=-75729..-58412,z=-48962..-35687 -on x=63409..77341,y=-21036..12184,z=29223..43584 -on x=-5980..19717,y=41947..72255,z=38283..56970 -on x=9718..12557,y=67771..85749,z=17773..34267 -on x=8015..28022,y=-18543..-3527,z=-89441..-59883 -on x=-64308..-56323,y=21361..38767,z=12257..42684 -on x=-11882..16043,y=30052..57566,z=57092..81130 -on x=-13820..53,y=-74086..-63407,z=37807..48599 -on x=40956..59336,y=58187..69842,z=25877..39207 -on x=-4691..23405,y=-79041..-70404,z=-14086..5935 -on x=66930..81266,y=-37722..-4197,z=27732..37351 -on x=-19848..-2104,y=61123..83113,z=11320..30475 -on x=-66891..-46977,y=-588..33596,z=33866..52493 -on x=-13090..15764,y=63984..75318,z=23277..60045 -on x=-14119..15900,y=-13901..1426,z=60017..94903 -on x=12498..29184,y=58541..70777,z=-50866..-38397 -on x=-67009..-43569,y=-69320..-39097,z=24026..51765 -on x=17594..36756,y=25770..47449,z=47460..61914 -on x=43517..53046,y=-56173..-37227,z=20953..36522 -on x=39963..42250,y=57583..75800,z=-1394..6811 -on x=19518..48960,y=52233..66739,z=-48141..-30882 -on x=52411..62263,y=-70027..-49483,z=516..15609 -on x=-27930..-5097,y=-74677..-52111,z=-59808..-41624 -on x=56383..62339,y=-62443..-42931,z=7509..24599 -on x=43191..61390,y=36457..58193,z=-16838..1525 -on x=32499..55237,y=-69168..-42561,z=-10459..-1917 -on x=-58208..-37739,y=-28039..-4075,z=40414..61838 -on x=879..22641,y=74295..88511,z=-19483..9324 -on x=-5492..8717,y=-85892..-60796,z=-41420..-29271 -on x=-61450..-39696,y=-49010..-38395,z=21478..40987 -on x=32490..45756,y=-8722..-4698,z=-76184..-56133 -on x=-90953..-70436,y=-29377..-3902,z=-40397..-23576 -on x=20598..38603,y=66163..85567,z=9851..28068 -on x=27571..32595,y=-59796..-30762,z=-63579..-38559 -on x=12086..41959,y=50402..75453,z=-54908..-21406 -on x=-14331..1008,y=71841..90790,z=-2133..19891 -on x=3915..28155,y=-5795..4405,z=75839..94136 -on x=-55589..-36558,y=47040..66883,z=-30804..-10538 -on x=-82372..-51132,y=-47601..-21545,z=-40952..-21789 -on x=-231..19231,y=-59449..-29763,z=56397..73100 -on x=-85290..-58709,y=-16609..-8329,z=-29163..4167 -on x=-63346..-48051,y=52873..69585,z=-30842..3080 -on x=-25328..-4496,y=12591..44061,z=-84403..-55728 -on x=-21682..13927,y=-80747..-59930,z=-5486..20947 -on x=8693..18060,y=4143..13917,z=72062..87750 -on x=-58360..-31194,y=47907..73246,z=8480..21809 -on x=2105..34277,y=52967..69971,z=-50821..-20714 -on x=22406..39629,y=50181..61542,z=43485..55870 -on x=-39074..-13502,y=50579..72036,z=-60260..-46008 -on x=-16311..-6287,y=16984..36635,z=68924..86294 -on x=-48550..-15024,y=-61029..-31290,z=54895..67840 -on x=-50877..-30410,y=-1926..13529,z=53814..85287 -on x=-36471..-13748,y=36383..48289,z=-83446..-48216 -on x=26766..48259,y=-43762..-25681,z=56822..77314 -on x=-17837..10480,y=-63530..-38447,z=-59572..-41895 -on x=20337..49911,y=55663..87453,z=5287..22885 -on x=-55628..-21884,y=37700..65006,z=38798..55418 -on x=-67405..-42145,y=-7082..13919,z=-63850..-39429 -on x=-62190..-49213,y=49865..67498,z=3390..13755 -on x=-51622..-18963,y=51212..74783,z=-28793..-8944 -on x=66722..82965,y=5925..20106,z=28397..44234 -on x=-66827..-51821,y=2821..11144,z=30591..50432 -on x=35642..66682,y=-74513..-45994,z=-15026..5100 -on x=27277..36975,y=-73319..-45025,z=-54816..-32826 -on x=17935..54757,y=-61336..-35653,z=55321..68784 -on x=-53245..-32593,y=-8830..8348,z=-76698..-59749 -on x=-43668..-18711,y=49769..78016,z=-50596..-28488 -on x=-72259..-40599,y=40207..59440,z=21612..41506 -on x=50424..74664,y=24414..39823,z=-38827..-9157 -on x=-58443..-41638,y=19203..40243,z=-54425..-48848 -on x=-55245..-32288,y=56063..70391,z=-61296..-37638 -on x=-49262..-36162,y=40765..56914,z=39896..58492 -on x=71936..78823,y=21562..36332,z=-6530..9437 -on x=21183..33209,y=-63451..-35210,z=43680..67677 -on x=35315..59459,y=-79781..-55078,z=-5718..9678 -on x=5598..19316,y=62740..70153,z=-38729..-30069 -on x=59043..77670,y=-53992..-36698,z=-18798..1018 -on x=32561..52959,y=54567..76299,z=-6363..11619 -on x=64072..83686,y=19684..46937,z=-26206..-226 -on x=66407..80678,y=-6031..15815,z=-50231..-28853 -on x=-62433..-51106,y=-50185..-42513,z=-59329..-34248 -on x=69442..84353,y=-37609..-18888,z=15039..22599 -on x=-75863..-45632,y=-67797..-44088,z=13448..35319 -on x=-57525..-34978,y=49512..61488,z=-34514..-10529 -on x=-78241..-45455,y=-41939..-25787,z=-37581..-12052 -on x=26231..48086,y=55721..87000,z=-26989..-2861 -on x=-4820..16896,y=-89410..-59766,z=-12799..17397 -on x=-65173..-53273,y=33923..60231,z=22787..35885 -on x=-25789..-12467,y=-20692..-1528,z=-90659..-77680 -on x=-13681..4235,y=-72843..-65344,z=37936..54871 -on x=-11..15471,y=-77300..-67134,z=30860..37972 -on x=-28323..2329,y=43128..57045,z=40410..68197 -on x=-77368..-60587,y=-40892..-36302,z=-4933..14472 -on x=-71440..-43438,y=29241..61084,z=-45200..-17748 -on x=-46541..-29430,y=-30481..-20386,z=-77000..-48239 -on x=-7222..17417,y=-82920..-65369,z=-24777..-2228 -on x=2428..23021,y=49309..71893,z=33651..47624 -on x=-79286..-73434,y=-4555..3976,z=-30692..-15990 -on x=-57833..-36691,y=50060..70993,z=-49705..-40886 -on x=-13633..-3901,y=70191..89145,z=-9546..8579 -on x=30203..51142,y=41221..64139,z=-49984..-36750 -on x=25779..40661,y=62196..84217,z=3820..31889 -on x=-58668..-46042,y=46561..68990,z=-29470..-12201 -on x=8943..46059,y=-61596..-28191,z=45500..78129 -on x=28768..53964,y=-39042..-2958,z=61006..67475 -on x=-10473..2243,y=-57135..-35805,z=50664..61840 -on x=63395..88485,y=-28148..-8518,z=-20034..6196 -on x=6817..17829,y=-22295..-6626,z=60702..92502 -on x=-54667..-43405,y=-35771..-14244,z=-62194..-47623 -on x=18751..34299,y=44719..66964,z=-65540..-32700 -on x=-24683..-8536,y=-57872..-22245,z=57265..75481 -on x=-62653..-47058,y=-71546..-56371,z=4383..22163 -on x=47349..60320,y=54753..74576,z=-21348..2434 -on x=-38274..-12869,y=-7578..3906,z=-87883..-58190 -on x=-33826..4521,y=-11790..8404,z=-86733..-67748 -on x=-52661..-35931,y=26091..49288,z=-66021..-48412 -on x=44264..57460,y=58198..70004,z=2720..15895 -on x=17474..36290,y=67465..77999,z=1861..17546 -on x=-38975..-10327,y=-27672..4843,z=-83570..-68390 -on x=-33746..-20547,y=-74631..-45171,z=39800..51056 -on x=-24599..-21768,y=-46393..-24475,z=55208..71397 -on x=3164..19967,y=-65190..-44643,z=50418..72570 -on x=53619..66155,y=-51057..-29658,z=-55773..-20405 -on x=2427..22904,y=-95956..-66495,z=-36877..-18825 -on x=2944..9603,y=-86498..-58478,z=-47818..-30617 -on x=-10384..6884,y=38548..65953,z=48033..75190 -on x=41974..68250,y=34200..53098,z=30209..46591 -on x=-90428..-64064,y=-9949..-7541,z=-23619..-456 -on x=-66305..-49896,y=12749..28681,z=57529..59079 -on x=-93786..-65183,y=13210..20464,z=22646..36054 -on x=-71583..-55593,y=-18075..-7073,z=17505..49567 -on x=-63215..-45228,y=-11391..7580,z=58194..80874 -on x=-24085..-13987,y=-74188..-54667,z=40270..59993 -on x=41063..66463,y=-60593..-28582,z=-57706..-22356 -on x=-56785..-44700,y=-53712..-30970,z=27312..36091 -on x=-14349..6107,y=-5236..15914,z=-89681..-61552 -on x=-2414..15438,y=69685..96612,z=-17622..9238 -on x=58420..63800,y=5990..23102,z=34891..71606 -on x=6179..27982,y=-74431..-54768,z=14204..36485 -on x=61894..69769,y=34173..44733,z=8902..19407 -on x=-78362..-63040,y=19103..50632,z=-32334..-17303 -on x=62182..90308,y=-18030..8929,z=-2180..13388 -on x=30390..48405,y=-72383..-48673,z=36144..57755 -on x=-45454..-20423,y=-70458..-62117,z=-21023..1613 -on x=36175..58944,y=-81657..-52999,z=2448..22806 -on x=54470..71193,y=41067..44776,z=25090..44500 -on x=-91961..-67717,y=3964..29558,z=-28094..6750 -on x=-31391..-9169,y=-18878..6593,z=-78341..-75988 -on x=47896..79657,y=-67744..-30097,z=-24880..-16 -on x=-64300..-45475,y=7409..21358,z=-57363..-47213 -on x=-73942..-56617,y=-35835..-23791,z=-67498..-46695 -on x=2869..23028,y=36519..60117,z=-54212..-41508 -on x=2029..20149,y=52897..82718,z=28679..40476 -on x=-36196..-4590,y=-63991..-45779,z=42563..79330 -on x=14025..39832,y=49218..57689,z=-59867..-36377 -on x=48031..55950,y=52029..77629,z=-8043..15625 -on x=20246..41538,y=-11202..9933,z=72656..87842 -on x=-67616..-40170,y=12132..31220,z=-74768..-55643 -on x=-5329..848,y=13794..51295,z=-77787..-65482 -on x=-75861..-64089,y=-21592..-3946,z=-39892..-8479 -on x=-77211..-65745,y=27088..38134,z=-13374..-8928 -on x=37830..58943,y=47065..77746,z=298..18874 -on x=-75469..-41239,y=-60573..-47270,z=-8955..16006 -on x=-56176..-39724,y=-61947..-41061,z=-68714..-31253 -on x=-86282..-64173,y=12949..39281,z=24182..46117 -on x=-41914..-22656,y=-79945..-51310,z=15689..35920 -on x=21347..36914,y=56858..86289,z=19672..35772 -on x=12201..29696,y=59898..74244,z=31480..58564 -on x=23451..53913,y=5070..36118,z=-71964..-55710 -on x=52084..63506,y=2554..22599,z=-55360..-32465 -on x=13753..23490,y=63510..88732,z=4051..12664 -on x=-69866..-44325,y=36781..64233,z=29840..36459 -on x=-8139..-4203,y=19157..40182,z=-93960..-65960 -on x=42305..64756,y=22258..36563,z=41947..60736 -on x=-23146..10560,y=-99141..-74322,z=30..10375 -on x=-67502..-44911,y=-58624..-54469,z=-20071..40 -on x=-1816..30980,y=-93210..-68893,z=17460..29017 -on x=-66971..-39649,y=46207..60551,z=-2186..20048 -on x=57315..58674,y=33730..47187,z=-32958..-18355 -on x=55047..84474,y=24699..40492,z=-46207..-20341 -off x=-33063..-21256,y=-57696..-30224,z=-58827..-49473 -on x=15782..43013,y=-31004..-22072,z=65339..89647 -on x=-46864..-38602,y=-59421..-34651,z=-42145..-38505 -on x=338..19140,y=67761..75432,z=28552..32028 -on x=1165..3108,y=-84103..-65417,z=-7021..18773 -off x=61765..73452,y=-45659..-31483,z=6273..20553 -on x=-5904..9216,y=-95279..-75566,z=-15436..-7219 -off x=32482..50315,y=18574..37548,z=55762..79297 -off x=28578..60666,y=-57164..-47836,z=-37456..-18580 -off x=-3114..3055,y=-95936..-75112,z=16370..29867 -on x=-10868..13285,y=-23894..-5902,z=-93321..-72263 -on x=-41991..-24954,y=31908..51061,z=-70741..-48428 -on x=72292..78583,y=13091..46604,z=-16520..-8162 -on x=-80845..-74837,y=15441..28048,z=-5348..4713 -off x=51932..73538,y=-55178..-32685,z=-46650..-27464 -on x=46484..64440,y=22782..44759,z=-50796..-20460 -off x=-34434..-14835,y=27486..46328,z=56348..82832 -on x=-44176..-28566,y=-11705..15875,z=56902..81288 -on x=-33731..-11689,y=73052..83023,z=16583..38825 -on x=6312..27150,y=-793..26604,z=-92489..-61569 -off x=14092..28444,y=66009..93462,z=-21640..4954 -on x=16209..38551,y=-13562..-1358,z=-88722..-74583 -on x=-59972..-25520,y=41806..72865,z=-54134..-33465 -on x=-61623..-33367,y=-896..19881,z=51101..71993 -on x=-9583..14577,y=-86565..-55523,z=-51532..-34350 -off x=-33213..-7919,y=-90889..-66554,z=-39490..-10974 -on x=4294..20106,y=62156..76620,z=32450..55005 -off x=-40471..-12398,y=71892..92866,z=-19239..3156 -on x=61770..76100,y=31826..33819,z=-9830..20872 -on x=-25575..-23040,y=41833..59675,z=44548..55450 -off x=68252..71314,y=-21177..2051,z=31408..54792 -off x=-8045..11292,y=-72391..-63911,z=33543..45802 -on x=-8743..10578,y=-32006..-6402,z=-93482..-68214 -off x=73561..91272,y=5808..21229,z=-9935..2763 -on x=-30457..-8215,y=68079..79651,z=-10259..-6593 -on x=47517..81726,y=-2770..15448,z=25263..47900 -on x=54080..68182,y=-23598..5989,z=-59609..-46354 -off x=-75813..-65614,y=-15792..17698,z=22522..37787 -on x=-87006..-65845,y=-33396..-12386,z=5059..13493 -off x=-7171..8455,y=-92708..-74085,z=13156..24440 -on x=-10212..9937,y=59394..87542,z=-40866..-18151 -off x=6150..43593,y=-40711..-23001,z=55695..76253 -on x=-35948..-15354,y=-62908..-59402,z=-45479..-22686 -on x=805..9285,y=59136..71915,z=-59038..-37416 -on x=38933..59498,y=49011..71006,z=-8794..14206 -on x=-60069..-28629,y=21605..46948,z=41655..66447 -off x=-11597..14682,y=-89638..-61313,z=11985..34734 -on x=49754..60626,y=-10194..4245,z=-57384..-56173 -on x=-76993..-49823,y=1985..21722,z=27195..40273 -on x=3697..32693,y=39006..59117,z=47166..67641 -on x=-46344..-31390,y=26350..43919,z=-59943..-51289 -off x=-61186..-23421,y=3628..26108,z=-75248..-54653 -on x=-32256..3212,y=65884..75652,z=26282..48080 -on x=24335..60592,y=26877..56269,z=-59010..-35566 -on x=-47929..-11220,y=61537..80705,z=-951..12658 -off x=-34766..-24336,y=-88672..-68491,z=-22764..-2566 -off x=53419..59301,y=43238..55188,z=2622..33800 -off x=-10211..14650,y=-84660..-49473,z=-60698..-24956 -on x=-79252..-61788,y=12398..35394,z=1279..18242 -on x=-7059..9529,y=47864..69006,z=49118..58161 -off x=71189..88378,y=30685..51825,z=-9146..-3034 -off x=-81189..-65062,y=-10666..93,z=-49110..-27410 -on x=-32473..3746,y=-64466..-43485,z=32647..60505 -off x=13789..47745,y=25232..46055,z=58850..67334 -on x=36081..58769,y=6844..15343,z=53742..79111 -on x=69079..94470,y=-15594..4678,z=3766..24355 -off x=-67105..-49557,y=-38660..-26297,z=43118..59948 -off x=50681..80664,y=-19761..-8580,z=-42615..-37383 -off x=-47909..-18354,y=49435..68877,z=-43529..-15345 -on x=-88967..-59205,y=-13016..3451,z=-54832..-19130 -off x=10643..25625,y=10545..27433,z=64296..89575 -off x=4907..32957,y=-83127..-55966,z=-39854..-32569 -on x=22784..48884,y=-57836..-21249,z=-65327..-56473 -off x=10992..29981,y=66267..77315,z=-41222..-18950 -off x=-52091..-37868,y=-20232..-474,z=47891..72527 -on x=60481..75081,y=24637..41188,z=-46716..-40883 -off x=-23632..5610,y=1514..22656,z=74313..88576 -off x=31575..38873,y=40494..57318,z=32877..56552 -off x=24103..51366,y=-54507..-36072,z=-65355..-36367 -off x=-25237..-3440,y=-72086..-51759,z=-59419..-40897 -off x=-18141..16100,y=11832..33275,z=-87594..-71462 -off x=12042..37177,y=-86189..-74493,z=-19781..-3966 -on x=-12444..12639,y=-85487..-65396,z=-35640..-9225 -off x=-61040..-36584,y=-81216..-48830,z=-14964..12506 -off x=-23554..-6117,y=-72205..-47980,z=31059..61897 -off x=65088..79105,y=-37874..-16691,z=3979..35678 -off x=-53117..-33574,y=-13523..-5076,z=51420..78156 -on x=-25476..-9172,y=-82861..-63199,z=-43771..-26786 -on x=-86034..-56752,y=6474..32237,z=18690..35512 -off x=21171..53995,y=-36024..-8618,z=-85718..-54617 -on x=24027..48916,y=30554..49211,z=56592..63360 -off x=-31460..-8363,y=-91538..-67279,z=-20883..11877 -off x=50868..72728,y=-43133..-20868,z=30586..59496 -on x=60180..77450,y=-28264..-4028,z=27566..46058 -off x=25248..40253,y=52738..82118,z=-10027..10323 -off x=-53149..-35544,y=26124..57599,z=41182..47863 -on x=6893..26612,y=-56766..-18582,z=-76077..-64415 -off x=29251..43365,y=-56034..-33329,z=-74917..-58876 -off x=55417..84034,y=13218..36893,z=29426..38841 -off x=15245..41851,y=-51152..-25375,z=51072..78544 -off x=-19619..360,y=49798..63770,z=-68779..-57126 -off x=48875..73188,y=36354..65964,z=20137..55472 -on x=-50376..-23916,y=-84993..-56907,z=15202..30720 -on x=-63177..-46387,y=30846..55077,z=19244..38186 -on x=40274..55030,y=-71784..-45007,z=-4208..20470 -on x=28347..49207,y=63036..73385,z=-17068..13520 -off x=-26968..-3637,y=-9695..16790,z=66767..90772 -on x=68705..98416,y=-8622..10759,z=3213..26868 -off x=-3059..12360,y=66783..80670,z=-28986..7977 -on x=-58388..-40646,y=-33991..-31773,z=44197..59752 -on x=2865..11833,y=-67250..-57894,z=-62792..-24337 -off x=-57030..-37005,y=51218..75936,z=7769..32000 -on x=47527..74301,y=-58273..-36741,z=10584..15071 -on x=-60184..-39571,y=-30740..-20737,z=-68300..-39656 -off x=-86850..-65643,y=-5574..16927,z=3990..27771 -off x=13811..46354,y=-31173..3401,z=-79763..-64407 -off x=-13279..4029,y=74369..84704,z=-9402..6592 -off x=-38919..-37515,y=42906..53285,z=33500..63457 -off x=-3774..27927,y=-52395..-36924,z=50341..76959 -off x=-86316..-65121,y=-11814..7408,z=-13538..17834 -off x=39060..65192,y=-49523..-12954,z=44981..65013 -on x=44289..52572,y=5584..40317,z=-73249..-41724 -on x=41428..64314,y=-52679..-24605,z=-44071..-26710 -on x=-46798..-20610,y=-70188..-56150,z=-53205..-16499 -on x=-40671..-20938,y=69319..88891,z=5610..16726 -off x=13893..35132,y=-15329..7573,z=-95287..-72786 -on x=-31073..-26913,y=-77563..-57760,z=1928..22949 -on x=-53823..-47132,y=7432..14072,z=-65922..-42630 -off x=-92914..-60621,y=-25654..5949,z=12601..22146 -off x=24459..62772,y=61174..75406,z=24143..41263 -on x=-73652..-36824,y=23996..28076,z=-68072..-50254 -off x=5695..26986,y=-27324..-3742,z=58054..83456 -on x=30188..51914,y=53458..67994,z=5460..30526 -off x=67145..80765,y=-3482..25880,z=29419..47511 -off x=-89026..-70655,y=-42051..-13350,z=15265..35268 -off x=-28593..-19842,y=27064..45165,z=57782..73792 -on x=-46554..-23972,y=33019..60152,z=46108..61039 -on x=-51229..-27692,y=62079..81900,z=-25204..-10313 -off x=75830..79640,y=-8232..15863,z=12397..27598 -off x=47654..68376,y=351..18328,z=-61385..-30558 -off x=-49195..-23856,y=57499..72955,z=-5783..32067 -off x=-4065..13165,y=-53869..-18692,z=-77892..-68369 -on x=21771..41037,y=33685..63960,z=35189..54429 -on x=-62848..-42784,y=-53293..-32454,z=-42889..-23060 -on x=16633..41662,y=-77505..-49183,z=34223..52408 -on x=41423..65193,y=-74897..-45854,z=-16083..15691 -off x=5197..23912,y=-2192..30686,z=58695..84997 -on x=51540..52711,y=-68340..-53654,z=-20777..-19220 -on x=-48130..-28617,y=-9415..-1637,z=69241..89576 -on x=2500..18895,y=-56133..-49184,z=52561..81563 -off x=55700..81258,y=14145..34650,z=25325..46304 -off x=-24233..-94,y=-4089..20455,z=75592..93976 -off x=-73100..-65288,y=-8770..2793,z=-46595..-28483 -off x=20475..36233,y=65981..81822,z=10098..30519 -on x=-47992..-30588,y=-64098..-33920,z=48972..77171 -on x=-13261..8398,y=48870..70645,z=54671..71340 -on x=-70105..-48865,y=35572..63927,z=-16566..-3809 -off x=-90578..-69121,y=7582..45468,z=-7064..10904 -off x=-31215..-10949,y=72290..79639,z=-6286..6345 -on x=74052..84728,y=16884..29952,z=-19273..9356 -off x=35204..64806,y=55000..69546,z=-3598..9749 -off x=-49474..-24068,y=53139..55822,z=-57619..-47785 -off x=32313..52383,y=-26381..-13630,z=58768..73790 -off x=13580..35467,y=61719..88895,z=8669..29467 -on x=-54515..-49805,y=-4119..23034,z=-69401..-56491 -on x=-73961..-54235,y=25557..37602,z=-59903..-33239 -off x=-10313..2971,y=-56537..-21479,z=-73118..-56758 -on x=-74109..-68245,y=-14640..6255,z=-32056..-9919 -on x=-8704..1766,y=35410..57231,z=64345..76443 -off x=73047..81163,y=-5773..17096,z=24433..32163 -off x=-91886..-62451,y=-482..26130,z=8006..26319 -off x=17921..36441,y=-67251..-44885,z=34231..42934 -on x=49934..68358,y=-53246..-19769,z=39469..43842 -on x=56532..66012,y=-63433..-34360,z=-5761..16747 -off x=50888..66910,y=-73766..-45524,z=-34269..-15791 -off x=-53699..-35241,y=-53482..-17862,z=-72515..-42474 -off x=-48183..-29326,y=46638..54456,z=-54302..-33975 -off x=53493..67034,y=45776..48825,z=2583..8620 -on x=-6073..10138,y=62545..85278,z=23621..57001 -on x=-38508..-4523,y=54082..70881,z=50826..67962 -off x=37169..76620,y=47581..59105,z=-10872..8763 -on x=-28636..-16986,y=33405..60075,z=44952..63962 -on x=-8687..15348,y=-83584..-62431,z=-17101..-2245 -off x=36300..56740,y=46976..69120,z=-8811..2238 -off x=-5004..12191,y=-40112..-21492,z=-79188..-55268 -on x=23083..34899,y=2757..27461,z=-80465..-53265 -off x=36563..47394,y=34869..51935,z=-60753..-41403 -off x=-65592..-49393,y=-38929..-37743,z=-52793..-22052 -off x=-56455..-27816,y=-57252..-39373,z=-64915..-35370 -off x=-55271..-22482,y=36129..49610,z=34155..56011 -on x=-16603..-11223,y=6299..34093,z=-82645..-58961 -on x=41076..70147,y=7237..29376,z=-49485..-30152 -on x=535..30263,y=-52689..-37336,z=46273..84327 -on x=-21910..3792,y=22950..52814,z=63693..76400 -off x=-81116..-50991,y=276..6719,z=-61422..-30155 -on x=70070..94722,y=3705..21041,z=-36356..-6622 -on x=-58964..-32366,y=-64952..-47587,z=-392..17097 -off x=10390..21102,y=64923..80569,z=34182..56673 -on x=-45522..-28586,y=-67635..-47968,z=-6313..27037 -on x=-18210..17089,y=71004..89678,z=-15469..10434 diff --git a/2021/23/input.in b/2021/23/input.in deleted file mode 100644 index a8bbe18..0000000 --- a/2021/23/input.in +++ /dev/null @@ -1,5 +0,0 @@ -############# -#...........# -###D#D#B#A### - #C#A#B#C# - ######### diff --git a/2021/24/input.in b/2021/24/input.in deleted file mode 100644 index 6a65df2..0000000 --- a/2021/24/input.in +++ /dev/null @@ -1,252 +0,0 @@ -inp w -mul x 0 -add x z -mod x 26 -div z 1 -add x 14 -eql x w -eql x 0 -mul y 0 -add y 25 -mul y x -add y 1 -mul z y -mul y 0 -add y w -add y 8 -mul y x -add z y -inp w -mul x 0 -add x z -mod x 26 -div z 1 -add x 13 -eql x w -eql x 0 -mul y 0 -add y 25 -mul y x -add y 1 -mul z y -mul y 0 -add y w -add y 8 -mul y x -add z y -inp w -mul x 0 -add x z -mod x 26 -div z 1 -add x 13 -eql x w -eql x 0 -mul y 0 -add y 25 -mul y x -add y 1 -mul z y -mul y 0 -add y w -add y 3 -mul y x -add z y -inp w -mul x 0 -add x z -mod x 26 -div z 1 -add x 12 -eql x w -eql x 0 -mul y 0 -add y 25 -mul y x -add y 1 -mul z y -mul y 0 -add y w -add y 10 -mul y x -add z y -inp w -mul x 0 -add x z -mod x 26 -div z 26 -add x -12 -eql x w -eql x 0 -mul y 0 -add y 25 -mul y x -add y 1 -mul z y -mul y 0 -add y w -add y 8 -mul y x -add z y -inp w -mul x 0 -add x z -mod x 26 -div z 1 -add x 12 -eql x w -eql x 0 -mul y 0 -add y 25 -mul y x -add y 1 -mul z y -mul y 0 -add y w -add y 8 -mul y x -add z y -inp w -mul x 0 -add x z -mod x 26 -div z 26 -add x -2 -eql x w -eql x 0 -mul y 0 -add y 25 -mul y x -add y 1 -mul z y -mul y 0 -add y w -add y 8 -mul y x -add z y -inp w -mul x 0 -add x z -mod x 26 -div z 26 -add x -11 -eql x w -eql x 0 -mul y 0 -add y 25 -mul y x -add y 1 -mul z y -mul y 0 -add y w -add y 5 -mul y x -add z y -inp w -mul x 0 -add x z -mod x 26 -div z 1 -add x 13 -eql x w -eql x 0 -mul y 0 -add y 25 -mul y x -add y 1 -mul z y -mul y 0 -add y w -add y 9 -mul y x -add z y -inp w -mul x 0 -add x z -mod x 26 -div z 1 -add x 14 -eql x w -eql x 0 -mul y 0 -add y 25 -mul y x -add y 1 -mul z y -mul y 0 -add y w -add y 3 -mul y x -add z y -inp w -mul x 0 -add x z -mod x 26 -div z 26 -add x 0 -eql x w -eql x 0 -mul y 0 -add y 25 -mul y x -add y 1 -mul z y -mul y 0 -add y w -add y 4 -mul y x -add z y -inp w -mul x 0 -add x z -mod x 26 -div z 26 -add x -12 -eql x w -eql x 0 -mul y 0 -add y 25 -mul y x -add y 1 -mul z y -mul y 0 -add y w -add y 9 -mul y x -add z y -inp w -mul x 0 -add x z -mod x 26 -div z 26 -add x -13 -eql x w -eql x 0 -mul y 0 -add y 25 -mul y x -add y 1 -mul z y -mul y 0 -add y w -add y 2 -mul y x -add z y -inp w -mul x 0 -add x z -mod x 26 -div z 26 -add x -6 -eql x w -eql x 0 -mul y 0 -add y 25 -mul y x -add y 1 -mul z y -mul y 0 -add y w -add y 7 -mul y x -add z y diff --git a/2021/25/input.in b/2021/25/input.in deleted file mode 100644 index 7b300b0..0000000 --- a/2021/25/input.in +++ /dev/null @@ -1,137 +0,0 @@ -v.....>..v...vv>v>.v>v.....>v.v>.>..v>>>.>>..vvv>.vvvvvvvv..vv....>..>>vv..........>>...v>.>...v>vvvv>>..v>vv..v>.v..>>...>v>....>>>......v ->>>>.v....v>.....>.v..>.v>v.v..>..>>>.v....v.v>.>>.v>..v>>v...v>..v..>.>v>>.>vv.>..v..vv.>v>v.>v..v.v>v>>vv..>..>.v.vv.>v.v..vvv..>...>>... -.>>>...v.>.vv.>.vv.v>v>.v..v>>.>..v>.>....>>...>v.....v..v>..v>...v>v.>.v..>vvv..>v..vvvvvv......>>v.v.v.>..>.v...>v..vv.v.v>.v...>vv.>.... ->>>vv.v.>...v.....>>v..>>vv..vvv.v..>v>.>.>>..vv>..>.v>v.v.v>.v.vv>>v....>.>.v>>.>vvv.>>..vvvv>v.....>.v...>.>vv.v.>>.>...v.vv.>.vvv.v>>... -.>>v.v>....>vv.>v>.v>...>>>.v>>.>vv.>>....vv....>v...>..>..>.v..>.>.>>vv>>..v>...v>>v.v>.v.vvv..>..v.>v.>>>>...v...vv>.>vv...>>.>..>>>vv>.v ->....>>>>v>.>>v>.>>..v..v....v...>>v.vvv..>..>vvv.v.v.>....vv.v>v..v.vv.v..vv>..>>..>v.>.....v.>>v.>>.>......v.>.v>>>>>...vv...v.......v.>v -.>..>>>.>>>v...vvv.>..>.>v..v.v>..>.>v.>......v>vvv.>v>..>v.vv.v...v.v.vv...vv.>.>....>.vv...vvv>..v>vv>v.>...>..>.vv.....v........>v..v>.v -.>v>...>v.>..>v.>.>..>.>>.>.v...>.v.vv>....v.v..v...v>v.>vv>>.>>...>>vv>>v>v>...v.>...>>.v>>v>>....>>v.v..v.v..v...>....>..>>.vv..v>.v>v>.. -.v....>v>.....>v.v>v.>...>.vv....v..>....>..>.>v..v.>.>>>.>v>>v...>..>....>>v.vv.v>.v.>.vv>..>...>v.v>.>.>..v.v.v>vv....>...v.v.v.v...>.>.. -v>>..v>>...vvv..vv..>.>>>...>.v.>v>>...v.v>>vvv>>>....v...>v>.>...vv>>v..>.vvv..>.>.v.>v>v....v.v>>.v.>v.v.....>vv>.......v..v.v>.v..>v>.>. -....v.>.v..v.>>v.vv.>.v>vv.v.>>v.vv>v...>>>v>.>vvv>..v.>.v..>v..>>vv...vvvv..>>....v.vv>>>vv.>.v..>...>>v...>..>..v..v>vv.vv..v>vvv>v.v...> -.v>>v..>>v.>.v.>v.vv>...>...v>..v>vvv.vvv...v..>..>v>.>...v.>>.v>>vv.v...v..v.>v.v>.v>v.>.v..vvvv.>.>v>.......>>.>v>>>....>>v.>.v>vv..>>>.v -.v.>.>>v.>v>vv...>.....v>.vv.>>.v>v.vv...v>.>v..vvvvv......>v.v..>.......>v.>.....>v.v>.>v>.v>..v.>vv.v....>.vvv.>vv..vv.v>v>.......>>..vvv -vvvv>..>v.v......>vv.vv..>v.>...>.v.v.>.>>>..v>.>.vvv...v..v>.>v.>v>...>..>.>>.v.>v...>v>..>.v.>.>>>>>.v>.v.>v...v.>.vv>..v...vv.......>.>v ->>.>.>.v.>.vv>v.v>>v>>v.>>.>..v...>.>>..vv>.>>v>.>v..>.......v.....v....v.>>...>.vv.>>...vv>.>>.>v.>>vv>.v>v.>>.vvv>>>v>.>>..>>..v....v>>.> -v..>>.v...>..>....>v>.>>.......>..>v>..>..>vv.>vv.v......>v.v>v.......vv.>...v..v>>v..>.>>v...v>>.vv.>>..v.>>.......>.v...>....>>>..>v..... -...>.v..>>.>>>>>..vvv.v>vv>.>....v>vv>..vv.vv...>v>v...>>v..>...v..>vv.v.vv...v.>.>...>>....>.v...>vvvvv..v>.vv.>..v.>...v.>.v...v.>>.v.v>v ->>>..>.>v.vv>>...>>..>v>.>v>v.v..>...>>vv>..>v.>vv.>>.>.....v>>vv.>.>.............>>.vv..vv.>.>v>vv>...>...>.v>v.v>.>v.....>.>>>.>v>.>..vv. -.vv>....v.v.v...>v>.vv>v.....v.v>...>>>>>v>...v..>>v.>>>v.......>vv...v>..v..v.....v...>v....v.v>v>>.....v...v.>.>...>v..>>..>>.>.v...v>>>. -.v.vv..v>v>v>.v....>..v>>..>.v....v>vv.vv..>...v>..v....>..>>v........>.>...v..>....>vv..>.v..>>.>..v>.vv..v>.>.>.v.v.....v.>..>v..v>>.vv>v ->>v>.>>....v.v>.>>>.v...>>v.>.>.v.>...vv.>.......>>.v..>.>>>..v.v.v.......v.>.>>..vv.>...>>......v....v..v>...>v...>.v>.v..>.vv.....>>.vv>v -.vv.>.>>...v.v.vv>..>v>..>vvv>>>.vv...>>.vv.v.v>>.>>v.v.v..>..>v...vv..vv....>v>v..>vvv.....>v>v..>...>>v.>.>>>>..>.>>.v>...>...>..v..>..>. -.>>.v.v...>..>..>vv.v>v.>v>v.v.v>>..vvvvv...v.vvvvvv>>v........v.v..v>v.>>>.>v...v.>..>>v...v...>>.v....v...>.>....>v.v>>>.....>...v.v.vv.. ->.vvv>v.v>..v>.>vv.........>.......>>.vv>v.>...v>>.v>.v.v.>.>......>........v.v..>.v>>>.v......>>.>..v>v..>.vv.....v>..v>vv>..>..v..>vv>>.. -.v>..v..>.v....v>....>.vvv>.>.>v>vv>v>>..........vvvv>vvvv..v>vv......>>v..>>>v>>.>..>vvv..>..>>v>v.vv>>..>.>v.>>.vv>.>....vv.v...>....>v.v ->vvvv>>v.v..v.>>..v>...v.v.v>..>>..>..>.>>vv.v.v...vv>...v.v>v...v.>.>vv...v.>.v>..v>..v>>>.v>.vv>..v>>....>....>...v>.v......vv.v.>.>>>>v. -v..>......v.v>>.>>..v.v>v...>>.v...>....vv>....>.>.>>..v.vvv>>vvv.v>......v>>...vv>...v.>>vv...>v.>>vv.vv......>.v.>.v>>..>v.>>>..>v.v>.vv. ->..>v..v>vv>.v>>..vv.v>.>>..v.>vv.>v..>v>..>...>...v........v...>vv....>.>...>.>..v....v.v>.v.v....v.v>..v>>.>>.>..v>..>>vvv.>>..v..v.>v... ->.>.v>>....v>>v>.vv..v>.v>....vv>.......>v>..>v>>v.>vv.>v.v>>v.vv..>.v.>.>..v.>...>.v..>.v..>.>.>v.vv>..>.>>..v...>>...v..v>>>.>>.v>.>.>.v> -....v.v.>.>>.>.....v...v>>>.>v..v..v....>>>..vv>.>>>>>.......>...>...>..........>.v>...>...v.v....>.v>>>v.>..vv.....vv>v..>v.>v>>.v......v. -.>.v>>v>>v>>...>v..v.v>.>>.>v.>v.>.vv.v>>>>vvvv>.>>v..vv>>.vv.>>v..v.>>...>v>>>....v.v>v>v>>>........v.v>v>>>v....>...vv>>>>v>v.>>v>>vv.... ->.>>..v..vv.>....>.v.>.v.v>>.>..vv..>.v...>.>vv...>...>....v.v...v>>.v.v>>..>...v...vv>>.>vvvv....>.....>......>.vv.>..>vv>>v>v....v......v -v..>v.vv.v.v>>v>..v..v>>...>>.vvv>.v..vv>.v>>.>..>v.v>.>.vv.v.>....v.>>.>>.v>v>.v..vv.v>.v...>...vv>v>v..>>.>.v..>.>v>...>...>vv.>..v..v>vv ->>.>.....>v..>vvvvv.>>..v..v>..>v...>.v..vv>>>......>...v..>v>..vvvvvv...vv>.>...vv>v..v..>.......>.>v.>...v.>>.v...>...>...>v...v.>vv..v.v -.>>v>...vv.>.v>.v.>v..>v..>v.>v>v.v.>.........v.>v..v.v.>..v>....v....>v.>>>..>>v>.v...vvv.>.....v.>>>>v>v>..>..v.vv>>..>>.....>v...v>..... ->.>.>v>>>vv>>...>...>>>vv......v...>.>vv.>>v>.v.vv...v.>.>..v....v.v.>v>.>....>>.v...>>.v..>.v...v.v>vv...v.vv...vv.........>....v.....v... -..>>.v...>..vvv.>....v>.>v.>>.>..>>.>.....vvv..>......>>>.>.....>.>>v...v..>.v.v.>.v>>..>>>....>...v>>vv>v..>vv>..vv>.>>>>.vv.v.>>>v...>>vv -.>vv>.v>.>.>.v>......>.v>v......>......>>v..>v..v.v...vvv>>....v...v>v.v>>v.>v.v.>>>>vv.vv....>.>.v>.vv.v..>.>v>>.vv.v>..>v>.....>..v.>.>v. ->v.v..>.>.vv>.v>v>....>..v....>.vvv..>>>>..>v..>>..v>...v>....>>.v..>v...>.>..v>..v.v.v>>.vv...>v.>...v.v..>v....v.v..vvv.>.v>v..>vv>...... -...v.v.v..>..vv>v>v>>v..>>>>v.....v>v.>>...v..v..>vvv>v>v.>vv>..>vv...>.....>..vv..>>.....>.v.....>.v.>>..>..>.v..>v.v>>..>.>v>v>.v>.>>v.>v -vv>..>v.vv>>>v.....vv>...v>v>.>..>.v..v>v......>.>v.....v>.>.v.v..>>....vv>......>>v.>v.v..v..>v.v.>>.>vv....>.>>>.vv.v.vv>..>..v...>.vvv.v -vv>>>v..v.v..vv.>>>.>..v>vv..>v>..>vvv.v.v..v.>.>v.v.v.>.>v..v..>.>v..v.v.v>.v...>v.>.>..v..>..v..v.>vvv>>.v..v..>v..>.v...v.v.v.v>.>.v>.>. -.>>.>.v....>..v.v..>.v>.>>>.>v.>>v...v...>v>v.>..>.......>>..v..v>.>...vv.>...>>.>....>...>>..v....v>..>v.v>vv>.>.v>v.>.>......v..v.v>.vv>. -...>v.v>v.vv.>.>...v..v....>v.v>.v.>.>v>v>>.v..vv.>>.vvv.>>.vv>>>..>v.v.v..>.>>.....>>...>v.>vv.>>...>...>.....>.>>.>.....vv>.>v>v..>..>vv. -.....>..v...v.vv.....vv..>>vvv>.>..vv...>..>>..>..>.>..>......v.>.v.>.>.v>.>>v.....v.v...v..>.......>>v>>>...vv>v.....v..>v..>.>...>v...>>v -..v.vv...>.>>..>...>..>>>..v.vv.v>>vv>v.>.v...v....>>.>.>vv.v.vv>v..>..vv.>>>.........>..>.>v..v>.v>.v..>>v..vvv.vv...v>>vv..v.>..>v..v.v.. ->.v>.>.>v.v..v>>.v.v..v>v>>v.v.>v>..>..>vv.vvv..v>>....v..v>>vv>......>...>>.v..v..>..v...>..>v..>v...v.v.v.>vv.vv.>>...>>..>....v>v>>>v..v -.>.>..v.>v.>....>....>>v...v>..>.>v.v>>>.>.>........>v.>v.>..>>...>.>..>..v>.>..v>..v>.vv.v...v.>v..>v.vv>..v>>v.v.>>v...v>v...>.v...vvv>.. -..>>>.vvv.vv..vvvvvv.v.>v.v.>...vv....>v.v>>..v.>>.......>.v.>vvv..>v..>.v....>vv.>...>>...v....>.....>.v.>>>>>...>..>..>>v.vv.>vvv>vvv.... -.v>v>>v.v.....>..>>..>>>>..v>...v..v>..>v.vv...v>...>...v>..v..>..v>.>v>....>>vv>vv.v..v>v...vv>v>v>>.v..>v.>>..>.v>>>v.v>v>..v....v...>>.. -v>......v..v.>vv.vv>..vv...v...>v..v.>>vvv.v>...>.>...>>..v....v..v.>.>>v......v.v.vv.>...v.>>.>>......v..>v>>v>>...v>>......>..>..v..>...> -vv.>..>.v.>...>>>..>.v..vv>......>>..vvv..v.>.>.>.........>>....v....>v>>.....v.v.v.v..>v.....>......vv.v..>>>>>>..>..v..v>v>...>v>>.>....v -.>v.v>v>>v..v..v.v...v.v....v..vv>.v>.>.v.>>>>.v.>.vvvvvv>v>>......>vv.>>.........>.v.>.....>>..>.>.vv.v.>.>.....v.>>v.....v.v..>v>..v.vv.. ->....>>>>v.v>.>..v>..v>vv.>>..>v>.>>..v>v.>..vvvvv....v>>..>.v>>.>.v.>v>...>.>.v>...v.....v...v.vv>v>..v.......>.>.v>>>...>........vv...>vv -v>v.vv.>>>v>.....v....>....>.......>..>...v.>v.v.v.....>v>>>...v.......>v...>>v.>v.v.v..v.>..>.>v..vv.v.v.>v..v...v..v>.vv>>..v...v.>.v..v. -v..v....>v.>.>...>..v.>v.vv.....>.v>....>..>>vv..v...>>..>.vv>v>.>v..>vv...v>vvv>v>.>v>v>>>.vv.v>>v.vv.>.v.>........>v......>.>.v..v>vv.... ->vvv>..>..>.v>>v..........v>.>.>>.>.v>.....vv>...>...v..>v>.>v>>.vvvv.>>.v......v....v....vv..v..vvv.>...>...v>vv....>>>v>vv.v>>>.>.v.>>v.v -v..>vv>>vv.v.v..v.>>..vv.>>v.>v>v...v.>..>.>v......v....vvv.>..>....v..>..v>.>v..>.>v.>.......>.>v...vv>>.v....>.>v.>>>v.>v...>..v>v>..>>>v -vv.vv.v.vvvvv>...vv..........v>vv.v.v...>v.>>..>>vv>..vv>v.v.>.v..vv>>...vv.v.v.>.vv.>vv>.v>>.....v...>>.>v.....>..>>..>>..v...>vv>.v...v>> -.v.v..>v..>...v.>.v.....>>..>.>>vv>>>v>.......>.>>...>..>.>>..v...vvv.>..vv..>v>v..>>..>.....>..v..v....v>>v.v.>>>.v>.vv.v..v..>v.>.>>...>> -.>..v>>v....v.>v..>vv.v.>..>..>>v.v>>.....v.>>..>>.>..>>>>.v>vv..>.v.>.>...>>>.>......vv...v.v.v...v>.>.>.v..vv..v...>v.....>.v>...>..>..v. -.....vv>..v.vv>.>>>.....>.>v.......v>vvv..v.>>.v....v..v.>v.>v>.v>vvv...>>>>>>.vv.>.v.>...>v..v....>..>v.>>>vv.v>.>.>.vv>...>>v.>>.vv.>.>v. -..>>v...>..vvv>>.>v>vv....v..>v..v..>v>...>.v...>>.>>.vv...v>v.v..>.>>.v...>v....>>>>.v.v.vv.v.>>.vv...vv>.>.vv..>>.>.>vv.>..v>..>.>.v...v> -vv>>v>v.v>v>>v>v>>v>v..v....>..>.>.....v>>.>>v.v.>>>v>.vv.>vvvv>..>>>...>....v>..>vvv.>.vvv>>v.v>..>.v.v.>.v.v...vvvv.>>......>..>v.....>>v ->.v>.v>v..>.>..>.....>.>>.>.>..v.v..v.vvv>.>>.v..>.v.>.>v>v>.v>>>v.v...v>v..>..>>.v.v>.>.>..>.>v...>.v..v>v>v...v..>>...v.>>....v.>v.vvvv>. -..v..v>.v.>v..>..>.vv.v....v.v..v..>>.>>.v..v.vv>v.>.vv..v.>.v....v......vv....>>>v..v...v..v>>>.>...>>v.v>vv>vvvv>.vvvv.>v>..v.>>....>.vv> -v..vv.vv.v.>...>.v..>v.v.......>...>>.>.>..>>.>.>>.....v..vv>.v.>v..>...v>.v>.v>>v...vv>v..v...v.>.>...v...vv..v>v....>.>v>>>v..v>.>v>.>... -..>..vv..v..vvv>v>v..>>.>....vv>...v...v..>.v.v>......>>..v...vv>>...v>v.v...v....v>v>..>v>.......>>.>v..v.....vv.v..>.>..>v>.>.>.v>..>vv>. -v>>v.......>.vv....>>.....v>>v.....vv...>vv>vv>...v...v>>.>.v...v.v.....v>....v>.>.vv.vv...vv>>v..>v...>.v....v>v>..vv>..>....v>v>.v.v.>... -v.v.v>.>>.v>>vvv..v>>.>...>.....v.>.vv>v.vvv.>>>v.v...>..vv..>..>.>v.....>...>..v.....>....>.>>.>>v.v>...vv.....>.>.>v..v.>vv...v>>>>.>.v.. -.vvv>>>>.v.v.vv.v.v.v.>....>v>....>.v>.v>...v.>.v.>..>.v..>>..v>.vv.v......v...v>>..vv>>.>.vvv>.>>..v.>>>..>.>>>.>>v...v.>.>..>>v>>>v>>.vv> ->.>v...v.>>v.>v..vv.>.>.vvv....>.v>v..>v.>..vv>.>v....>>.>>....v.v>>>.>vv>>.vv......>v...v.>.....>..>..>.>.v...>v...v...v...>v.v.vv.....>v. -...>.vvv>.v.v.v.>..>...>..>>>.>..>.>..>..v..>vv.v.v.>.....>.v>....>.>.>....>v.v>.>.>.v..>...>..>>..>>...>.v.v.>..>.>vv....>>>..>>.>.>..>... ->>......>vv....v.....>..>>.>...vvvvv>......vvv.v>.v>.>....>>v.>>vvv...vv.>...>>.v>..>........>>vv>v....>.>..v.>v.>..>......vvv>>......>>.v> -v.>....>.v.v>>..>.v.>>v>vv>>>>.v..>v>v>.>..>>.v>>.v.v..v>v.>v.v>vvvvv...>.v..v.v.....>.......v..vv...vv.........>..v....vvv...>..vv>.v.>>.v -....>v.>.....>....>v.>...v.>v.v>.v>.v.>.>v>>v>>>v..>>v..>v.>....v.>>>...vvv.>....v..>.>...>.v>...v>v.vvv.>v.v.v>>>>..>..vv.>..v.vv.v..v.v.> -v...v...vvv.>>>v.>....vv>..v..v.>v.>v..>.>v.v.....v>...>...vv>..>.v.v>>vvvv>.v>>>...v>.v>>...v>vv..vvv>.v........>v>.vvv.vvv...v>.v.....v.> ->....>v>>..v.v..vv>.v>.v...vvvvvv..v.>.>...vv..>>.vv.>..>v>v..>>...>....v>v.>.>>vv.vvv>v.v>>..vv.>..>...vvv....>..vvv..>v>v..>.v.>>vv.>vv>v -vvv>...vvvvv>>v....>..>.v>v.>.>..v.>v.v>...>>..>v>.>v>..vvv.....v>..>.>>vv.>>>>>....vv.>>v.v.v...v>>.v....v.>v...>..>..>.>.v.v>.>.>.>v..vvv -..>>>>>.v>v..>v.v>v>>>v..v>>.>vv...>.....v>>v....vvv..>...>.>.>>..>.v....v..v>v....>>vv..>v>>..>...>>..>.v.v.v>.v.>.vv>v.v.>......>>.v....v -.>v..>..v.v.>v.>.....>vv>..v>v.>.........v>.>v....>..>>..>>..>>.....>v>vv..>.....v.>...>.>>.>v....>>>.>....vv>.>>>>.>..>>.>v>>vv.vvvv>v.v.> -.v.>.>>.>.>v>v>v>vv>.vv>.>>v.vvv>v..>.>v>v.v..>..>.>>>>>..v..v.>.vv...>.vv..>>v>>v..>v>....>>....v>v.vv>>v.v.v..>..>v..vv.v.v>v>.>...>..>.. -vv>...v>>.....>>>v..>..v.>v.>v.v>vv...>........v..vv.>..>>>>..>>v..>...>v.>>>>vv.>vv>....>.vv.>>.v....v.vv.v>.v>>.v...v.v>.>.....v>....v.>. -v..>>.v....v..>.v.v..vv..vv>>vvv.v..>>.>.v>.>v>...>.>>>>>vv>>...>v>.>>>v..vv>>vv.>v.v>.v...v.....v>>v..v..v.v>v>>....>.vvvv.>vv>>v>>>>>v... -v.>v.v..>v>..vv>....v.vvv.vv.v>.vvv.vv.v>..v.v.>>>>..>.>v...v.....>>..v..>..>vv.>..>v>.v>......>...v.vvv.....v..>.>v>.....>.>>..>>..>>.>vv. -.vv.>v....v>>v.>...>v..v>vv>.>.....>v>......v>..v.v>.vv>.v>.v.>.v..v.>...vv..v.v.>>v>vv>v..v.>.v.>>>>..>.>>..>......v.>...>v>.vv.>>.>..v>v> -vv>>>v..v..v..>.v.v>.>vv>v..v>>>>.>.v..>vv.>.....>v>vv.>vv.....vv.>.v...v.>>...>.v>v>..v...>v.v>>.>>.>v.v>>v..>.>>.>v.v>.>.>vv.>..v>>v>..>. -v.vvv>......v...>..>vv...>.>.>..>>....v>>..>.vv..>..v.v.v.>>.vv...>..v>.v....>v.v>.vv>v.>.>.v.>.>v.v.....v.v.v>.>..vvvv..>v.>v>.>...v>>>... -........>>v..v.v..>.>>.vv.>...>.v.>v...v....v.vv.>v>>.>.v...>>>>.>...v.>>...>>v.v.v>.v..>>vv...v.....>..v....>vv>.v>....v.>..v>...>..vvv>.v -vv.v...>......>.....vv>..vv...>.v>>>>.>v.v>..v.v..v>.>vv.>>.v.>..>>.......v..>>...v>>.>.>...v>>>.vv>..>.>.>v>..v>...v.v..v>.>......v>v..>vv -..v.>..>vvv........v..v.....v...>.v..>.v>>>.v...v..>v...>>>>...>....>v..>.>..v.v..>.v..>..>>.>>..v..>>v.>v..v.....vv.>>>.>....vv>.v.>v..... -v..v..v.>.>..>..vv>.>>.>>.v>...v...v>vv>>.vv.>....>.v.....v..>.vv.v..vvv.v>>v..v.vv..v....v.v..v>..vvvvv.v..>v>.v>v.>>v>..>v.vv.>>..>>..... -.>....>..v..v.v.>.>..v>.>>vv>vv...v>>...>v..v..vv.v>v>.>>>.v.>.>v>.vv.v...>>.vv.>..>.....v.>v>v...vv.....vvv>vvv>vvv..vv...v...>v.v.vvv..>v ->.vvv..>.>.>..v>v.>....>v.>>.>....>v>...v.>..>...>.v...>v..>....vv....vv..v.>..>.v.>..>v>...>>..v.>..>>..>v..vv>>>..v..v>......>>>v..v...>. -v>>..>>v..>....>vv.....v>.v>..>v>..>v..>...>..>v..v>.v>...>v.>.v.>.>..>v...v>vv>v..>>.>v...v>>v>v.v.>vv...>>v..v>.vv...v..v>.vvv>.vvv..v.v> -..>.....v>.v........v>....v.>>...>>.v>>>>>vvv......>>..v.>v>v.vv..>..>>.>.v>.vv.>...>v....v.....>>..v..v>.>v..>>......v.....>..v.v......>v. ->.>.>vv....v>....>....>v.v.>..>>........v.v...vv..v.>..vv.>......>.v.v.vv...>>>..v>v..v.v>.vv>>...>....v..v.>v.v>v..>>..vvv.vv...>.>.v..v.> -..>.>.>v.v.>vv.v>.v.>v.>>..>..>v>vv.v.vv>.>>>...>v......vvv.vv..v.v.v.v...>.>>v..v.v.v>.v.v....>>.v.v.>>v.v.>..>..>..v.>....>>v>..v.v.vv..v -..vvv..v>..vv>..>vv..>.>...v>.......v.>>..v.>>.>..v.>>>..>v..>.vv.>vv.v>v......v.v.....>..>.v....>.v....>v.v>..>>.>>>vv.>v.vv.>vv.v.>..>... -.>>vv>.........>.v>..>.>....vvvvv.v....v...v....>..>.v.v...vvv...v>v>.v.>v..>v>v..>.v..vv>...>vvv...v>..v....>vv.>.v.>.>v..>..vvv..vv...>.> ->.v>.v..vv>>.>...v>.>...vv.>.v.vvv>..>...>v..>.>>v.vv..v.v...>>...>.>v..v.>v.>.vv.>>v.v.vv.>v>.>>.....>.....>>>.>..>.>..>..>.>.>..v...v...> -vv..v.>>>..>>...>vv>.>>.>v>v...>.v>..>..>v.>.>.v>>..v>...v>..v>v....vv>....v>v.>.v.>..v....>v.>>v.......v.>>>..>..v.vv>>.>>>..>v>>v.v..v.>v ->.>..>...v.v>v.v..>.......>..>.vv>...>>vv..vv....>.....>....v.vv.>>>>v>>>.>vv...>>....>v...vv.v>.>.....vv...>>v.>v>>..v.vvv.vv.v...>.>>..v. ->>....v.v.v...v.v>.>v>...>.v>v.>..>v>>v.vv...>....>......>..>vv....v.v.>....v>>...v.v.v.>>..v...>....v>..>.v>v..vv.v.>..>>vvv....>>..>.>>>. -......v..>>>>>.>..v..>>>.....v.v..>..>v>...v.>..vv>>>>...v..v>...>.v>..>.vv....>>.>v....>...>.....v....vv...v..>.>v>.>>.>>.>>...v.>.>.v..>. -v>vv.v.v.v>.>v>v.>...v.>>..v.v>.>.>vv>>.v>.vv.v..vv..v.v.v>vvvv.>v>v..>v>vv>.>.v.>.>>.>v.>.v.>>>.>.v.......v>>v...>.v..vvvv.vvv>.v.v>>>>.v. ->v>....>>>.>v.>..>.v.>>..v....>....>...>..>>vv....vvv>v...vv>>.....>..vvv>.vv.....vv.v>>.v...>v.>v>.>..v.v.v>v>>.v>....>>v..v..vvvv..>>v..v ->v....vv.v.>.>..>v.vv....v>v...>v...>.v.>>....>.v>.>.v.>.v...>.>..vv.vv>...v.v>.....>...>>..>vvv>.v..>>vv>.>.>v.v>>vvv.>v.>.>>>>vv....vv>.> -.v>vv..>vv>vv.>.>..v..>...>.v>>v..v>>v..>......>..>..>>v>>.>.....v..vvv.....v...>>.....>>>>.>>...>>>..v.v....v.vv>>...>.>.>vv.>...>.>.>>v.> -..v.v>v..v>..>..v...v..v......>.>.>...>>.>v..v>..>v...v...>>v........>.v>..v.v.....>v....vv>>....vv..v>>.>.>.>>vv...>.v>.v....v..vv........ -.v>>...>v..>v...>>.>....>>v>vv>v..v..v..>...>>vv...>..v>v..v>v.>v..>....>.v.>v..v>>>v.v.>>>v.v>v.v>..>>v>v....>v..>>.....v.v....v>v..>...>. -v.>.>.....v.v.>>v>>...vv.v.vvvv.>>....v..v.v>.>.v>.vv.>>v..>..>...vv>.>v>..v>.v.>v>v..v.v>v>vvv.>>.>.vv.vvv.v...v....v..v..>>....>vv...v.v. -.>..>>>..>..>>..v..vv>.>.v>.>v..>>>..v...>..v.v..>...v...v....>>.v......v..v..>>v.>vvv>..v.>..v...v..v..v..>>>.....>...v.v.>>....v.>v.>.>>v -v..v.>..vv....>v...vv..>..>>..vv>>v.v.vv>.>.v.v.v>.v.v>>v.v>..vv.v..v>>>>v.v>..vv....>>v....>.v..v.>>.>vv>.>v>...>>>vv.v..>v.v>.>........>. -v.>>>....v...v>..v.v.>.v...>.>.v>v.v.vvv.>v.>>.v>vv....v.v.v.>..vv>...>>..v...>.v>.>.>v.>>>>..>>>>>>v.v.v..>v.>>.v>.....>..v...v..>>...v>>. -.vvvv..v.>.>.>v>v.v>.>.v.vv>.>v.v.....>...>>vv.v..vv..>...>v...>vv.vv.v...v..vv>>..v>.>.>.v.>..>..>.>.>.....v..vv..>.....vvv>>....>v.....v. -v.>>.>..>.>v>>>vvv>.>.vvv>...v........>...vv..v..>>.v>.>.vv..>>vv>....>>vvvv..v.....>vv.v.>>v>>.>>v..>.>...v>...>.>v.v..>.v....>>....>>v..v -..vv.v.>v>v...>.vv.vvvv>....vv....>.>.vv>...>..>..>.>.>.....>v>.....>...>v..>v>>..>>>.....>......>.>v>>..v..v.vv.>>..>..>>vvv>>vvv>...>...v ->..v..>>>.>>v.>.v>>>>..>....vv>>...v>....>.v>v..>>.>..>v>.>>.v..vvv.>v...vvv>..>>v.v>>v.>v.>...>vv>..v.v>..>.>......>......>>..>>..>>...>v> -..>>....v.>>....v...>.v.v.>v..v....>.>.>.>>...v>..>.v.>.v>.vv>>>v.>.>>>vv..>>v>.vv.v>......vvv.....vv>.vv...>..v...>>.>>..v>.>>v>.v>>.vv>.. -.v......vv.>.v..v..>........v>.>.v...v>vvv>.vv...>..>....v>.v..>v>.>>.>v...vv.>>......>vv..vv>.vvv>>>..>..>v.v..v.....>.....vv>.>vv....>>.v -..>>v>.vv>v.>....v>>>vvv>>vv.v.>..vv.>.v....v>>...v....>.>vv...>...v.v>..>.vv.>.v...>....v.v>>......vv.vv..>>vv>.....>v...>>...>..v.v.v.vv. -v..v.>.v.vv.>v.>...v>.........>>v.v.>>..........>vv.>>......>v.vv..>..v.v>v.>.v...>v.v...>.>...>>vv>.v..>vv.v>>..v.v...v...v.>.v.vvv>>..... -....>....v>.>.>v.>v..v.v>>v>>v..vvv...>.>..>vv>>>..v.v..v..v....>>.>........>.>>vvv..v>>..>.v>>v.>.v>>v.vv...>.>v....>v>..v.>vvv..v..>vv>.v -..>v.>..........v.>.v.>.>.>..v..v.>...>.v........vv.>vv..v>.>..>..>v...vv..>v>>...v>..v..v..>vvvv.>v....vv...>.>....v.>.>.>...>.v.>>.v.vv.. -..v>vv..>.v.>.>vv>v..vv.>.vvvv..v>v..v>.v>v.....vvvv.v>.>.>v.>.>....>.>.v.>.v.v>>..v>v.>vvv..>>..>..>>..vv.v...>.v...>v..>.>>.v..v>...v>..> ->v.v.......v..>>v>v.>v.....>v.>.vv....>.v>>v...>v.v>>>.>v>>...>v.vv.vv.v>.vv>..v.vv>v.>..>.v.>........>.>....>.>.v...>...v>....v.v>>v>..>v. -v>vv.v>.v...>..>..>..v.>v>..>v.>..v>>v.>>.v.vvv...>.v>.....>.>>..v>v..>>v>.>..>..>...>vvv....>.>.vv>>>.v...v.v>.>>v>...>...>.>vv.vv>.v.>v.v -..>v..v>v.>>.vvv..v>>v..vv..v>vvv.>..>>>.v>.......>..vvv.>v...vvvv.v...>v>>>..>.v...>.>>v..v..>v.>......v....v>v>>>..v.v.......>.vv.v.v..>. -v...>>......v>>......>>v.....>....v.>v.>>v>>>>v>v..v>.v....>...vv..>>.v>v>..vv>.vvvv.>>.>>>v>.vv.>>.v.v......v>>v.v>.>...>.>..>.>>.vv...... ->..v..>>>v>>.v.vv.....>>>..vv..>vv..v.v>..>v.>v..>v..v....>..>>>vv>>.v>>..>v...v....>>>vv.v.vvv.vv..>vv.>.vvv..>>>>.>>.>v.v>>>..>v..vv....v -.v..>v.>v..vvv.>.>v..>..>vv...v..>vvv...>v.v...>.v....>vv.v.v>v...v>>v.v.vvv..>.v>v>>.>..>>....>>.>..vvv.vv...v...v.v..v....v...v.vv>>vvv>> -..>.>.v.v.>v>.vv..v.v.>.vv..vv.v...>..>.....v.>.......>vv>>>....v...>.....>.v..vvv>.>>v..>.>.......>.>v>.v....>v>>.v>>.v...>.v>.v>..v>>.v>. -..>.v.>.>>.>v>.v..v>...v>.v.>>.v>.>.>>..v....vvv>>...v>v.v>...v....>..>v.....>>.>vv.>>>..>..>.v.>>..>v>>>.vv>..vv.v..>.>...........v>.v.... -..v>v..>......v>v..>.vv.vv>....>...vv.v>>.>.....>>..>>>v.vv.v....vvv>v..v..v>vv.>....>v.v...>v.v>v.>..>>..>>....>...v..>.v>.vvv>.>>.vv.v>v. -v.v>..>.vv.>>>..vv.>.>>>v...>v>v.>.>>..>>...v.v>v>>>vv.>>.>v.v.>.>vv>..v.v..>.v..v......>v>v.v..>...>.......>v>.>.>.>..v.v..v>.>>....>.>>>. -.....>....>v...v....>...>..>v..v.vv>v>....>...v>v.>.v>>..v>>v>vv.....v.>..>>v>>....v.>.>..>.v...>.>vv>...vv>>.vv>v>.v.>v..>>vv>v..>...>..v. diff --git a/2022/01/input.in b/2022/01/input.in deleted file mode 100644 index 9edd9dc..0000000 --- a/2022/01/input.in +++ /dev/null @@ -1,2235 +0,0 @@ -2000 -12013 -5489 -11485 -2430 -7722 -5456 - -6693 -3867 -1645 -3924 -1545 -1910 -5443 -6276 -4574 -4147 -3942 -6322 -2904 - -3455 -4347 -3569 -1871 -2198 -4525 -1367 -4290 -3608 -1105 -3788 -2669 -4095 -4539 -5643 - -2604 -2317 - -14469 -11148 -21992 - -10429 -10440 -1343 -4878 -2948 -9949 -11600 - -5441 -9456 -6912 -5164 -8648 -1303 -6552 -2352 -3902 - -8892 - -5874 -5476 -5816 -6062 -4749 -7295 -5274 -3757 -4919 -1381 -2456 - -5666 -5732 -2628 -3367 -1078 -4688 -9294 -2707 -7664 - -5401 -5514 -2397 -2682 -4270 -4617 -4239 -3388 -3777 -4618 -3126 -3569 -2170 -2255 -2016 - -5280 -3530 -4338 - -5903 -3387 -4212 -4947 -6546 -2273 -3289 -1591 -3206 - -8124 -13697 -5396 -4215 - -10125 -3806 -1106 -3350 -3431 -5926 -7847 - -5469 -5422 -2685 -5531 -4385 -4847 -2398 -3642 -2325 -1926 -3775 -3297 -5138 -1024 -2836 - -25034 -3503 -5769 - -1671 -8174 -11469 -9030 -7977 -3121 - -2292 -2384 -2367 -2859 -5515 -1402 -3983 -2785 -4189 -3664 -2638 - -8501 -5749 -4371 -7714 -3618 -8797 -7521 -4810 -5952 - -11970 -3818 -8416 -2058 -3409 -5663 -2814 - -69727 - -17674 -13729 -3317 -9347 - -3510 -2853 -1174 -8648 -3013 -3180 -5821 -8659 -2097 -1476 - -6002 -5173 -7120 -7164 -7458 -1809 -3670 -7347 -5794 - -4942 -1785 -4233 -2135 -1376 -2520 -1378 -2773 -3397 -2282 -1569 -6008 -5744 -1410 -1262 - -6555 -21542 - -5022 -2557 -2845 -3449 -4442 -1529 -3932 -3888 -5702 -5524 -1829 -2792 -4951 -4197 -5339 - -4528 -7367 -7203 -3805 -3022 -2283 -5165 -4720 - -2529 -7119 -5022 -4026 -6782 -7010 -2746 -4621 -6460 -6438 -3916 -6198 - -8188 -7839 -1230 -7053 -5874 -1743 -6466 -3943 -4229 -3021 - -1633 -5005 -3953 -4288 -5359 -7236 -6473 -7179 -4113 -2967 -1069 -5298 - -9328 -8969 -1533 -7921 -3957 -7449 -9265 - -7288 -13654 - -13363 -10444 -7624 -5247 -4751 -13837 - -3745 -3728 -5915 -4513 -3818 -1513 -4459 -3653 -5544 -1338 -1238 -3669 -5828 -1106 -5085 - -6206 -1598 -4359 -2383 -2149 -6053 -3484 -3172 -1510 -2699 -5494 -5774 -2974 -3283 - -4445 -3583 -6550 -9320 -6905 -9518 - -1672 -6088 -1641 -4253 -5059 -1842 -5265 -5001 -2769 -3991 -4020 -5489 -2967 -4002 - -3001 -4264 -6668 -6710 -5047 -8208 -2616 -8105 -8447 - -18600 -8322 - -6235 -7323 -7792 -8248 -4100 -7035 -8449 -1210 -1192 -8322 - -7343 - -2856 -5366 -4283 -3323 -6541 -4019 -2086 -7435 -4204 -6713 -7217 -3566 - -6811 -11637 -15098 -12874 -5395 - -2458 -1446 -9495 -4442 -4083 -10324 -8491 -5798 - -4799 -7993 -9479 -9826 -4574 -5683 -7240 -3448 - -6258 -8840 -7347 -3031 - -2579 -5140 -4185 -2888 -1014 -1179 -1638 -7703 -2204 -2228 -3762 - -6131 -4685 -3479 -5372 -1684 -5034 -5408 -1289 -1485 -3238 - -5495 -4133 -7093 -1907 -1426 -6798 -1580 -4938 -5403 -6920 -6581 -2688 - -10432 -6345 -1313 -9521 -2652 - -11713 - -14255 -13867 -15482 -7519 - -5819 -4070 -7290 -12708 -10815 -3499 - -4093 -5266 -4175 -3484 -1079 -7116 -5720 -2947 -1490 -5802 -5832 -4027 - -5302 -4837 -4475 -6506 -2261 -5930 -4607 -4285 -2439 -1585 -5288 -4918 -4018 -4777 - -3993 -5624 -11935 -7174 -5086 - -20487 -32607 - -1000 -4167 -1648 -4736 -4700 -4988 -5027 -2712 -4757 -3660 -5855 -4279 -5947 - -16263 - -5100 -2601 -4242 -4474 -2536 -4038 -2529 -3851 -2317 -5986 -1252 -5888 -6087 -1136 -2814 - -6120 -5103 -4874 -5071 -2853 -3825 -1176 -6443 -5622 -4532 -6640 -5708 -4638 - -5743 -7765 -7447 -5287 -5795 -10093 -3239 -6527 - -1428 -3994 -1836 -4892 -1438 -1435 -5189 -6019 -4158 -5205 -5136 -1204 -2092 -4873 -1218 - -17476 -3121 -18812 -17122 - -9187 -14591 -13655 -7065 -15792 - -2341 -1577 -2445 -4855 -2657 -5445 -4048 -4569 -5963 -5044 -2136 -1759 -4685 -2679 -4660 - -9542 -9113 -7941 -13631 -11441 - -6754 -4063 -2779 -1508 -1170 -4159 -8253 -2180 -4129 -7077 - -4446 -4590 -1493 -1078 -5821 -4667 -3183 -4552 -4455 -5375 -1928 -5735 -4996 -5378 -2824 - -1548 -1205 -6097 -3363 -1700 -3600 -3328 -2977 -6557 -4861 -5367 -4588 - -3697 -5237 -3158 -2554 -3247 -4739 -4681 -1545 -5120 -5068 -4503 -5976 -6310 -2543 - -6680 -10760 -6051 -10641 -3566 - -8220 -7876 -9232 -7095 -2648 -5501 -6612 -3274 -2457 - -2712 -4371 -5504 -5360 -2857 -2830 -4816 -1280 -1656 -1684 -1486 -4828 -6423 -1417 - -1045 -9577 -3208 -4431 -4123 -9169 -2461 -10148 - -3064 -5159 -4043 -8403 -5156 -3064 -3536 -3217 -3155 -4971 - -10095 -1648 -3386 -7769 -8939 -12452 - -4251 -3782 -6474 -7009 -7544 -7002 -7021 -7772 -3741 -6936 -6434 - -5581 -2307 -5266 -2754 -6806 -6256 -2913 -4808 -4584 -4004 -5546 -4708 -5767 - -4983 -2055 -3830 -6590 -6740 -3801 -2573 -5583 -2100 -5639 -7335 -7202 - -4832 -2801 -2596 -2966 -2341 -1578 -5677 -1669 -2803 -3575 -1217 -1076 -1420 -1083 -3243 - -16734 -16781 -12618 -19292 - -15489 -4607 - -7462 -1425 -7387 -1314 -1882 -7505 -5348 -7688 -2949 -7299 - -14078 -9935 -11384 -5818 -5623 - -6522 -19523 -15630 -13173 - -3537 -6139 -1118 -1589 -4968 -5038 -5280 -4373 -7962 -4267 -1323 - -2307 -5224 -4833 -4980 -5326 -1991 -1244 -4500 -4363 -2821 -4733 -4762 -2921 -3086 -1901 - -2103 -13127 -11788 -13781 -8246 - -4062 -19254 -19281 - -3726 -3172 -3545 -2096 -5260 -4609 -6360 -3044 -3542 -3442 -2884 -6213 -3982 -4176 - -5618 -7100 -4100 -4484 -10523 - -4578 -21767 -18797 - -5804 -2039 -4951 -6614 -6712 -6601 -6723 -3273 -4967 -4251 -2717 -6879 -1130 - -3748 -1778 -2441 -2167 -6478 -6513 -1402 -5897 -5320 -1759 -3821 -1165 -2703 - -7785 -5718 -7591 -7405 -5215 -4948 -5360 -3833 -6676 -5336 -2322 - -9384 -5082 -8330 -3388 -7562 -9846 -6428 -2567 - -9425 -7189 -8053 -6364 -6519 -6651 -2533 -7207 -5083 - -9249 -3223 -13585 -5668 -1615 -4607 - -2413 -6755 -7232 -8941 -8094 -7381 -5055 -4533 -5926 - -5443 -3258 -2216 -1140 -1564 -3022 -4633 -6005 -3551 -2090 -4581 -3599 -5918 -2745 -2474 - -7269 -29961 - -24014 -1656 -15112 - -7256 -5880 -7761 -6115 -6998 -9817 -3909 -10327 - -7111 -7151 -14411 -7103 -4379 - -5629 -6790 -3207 -8582 -5495 -5001 -5746 -6514 -3874 -3418 - -48033 - -55352 - -17712 - -26192 - -4502 -2348 -5398 -1460 -3537 -1146 -5091 -5345 -4306 -5842 -2507 -1451 -2670 -5451 -3388 - -11840 -12162 -12739 -10712 -3310 -5666 - -1451 -3213 -3751 -11454 -1752 -3636 -1806 - -7334 -4388 -5412 -6933 -2190 -4459 -3381 -6348 -6496 -7301 -5371 -6646 - -3921 -5752 -4586 -1587 -5277 -4372 -2656 -5566 -5056 -3704 -4211 -1753 -3995 -2165 -5532 - -1727 -6476 -2534 -2477 -1148 -5239 -5307 -7327 -4054 -7851 -6930 - -4697 -2696 -2428 -5596 -2876 -1746 -4079 -7306 -2440 -4911 -1710 - -10476 -3062 -5844 -5147 -1883 -3752 -9934 -6027 - -8015 -6689 -3160 -2887 -1665 -2601 -8194 -4085 -1697 -2469 - -1753 -2578 -4683 -2644 -3087 -2515 -6491 -5682 -3961 -3249 -5121 -1165 -1473 -4068 - -5397 -5486 -5855 -5154 -8269 -1508 -1032 -7519 - -7692 -5792 -4375 -1173 -3946 -5005 -8464 -2453 -1922 -1893 - -1927 -1188 -6132 -1822 -8085 -6417 -6684 - -5178 -2048 -8063 -3690 -4662 -1628 -6887 -5722 -7857 -8631 - -8993 - -2860 -6116 -6941 -2070 -7288 -5318 -2652 -4299 -6755 -1441 -3203 -1748 - -5917 -2853 -4440 -3392 -3644 -2393 -1085 -6051 -2565 -2631 -4641 -2518 -1824 -5642 -5924 - -4764 -1055 -2484 -1925 -2232 -5127 -3225 -2121 -2186 -5038 -2716 - -24479 -8643 - -2867 -3981 -3058 -4040 -6531 -5535 -1039 -3116 -5489 -5158 -5460 -3323 -3215 - -10545 -6549 -4412 -6210 -8343 -10374 -5154 - -4381 -3278 -3891 -2751 -5091 -4845 -4298 -6630 -2909 -7551 -3107 - -4872 -4965 -4496 -3070 -1645 -4932 -5065 -2171 -2624 -5784 -4419 -5578 -4642 -2713 - -4642 -2714 -10705 -9640 -1399 -6387 -5252 -7016 - -9541 -1249 -5048 -9289 -9480 -8837 -4909 -7487 -8353 - -3978 -5490 -2898 -5709 -3938 -1814 -3809 -4040 -2176 -5688 -1884 -6412 -6864 - -9996 -32317 - -7417 -7170 -7507 -3805 -7964 -7075 -3843 -3455 -2809 -2909 -7161 - -4252 -1443 -5292 -3287 -5288 -5457 -3209 -3415 -1072 -5708 -4588 -1235 -2811 -3625 -5214 - -6408 -30501 - -5289 -7718 -6475 -2989 -2558 -4973 -7907 -4475 -8002 -4285 -7517 - -1989 -2992 -6113 -5009 -5438 -5115 -5923 -1605 -5285 -3161 -6176 -4008 -3803 -2853 - -6837 -13946 -6830 -2191 -5305 -6818 - -4630 -5907 -8041 -6326 -6155 -2804 -4927 -1890 -4410 -2479 - -8616 -12042 -7557 -9302 -3550 -5145 -9512 - -7975 -8541 -8278 -1930 -10634 -7828 -9461 -7555 - -4903 -4483 -6828 -7556 -5002 -5388 -7594 -3786 -5510 -1435 -2937 - -1652 -13742 -12057 -2081 -1835 -10753 - -9583 -7784 -10572 -5049 - -1825 -1844 -6445 -4803 -6480 -1823 -5178 -1785 -1964 -3261 -3736 -6179 -1474 - -2338 -7208 -4272 -3162 -8804 -1105 -3199 -8775 -9596 - -55557 - -1794 -6972 -9252 -7528 -9889 -8781 -6211 -5404 - -16416 -1570 -12987 -4782 - -4131 -1557 -5866 -5478 -2687 -6055 -2566 -2679 -3358 -4278 -3811 -2651 -3102 -5967 -5162 - -6250 -9703 -5470 -11096 -10740 -9661 -3837 - -4924 -4366 -5433 -2194 -5479 -4948 -4856 -2106 -5388 -3078 -2212 -5433 -2587 -4454 -5515 - -11890 -9537 -7022 - -6178 -4820 -4718 -1506 -3796 -4091 -2414 -2632 -2549 -5416 -2436 -4825 -2468 -4289 - -7074 -5761 -14281 -3437 -2925 - -2075 -4353 -4461 -9670 -8279 -8520 -4298 -6878 -8073 - -6162 -6378 -2835 -1313 -1321 -10490 -2249 -8191 - -6256 -3604 -2093 -3574 -5930 -2602 -1803 -8513 -6114 -3344 - -1430 -13233 -1690 -3032 -5910 -2246 - -6165 -2502 -5932 -6907 -7367 -6034 -1371 -2079 -5468 -4296 -6170 -1078 - -23178 -3808 - -27854 -19375 - -5861 -5506 -4757 -6075 -5432 -1111 -5629 -3145 -3755 -5346 -5442 -4707 -5765 -4569 -2783 - -2961 -3499 -6107 -2519 -1666 -1039 -4124 -1691 -6572 -3737 -1100 -5706 -3136 - -2962 - -15411 -6154 -8790 -12518 -7791 - -2242 -6736 -4039 -8306 -4600 -5255 -3039 -3580 -7944 -4855 - -3937 -2432 -2846 -2014 -3969 -4660 -2019 -2586 -3541 -5566 -5674 -4183 -2974 -5856 -1958 - -7021 -11044 -3687 - -6217 -2789 -6810 -4867 -7357 -5889 -6412 -7377 -3079 -1662 -5227 -6301 - -4362 -5552 -4927 -8808 -3339 -5795 -7918 -7131 -9104 - -11573 -21000 - -20018 -11773 -4418 -4415 - -4464 -3642 -5289 -4341 -3270 -3263 -3555 -1005 -5012 -4993 -6055 -7101 - -9336 -1496 -8827 -6642 -5093 -4205 -6397 -4493 -6916 - -6773 -4955 -5473 -4893 -3357 -7459 -3591 -7272 -3718 -6528 -6807 -2867 - -59816 - -6075 -1639 -15157 - -1665 -1561 -6003 -5483 -1795 -6164 -3933 -6998 -5216 -5136 -5143 -7065 - -4855 -5076 -2777 -1203 -6902 -2405 -3796 -8673 -6574 -6254 - -16039 -6855 -11922 - -18026 -8052 -16434 -14954 - -11381 -2762 -5314 -13850 -5874 -4704 - -2628 -1783 -2991 -7589 -7261 -8961 -8368 -4071 -3959 - -4984 -3604 -5401 -6458 -4894 -1871 -2268 -6735 -4139 -5772 -6534 -6199 - -2613 -4511 -14053 -15595 - -25475 -11850 -12168 - -34501 - -14232 -10228 -15816 -9481 -6643 - -5029 -7410 -3023 -2000 -7915 -5569 -1379 -2946 -7013 -4292 - -5447 -5243 -6352 -1660 -2347 -4029 -5794 -6723 -2073 -7518 - -7190 -1021 -1045 -5807 -4104 -4188 -5510 -3145 -2473 -3279 -1489 -2850 - -12531 -5773 -2373 -5971 -2821 -11792 - -6616 -1617 -6994 -2194 -7213 -5263 -4764 -2029 -6976 -6955 -1018 -3830 - -6011 -6522 -2785 -6336 -1221 -5433 -1998 -2990 -5341 -2213 - -15845 -16017 -6817 -2350 -9955 - -18485 -10512 -18191 - -10963 -18879 -1288 -12514 - -7206 -11431 -5079 -1767 -1478 -1173 - -1653 -1462 -5197 -3378 -3011 -6671 -5170 -2654 -6005 -7759 -5265 - -4457 -4696 -5685 -5934 -2295 -2864 -3115 -3941 -3921 -4557 -4973 -2993 -2151 -2311 - -6867 -7819 -4407 -2792 -1571 -3345 -1642 -7461 -5816 -6697 - -3291 -3084 -4832 -1195 -8411 -7009 -3863 - -6455 -5008 -7351 -5320 -3745 -3554 -4741 -1938 -6275 -6867 -6466 - -48508 - -6790 -4190 -1003 -5524 -5145 -3348 -1088 -5249 -6326 -3637 -5766 -4961 -3031 - -24120 -1811 -6650 - -3129 -4133 -3814 -2893 -3749 -6315 -2418 -2726 -3483 -3877 -2043 -5079 -4440 -1787 - -8110 -5553 -6158 -4811 -3133 -3737 -2611 -2075 -4188 -5086 - -19318 - -5872 -6372 -5416 -1309 -6321 -7020 -3273 -4175 -3717 -5140 -7438 -5079 - -1336 -9155 -6709 -2722 -4065 -1618 -1492 -6562 - -5440 -4334 -4617 -3830 -2468 -2110 -1474 -2171 -4903 -5984 -3652 -3808 -4988 -3253 -5376 - -9374 -3614 -1620 -1340 -9642 -4596 -2325 -3680 -6480 - -6328 -1140 -4212 -4673 -6003 -3907 -1897 -5136 -5398 -5164 -1340 -6152 -5189 -5705 - -4086 -4307 -4252 -3336 -2311 -1017 -5877 -2410 -2087 -2151 -2581 -3720 -4578 -3279 -2417 - -14837 -8046 -6307 -12835 - -6737 -5747 -5476 -3975 -8761 -1607 -3930 -5819 -6597 - -2404 -4632 -9393 -2482 -7537 -10334 -6698 -1194 - -7778 -11298 -6485 -1039 -11800 -4406 -4824 - -1317 -7026 -8237 -6529 -5450 -8785 -4565 -5485 -2066 -5517 - -15025 -18252 -18684 -11672 - -4554 -1621 -2494 -4759 -7009 -2702 -6973 -1681 -7204 -2369 -5719 -5105 - -7942 -3730 -9426 -12559 -11015 -2978 - -1535 -9079 -1988 -7192 -7933 -1625 -7926 -1389 -3112 - -3316 -1145 -4696 -7752 -8697 -3344 -11835 - -1354 -1589 -7545 -6150 -6746 -2918 -6788 -4965 -5385 -6289 - -16280 -7614 -19318 -10871 - -1389 -5027 -2440 -10135 -13799 - -1323 -5820 -5780 -4612 -3452 -4654 -2567 -1202 -1445 -1458 -3210 -4807 -2684 -1996 -1384 - -4093 -8449 -1615 -5801 -4196 -6076 -7989 -5862 -6156 -4328 - -18948 - -3089 -7778 -7239 -5381 -2587 -1405 -4676 -6439 -7005 -2918 diff --git a/2022/02/input.in b/2022/02/input.in deleted file mode 100644 index 787ae71..0000000 --- a/2022/02/input.in +++ /dev/null @@ -1,2500 +0,0 @@ -B Y -A Z -A Z -C Z -B Y -B Y -B X -B Z -C Z -B X -B Y -A Z -B Y -B Z -B Y -C Z -B Z -B Y -B Z -C Y -B Y -A Z -B Y -B Y -B Y -C Y -A Z -B Y -B X -A Z -B X -A Z -A Z -B Y -B Y -B X -A Z -B Y -B Z -C X -C X -B Y -B Y -B X -B X -C X -B X -A Z -B Y -B Y -C X -A Z -B Y -B Z -B X -B X -A Z -A X -B Y -B Y -B Z -C Z -B Z -B Z -B Z -A Z -A Z -B X -B X -B Y -B X -B X -C Z -C Z -A Z -A Y -A Z -B Z -A Z -B Y -C X -B X -C X -B Z -B Z -C Z -B Z -B X -C X -A Z -C X -B Z -A Y -C Z -B Y -C Y -B X -A X -B Y -B X -B X -B Z -B Y -A Z -B Z -B Y -B Y -A X -A Z -B X -B X -B X -B X -B Z -B Z -B Y -C X -A Z -A Z -B Y -B Z -B Y -A Z -B Z -A Z -A Z -C X -B Z -A Z -A Z -B Y -B Z -A Z -B Y -B Y -A Z -B Y -C X -B Z -B Y -B X -C X -B X -B X -B X -A Z -A Z -C Y -A Z -B Y -A Z -C X -B Z -B Z -C X -B Y -C X -B X -B X -C X -A Z -B Y -C X -B X -B Y -A Z -B Y -B Y -C X -B Y -C X -A Z -A Z -A Z -B Y -B Y -A X -A Z -A Z -B Y -C X -C Y -B Y -C X -A Z -B X -A Z -A Z -C X -B Y -A Z -B Y -C X -A Z -B X -B Y -A Z -B Y -B X -B X -C X -B Y -C Y -A Z -B Y -B Y -C Y -B Y -C Y -C X -A Y -A Y -B Z -B Y -A Z -B Z -B X -B X -B Y -A Z -B Y -B X -B Y -B Y -C Z -B Y -B Y -A Z -A Z -B Z -A Y -C X -B Y -B Y -B Z -B Z -B Y -C X -B Y -B X -B Z -B Y -B X -B Y -C Z -B Y -B X -A Z -B Z -B Z -A Z -C X -B Y -C Z -A Z -B Y -C Z -B Y -B X -B Y -B X -C Z -B Z -A Z -A Z -A Z -A X -B Z -B Y -B X -B Y -A Z -B Z -C Z -B X -B Z -B Z -A Z -B Y -B X -A Z -A Z -B Y -B X -A Z -A Z -C Z -A Z -C Z -B Y -B Y -B Z -C X -A Z -B X -B Y -B X -B Y -B Y -B X -B Z -B X -C Z -C X -C X -A Z -A Z -B X -B X -A Y -C X -B Y -A Y -B Z -B X -A Z -B X -B Y -B Y -B Y -B Y -A Z -A Z -B Y -B X -C Z -B Z -C X -B Z -B Y -C X -A Z -B Y -A Z -A Z -B Z -B Y -B X -A Z -B X -B Y -A Z -B Z -B X -B X -A Z -C Y -B X -A Z -B X -B Y -C X -B Y -C Z -C X -B Y -B Y -B Y -B X -B Y -B X -A Y -A Z -B Z -B Y -B X -B Z -B Y -C Z -B Y -A Z -B X -A Z -C X -A X -B Z -B Z -C X -A Z -B X -A Z -A Z -B Z -A Z -B Y -B Z -C Z -A Y -A Z -A Z -A Z -C X -B Z -B Z -B Y -B X -B Y -B Y -B Y -B Z -B Y -B Y -A Z -B Z -A Z -C X -B Y -B X -B Y -B X -B Y -B Y -C X -B Y -B Y -B Z -B Y -C X -B Y -B X -B Y -C X -A X -A Z -C Z -B Y -C Z -B X -C Z -C X -C Z -B Y -B Y -C X -C X -B Y -C X -A Y -B Y -B X -B X -B Z -B Y -C Y -C X -B X -B Y -B Z -B X -B Z -B Z -C X -B X -B Y -B Z -B X -C Z -A Y -B Y -B Y -B Y -A Y -C Y -B Y -B Z -B Z -B Y -B Y -B Z -B X -B X -B Y -A Z -C Y -C Z -B Y -B X -B Y -B Y -C X -B Y -C X -A Z -B X -C X -C Z -A Z -A Z -B Y -C X -A Z -A Z -B Y -A Y -B Y -A Z -A Z -B X -C X -A Z -B X -B Z -A Z -A Z -B X -B Y -B X -B Z -B Y -B Y -B Z -C X -C X -B Y -A Z -B X -B X -B Y -B Z -B Y -B X -B Z -B X -B Y -C X -B Y -B Y -C Y -A Z -B Y -B X -B Y -A Z -C X -A Z -A X -B Z -B X -A Z -B Y -B X -B X -A Z -B Y -A Z -B Z -B Y -A Z -B Y -B Y -A Z -B Z -C Z -B Y -B Y -C Y -A Z -B Y -B Y -B Y -B Y -B Z -B Y -B Y -B Y -C X -B Z -B X -A Z -B Z -C X -B Y -B Y -A Z -B Y -B X -A Z -A Z -C Z -B X -B X -B Y -B Z -B Z -B Z -B Y -B Y -B Y -B Y -B Z -B Y -A Z -A Y -A Z -B Y -B Y -A Z -B X -B Y -A Z -C Z -B Z -B Z -B Y -A Z -A Z -B Y -B X -B Z -B X -B Y -B Y -B X -C X -B Z -B X -A Z -B Y -C Z -B X -A Z -C Z -C Z -A Z -B Y -B Y -A Y -B Y -C Z -B X -C X -B Y -B X -B Z -B Y -B Z -B Y -B Y -A Z -B X -B X -A Y -B Z -B X -B Z -A Y -B Z -C X -B X -B X -B Z -B X -C Y -B Y -C X -C X -B Z -B X -C Z -B Z -A Z -C Y -B Y -B Y -B X -B Z -B Y -B Y -B X -C X -B Y -B Y -C Y -B Z -C X -A Z -B X -B X -B Z -B X -B Y -A Z -B Z -B X -A Z -B Y -C X -A Y -A Z -C X -B X -B Z -B X -C X -A Z -B X -B Y -B Y -A Z -B Z -C X -A Z -B Z -C X -B X -A Z -C X -C Z -B Y -B Z -B Y -B X -C Z -B Z -B Z -B Y -A Z -C Z -A Y -B Y -C X -B Y -B Z -A Z -B Z -A Z -B X -C X -B Y -A Z -B Y -B X -C Z -B Z -C X -B Y -B X -C Y -B Y -C X -B Y -B Y -B Y -B Z -B Y -B X -B Y -B Y -A Z -A Z -C X -B Z -B Y -A Z -B X -C X -B Y -B X -A Z -C Z -A Z -B Z -B Y -B X -B Z -B Y -A Z -C X -C Z -A Y -A Z -C X -C Y -C Z -B Y -B X -B Z -B Y -B X -B Y -A Z -B Y -C X -B X -B Y -C Z -B Y -B Y -B Y -B X -B Y -C Z -B X -B Y -B Y -B Z -B X -B X -B Z -B Z -A Z -A Z -C X -B Y -B Y -C X -B Y -B X -A Y -C Z -B Y -B Z -B Y -B Y -A Z -B Y -B Z -B Y -B Z -B X -B Z -B Y -A Z -B X -B Z -B Y -B Y -B Z -B Y -A Z -B X -B Y -B Z -B X -B Y -B X -B X -B Y -B X -C Y -B Z -B Y -B Z -C Y -A Z -B Y -A Z -B X -A Z -A Z -C Z -B X -C Y -A Z -B Z -B Z -B X -B Z -B Y -A Z -B Z -C Z -A Z -C Y -A Z -B Y -A Z -B Y -A Z -B X -A Z -B Z -C X -B Y -B Y -B Y -C X -B Z -C X -A Z -A Z -C X -B Y -B Z -B X -B Y -B X -A Z -B Y -B Y -A Z -B Y -B Z -B Z -B X -B Z -B Y -B X -B Y -B Y -C X -C Z -B Y -B Y -B Y -B Z -B Y -B Y -B Y -A Z -B Y -B X -B Y -B X -B Z -B Y -B X -B X -A Y -B Y -B X -B Y -B Y -B Y -B Z -B X -A Z -B Y -B Y -B Y -A Z -B X -B X -C Z -B Y -B Y -A Z -B Y -B Z -B X -C X -B Y -B Y -C X -C Z -B X -A Z -B Y -B Y -B X -B X -B X -B Y -B Y -A Z -A Z -B Y -B Y -A Z -B Z -A Z -C X -C X -B Y -B Y -A Z -A Z -C Z -B Z -B X -A Z -B X -B Y -B Y -B X -B Y -B Y -C Z -B Y -B X -C Z -C Z -B X -B Y -B Y -B Z -A Z -B Y -B Y -B Y -B X -B X -A Z -A Z -B X -B Y -B Z -B Y -B Z -B Y -B Z -C X -B Y -C X -B Y -B Y -C Y -A Z -B X -C Z -B Y -B Z -B Y -B Y -B Y -C X -B X -B Y -A Z -C Y -B Y -A Z -B Y -B Z -B Z -B Y -B Y -B Y -C X -B Y -A Y -C Y -B X -B X -B X -B X -B Z -B X -B Z -B Y -B Y -A Z -B X -B X -A Z -A Y -B Y -B Z -B Y -C X -B Y -B X -B Z -C X -B Z -B Y -B X -B X -A Z -B Y -B Y -B Y -C X -A X -B X -C X -B X -C X -B X -A X -B Y -B Y -B Y -B Y -B Z -C Y -C X -A Z -B Z -B Z -B Y -B Z -B Y -B Y -B X -B Z -A Z -A Z -B Z -B X -B Z -A Z -B Y -B Y -B Y -B Z -A Y -B X -B Z -B Y -B Y -B Y -B Y -C X -B Z -C X -A Z -A Z -B Z -A Y -C X -B X -B X -C X -A Z -A Z -A Z -B Y -B Z -A X -A X -B Y -C X -A Z -B Z -A Z -B Y -B Y -B X -B X -B Y -C X -B Z -B Y -B X -B X -B Y -B Z -B Y -B Y -B X -B X -B X -B Y -C X -B Y -B Y -B X -B Y -B Y -B X -B X -A Z -C X -B X -A Z -B Y -B Y -B Z -B Y -B X -A Z -C Y -B X -B Z -B Y -C X -A Z -B X -A Z -A Z -B Y -B Z -B Y -A Z -B Y -B Z -A Z -C Z -B Y -B Y -B X -B Z -B Y -B X -B X -B Y -B Z -B X -B Y -C Z -A X -B Y -C X -A X -B X -B X -B Z -A X -B X -B Y -B X -A Z -B Z -C Z -B X -B X -A Z -B X -B X -B Z -B Y -B Y -A Z -B Y -B Y -B X -B X -B X -B Y -A Y -C X -B X -A Z -B X -B Y -C Z -B Y -B Y -A Z -B Y -A Z -B Y -A Z -B Y -B Y -A Z -B X -B X -B Y -B Y -B Y -A Z -B Y -B Y -A Z -B X -A X -A Z -B Y -B X -B Z -B Z -B Y -B Y -C Y -B Y -B Y -B X -B Y -A Z -C X -B Z -B X -B Z -A Z -B Y -B Z -B X -A Z -A Z -C X -B X -A Y -C X -B Z -B Z -C Z -B Z -B Z -C Y -A Z -C Z -A Z -C Z -B Z -B Y -C X -B Y -B X -A Z -C Y -B X -B Y -B Y -B X -B Y -A Z -A Z -B Y -B Z -B Y -C X -B X -B Y -B X -A Z -C X -B Y -B Y -B Y -B Y -C Z -B Y -C Z -A X -C Z -B X -B Y -B Y -B X -B Y -C X -C X -A Z -B Y -B Y -C X -B Z -C Y -B Z -B Z -B Z -B X -B X -B X -B Z -B X -C X -B Y -C X -B X -C Z -B Y -B X -B Z -B Y -B Y -B Y -B Y -B Y -B X -B X -A Z -B Y -B X -B Y -B Y -A Y -B Y -B Y -A Z -A Z -C Z -B X -B Y -B Y -B Z -C Z -C X -A Z -C X -A X -B X -B Z -B Y -A Z -C Z -B Y -C Z -B X -A Z -B X -A Z -B Y -A Y -B Y -B Y -A Z -C X -B X -B Y -A Z -B Z -B Y -B X -B X -C Y -B X -A Z -B Z -A Z -C X -C Y -B Z -B Z -A Z -B X -B Y -B X -C X -B Y -B Y -B X -C X -B X -B Y -B X -B Y -B Z -B Y -B X -B X -A Z -B Y -B Y -C X -C Y -C X -A Z -A Z -B X -B X -B Z -A Z -A Z -C Z -B Z -A X -B X -B Y -B Y -A Z -B Y -B X -B X -B X -B Y -B X -B Y -B Y -B Y -B Y -B Y -B Y -B Z -A Z -B Y -B X -C X -A Y -B Y -B Y -B Z -C Z -B X -C X -B Z -B Y -B Y -B X -B X -B X -A Z -B X -A Y -B Y -B Y -C X -A Z -B Y -C X -B Y -B X -B X -B X -C Z -B X -A Z -B Y -B Y -B Y -A Z -A Z -B X -A Y -B Y -B Y -B Y -B X -B X -B Z -B X -B Z -B X -B Y -A Y -A Z -C Y -B Z -C X -B Z -B Y -B X -A Y -B Y -B X -B Y -B X -C Z -B X -C Z -B Y -B X -B Z -A Y -A Y -C Z -B X -B X -B Y -A Z -B Y -B Z -A Z -B X -B X -B X -B X -B X -B Z -A Z -A Z -C Y -C X -A Z -A Z -C X -B X -B X -B Z -B X -A Z -B Y -B X -B Y -C X -A Z -B Z -C X -B Y -B Y -A Z -B Y -B Y -B X -B Y -C Y -B X -B Z -B Y -A Z -B Z -A Y -B Y -A Z -B X -B Y -A Z -B Y -C Z -B Z -B Y -C X -C X -B X -B Z -B Y -B Z -B Z -B Z -B Z -A Z -B Y -B X -B Z -B Y -B X -A Z -A Z -A Z -B Y -C Y -C Z -B Z -B X -B Y -B Z -B Y -A Z -A Z -C Z -B X -B Y -B Z -B X -A Y -A Y -B Y -A Y -B Z -B Y -A Z -B Y -B Y -B Y -C Z -B X -B Z -B X -B Y -B Y -B Y -C X -B X -B Y -B Z -B X -B Y -B Y -B Y -B X -B X -B X -A Z -B Y -B Y -C X -C X -C X -C X -B Z -A Z -A Z -B Z -B Y -B X -A Z -C Z -B Y -B X -C Z -C X -B X -B Y -B Y -B X -B X -B Y -A Z -B X -B X -B X -B Y -A Y -B X -A Z -B Y -B Y -B Y -C Y -B Z -B X -B Z -C X -B Y -B Z -C X -B X -B X -B Y -B Y -B Y -A Z -A Z -A Z -B Y -B X -C Z -B Z -B Y -B Y -B Y -B Y -B Z -C X -A Z -C Z -B Z -B X -B X -A Z -B X -B Z -A Z -B Y -B Y -A Z -B Y -B Y -C Y -C Z -B X -A Z -B Z -B Y -C Z -C X -B X -A Z -B Y -B Z -B X -A Z -A Z -A Z -B Y -B X -C X -B Z -B Z -B X -B X -B Y -A Z -B X -B X -B Z -A Z -C X -B X -B Y -B Z -A Z -B Y -B Y -B Y -C X -B Z -A Y -A Z -B Z -C X -A Z -A Z -B Y -C X -B Y -B Z -C X -B Y -B Y -A Z -B Z -A Z -C Z -A Z -B X -B Z -A Z -B X -B Y -C Z -A Y -B Y -B Y -B Y -A Z -B Z -A Y -A Z -B Z -B Y -B Y -A Y -B Y -C X -B Z -B Z -A Z -B X -B X -A Z -B Z -C Y -A Z -A Z -B Y -B Z -B X -C Y -B Y -B Y -B Z -B Y -B Z -B X -B X -B Y -B Y -C X -C X -B X -B X -C X -A Z -B Y -C Z -A Z -B X -B Y -B Z -A Z -C Y -A Z -B Z -A Z -C X -C X -B X -B X -B Y -B Y -B Y -B Y -B Z -B X -B Z -C Y -B Y -A Z -B Y -B X -A Y -B Y -B Z -C X -B X -A Z -A Z -B Y -B Y -A Z -C X -B X -B Y -B Y -B Z -A Z -A Z -C Z -A Z -B Y -B Y -B Y -A Z -B Z -B Y -A Z -A Y -B Y -B Y -B Z -A X -A Z -B Z -B X -A Z -B Z -B Y -B Y -B X -A Y -C Y -B Y -B Y -B X -B Z -A Z -B X -B X -B Y -B Y -A Z -B X -C X -B X -B X -A Z -B Y -C X -A Z -B X -C Z -A Z -B Y -B Y -B X -B X -A Z -C Z -B X -B X -B Y -A Z -B Y -B Y -B X -B Y -B X -A Z -B Y -B Z -B X -A Z -B Y -C Z -C X -A Z -A Y -B X -B Z -B Y -B Y -B Y -B Z -B Z -A Y -C X -B X -C X -B Y -B Y -B Z -B Y -C Y -C X -B Z -C X -B Y -B X -B Y -B Y -A Z -B Y -A Z -A Z -A Z -A Z -B Y -A Z -B X -B X -B X -C Z -B Z -C Y -B Y -A Z -B Z -B Y -B Y -B Y -A Z -B Z -C Y -C X -B Y -B Y -B Y -B X -B Y -B Z -A Z -B Y -B Y -C Y -B Z -B X -B Y -B X -B Z -B Y -C Y -C Y -A Z -B X -B X -A Y -B Z -A Z -B Y -B X -B X -B Z -B X -A Z -B Y -C X -C X -B Z -A Z -B Y -B Y -B Y -B Y -B Y -B X -B Y -B Y -B Z -B Z -A X -A Z -A Z -A Z -A Y -C X -B Y -B Z -B X -A Z -B Y -B Y -B X -B Y -B Y -C Y -C Y -B X -A Z -B Y -C X -B Y -A Y -B X -B X -B Y -C X -A Z -B Y -B X -C X -C Z -B Y -B Y -B Y -A Z -B X -A Z -C Z -B Z -B Y -B Y -B X -B Y -B Y -B X -A Z -C X -C Z -B X -B Y -C Y -B X -A Z -B Y -A Z -B Y -A Y -A Z -A Z -B Y -B Y -B Z -C Z -C X -B Y -B Z -B Y -A Z -B Y -B Z -B Y -B X -B Y -B Z -B Y -B Z -C X -B Y -B Y -C Z -A Z -B Y -C X -B X -A Y -B Y -A Z -B Y -B X -B Y -B Y -B X -B X -B X -B Y -B Y -C Z -B Z -C X -C Z -B Y -C X -B X -A Z -B Y -C Z -A Y -B Y -B Y -B Y -C X -B X -B Y -B Y -B Z -C X -B X -B Z -A Z -B X -B Z -B X -A Z -B Y -B Z -C X -B X -C X -B X -B Y -B Z -B Z -B Z -A Z -B Y -B X -B Y -B Y -B X -B Z -B Y -C X -A Z -B Z -B X -A Z -B Y -B Y -B Y -A Z -A Z -C X -B X -A Y -B Y -B Y -B Y -A Z -A Z -A Z -C Y -B Z -A Y -B Y -B X -B X -B Y -C X -B Y -C Z -B Y -A X -B Y -B X -B Y -B X -C Z -B Y -B Z -B X -B Z -A Z -B Y -B X -B Y -A Z -B X -C Y -B X -B Y -B Y -B Y -C X -B Y -B Y -B Y -A Z -B Z -C X -A Z -B Y -C Y -B X -A Z -C Z -B X -B Y -B X -C Z -B X -B Z -C Y -B X -B Y -B X -B Z -B X -B Z -B Y -B Z -B X -A Z -B X -A X -B X -B Y -B Y -B Y -A Z -B Y -B Y -B Z -C X -B Y -B Y -B Y -B X -B X -B X -C Z -B Z -B X -A Z -B Y -B Z -B Y -B Y -B Y -B Y -C X -A Z -B Z -B Y -B Y -B Z -A Z -B Y -B Z -B Y -B Y -C Y -A Z -B Z -C X -B X -C Z -B X -B X -B Y -B Y -A X -B Y -C Z -A Z -B X -C Z -C Z -B X -A Z -B X -C Z -B Z -B Y -B Y -C X -A Z -B X -B Y -B X -B X -B X -B Y -C X -B Z -B Y -B Y -B Y -B X -A Z -A Z -B Y -B Z -B Y -A Z -B Y -B X -A Z -B Z -B Y -B X -B Y -A Y -B Y -B Y -B Y -B Z -B X -B Y -C Z -C X -B Y -C Y -B Z -A Z -A Z -B Y -B Y -A Z -B Z -B Y -B X -A Z -A Z -C X -A Z -C X -A Z -B Y -C X -B X -B X -B Y -A Y -B Y -B Z -B X -B Y -B Y -A Z -B X -B Y -A Z -A Y -A Z -C X -A Z -C X -A X -B Y -B Y -A Z -B X -B Z -B Y -B Y -B Z -B Y -B Y -B X -B Y -C X -C X -B Y -B Y -B X -C Z -C Z -C Z -C X -B Y -C Z -A Z -C Z -B Y -A Z -B Z -B X -A Y -B Y -B Y -B X -B Y -B Y -C X -B Y -A Z -B Y -A Z -C Z -A Z -B Y -B Z -A Z -B X -B X -B Z -B X -B Y -A Z -B Y -C X -A Z -C Z -B X -A Z -B Y -B Y -C Z -B Z -A Z -B Y -B X -B Y -B Z -C Z -A Y -A Z -B X -B X -A Z -C Y -B Y -A X -A Z -B X -B Y -B X -A Z -C X -B Y -B Y -C X -A X -B Y -A Z -A Z -B Y -B Z -B Y -B Y -B Y -B X -B Y -B X -B X -B X -B Y -A Z -C X -A Z -A Z -A X -A Z -B X -B Z -B Y -A Z diff --git a/2022/03/03.kt b/2022/03/03.kt new file mode 100644 index 0000000..c0e77b9 --- /dev/null +++ b/2022/03/03.kt @@ -0,0 +1,16 @@ +fun main() { + val rucksacks = generateSequence(::readlnOrNull).toList() + val cost = " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" + + val s1 = rucksacks + .map { it.chunked(it.length / 2)} + .map { it[0].toSet() intersect it[1].toSet() } + .sumOf { cost.indexOf(it.first()) } + println(s1) + + val s2 = rucksacks + .chunked(3) + .map { it[0].toSet() intersect it[1].toSet() intersect it[2].toSet() } + .sumOf { cost.indexOf(it.first()) } + println(s2) +} diff --git a/2022/03/03.py b/2022/03/03.py new file mode 100644 index 0000000..df0ca82 --- /dev/null +++ b/2022/03/03.py @@ -0,0 +1,16 @@ +import sys +import string +s1, s2 = 0, 0 +lines = sys.stdin.read().strip().split("\n") + +for line in lines: + half = len(line) // 2 + for c in set(line[:half]) & set(line[half:]): + s1 += string.ascii_letters.index(c) + 1 + +for l1, l2, l3 in zip(lines[0::3], lines[1::3], lines[2::3]): + for c in set(l1) & set(l2) & set(l3): + s2 += string.ascii_letters.index(c) + 1 + +print(s1) +print(s2) diff --git a/2022/03/example.ans b/2022/03/example.ans new file mode 100644 index 0000000..f5fb061 --- /dev/null +++ b/2022/03/example.ans @@ -0,0 +1,2 @@ +157 +70 diff --git a/2022/03/example.in b/2022/03/example.in new file mode 100644 index 0000000..f17e726 --- /dev/null +++ b/2022/03/example.in @@ -0,0 +1,6 @@ +vJrwpWtwJgWrhcsFMMfFFhFp +jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL +PmmdzqPrVvPwwTWBwg +wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn +ttgJtRGJQctTZtZT +CrZsJsPPZsGzwwsLwLmpwMDw diff --git a/2022/03/input.ans b/2022/03/input.ans new file mode 100644 index 0000000..9f66917 --- /dev/null +++ b/2022/03/input.ans @@ -0,0 +1,2 @@ +7863 +2488 diff --git a/2022/04/04.kt b/2022/04/04.kt new file mode 100644 index 0000000..886acde --- /dev/null +++ b/2022/04/04.kt @@ -0,0 +1,15 @@ +fun Boolean.toInt() = if (this) 1 else 0 + +fun main() { + val seq = generateSequence(::readlnOrNull).toList() + .map { it.replace(',', '-').split('-') } + .map { it.map { it.toInt() } } + val s1 = seq + .map { (a, b, c, d) -> (a..b intersect c..d).size-1 in setOf(b-a, d-c) } + .sumOf { it.toInt() } + val s2 = seq + .map { it[0]..it[1] intersect it[2]..it[3] } + .sumOf { (!it.isEmpty()).toInt() } + println(s1) + println(s2) +} diff --git a/2022/04/04.py b/2022/04/04.py new file mode 100644 index 0000000..0e65399 --- /dev/null +++ b/2022/04/04.py @@ -0,0 +1,13 @@ +import sys + +s1 = s2 = 0 +for line in sys.stdin.readlines(): + a, b, c, d = map(int, line.strip().replace(",", "-").split("-")) + range1, range2 = set(range(a, b+1)), set(range(c, d+1)) + + s1 += len(range1 & range2) in (b-a+1, d-c+1) + s2 += bool(range1 & range2) + +print(s1) +print(s2) + diff --git a/2022/04/example.ans b/2022/04/example.ans new file mode 100644 index 0000000..da7f847 --- /dev/null +++ b/2022/04/example.ans @@ -0,0 +1,2 @@ +2 +4 diff --git a/2022/04/example.in b/2022/04/example.in new file mode 100644 index 0000000..9f9e9cf --- /dev/null +++ b/2022/04/example.in @@ -0,0 +1,6 @@ +2-4,6-8 +2-3,4-5 +5-7,7-9 +2-8,3-7 +6-6,4-6 +2-6,4-8 diff --git a/2022/04/input.ans b/2022/04/input.ans new file mode 100644 index 0000000..74c4295 --- /dev/null +++ b/2022/04/input.ans @@ -0,0 +1,2 @@ +459 +779 diff --git a/2022/05/05.kt b/2022/05/05.kt new file mode 100644 index 0000000..a047d30 --- /dev/null +++ b/2022/05/05.kt @@ -0,0 +1,38 @@ +fun solve(input: String, moveTogether: Boolean) { + val (raw_towers, moves) = input.split("\n\n") + val towers = raw_towers.split("\n").dropLast(1).asReversed() + val stacks: MutableList> = mutableListOf() + + for (j in 1 until towers[0].length step 4) { + stacks.add(mutableListOf()) + for (i in 0 until towers.size) + if (towers[i][j] != ' ') + stacks.last().add(towers[i][j]) + } + val nums = moves + .split("\n") + .map {it.filter {!it.isLetter()}} + .map { it.split(" ")} + .map { it.map {it.trim().toInt()}} + + for ((num, from, to) in nums) { + if (!moveTogether) + for (i in 1..num) + stacks[to-1].add(stacks[from-1].removeLast()) + else { + val tmp: MutableList = mutableListOf() + for (i in 1..num) + tmp.add(stacks[from-1].removeLast()) + for (i in 1..num) + stacks[to-1].add(tmp.removeLast()) + + } + } + println(stacks.map { it.last() }.joinToString("")) +} + +fun main() { + val input = generateSequence(::readlnOrNull).joinToString("\n") + solve(input, false) + solve(input, true) +} diff --git a/2022/05/05.py b/2022/05/05.py new file mode 100644 index 0000000..43c335a --- /dev/null +++ b/2022/05/05.py @@ -0,0 +1,27 @@ +import sys, re +towers, instructions = sys.stdin.read().rstrip().split("\n\n") +*towers, indices = towers.split("\n") +tower_count = int(indices.strip().split()[-1]) + +stacks1 = [[] for _ in range(tower_count)] + +for line in towers[::-1]: + for i in range(tower_count): + c = line[i*4+1] + if c != ' ': + stacks1[i].append(c) + +stacks2 = [l.copy() for l in stacks1] + +for line in instructions.split("\n"): + a, b, c = map(int, re.fullmatch(r"move (\d+) from (\d+) to (\d+)", line).groups()) + for _ in range(a): + new = stacks1[b-1].pop() + stacks1[c-1].append(new) + + stacks2[c-1].extend(stacks2[b-1][-a:]) + for _ in range(a): + stacks2[b-1].pop() + +print(''.join(s[-1] for s in stacks1)) +print(''.join(s[-1] for s in stacks2)) diff --git a/2022/05/input.ans b/2022/05/input.ans new file mode 100644 index 0000000..6a2ba93 --- /dev/null +++ b/2022/05/input.ans @@ -0,0 +1,2 @@ +MQSHJMWNH +LLWJRBHVZ diff --git a/2022/06/06.kt b/2022/06/06.kt new file mode 100644 index 0000000..83ff839 --- /dev/null +++ b/2022/06/06.kt @@ -0,0 +1,7 @@ +fun String.solve(n: Int) = n + this.windowed(n).indexOfFirst { it.toSet().size == it.length } + +fun main() { + val s = readln() + println(s.solve(4)) + println(s.solve(14)) +} diff --git a/2022/06/06.py b/2022/06/06.py new file mode 100644 index 0000000..16c3faf --- /dev/null +++ b/2022/06/06.py @@ -0,0 +1,8 @@ +s = input() +def solve(n): + for i in range(len(s)): + if len(set(s[i:i+n])) == n: + return i+n + +print(solve(4)) +print(solve(14)) diff --git a/2022/06/input.ans b/2022/06/input.ans new file mode 100644 index 0000000..78223cb --- /dev/null +++ b/2022/06/input.ans @@ -0,0 +1,2 @@ +1794 +2851 diff --git a/2022/07/07.kt b/2022/07/07.kt new file mode 100644 index 0000000..f9df501 --- /dev/null +++ b/2022/07/07.kt @@ -0,0 +1,33 @@ +data class Tree(val name: String, var parent: Tree?) { + var size: Int = 0 + val children: MutableList = mutableListOf() +} + +fun main() { + val shell = generateSequence(::readlnOrNull).toList() + .map { it.replace("$ ", "") } + .filter { it != "ls" } + val root = Tree("/", null) + var current = root + for (line in shell) { + var (command, arg) = line.split(" ") + when (command) { + "cd" -> when (arg) { + "/" -> current = root + ".." -> current = current.parent!! + else -> current = current.children.filter { it.name == arg }.first() + } + "dir" -> current.children.add(Tree(arg, current)) + else -> current.size += command.toInt() + } + } + val sizes: MutableList = mutableListOf() + fun recursiveSizes(tree: Tree): Int { + sizes.add(tree.size + tree.children.sumOf(::recursiveSizes) ) + return sizes.last() + } + recursiveSizes(root) + println(sizes.filter { it <= 100000 }.sum()) + val needed = 30000000 - (70000000 - sizes.max()) + println(sizes.filter { it >= needed }.min()) +} diff --git a/2022/07/07.py b/2022/07/07.py new file mode 100644 index 0000000..2f1857f --- /dev/null +++ b/2022/07/07.py @@ -0,0 +1,40 @@ +import sys +from dataclasses import dataclass, field + +@dataclass +class Tree: + name: str + parent: "Tree" = None + size: int = 0 + children: dict = field(default_factory=dict) + +current = root = Tree("/") + +for line in sys.stdin.read().strip().split("\n"): + match line.split(): + case ["$", "cd", "/"]: + current = root + case ["$", "cd", ".."]: + current = current.parent or current + case ["$", "cd", name]: + current = current.children[name] + case ["$", "ls"]: + pass + case ["dir", name]: + current.children[name] = Tree(name, current) + case [num, name]: + current.size += int(num) + +sizes = [] +def rec_size(tree): + size = (tree.size or 0) + sum(map(rec_size, tree.children.values())) + sizes.append(size) + return size + +rec_size(root) + +print(sum(s for s in sizes if s <= 100000)) +needed = 30000000 - (70000000 - max(sizes)) +print(min([a for a in sorted(sizes) if a >= needed])) + + diff --git a/2022/07/input.ans b/2022/07/input.ans new file mode 100644 index 0000000..05a6269 --- /dev/null +++ b/2022/07/input.ans @@ -0,0 +1,2 @@ +1749646 +1498966 diff --git a/2022/08/08.kt b/2022/08/08.kt new file mode 100644 index 0000000..3986e8d --- /dev/null +++ b/2022/08/08.kt @@ -0,0 +1,48 @@ + + +fun main() { + val s = generateSequence(::readlnOrNull).toList() + val indices = (0..s.size-1).toList() + val visible: MutableSet> = mutableSetOf() + var highest: Int + for (i in indices) { + for (order in listOf(indices, indices.reversed())) { + highest = 0 + for (x in order) { + if (highest < s[i][x].code) + visible.add(Pair(i, x)) + highest = maxOf(s[i][x].code, highest) + } + highest = 0 + for (y in order) { + if (highest < s[y][i].code) + visible.add(Pair(y, i)) + highest = maxOf(s[y][i].code, highest) + } + } + } + println(visible.size) + + var best = 0 + fun is_valid(y: Int, x: Int, size: Int) = 0 <= y && y < size && 0 <= x && x < size + for (Y in indices) { + for (X in indices) { + var scenic = 1 + for ((ya, xa) in listOf(Pair(1, 0), Pair(-1, 0), Pair(0, 1), Pair(0, -1))) { + var dist = 0 + var y = Y+ya + var x = X+xa + while (is_valid(y, x, s.size)) { + dist += 1 + if (s[y][x] >= s[Y][X]) + break + y = y+ya + x = x+xa + } + scenic *= dist + } + best = maxOf(best, scenic) + } + } + println(best) +} diff --git a/2022/08/08.py b/2022/08/08.py new file mode 100644 index 0000000..e988d39 --- /dev/null +++ b/2022/08/08.py @@ -0,0 +1,36 @@ +import sys +s = [list(a) for a in sys.stdin.read().strip().split("\n")] + +# === Part 1 === +visible = set() +indices = list(range(len(s))) +for i in indices: + for order in (indices, list(reversed(indices))): + m = '/' + for x in order: + if m < s[i][x]: + visible.add((i, x)) + m = max(s[i][x], m) + m = '/' + for y in order: + if m < s[y][i]: + visible.add((y, i)) + m = max(s[y][i], m) +print(len(visible)) + +# === Part 2 === +best = 0 +is_valid = lambda y, x: 0 <= y < len(s) and 0 <= x < len(s[0]) +for Y in range(len(s)): + for X in range(len(s[0])): + scenic = 1 + for ya, xa in [(1, 0), (-1, 0), (0, 1), (0, -1)]: + dist, y, x = 0, Y+ya, X+xa + while is_valid(y, x): + dist += 1 + if s[y][x] >= s[Y][X]: + break + y, x = y+ya, x+xa + scenic *= dist + best = max(best, scenic) +print(best) diff --git a/2022/08/input.ans b/2022/08/input.ans new file mode 100644 index 0000000..4341940 --- /dev/null +++ b/2022/08/input.ans @@ -0,0 +1,2 @@ +1794 +199272 diff --git a/2022/09/09.kt b/2022/09/09.kt new file mode 100644 index 0000000..d99e63d --- /dev/null +++ b/2022/09/09.kt @@ -0,0 +1,24 @@ +operator fun Pair.plus(o: Pair) = Pair(this.first + o.first, this.second + o.second) + +fun main() { + val input = generateSequence(::readlnOrNull).toList().map { it.split(" ") } + val visited2: MutableSet> = mutableSetOf() + val visited10: MutableSet> = mutableSetOf() + val lookup = mapOf("D" to Pair(0, 1), "U" to Pair(0, -1), "L" to Pair(-1, 0), "R" to Pair(1, 0)) + val rope = MutableList(10) { Pair(0, 0) } + for ((dir, steps) in input) { + for (j in 1..steps.toInt()) { + rope[0] = rope[0] + lookup[dir]!! + for (i in 0..rope.size-2) { + val dx = rope[i].first - rope[i+1].first + val dy = rope[i].second - rope[i+1].second + if (Math.abs(dx) >= 2 || Math.abs(dy) >= 2) + rope[i+1] = rope[i+1] + Pair(dx.coerceIn(-1..1), dy.coerceIn(-1..1)) + } + visited2.add(rope[1]) + visited10.add(rope.last()) + } + } + println(visited2.size) + println(visited10.size) +} diff --git a/2022/09/09.py b/2022/09/09.py new file mode 100644 index 0000000..e4fdc0d --- /dev/null +++ b/2022/09/09.py @@ -0,0 +1,17 @@ +import sys +visited_segment2 = set() +visited_segment10 = set() +rope = [[0, 0] for _ in range(10)] +lookup = {"L": (-1, 0), "R": (1, 0), "D": (0, 1), "U": (0, -1)} +for dir, steps in [line.split() for line in sys.stdin.readlines()]: + for _ in range(int(steps)): + rope[0][0] += lookup[dir][0] + rope[0][1] += lookup[dir][1] + for i, ((hx, hy), (sx, sy)) in enumerate(zip(rope, rope[1:])): + if abs(hx - sx) > 1 or abs(hy - sy) > 1: + rope[i+1][0] += max(-1, min(hx - sx, 1)) + rope[i+1][1] += max(-1, min(hy - sy, 1)) + visited_segment2.add(tuple(rope[1])) + visited_segment10.add(tuple(rope[-1])) +print(len(visited_segment2)) +print(len(visited_segment10)) diff --git a/2022/09/input.ans b/2022/09/input.ans new file mode 100644 index 0000000..9fbd419 --- /dev/null +++ b/2022/09/input.ans @@ -0,0 +1,2 @@ +6337 +2455 diff --git a/2022/10/10.kt b/2022/10/10.kt new file mode 100644 index 0000000..4d12d71 --- /dev/null +++ b/2022/10/10.kt @@ -0,0 +1,12 @@ +fun main() { + val vals = generateSequence(::readlnOrNull).joinToString("\n").split(" ", "\n") + .map { it.toIntOrNull() ?: 0 } + .scan(1, Int::plus) + .withIndex() + println(vals.filter { (it.index+1) % 40 == 20 }.sumOf { (it.index+1) * it.value }) + val p2 = vals + .map { (i, v) -> if (v-1 <= i % 40 && i % 40 <= v+1) "#" else " " } + .chunked(40) + .map { it.joinToString("") } + println(p2.joinToString("\n").trim()) +} diff --git a/2022/10/10.py b/2022/10/10.py new file mode 100644 index 0000000..939869d --- /dev/null +++ b/2022/10/10.py @@ -0,0 +1,11 @@ +import sys +X, s = 1, 0 +crt = [[] for _ in range(6)] +for cycle, line in enumerate(sys.stdin.read().replace(" ", "\n").split()): + crt[cycle // 40].append('#' if X - 1 <= cycle % 40 <= X + 1 else ' ') + if (cycle+1) % 40 == 20: + s += X * (cycle+1) + if line not in ["addx", "noop"]: + X += int(line) +print(s) +print(*[''.join(line) for line in crt], sep='\n') diff --git a/2022/10/example.ans b/2022/10/example.ans new file mode 100644 index 0000000..323646a --- /dev/null +++ b/2022/10/example.ans @@ -0,0 +1,7 @@ +13140 +## ## ## ## ## ## ## ## ## ## +### ### ### ### ### ### ### +#### #### #### #### #### +##### ##### ##### ##### +###### ###### ###### #### +####### ####### ####### diff --git a/2022/10/example.in b/2022/10/example.in new file mode 100644 index 0000000..37ee8ee --- /dev/null +++ b/2022/10/example.in @@ -0,0 +1,146 @@ +addx 15 +addx -11 +addx 6 +addx -3 +addx 5 +addx -1 +addx -8 +addx 13 +addx 4 +noop +addx -1 +addx 5 +addx -1 +addx 5 +addx -1 +addx 5 +addx -1 +addx 5 +addx -1 +addx -35 +addx 1 +addx 24 +addx -19 +addx 1 +addx 16 +addx -11 +noop +noop +addx 21 +addx -15 +noop +noop +addx -3 +addx 9 +addx 1 +addx -3 +addx 8 +addx 1 +addx 5 +noop +noop +noop +noop +noop +addx -36 +noop +addx 1 +addx 7 +noop +noop +noop +addx 2 +addx 6 +noop +noop +noop +noop +noop +addx 1 +noop +noop +addx 7 +addx 1 +noop +addx -13 +addx 13 +addx 7 +noop +addx 1 +addx -33 +noop +noop +noop +addx 2 +noop +noop +noop +addx 8 +noop +addx -1 +addx 2 +addx 1 +noop +addx 17 +addx -9 +addx 1 +addx 1 +addx -3 +addx 11 +noop +noop +addx 1 +noop +addx 1 +noop +noop +addx -13 +addx -19 +addx 1 +addx 3 +addx 26 +addx -30 +addx 12 +addx -1 +addx 3 +addx 1 +noop +noop +noop +addx -9 +addx 18 +addx 1 +addx 2 +noop +noop +addx 9 +noop +noop +noop +addx -1 +addx 2 +addx -37 +addx 1 +addx 3 +noop +addx 15 +addx -21 +addx 22 +addx -6 +addx 1 +noop +addx 2 +addx 1 +noop +addx -10 +noop +noop +addx 20 +addx 1 +addx 2 +addx 2 +addx -6 +addx -11 +noop +noop +noop diff --git a/2022/10/input.ans b/2022/10/input.ans new file mode 100644 index 0000000..c0147fc --- /dev/null +++ b/2022/10/input.ans @@ -0,0 +1,7 @@ +15880 +### # ## #### # # ## #### ## +# # # # # # # # # # # # # +# # # # ### ## # # # # +### # # ## # # # #### # # ## +# # # # # # # # # # # # +# #### ### # # # # # #### ### diff --git a/2022/11/11.kt b/2022/11/11.kt new file mode 100644 index 0000000..fc6aed4 --- /dev/null +++ b/2022/11/11.kt @@ -0,0 +1,55 @@ +class Monkey(monkey: String) { + var counter = 0L + var items: MutableList + var op: (Long) -> Long + val divisibleBy: Long + val idIfTrue: Int + val idIfFalse: Int + + companion object { + var modulo: Long = 1 + var monkeys: MutableList = mutableListOf() + } + + init { + val attributes = monkey.split("\n").map { it.split(":")[1].trim() } + val (_, _, _, opMultOrAdd, opArg) = attributes[2].split(" ") + val opFunc: (Long, Long) -> Long = if (opMultOrAdd == "*") Long::times else Long::plus + + items = attributes[1].split(",").map { it.trim().toLong() }.toMutableList() + op = { x -> opFunc(x, opArg.toLongOrNull() ?: x) } + divisibleBy = attributes[3].split(" ").last().toLong() + idIfTrue = attributes[4].split(" ").last().toInt() + idIfFalse = attributes[5].split(" ").last().toInt() + Monkey.modulo *= divisibleBy + Monkey.monkeys.add(this) + } + fun round(divideBy: Int = 1) { + for (item in items) { + val newWorry = op(item) % Monkey.modulo / divideBy + val index = if (newWorry % divisibleBy == 0L) idIfTrue else idIfFalse + Monkey.monkeys[index].items.add(newWorry) + counter++ + } + items.clear() + } +} + +fun main() { + val monkeys = generateSequence(::readlnOrNull).joinToString("\n").trim().split("\n\n") + + fun multLast2() = Monkey.monkeys.map { it.counter }.sorted().takeLast(2).reduce(Long::times) + fun rounds(count: Int, divBy: Int) = repeat(count) { Monkey.monkeys.map { it.round(divBy) } } + + // Part 1 + monkeys.map { Monkey(it) } + rounds(20, divBy=3) + println(multLast2()) + + // Part 2 + Monkey.modulo = 1 + Monkey.monkeys.clear() + monkeys.map { Monkey(it) } + rounds(10000, divBy=1) + println(multLast2()) +} diff --git a/2022/11/11.py b/2022/11/11.py new file mode 100644 index 0000000..21b9e75 --- /dev/null +++ b/2022/11/11.py @@ -0,0 +1,42 @@ +import sys, math, operator + +monkeys = [] + +class Monkey: + modulo = 1 + def __init__(self, monkey: str): + _, items, op, test, if_t, if_f = monkey.split("\n") + self.items = [int(a) for a in items.split(":")[1].split(',')] + ops = {"*": operator.mul, "+": operator.add} + *_, op, arg = op.split(":")[1].split() + self.op = lambda x: ops[op](x, x if arg == "old" else int(arg)) + self.divisible_by = int(test.split()[-1]) + Monkey.modulo *= self.divisible_by + self.if_t = int(if_t.split()[-1]) + self.if_f = int(if_f.split()[-1]) + self.passes = 0 + + def round(self, div_by_3: bool): + for item in self.items: + new_worry = self.op(item) // (3 if div_by_3 else 1) % Monkey.modulo + self.passes += 1 + new_index = self.if_t if new_worry % self.divisible_by == 0 else self.if_f + monkeys[new_index].items.append(new_worry) + self.items.clear() + + +monkeys2 = [] +for i, monkey in enumerate(sys.stdin.read().strip().split("\n\n")): + monkeys.append(Monkey(monkey)) + monkeys2.append(Monkey(monkey)) + +for i in range(20): + for monkey in monkeys: + monkey.round(True) +print(math.prod(sorted([a.passes for a in monkeys])[-2:])) + +monkeys = monkeys2 +for i in range(10000): + for monkey in monkeys: + monkey.round(False) +print(math.prod(sorted([a.passes for a in monkeys])[-2:])) diff --git a/2022/11/input.ans b/2022/11/input.ans new file mode 100644 index 0000000..a0acf60 --- /dev/null +++ b/2022/11/input.ans @@ -0,0 +1,2 @@ +108240 +25712998901 diff --git a/2022/12/12.kt b/2022/12/12.kt new file mode 100644 index 0000000..543c780 --- /dev/null +++ b/2022/12/12.kt @@ -0,0 +1,31 @@ +fun bfs(field: List, queue: MutableList>, target: Pair): Int { + val dist = queue.associate { it to 0 }.toMutableMap() + val dirs = listOf(-1 to 0, 1 to 0, 0 to 1, 0 to -1) + while (!queue.isEmpty()) { + val (y, x) = queue.removeFirst() + dirs + .map { (ya, xa) -> Pair(y+ya, x+xa) } + .filter { (ya, xa) -> ya in field.indices && xa in field[0].indices } + .filter { !dist.contains(it) } + .filter { (ya, xa) -> field[ya][xa] <= field[y][x] + 1 } + .forEach { + dist[it] = dist[Pair(y, x)]!! + 1 + queue.add(it) + } + } + return dist[target]!! +} + +fun main() { + var field = generateSequence(::readlnOrNull).toList() + fun findChars(c: Char) = field + .mapIndexed { y, l -> l.mapIndexed { x, _ -> y to x } } + .flatten() + .filter { (y, x) -> field[y][x] == c } + .toMutableList() + val S = findChars('S') + val E = findChars('E').first() + field = field.map { it.replace("S", "a").replace("E", "z") } + println(bfs(field, S, E)) + println(bfs(field, findChars('a'), E)) +} diff --git a/2022/12/12.py b/2022/12/12.py new file mode 100644 index 0000000..cbb2943 --- /dev/null +++ b/2022/12/12.py @@ -0,0 +1,23 @@ +import sys, collections + +field = sys.stdin.read().strip().split("\n") +S = next((i, f.index('S')) for i, f in enumerate(field) if "S" in f) +E = next((i, f.index('E')) for i, f in enumerate(field) if "E" in f) +field = ' '.join(field).replace("S", "a").replace("E", "z").split() +best_from_start = {} +is_valid = lambda y, x: 0 <= y < len(field) and 0 <= x < len(field[0]) +for sy, sx in [(sy, sx) for sy in range(len(field)) for sx in range(len(field[0]))]: + if field[sy][sx] == 'a': + queue = collections.deque([(sy, sx)]) + dist = {(sy, sx): 0} + while queue: + y, x = queue.popleft() + for y2, x2 in [(y+ya, x+xa) for ya, xa in [(1, 0), (-1, 0), (0, 1), (0, -1)]]: + if is_valid(y2, x2) and (y2, x2) not in dist: + if ord(field[y2][x2]) <= ord(field[y][x]) + 1: + dist[(y2, x2)] = dist[(y, x)] + 1 + queue.append((y2, x2)) + best_from_start[(sy, sx)] = dist.get(E, 1e9) +print(best_from_start[S]) +print(min(best_from_start.values())) + diff --git a/2022/12/input.ans b/2022/12/input.ans new file mode 100644 index 0000000..03ea824 --- /dev/null +++ b/2022/12/input.ans @@ -0,0 +1,2 @@ +391 +386 diff --git a/2022/13/13.kt b/2022/13/13.kt new file mode 100644 index 0000000..3ba4f80 --- /dev/null +++ b/2022/13/13.kt @@ -0,0 +1,45 @@ +fun String.parseLists(): Any { + val stack: MutableList> = mutableListOf(mutableListOf()) + this.replace("]", ",}").replace("[", "{,").replace(",,", ",").split(",").forEach { + when (it) { + "{" -> { val m: MutableList = mutableListOf(); stack.last().add(m); stack.add(m) } + "}" -> stack.removeLast() + else -> stack.last().add(it.toInt()) + } + } + return stack[0][0] +} + +fun cmp(a: Any, b: Any): Int { + if (a is Int && b is Int) + return when { a < b -> -1; a > b -> 1; else -> 0 } + val aList = if (a is MutableList<*>) a else mutableListOf(a) + val bList = if (b is MutableList<*>) b else mutableListOf(b) + for ((u, v) in aList zip bList) + if (cmp(u!!, v!!) != 0) + return cmp(u, v) + return cmp(aList.size, bList.size) +} + +fun main() { + var lists = generateSequence(::readlnOrNull) + .filter { !it.isEmpty() } + .map { it.parseLists() } + .toMutableList() + + lists + .chunked(2) + .withIndex() + .filter { (_, pair) -> cmp(pair[0], pair[1]) <= 0 } + .sumOf { (i, _) -> i+1 } + .also(::println) + + val distress = listOf(listOf(listOf(2)), listOf(listOf(6))) + lists + .also { it.addAll(distress) } + .sortedWith(::cmp) + .withIndex() + .filter { it.value in distress } + .fold(1) { acc, (i, _) -> (i+1) * acc } + .also(::println) +} diff --git a/2022/13/13.py b/2022/13/13.py new file mode 100644 index 0000000..301aa52 --- /dev/null +++ b/2022/13/13.py @@ -0,0 +1,14 @@ +import sys, functools + +def cmp(a, b): + if isinstance(a, int) and isinstance(b, int): + return 0 if a == b else (-1 if a < b else 1) + a = [a] if isinstance(a, int) else a + b = [b] if isinstance(b, int) else b + return ([cmp(*p) for p in zip(a, b) if cmp(*p) != 0] + [cmp(len(a), len(b))])[0] + +lists = [eval(a) for a in sys.stdin.read().strip().replace("\n\n", "\n").split("\n")] +print(sum(i for i, pair in enumerate(zip(lists[::2], lists[1::2]), 1) if cmp(*pair) <= 0)) + +new = sorted(lists + [[[2]], [[6]]], key=functools.cmp_to_key(cmp)) +print((new.index([[2]]) + 1) * (new.index([[6]]) + 1)) diff --git a/2022/13/example.ans b/2022/13/example.ans new file mode 100644 index 0000000..5fc17d6 --- /dev/null +++ b/2022/13/example.ans @@ -0,0 +1,2 @@ +13 +140 diff --git a/2022/13/example.in b/2022/13/example.in new file mode 100644 index 0000000..af73fbb --- /dev/null +++ b/2022/13/example.in @@ -0,0 +1,23 @@ +[1,1,3,1,1] +[1,1,5,1,1] + +[[1],[2,3,4]] +[[1],4] + +[9] +[[8,7,6]] + +[[4,4],4,4] +[[4,4],4,4,4] + +[7,7,7,7] +[7,7,7] + +[] +[3] + +[[[]]] +[[]] + +[1,[2,[3,[4,[5,6,7]]]],8,9] +[1,[2,[3,[4,[5,6,0]]]],8,9] diff --git a/2022/13/input.ans b/2022/13/input.ans new file mode 100644 index 0000000..4d98468 --- /dev/null +++ b/2022/13/input.ans @@ -0,0 +1,2 @@ +6076 +24805 diff --git a/2022/14/14.kt b/2022/14/14.kt new file mode 100644 index 0000000..0caad8b --- /dev/null +++ b/2022/14/14.kt @@ -0,0 +1,27 @@ +fun main() { + val lines = generateSequence(::readlnOrNull).toList() + .map { it.split(" -> ", ",").map { it.toInt() }.chunked(2) } + val width = lines.flatten().maxOf { it[0] } + 200 + val height = lines.flatten().maxOf { it[1] } + 2 + val field = MutableList(height) { MutableList(width) { '.' } } + fun range(a: Int, b: Int) = minOf(a, b)..maxOf(a, b) + fun drawLine(rx: IntRange, ry: IntRange) = rx.map { x -> ry.map { y -> field[y][x] = '#' } } + lines.map { it.zipWithNext { (x1, y1), (x2, y2) -> drawLine(range(x1, x2), range(y1, y2))} } + + fun fill(): Int { + var endDfs = false + fun dfs(x: Int, y: Int): Boolean { + endDfs = endDfs || y >= field.size || field[0][500] == 'O' + if (endDfs || field[y][x] != '.') + return endDfs + if (!(dfs(x, y+1) || dfs(x-1, y+1) || dfs(x+1, y+1))) + field[y][x] = 'O' + return true + } + while (!endDfs) dfs(500, 0) + return field.flatten().count { it == 'O' } + } + println(fill()) + field.add(MutableList(width) { '#' }) + println(fill()) +} diff --git a/2022/14/14.py b/2022/14/14.py new file mode 100644 index 0000000..0cf4728 --- /dev/null +++ b/2022/14/14.py @@ -0,0 +1,28 @@ +from sys import stdin +lines = [[list(map(int, c.split(','))) for c in l.strip().split(" -> ")] for l in stdin.readlines()] +width = max(x+200 for x, _ in sum(lines, [])) +height = max(y for _, y in sum(lines, [])) + +def solve(floor='.'): + field = [['.'] * width for _ in range(height + 2)] + [[floor] * width] + for walls in lines: + for (x1, y1), (x2, y2) in zip(walls, walls[1:]): + for x in range(min(x1, x2), max(x1, x2)+1): + for y in range(min(y1, y2), max(y1, y2)+1): + field[y][x] = '#' + + while True: + sx, sy = 500, 0 + while sy+1 < len(field): + for xa in (0, -1, 1): + if field[sy+1][sx+xa] == '.': + sy, sx = sy+1, sx+xa + break + else: + field[sy][sx] = 'o' + break + if sy+1 >= len(field) or field[0][500] == 'o': + return sum(field, []).count("o") + +print(solve(floor='.')) +print(solve(floor='#')) diff --git a/2022/14/input.ans b/2022/14/input.ans new file mode 100644 index 0000000..8ad5744 --- /dev/null +++ b/2022/14/input.ans @@ -0,0 +1,2 @@ +793 +24166 diff --git a/2022/15/15.kt b/2022/15/15.kt new file mode 100644 index 0000000..7af877d --- /dev/null +++ b/2022/15/15.kt @@ -0,0 +1,23 @@ +fun dist(x1: Long, y1: Long, x2: Long, y2: Long) = Math.abs(x1 - x2) + Math.abs(y1 - y2) + +fun main() { + val sensors = generateSequence(::readlnOrNull).toList() + .map { Regex("-?\\d+").findAll(it).toList() } + .map { it.map { it.value.toLong() } } + .sortedBy() { it[0] } + val y = 2_000_000L + (-1_000_000L..6_000_000L).count { x -> + sensors + .filter { it[2] != x || it[3] != y } + .any { (xs, ys, xb, yb) -> dist(xs, ys, x, y) <= dist(xs, ys, xb, yb) } + }.run(::println) + + for (y in 0L..4_000_000L) { + var x = 0L + for ((xs, ys, xb, yb) in sensors) + if (dist(xs, ys, x, y) <= dist(xs, ys, xb, yb)) + x = xs + dist(xs, ys, xb, yb) - Math.abs(ys - y) + 1 + if (x <= 4_000_000L) + println(x * 4_000_000L + y) + } +} diff --git a/2022/15/15.py b/2022/15/15.py new file mode 100644 index 0000000..661ecac --- /dev/null +++ b/2022/15/15.py @@ -0,0 +1,22 @@ +# Use pypy, as otherwise this is slow +import sys, re +lines = sys.stdin.read().strip().split("\n") +sensors = sorted([[int(a) for a in re.findall(r"-?\d+", l)] for l in lines]) +sensors = sorted([[*map(int, re.findall(r"-?\d+", l))] for l in lines]) +dist = lambda x1, y1, x2, y2: abs(x1 - x2) + abs(y1 - y2) + +s, y = 0, 2_000_000 +for x in range(-1_000_000, 6_000_000): + for sx, sy, bx, by in sensors: + if dist(sx, sy, bx, by) >= dist(sx, sy, x, y) and (bx != x or by != y): + s += 1 + break +print(s) + +for y in range(4_000_001): + x = 0 + for sx, sy, bx, by in sensors: + if dist(sx, sy, bx, by) >= dist(sx, sy, x, y): + x = sx + dist(sx, sy, bx, by) - abs(sy - y) + 1 + if x <= 4_000_000: + print(x * 4_000_000 + y) diff --git a/2022/15/input.ans b/2022/15/input.ans new file mode 100644 index 0000000..9892397 --- /dev/null +++ b/2022/15/input.ans @@ -0,0 +1,2 @@ +5716881 +10852583132904 diff --git a/2022/16/16.kt b/2022/16/16.kt new file mode 100644 index 0000000..ebbcdd8 --- /dev/null +++ b/2022/16/16.kt @@ -0,0 +1,59 @@ +import java.util.PriorityQueue + +data class State( + var time: Int, + var current: String, + var elTime: Int? = null, + var elephant: String? = null, + var opened: Set = setOf(), + var flow: Int = 0, +) : Comparable { + override fun compareTo(other: State) = compareValuesBy(this, other, { -it.flow }) +} + +fun main() { + val input = generateSequence(::readlnOrNull).toList() + .map { Regex("([A-Z]{2}|\\d+)").findAll(it).toList().map { it.value } } + val neighbors = input.associate { it[0] to it.slice(2..it.size-1) } + val flows = input.associate { it[0] to it[1].toInt() } + + fun getNonZeroNeighbors(curr: String, dist: Int = 0, visited: Set = setOf()): Map { + val neigh = HashMap() + for (neighbor in neighbors[curr]!!.filter { it !in visited }) { + if (flows[neighbor]!! != 0) + neigh[neighbor] = dist+1 + for ((name, d) in getNonZeroNeighbors(neighbor, dist+1, visited + setOf(curr))) + neigh[name] = minOf(d, neigh.getOrDefault(name, 1000)) + } + return neigh + } + val nonZeroNeighbors = input.associate { it[0] to getNonZeroNeighbors(it[0]) } + + fun solve(initialState: State): Int { + val queue = PriorityQueue().also { it.add(initialState) } + var best = 0 + val visited: MutableMap, Int> = mutableMapOf() + while (queue.isNotEmpty()) { + var (time, current, elTime, elephant, opened, flow) = queue.remove() + best = maxOf(best, flow) + val vis = (opened.toList() + listOf(current, elephant ?: "")).sorted() + if (visited.getOrDefault(vis, -1) >= flow) + continue + visited[vis] = flow + if (elTime != null && elephant != null && time < elTime) { + time = elTime.also { elTime = time } + current = elephant.also { elephant = current } + } + for ((neighbor, dist) in nonZeroNeighbors[current]!!) { + val newTime = time-dist-1 + val newFlow = flow+flows[neighbor]!!*newTime + if (newTime >= 0 && neighbor !in opened) + queue.add(State(newTime, neighbor, elTime, elephant, opened+setOf(neighbor), newFlow)) + } + } + return best + } + solve(State(30, "AA")).run(::println) + solve(State(26, "AA", 26, "AA")).run(::println) // Takes ~10 seconds + +} diff --git a/2022/16/example.ans b/2022/16/example.ans new file mode 100644 index 0000000..74b0d1b --- /dev/null +++ b/2022/16/example.ans @@ -0,0 +1,2 @@ +1651 +1707 diff --git a/2022/16/example.in b/2022/16/example.in new file mode 100644 index 0000000..9f30acc --- /dev/null +++ b/2022/16/example.in @@ -0,0 +1,10 @@ +Valve AA has flow rate=0; tunnels lead to valves DD, II, BB +Valve BB has flow rate=13; tunnels lead to valves CC, AA +Valve CC has flow rate=2; tunnels lead to valves DD, BB +Valve DD has flow rate=20; tunnels lead to valves CC, AA, EE +Valve EE has flow rate=3; tunnels lead to valves FF, DD +Valve FF has flow rate=0; tunnels lead to valves EE, GG +Valve GG has flow rate=0; tunnels lead to valves FF, HH +Valve HH has flow rate=22; tunnel leads to valve GG +Valve II has flow rate=0; tunnels lead to valves AA, JJ +Valve JJ has flow rate=21; tunnel leads to valve II diff --git a/2022/16/input.ans b/2022/16/input.ans new file mode 100644 index 0000000..4783346 --- /dev/null +++ b/2022/16/input.ans @@ -0,0 +1,2 @@ +1789 +2496 diff --git a/2022/17/17.kt b/2022/17/17.kt new file mode 100644 index 0000000..e00d4ee --- /dev/null +++ b/2022/17/17.kt @@ -0,0 +1,130 @@ +val rocks = "@@@@ .@. @@@ .@. ..@ ..@ @@@ @ @ @ @ @@ @@".split(" ").map { it.split(" ") } +var input: List = listOf() + +data class Tower( + var stack: ArrayDeque> = ArrayDeque>(), + var occ: MutableMap, Int> = mutableMapOf(), + var highestRockIndex: Int = 0, + var dirIndex: Int = 0, + var indicesOfMostCommon: MutableList = mutableListOf(), + var mostCommon: List? = null, + var towerHeightLastSim: Long = 0L, + var towerHeight: Long = 0L, +) { + init { + stack.addFirst(MutableList(9) { '-' }) + } +} + +fun Tower.simulate(rockCount: Int, multiply: Long = 1L): Tower { + val towerHeightBefore = stack.count { it.contains('#') } + for (rockIndex in 0..rockCount-1) { + val rock = rocks[rockIndex % 5] + val needed = rock.size + 3 - highestRockIndex + repeat(needed) { + stack.addFirst(mutableListOf('|', '.', '.', '.', '.', '.', '.', '.', '|')) + highestRockIndex++ + } + var starty = highestRockIndex - 3 - rock.size + for (y in 0..rock.size-1) { + for (x in 0..rock[y].length-1) { + stack[starty+y][x+3] = rock[y][x] + } + } + + val cols = MutableList(7){stack.size-1} + for (x in 1..7) + for (y in 0..stack.size-1) + if (stack[y][x] == '#') { + cols[x-1] = y + break + } + cols.minOrNull()!!.run { (0..6).forEach { cols[it] -= this } } + cols.add(rockIndex % 5) + occ[cols] = occ.getOrDefault(cols, 0) + 1 + if (mostCommon != null && cols == mostCommon) + indicesOfMostCommon.add(rockIndex) + + while (true) { + val dir = input[dirIndex % input.size] + dirIndex++ + + // Left right (dir) + var isLegal = true + val lastx = stack[0].size-2 + val endy = starty + rock.size + for (y in starty..endy) + for (x in 1..lastx) + if (stack[y][x] == '@') + isLegal = isLegal && stack[y][x+dir] in ".@" + + if (isLegal) { + for (y in starty..endy) { + var new = stack[y].joinToString("").replace("@", ".").toMutableList() + for (x in 1..lastx) { + if (stack[y][x] == '@') { + new[x+dir] = '@' + } + } + stack[y] = new + } + } + + // Downward + isLegal = true + for (y in starty..endy) + for (x in 1..lastx) + if (stack[y][x] == '@') + isLegal = isLegal && stack[y+1][x] in ".@" + + if (isLegal) { + for (y in endy downTo starty+1) { + for (x in 1..lastx) { + if (stack[y-1][x] == '@') { + stack[y][x] = '@' + stack[y-1][x] = '.' + } + } + } + } else { + for (y in starty..endy) + stack[y] = stack[y].joinToString("").replace("@", "#").toMutableList() + while (stack[highestRockIndex-1].contains('#')) + highestRockIndex-- + break + } + starty++ + } + } + towerHeightLastSim = (stack.count { it.contains('#') } - towerHeightBefore) * multiply + towerHeight += towerHeightLastSim + return this +} + +fun main() { + input = readln().repeat(2).map { if (it == '>') 1 else -1 } + Tower().simulate(2022).towerHeight.run(::println) + + val forOcc = Tower().simulate(input.size) + val mostCommon = forOcc.occ.maxBy { it.value }.key + val indices = Tower(mostCommon=mostCommon).simulate(input.size).indicesOfMostCommon + + val repeatsAfter = indices.flatMap { a -> indices.map { Math.abs(a - it) } } + .filter { it != 0 }.groupingBy { it }.eachCount().maxBy { it.value }.key + + val target = 1000000000000L + val goal = Tower().simulate(1000).simulate(repeatsAfter).towerHeightLastSim + for (initial in 0..input.size-1 step 5) { + val part2 = Tower().simulate(initial) + val mult = (target - initial) / repeatsAfter + val mod = (target - initial) % repeatsAfter + + if (part2.simulate(repeatsAfter).towerHeightLastSim == goal) { + part2 + .simulate(repeatsAfter, multiply=mult-1L) + .simulate(mod.toInt()) + .run { println(this.towerHeight) } + break + } + } +} diff --git a/2022/17/example.ans b/2022/17/example.ans new file mode 100644 index 0000000..8951507 --- /dev/null +++ b/2022/17/example.ans @@ -0,0 +1,2 @@ +3068 +1514285714288 diff --git a/2022/17/example.in b/2022/17/example.in new file mode 100644 index 0000000..97a1aa1 --- /dev/null +++ b/2022/17/example.in @@ -0,0 +1 @@ +>>><<><>><<<>><>>><<<>>><<<><<<>><>><<>> diff --git a/2022/17/input.ans b/2022/17/input.ans new file mode 100644 index 0000000..29a2037 --- /dev/null +++ b/2022/17/input.ans @@ -0,0 +1,2 @@ +3059 +1500874635587 diff --git a/2022/18/18.kt b/2022/18/18.kt new file mode 100644 index 0000000..0aa6dff --- /dev/null +++ b/2022/18/18.kt @@ -0,0 +1,39 @@ +data class Point(var x: Int, var y: Int, var z: Int) { + operator fun plus(o: Point): Point = Point(x+o.x, y+o.y, z+o.z) + fun adjacent(): List = dirs.map { this+it }.toList() + fun min(): Int = minOf(x, y, z) + fun max(): Int = maxOf(x, y, z) +} + +val dirs = listOf( + Point(1, 0, 0), Point(0, 1, 0), Point(0, 0, 1), + Point(-1, 0, 0), Point(0, -1, 0), Point(0, 0, -1), +) + +fun main() { + val input = generateSequence(::readlnOrNull) + .map { it.split(",").map { it.toInt() } } + .map { (x, y, z) -> Point(x, y, z) }.toList() + val bounds = input.minOf { it.min()-1 }..input.maxOf { it.max()+1 } + + // Part 1 + input.sumOf { it.adjacent().count { !input.contains(it) } }.run(::println) + + // Part 2 + val queue = mutableListOf(Point(bounds.first, bounds.first, bounds.first)) + val visited: MutableSet = mutableSetOf() + var count = 0 + + while (queue.isNotEmpty()) { + val point = queue.removeAt(0) + if (point in visited) continue + visited.add(point) + for (adj in point.adjacent()) { + if (adj in input) + count++ + else if (adj.x in bounds && adj.y in bounds && adj.z in bounds) + queue.add(adj) + } + } + println(count) +} diff --git a/2022/18/input.ans b/2022/18/input.ans new file mode 100644 index 0000000..d2c40a3 --- /dev/null +++ b/2022/18/input.ans @@ -0,0 +1,2 @@ +3448 +2052 diff --git a/2022/19/19.kt b/2022/19/19.kt new file mode 100644 index 0000000..6b55ffb --- /dev/null +++ b/2022/19/19.kt @@ -0,0 +1,106 @@ +import java.util.PriorityQueue + +data class Blueprint( + val id: Int, + val oreForOreRobot: Int, + val oreForClayRobot: Int, + val oreForObsidianRobot: Int, + val clayForObsidianRobot: Int, + val oreForGeodeRobot: Int, + val obsidianForGeodeRobot: Int, +) + +data class State( + var timeLeft: Int, + var ore: Int = 0, + var clay: Int = 0, + var obsidian: Int = 0, + var geode: Int = 0, + var oreRobots: Int = 1, + var clayRobots: Int = 0, + var obsidianRobots: Int = 0, + var geodeRobots: Int = 0, +) : Comparable { + + fun handleMinute(): State { + timeLeft--; + ore += oreRobots; clay += clayRobots; obsidian += obsidianRobots; geode += geodeRobots; + return this + } + + override fun compareTo(other: State) = compareValuesBy(this, other, { it.heuristicScore() }) + + fun heuristicScore() = oreRobots + clayRobots + obsidianRobots + geodeRobots + + fun isBetterThan(other: State): Boolean = ore >= other.ore + && clay >= other.clay + && obsidian >= other.obsidian + && geode >= other.geode + && oreRobots >= other.oreRobots + && clayRobots >= other.clayRobots + && obsidianRobots >= other.obsidianRobots + && geodeRobots >= other.geodeRobots +} + +fun maxGeodes(blueprint: Blueprint, initialTimeLeft: Int): Int { + val queue = ArrayDeque() + queue.add(State(initialTimeLeft)) + + val bestRobots = PriorityQueue() + val visited: MutableSet = mutableSetOf() + + fun addState(state: State) { + if (state in visited) + return + visited.add(state) + for (robot in bestRobots) { + if (robot.isBetterThan(state)) + return + } + bestRobots.add(state) + if (bestRobots.size > 1000) + bestRobots.poll() + queue.add(state) + } + + var best = 0 + while (queue.isNotEmpty()) { + val state = queue.removeFirst() + val minute = state.copy().handleMinute() + if (minute.timeLeft == 0) { + best = maxOf(best, minute.geode) + continue + } + if (state.ore >= blueprint.oreForGeodeRobot && state.obsidian >= blueprint.obsidianForGeodeRobot) + minute.copy( + ore=minute.ore-blueprint.oreForGeodeRobot, + obsidian=minute.obsidian-blueprint.obsidianForGeodeRobot, + geodeRobots=minute.geodeRobots + 1 + ).run(::addState) + else if (state.ore >= blueprint.oreForObsidianRobot && state.clay >= blueprint.clayForObsidianRobot) + minute.copy( + ore=minute.ore-blueprint.oreForObsidianRobot, + clay=minute.clay-blueprint.clayForObsidianRobot, + obsidianRobots=minute.obsidianRobots + 1 + ).run(::addState) + else { + if (state.ore >= blueprint.oreForClayRobot) { + minute.copy(ore=minute.ore-blueprint.oreForClayRobot, clayRobots=minute.clayRobots + 1).run(::addState) + } + if (state.ore >= blueprint.oreForOreRobot) { + minute.copy(ore=minute.ore-blueprint.oreForOreRobot, oreRobots=minute.oreRobots+1).run(::addState) + } + addState(minute.copy()) + } + } + return best +} + +fun main() { + val input = generateSequence(::readlnOrNull).toList() + .map { Regex("\\d+").findAll(it).map { it.value.toInt() }.toList() } + .map { Blueprint(it[0], it[1], it[2], it[3], it[4], it[5], it[6]) } + + println(input.map { maxGeodes(it, 24) }.zip(input) { geodes, blueprint -> geodes * blueprint.id }.sum()) + println(input.slice(0..2).map { maxGeodes(it, 32) }.reduce { s, e -> s * e }) +} diff --git a/2022/19/input.ans b/2022/19/input.ans new file mode 100644 index 0000000..c7e1e26 --- /dev/null +++ b/2022/19/input.ans @@ -0,0 +1,2 @@ +1550 +18630 diff --git a/2022/20/20.kt b/2022/20/20.kt new file mode 100644 index 0000000..c390fd8 --- /dev/null +++ b/2022/20/20.kt @@ -0,0 +1,17 @@ +import java.util.Collections.swap + +fun MutableList>.simulate(times: Int, decryptKey: Long = 1L) { + for (index in 0 until size * times) { + var i = indexOfFirst { it.index == index % size } + var v = (this[i].value * decryptKey % (size-1)).toInt() + repeat(Math.abs(v)) { i = (i + v / Math.abs(v)).mod(size).also { swap(this, i, it) } } + } + val i0 = indexOfFirst { it.value == 0L } + (i0..i0+3000 step 1000).sumOf { this[it%size].value * decryptKey }.run(::println) +} + +fun main() { + generateSequence(::readlnOrNull).map { it.toLong() }.withIndex().toList() + .also { it.toMutableList().simulate(1) } + .also { it.toMutableList().simulate(10, 811589153L) } +} diff --git a/2022/20/example.ans b/2022/20/example.ans new file mode 100644 index 0000000..f5a56a6 --- /dev/null +++ b/2022/20/example.ans @@ -0,0 +1,2 @@ +3 +1623178306 diff --git a/2022/20/example.in b/2022/20/example.in new file mode 100644 index 0000000..52c68ff --- /dev/null +++ b/2022/20/example.in @@ -0,0 +1,7 @@ +1 +2 +-3 +3 +-2 +0 +4 diff --git a/2022/20/input.ans b/2022/20/input.ans new file mode 100644 index 0000000..5695e11 --- /dev/null +++ b/2022/20/input.ans @@ -0,0 +1,2 @@ +5904 +8332585833851 diff --git a/2022/21/21.kt b/2022/21/21.kt new file mode 100644 index 0000000..dea2fd5 --- /dev/null +++ b/2022/21/21.kt @@ -0,0 +1,42 @@ +fun main() { + val input = generateSequence(::readlnOrNull).map { it.split(": ") }.toList() + val known = input + .filter { (_, value) -> value[0].isDigit() } + .associate { (name, value) -> name to value.toDouble() } + .toMutableMap() + val inputsWithOps = input.filter { " " in it[1] }.map { (n, v) -> n to v.split(" ") } + + fun updateKnown() { + for (i in 1..50) for ((name, value) in inputsWithOps) { + var (var1, op, var2) = value + if (var1 in known && var2 in known) + known[name] = when (op) { + "+" -> known[var1]!! + known[var2]!! + "-" -> known[var1]!! - known[var2]!! + "*" -> known[var1]!! * known[var2]!! + "/" -> known[var1]!! / known[var2]!! + else -> 0.0 + } + } + } + updateKnown() + println(Math.round(known["root"]!!)) + val (rootVar1, _, rootVar2) = inputsWithOps.single { it.first == "root" }.second + + fun binSearch(increasing: Boolean): Long? { + var (lo, hi) = -1e20 to 1e20 + repeat (100) { + val mid = (lo + hi) / 2L + known["humn"] = Math.round(mid).toDouble() + updateKnown() + if (known[rootVar1]!! == known[rootVar2]!!) + return Math.round(mid) + if ((known[rootVar1]!! > known[rootVar2]!!) xor increasing) + hi = mid + else + lo = mid + } + return null + } + println(listOf(binSearch(true), binSearch(false)).firstNotNullOf { it }) +} diff --git a/2022/21/example.ans b/2022/21/example.ans new file mode 100644 index 0000000..0072717 --- /dev/null +++ b/2022/21/example.ans @@ -0,0 +1,2 @@ +152 +301 diff --git a/2022/21/example.in b/2022/21/example.in new file mode 100644 index 0000000..e14be60 --- /dev/null +++ b/2022/21/example.in @@ -0,0 +1,15 @@ +root: pppw + sjmn +dbpl: 5 +cczh: sllz + lgvd +zczc: 2 +ptdq: humn - dvpt +dvpt: 3 +lfqf: 4 +humn: 5 +ljgn: 2 +sjmn: drzm * dbpl +sllz: 4 +pppw: cczh / lfqf +lgvd: ljgn * ptdq +drzm: hmdt - zczc +hmdt: 32 diff --git a/2022/21/input.ans b/2022/21/input.ans new file mode 100644 index 0000000..8315578 --- /dev/null +++ b/2022/21/input.ans @@ -0,0 +1,2 @@ +66174565793494 +3327575724809 diff --git a/2022/22/22.kt b/2022/22/22.kt new file mode 100644 index 0000000..1fa7af0 --- /dev/null +++ b/2022/22/22.kt @@ -0,0 +1,197 @@ +// This solution was not golfed whatsoever, it still prints both parts, +// but is certainly not general to solve any input. However, some of the complexity arises +// a basic because of an ASCII visualization which has been added. +// +// Set this to true in order to paint a colorful ASCII image (needs ANSI support) +val visualize = false + +// This solution only works for inputs of shape: +// +// ## # ## # +// # or ## or # or ## +// ## # ## # +// # ## # ## +// +// Important is: +// * it has to be higher than its width +// * the middle column must be filled +// * the remaining 2 blocks have to be on opposite sites, one offset to the other by y=2 blocks + +val dirs = listOf(0 to 1, 1 to 0, 0 to -1, -1 to 0) + +class Painter(field: List) { + val visField = field.map { it.toMutableList() } + + var time = 0 + val coords: MutableList> = mutableListOf() + val atTime: MutableMap, Int> = mutableMapOf() + val MAX_TRAIL_LENGTH = 500 + + fun add(y: Int, x: Int, c: Char) { + visField[y][x] = c + atTime[y to x] = time + coords.add(y to x) + if (coords.size > MAX_TRAIL_LENGTH) + coords.removeAt(0) + } + + fun paint(withBackground: Boolean = false) { + if (!visualize) + return + print("") + var c = + if (withBackground) + visField[0].indices.flatMap { visField.indices.map { y -> y to it } } + else + coords + for ((y, x) in c) { + if (!withBackground && (y to x) !in atTime) + continue + fun t(mult: Double = 1.0, atLeast: Int = 50, max: Int = 255): Int = + maxOf(atLeast, (max - (time - atTime[y to x]!!) * mult).toInt()) + when (visField[y][x]) { + '#' -> "" + '.' -> "" + ' ' -> "" + else -> "[38;2;${t(1.0)};${t(0.25)};${t(0.01)}m" + }.run(::print) + print("[${x};${y}H▓") + } + println() + time++ + } +} + + +fun solve(asCube: Boolean, field: List, seq: List) { + val painter = Painter(field) + val instructions = Regex("(\\d+|[RL])").findAll(seq[0]).toList() + var currDir = 0 + var (cy, cx) = 0 to field[0].indexOfFirst { it == '.' } + painter.paint(true) + for (instruction in instructions.map { it.value }) { + if (instruction in "RL") { + currDir = (currDir + if (instruction == "R") 1 else -1).mod(4) + continue + } + var (ny, nx) = cy to cx + for (i in 1..instruction.toInt()) { + painter.paint() + var ny3 = ny + dirs[currDir].first + var nx3 = nx + dirs[currDir].second + var dir3 = currDir + + val yIsShorter = field.size < field[0].length + val alongShortAxis = (dirs[currDir].first != 0 && yIsShorter) || (dirs[currDir].second != 0 && !yIsShorter) + if (asCube && (ny3 !in field.indices || nx3 !in field[0].indices)) { + if (!yIsShorter && alongShortAxis) { + dir3 = (dir3 + 2).mod(4) + ny3 = (50*2 + ny3 - ny3 % 50 + (49 - ny3 % 50)).mod(field.size) + nx3 = nx3 + dirs[dir3].second + assert(ny3 in field.indices && nx3 in field[0].indices) { "$ny3 $nx3 out of bounds" } + } + } + ny3 = ny3.mod(field.size) + nx3 = nx3.mod(field[0].length) + ny = (ny + dirs[currDir].first).mod(field.size) + nx = (nx + dirs[currDir].second).mod(field[cy].length) + var ny2 = ny + var nx2 = nx + if (field[ny][nx] == ' ' && field[ny2][nx2] == ' ') { + var nyxp: MutableList> = mutableListOf() + var nyx2p: MutableList> = mutableListOf() + var nyx3p: MutableList> = mutableListOf() + painter.add(ny3, nx3, '?') + val moveStraight = !asCube || alongShortAxis && (cy in 0..49 || cy in 100..149) + while (field[ny][nx] == ' ' && field[ny2][nx2] == ' ') { + // If there is an adjacent block go diagonally + if (!moveStraight) { + ny = (ny + dirs[(currDir+1).mod(4)].first).mod(field.size) + nx = (nx + dirs[(currDir+1).mod(4)].second).mod(field[cy].length) + ny2 = (ny2 + dirs[(currDir-1).mod(4)].first).mod(field.size) + nx2 = (nx2 + dirs[(currDir-1).mod(4)].second).mod(field[cy].length) + } + + if (field[ny][nx] != ' ' || field[ny2][nx2] != ' ' || field[ny3][nx3] != ' ') + break + if (moveStraight) { + ny3 = ny3 + dirs[dir3].first + nx3 = nx3 + dirs[dir3].second + } + else { + ny = (ny + dirs[currDir].first).mod(field.size) + nx = (nx + dirs[currDir].second).mod(field[cy].length) + ny2 = (ny2 + dirs[currDir].first).mod(field.size) + nx2 = (nx2 + dirs[currDir].second).mod(field[cy].length) + } + + if (asCube && (ny3 !in field.indices || nx3 !in field[0].indices)) { + if (!yIsShorter && alongShortAxis) { + dir3 = (dir3 + 2).mod(4) + ny3 = (100 + ny3 - ny3 % 50 + (49 - ny3 % 50)).mod(field.size) + nx3 = nx3 + dirs[dir3].second + assert(ny3 in field.indices && nx3 in field[0].indices) { "$ny3 $nx3 out of bounds" } + } + } + ny3 = ny3.mod(field.size) + nx3 = nx3.mod(field[0].length) + nyxp.add(ny to nx) + nyx2p.add(ny2 to nx2) + nyx3p.add(ny3 to nx3) + } + if (field[ny][nx] != ' ') { + if (field[ny][nx] != '#') + currDir = (currDir+1).mod(4) + } + else if (field[ny2][nx2] != ' ') { + ny = ny2 + nx = nx2 + nyxp = nyx2p + if (field[ny][nx] != '#') + currDir = (currDir-1).mod(4) + } + else if (field[ny3][nx3] != ' ') { + ny = ny3 + nx = nx3 + nyxp = nyx3p + if (asCube && field[ny][nx] != '#') + currDir = (currDir+2).mod(4) + } + for ((nyp, nxp) in nyxp) { + painter.add(nyp, nxp, if (currDir % 2 == 0) '\\' else '/') + painter.paint() + } + } + if (field[ny][nx] == '.') { + cy = ny + cx = nx + painter.add(cy, cx, ">v<^"[currDir]) + } + else if (field[ny][nx] == '#') + break + } + } + painter.paint() + println(1000 * (cy+1) + 4 * (cx+1) + currDir) +} + + + +fun main() { + var (field, seq) = generateSequence(::readlnOrNull).joinToString("\n").split("\n\n").map { it.split("\n") } + + // Part 1 + solve(asCube=false, field, seq) + + // Part 2 + val cube = field.map { it.toMutableList() } + // Rotate last face of cube in input to make it easier + for (y in 0..49) { + for (x in 0..49) { + cube[199-x][50+y] = cube[150+y][x] + cube[150+y][x] = ' ' + } + } + field = cube.map { it.joinToString("") } + solve(asCube=true, field, seq) +} diff --git a/2022/22/input.ans b/2022/22/input.ans new file mode 100644 index 0000000..5556f25 --- /dev/null +++ b/2022/22/input.ans @@ -0,0 +1,2 @@ +88226 +57305 diff --git a/2022/23/23.kt b/2022/23/23.kt new file mode 100644 index 0000000..e1071b6 --- /dev/null +++ b/2022/23/23.kt @@ -0,0 +1,51 @@ +typealias Point = Pair + +val DIRS8 = listOf(-1 to -1, -1 to 0, -1 to 1, 0 to 1, 1 to 1, 1 to 0, 1 to -1, 0 to -1) +val DIRS = mutableListOf( + listOf(DIRS8[0], DIRS8[1], DIRS8[2]), // N + listOf(DIRS8[4], DIRS8[5], DIRS8[6]), // S + listOf(DIRS8[6], DIRS8[7], DIRS8[0]), // E + listOf(DIRS8[2], DIRS8[3], DIRS8[4]), // W +) + +fun main() { + val input = generateSequence(::readlnOrNull) + .flatMapIndexed { y, row -> row.mapIndexed { x, v -> (y to x) to v } } + .filter { it.second == '#' } + .map { it.first } + .toMutableSet() + var round = 0 + while (true) { + val proposals: MutableMap> = mutableMapOf() + for ((y, x) in input) { + val adj = DIRS.map { it.map { (ya, xa) -> y+ya to x+xa } } + if (adj.flatten().count { input.contains(it) } > 0) + for (dirs in adj) { + if (dirs.count { input.contains(it) } > 0) + continue + if (dirs[1] !in proposals) + proposals[dirs[1]] = mutableListOf() + proposals[dirs[1]]!!.add(y to x) + break + } + } + for ((point, candidates) in proposals) { + if (candidates.size == 1) { + input.remove(candidates[0]) + input.add(point) + } + } + DIRS.add(DIRS.removeAt(0)) + round++ + if (round == 10) { + val minY = input.minOf { it.first } + val minX = input.minOf { it.second } + val maxY = input.maxOf { it.first } + val maxX = input.maxOf { it.second } + println((maxY - minY + 1) * (maxX - minX + 1) - input.size) + } + if (proposals.isEmpty()) + break + } + println(round) +} diff --git a/2022/23/example.ans b/2022/23/example.ans new file mode 100644 index 0000000..3ef9547 --- /dev/null +++ b/2022/23/example.ans @@ -0,0 +1,2 @@ +110 +20 diff --git a/2022/23/example.in b/2022/23/example.in new file mode 100644 index 0000000..14005cf --- /dev/null +++ b/2022/23/example.in @@ -0,0 +1,7 @@ +....#.. +..###.# +#...#.# +.#...## +#.###.. +##.#.## +.#..#.. diff --git a/2022/23/input.ans b/2022/23/input.ans new file mode 100644 index 0000000..75cda28 --- /dev/null +++ b/2022/23/input.ans @@ -0,0 +1,2 @@ +4091 +1036 diff --git a/2022/24/24.kt b/2022/24/24.kt new file mode 100644 index 0000000..a1739bf --- /dev/null +++ b/2022/24/24.kt @@ -0,0 +1,58 @@ +typealias Point = Pair + +val dirs = listOf(0 to 1, 1 to 0, 0 to -1, -1 to 0) +val dirsChars: Map = mapOf('>' to dirs[0], 'v' to dirs[1], '<' to dirs[2], '^' to dirs[3]) +fun lcmOf(a: Int, b: Int) = (1..100000).first { it % a == 0 && it % b == 0 } + +fun main() { + val input = generateSequence(::readlnOrNull).toList() + val (height, width) = (input.size - 2) to (input[0].length - 2) + val lcm = lcmOf(height, width) + val blizzards = List>(lcm+1) { mutableSetOf() } + for ((y, row) in input.withIndex()) { + for ((x, v) in row.withIndex()) { + if (v in dirsChars) + for (t in 0..lcm) + blizzards[t].add( + (y + dirsChars[v]!!.first * t - 1).mod(height)+1 to + (x + dirsChars[v]!!.second * t - 1).mod(width)+1 + ) + } + } + // Blizzard repeats every 700 steps + assert(blizzards[0] == blizzards[lcm]) + assert(blizzards[1] != blizzards[lcm]) + + fun isInside(p: Point): Boolean = p.first in input.indices && p.second in input[0].indices + + fun minTimeToMoveFromTo(atTime: Int, from: Point, to: Point): Int { + val queue = ArrayDeque>() + queue.add(atTime to from) + val visited: MutableSet> = mutableSetOf() + + while (queue.isNotEmpty()) { + val (t, yx) = queue.removeFirst() + val (y, x) = yx + if (y == to.first && x == to.second) + return t + val vis = t % lcm to (y to x) + if (visited.contains(vis)) + continue + visited.add(vis) + for ((ya, xa) in dirs.map { y+it.first to x+it.second }.filter(::isInside)) { + if (input[ya][xa] != '#' && !blizzards[(t+1).mod(lcm)].contains(ya to xa)) + queue.add(t+1 to (ya to xa)) + } + if (!blizzards[(t+1).mod(lcm)].contains(y to x)) + queue.add(t+1 to (y to x)) + } + return -1 + } + val start = 0 to 1 + val end = height+1 to width + val t1 = minTimeToMoveFromTo(0, start, end) + println(t1) + val t2 = minTimeToMoveFromTo(t1, end, start) + val t3 = minTimeToMoveFromTo(t2, start, end) + println(t3) +} diff --git a/2022/24/example.ans b/2022/24/example.ans new file mode 100644 index 0000000..a673c3c --- /dev/null +++ b/2022/24/example.ans @@ -0,0 +1,2 @@ +18 +54 diff --git a/2022/24/example.in b/2022/24/example.in new file mode 100644 index 0000000..685dc4f --- /dev/null +++ b/2022/24/example.in @@ -0,0 +1,6 @@ +#.###### +#>>.<^<# +#.<..<<# +#>v.><># +#<^v^^># +######.# diff --git a/2022/24/input.ans b/2022/24/input.ans new file mode 100644 index 0000000..51fd5ae --- /dev/null +++ b/2022/24/input.ans @@ -0,0 +1,2 @@ +242 +720 diff --git a/2022/25/25.kt b/2022/25/25.kt new file mode 100644 index 0000000..74187b1 --- /dev/null +++ b/2022/25/25.kt @@ -0,0 +1,14 @@ +import kotlin.math.* +fun pow5(e: Int): Long = 5.0.pow(e.toDouble()).toLong() + +fun main() { + var s = generateSequence(::readlnOrNull) + .map { it.map { "=-012".indexOf(it) - 2 } } + .sumOf { it.reversed().mapIndexed { i, v -> pow5(i) * v }.sum() } + + for (power in log(1.0 * s, 5.0).toInt() downTo 0) + (-2..2) + .minBy { abs(s - pow5(power) * it) } + .also { s -= pow5(power) * it } + .also { print("=-012"[it+2]) } +} diff --git a/2022/25/example.ans b/2022/25/example.ans new file mode 100644 index 0000000..91cc46f --- /dev/null +++ b/2022/25/example.ans @@ -0,0 +1 @@ +2=-1=0 diff --git a/2022/25/example.in b/2022/25/example.in new file mode 100644 index 0000000..027aeec --- /dev/null +++ b/2022/25/example.in @@ -0,0 +1,13 @@ +1=-0-2 +12111 +2=0= +21 +2=01 +111 +20012 +112 +1=-1= +1-12 +12 +1= +122 diff --git a/2022/25/input.ans b/2022/25/input.ans new file mode 100644 index 0000000..adf42f9 --- /dev/null +++ b/2022/25/input.ans @@ -0,0 +1 @@ +20-==01-2-=1-2---1-0 diff --git a/2023/01/01.py b/2023/01/01.py new file mode 100644 index 0000000..ca9fb96 --- /dev/null +++ b/2023/01/01.py @@ -0,0 +1,11 @@ +import re +s1, s2 = 0, 0 +digits = "0|1|2|3|4|5|6|7|8|9|_|one|two|three|four|five|six|seven|eight|nine" +as_num = lambda num: digits.split('|').index(num) % 10 + +for line in open(0): + nums1 = [as_num(n[1]) for n in re.finditer(f'(?=({digits[:20]}))', line) if n[1]] + nums2 = [as_num(n[1]) for n in re.finditer(f'(?=({digits}))', line) if n[1]] + s1 += nums1[0]*10 + nums1[-1] if nums1 else 0 + s2 += nums2[0]*10 + nums2[-1] if nums2 else 0 +print(s1, s2, sep="\n") diff --git a/2023/01/01.rs b/2023/01/01.rs new file mode 100644 index 0000000..fee2057 --- /dev/null +++ b/2023/01/01.rs @@ -0,0 +1,30 @@ +use std::io::Read; + +const DIGITS: [&str; 10] = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]; +const WORDS: [&str; 10] = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"]; + +fn main() { + let mut input = String::new(); + std::io::stdin().read_to_string(&mut input).unwrap(); + + let mut s1 = 0; + let mut s2 = 0; + for line in input.lines() { + let mut nums: Vec<(usize, i32)> = vec![]; + DIGITS.iter().for_each(|digit| { + line.match_indices(digit) + .for_each(|i| nums.push((i.0, i.1.parse().unwrap()))) + }); + nums.sort(); + s1 += nums.first().unwrap_or(&(0, 0)).1 * 10 + nums.last().unwrap_or(&(0, 0)).1; + + WORDS.iter().for_each(|digit| { + line.match_indices(digit).for_each(|i| { + nums.push((i.0, WORDS.iter().position(|&x| x == i.1).unwrap() as i32)) + }) + }); + nums.sort(); + s2 += nums.first().unwrap_or(&(0, 0)).1 * 10 + nums.last().unwrap_or(&(0, 0)).1; + } + println!("{}\n{}", s1, s2); +} \ No newline at end of file diff --git a/2023/01/input.ans b/2023/01/input.ans new file mode 100644 index 0000000..39b9ad3 --- /dev/null +++ b/2023/01/input.ans @@ -0,0 +1,2 @@ +54644 +53348 diff --git a/2023/02/02.py b/2023/02/02.py new file mode 100644 index 0000000..ce62f1e --- /dev/null +++ b/2023/02/02.py @@ -0,0 +1,8 @@ +import re +s1, s2 = 0, 0 +for i, line in enumerate(open(0), 1): + r, g, b = [max(map(int, re.findall(fr"(\d+) {c}", line))) for c in "rgb"] + s1 += (r <= 12 and g <= 13 and b <= 14) * i + s2 += r * g * b + +print(s1, s2, sep="\n") diff --git a/2023/02/02.rs b/2023/02/02.rs new file mode 100644 index 0000000..56bf67e --- /dev/null +++ b/2023/02/02.rs @@ -0,0 +1,33 @@ +use std::io::Read; +use regex::Regex; +use std::cmp::max; + +fn main() { + let mut input = String::new(); + std::io::stdin().read_to_string(&mut input).unwrap(); + let re = Regex::new(r"(\d+) (r|g|b)").unwrap(); + + let mut s1 = 0; + let mut s2 = 0; + for (index, line) in input.lines().enumerate() { + let mut r = 0; + let mut g = 0; + let mut b = 0; + for cap in re.captures_iter(line) { + let num = cap.get(1).unwrap().as_str().parse().unwrap(); + let col = cap.get(2).unwrap().as_str(); + match col { + "r" => r = max(r, num), + "g" => g = max(g, num), + "b" => b = max(b, num), + _ => {} + } + + } + if r <= 12 && g <= 13 && b <= 14 { + s1 += index + 1 + } + s2 += r * g * b + } + println!("{}\n{}", s1, s2); +} diff --git a/2023/02/input.ans b/2023/02/input.ans new file mode 100644 index 0000000..b0c8433 --- /dev/null +++ b/2023/02/input.ans @@ -0,0 +1,2 @@ +2156 +66909 diff --git a/2023/03/03.py b/2023/03/03.py new file mode 100644 index 0000000..0dd5584 --- /dev/null +++ b/2023/03/03.py @@ -0,0 +1,28 @@ +from sys import stdin +from collections import defaultdict + +lines = stdin.read().strip().split('\n') +gear_to_num = defaultdict(list) +s1 = 0 + +def is_valid(y, x): + return 0 <= y < len(lines) and 0 <= x < len(lines[0]) + +for y in range(len(lines)): + for x_start in range(len(lines[y])): + x_end = x_start + if lines[y][x_start].isdigit() and (not is_valid(y, x_start-1) or not lines[y][x_start-1].isdigit()): + while is_valid(y, x_end+1) and lines[y][x_end+1].isdigit(): + x_end += 1 + good = False + for yd in range(y-1, y+2): + for xd in range(x_start-1, x_end+2): + if is_valid(yd, xd) and lines[yd][xd] not in '.0123456789': + good = True + if lines[yd][xd] in '*': + gear_to_num[(yd, xd)].append(int(lines[y][x_start:x_end+1])) + + s1 += good * int(lines[y][x_start:x_end+1]) + +s2 = sum(n[0] * n[1] for n in gear_to_num.values() if len(n) == 2) +print(s1, s2, sep="\n") diff --git a/2023/03/03.rs b/2023/03/03.rs new file mode 100644 index 0000000..d35225d --- /dev/null +++ b/2023/03/03.rs @@ -0,0 +1,44 @@ +use std::{io::{stdin, Read}, collections::HashMap}; +use regex::Regex; + +fn is_valid(y: i32, x: i32, lines: &Vec<&str>) -> bool { + (0..lines.len() as i32).contains(&y) && (0..lines[y as usize].len() as i32).contains(&x) +} + +fn main() { + let mut input = String::new(); + stdin().read_to_string(&mut input).unwrap(); + let lines = input.trim().split("\n").collect::>(); + + let mut gear_to_nums = HashMap::new(); + + let mut s1 = 0; + let mut num; + for (y, line) in lines.iter().enumerate() { + let re = Regex::new(r"\d+").unwrap(); + for cap in re.captures_iter(line).map(|g| g.get(0).unwrap()) { + num = line[cap.start()..cap.end()].parse::().unwrap(); + let mut good = false; + for ya in y as i32 - 1..y as i32 + 2 { + for xa in cap.start() as i32 - 1..cap.end() as i32 + 1 { + if is_valid(ya, xa, &lines) { + let c = lines[ya as usize].chars().nth(xa as usize).unwrap(); + good |= !c.is_ascii_digit() && c != '.'; + if c == '*' { + gear_to_nums.entry((ya, xa)).or_insert_with(Vec::new).push(num); + } + } + } + } + if good { + s1 += num; + } + } + } + let s2: i32 = gear_to_nums + .values() + .filter(|v| v.len() == 2) + .map(|v| v[0] * v[1]) + .sum(); + println!("{}\n{}", s1, s2); +} \ No newline at end of file diff --git a/2023/04/04.py b/2023/04/04.py new file mode 100644 index 0000000..c937250 --- /dev/null +++ b/2023/04/04.py @@ -0,0 +1,13 @@ +from sys import stdin + +lines = stdin.read().strip().split("\n") +p = 0 +repeat = [1] * len(lines) +for i, line in enumerate(lines): + right, left = line.split(":")[1].split("|") + shared = len(set(right.split()) & set(left.split())) + if shared: + p += 2**(shared - 1) + for j in range(i+1, min(i+1+shared, len(lines))): + repeat[j] += repeat[i] +print(p, sum(repeat), sep='\n') diff --git a/2023/05/05.py b/2023/05/05.py new file mode 100644 index 0000000..039eb92 --- /dev/null +++ b/2023/05/05.py @@ -0,0 +1,26 @@ +from sys import stdin + +seeds, *mappings = stdin.read().strip().split('\n\n') + +seeds = list(map(int, seeds.split()[1:])) +mappings = [[[int(a) for a in m.split()] for m in maps.split('\n')[1:]] for maps in mappings] + +def solve(for_ranges): + min_seed = (1e12, 1e12) + for for_range in for_ranges: + for seed in for_range: + initial_seed = seed + for mapping in mappings: + for dst, src, size in mapping: + if src <= seed < src + size: + seed = dst + (seed - src) + break + if seed < min_seed[1]: + min_seed = (initial_seed, seed) + return min_seed + +print(solve([[seed] for seed in seeds])[1]) + +ranges = [range(s, s+count, 100000) for s, count in zip(seeds[0::2], seeds[1::2])] +initial, _ = solve(ranges) +print(solve([range(initial-100000, initial+1)])[1]) diff --git a/2023/06/06.py b/2023/06/06.py new file mode 100644 index 0000000..55c16e9 --- /dev/null +++ b/2023/06/06.py @@ -0,0 +1,14 @@ +import re +get_nums = lambda string: [int(a) for a in re.findall("\d+", string)] + +def solve(times, distances): + times, distances = get_nums(times), get_nums(distances) + result = 1 + for time, dist in zip(times, distances): + result *= sum((time - start) * start > dist for start in range(time)) + return result + +times, distances = input(), input() +print(solve(times, distances)) +print(solve(times.replace(' ', ''), distances.replace(' ', ''))) + diff --git a/2023/07/07.py b/2023/07/07.py new file mode 100644 index 0000000..71330b7 --- /dev/null +++ b/2023/07/07.py @@ -0,0 +1,18 @@ +from sys import stdin +from collections import Counter + +def sort_by(cards_and_bid, joker='_'): + cards = cards_and_bid[0].replace(joker, "") + types = [c[1] for c in Counter(cards).most_common()] or [0] + types[0] += cards_and_bid[0].count(joker) + strength = [f'{joker}23456789TJQKA'.index(card) for card in cards_and_bid[0]] + return types, strength + +def solve(joker=''): + as_sorted = sorted(hands, key=lambda k: sort_by(k, joker)) + return sum(i * int(bid) for i, (cards, bid) in enumerate(as_sorted, 1)) + +hands = [line.split() for line in stdin.read().strip().split("\n")] + +print(solve()) +print(solve(joker='J')) diff --git a/2023/08/08.py b/2023/08/08.py new file mode 100644 index 0000000..4e55376 --- /dev/null +++ b/2023/08/08.py @@ -0,0 +1,19 @@ +from sys import stdin +import re +import math + +rl, _, *lines = stdin.read().strip().split('\n') + +parsed = [re.findall(r'[A-Z]{3}', line) for line in lines] +tree = {top: (left, right) for top, left, right in parsed} + +def solve(curr, s=0): + while not curr.endswith('Z'): + curr = tree[curr][rl[s % len(rl)] == 'R'] + s+=1 + return s + +print(solve("AAA")) +print(math.lcm(*[solve(top) for top in tree if top.endswith('A')])) + + diff --git a/2023/09/09.py b/2023/09/09.py new file mode 100644 index 0000000..815e184 --- /dev/null +++ b/2023/09/09.py @@ -0,0 +1,15 @@ +from sys import stdin + +lines = stdin.read().strip().split('\n') + +first = last = 0 +for line in lines: + diff = [int(a) for a in line.split()] + sign = 1 + while any(diff): + last += diff[-1] + first += diff[0] * sign + sign *= -1 + diff = [b - a for a, b in zip(diff, diff[1:])] + +print(first, last, sep='\n') diff --git a/2023/09/09.rs b/2023/09/09.rs new file mode 100644 index 0000000..4838aba --- /dev/null +++ b/2023/09/09.rs @@ -0,0 +1,21 @@ +use std::io::{stdin, Read}; +use itertools::Itertools; + +fn main() { + let mut input = String::new(); + stdin().read_to_string(&mut input).unwrap(); + + let mut first = 0; + let mut last = 0; + for line in input.lines() { + let mut diff = line.split(' ').map(|n| n.parse().unwrap()).collect::>(); + let mut sign = 1; + while let [a, .., z] = *diff { + first += a * sign; + last += z; + sign *= -1; + diff = diff.iter().tuple_windows().map(|(a, b)| b - a).collect(); + } + } + println!("{}\n{}", last, first); +} \ No newline at end of file diff --git a/2023/10/10.py b/2023/10/10.py new file mode 100644 index 0000000..85dd408 --- /dev/null +++ b/2023/10/10.py @@ -0,0 +1,51 @@ +from sys import stdin +from collections import deque + +lines = stdin.read().strip().split('\n') + +dirs = [(0, 1), (1, 0), (-1, 0), (0, -1)] +allowed = ["-7J", "|JL", "|F7", "-FL"] + +def is_valid(y, x): + return -0.5 <= y < len(lines) and -0.5 <= x < len(lines[0]) + +q = deque() +for y, line in enumerate(lines): + if 'S' in line: + q.append((y, line.index('S'), 0)) + +# Part 1: use BFS with allow_from and allow_to to check whether there is a connection +inside = {(y, x) for y in range(len(lines)) for x in range(len(lines[0]))} +visited = set() +max_dist = 0 + +while q: + y, x, dist = q.popleft() + max_dist = max(max_dist, dist) + visited.add((y, x)) + inside.discard((y, x)) + + for (dy, dx), allow_to, allow_from in zip(dirs, allowed, allowed[::-1]): + ya, xa = y+dy, x+dx + if is_valid(ya, xa) and lines[ya][xa] in allow_to and lines[y][x] in allow_from+"S": + if (ya, xa) not in visited: + q.append((ya, xa, dist+1)) + visited.add((y+dy/2, x+dx/2)) + + +# Part 2: use a 0.5 grid to find all non-visited spaces, using the same visited set as in P1. +# Since we start outside of the grid, any cells inside will not be reached. +q.append((-0.5, -0.5)) + +while q: + y, x = q.popleft() + inside.discard((y, x)) + + for dy, dx in dirs: + ya, xa = y+dy/2, x+dx/2 + if is_valid(ya, xa) and (ya, xa) not in visited: + q.append((ya, xa)) + visited.add((ya, xa)) + +print(max_dist) +print(len(inside)) diff --git a/2023/10/10.rs b/2023/10/10.rs new file mode 100644 index 0000000..db011ce --- /dev/null +++ b/2023/10/10.rs @@ -0,0 +1,69 @@ +use std::{io::{stdin, Read}, collections::{VecDeque, HashSet}}; + +use itertools::{Itertools, izip, iproduct}; + +const DIR: [(i32, i32); 4] = [(0, 1), (1, 0), (-1, 0), (0, -1)]; +const ALLOW_TO: [&str; 4] = ["-7J", "|JL", "|F7", "-FL"]; +const ALLOW_FROM: [&str; 4] = ["-FLS", "|F7S", "|JLS", "-7JS"]; + +fn in_bounds(y: i32, x: i32, ys: usize, xs: usize) -> Option<(usize, usize)> { + match (usize::try_from(y), usize::try_from(x)) { + (Ok(y2), Ok(x2)) if y2 < ys && x2 < xs => Some((y2, x2)), + _ => None, + } +} + +fn main() { + let mut input = String::new(); + stdin().read_to_string(&mut input).unwrap(); + let lines: Vec<&str> = input.lines().collect_vec(); + let (ys, xs) = (lines.len(), lines.get(0).unwrap().len()); + + let start = input.lines() + .find_position(|line| line.contains('S')) + .map(|o| (o.0, o.1.find('S').unwrap(), 0)); + + let mut q = VecDeque::from([start.unwrap()]); + println!("{:?}", q); + + let mut visited = HashSet::new(); + let at = |y: usize, x: usize| lines[y].chars().nth(x).unwrap(); + let mut inside: HashSet<(usize, usize)> = iproduct!(0..ys, 0..xs).collect(); + + let mut max_dist = 0; + while !q.is_empty() { + let (y, x, dist) = q.pop_front().unwrap(); + visited.insert((y+y+1, x+x+1)); + inside.remove(&(y, x)); + max_dist = max_dist.max(dist); + for ((dy, dx), to, from) in izip!(DIR, ALLOW_TO, ALLOW_FROM) { + if let Some((ya, xa)) = in_bounds(y as i32+dy, x as i32+dx, ys, xs) { + if to.contains(at(ya, xa)) && from.contains(at(y, x)) { + if !visited.contains(&(y+ya+1, x+xa+1)) { + visited.insert((y+ya+1, x+xa+1)); + q.push_back((ya, xa, dist+1)); + } + } + } + } + } + q.push_back((0, 0, 0)); + + while !q.is_empty() { + let (y, x, _) = q.pop_front().unwrap(); + visited.insert((y, x)); + if let Some((ydiv2, xdiv2)) = in_bounds((y as i32-1)/2, (x as i32-1)/2, ys, xs) { + inside.remove(&(ydiv2, xdiv2)); + } + for (dy, dx) in DIR { + if let Some((ya, xa)) = in_bounds(y as i32+dy, x as i32+dx, ys*2+1, xs*2+1) { + if !visited.contains(&(ya, xa)) { + visited.insert((ya, xa)); + q.push_back((ya, xa, 0)); + } + } + } + } + + println!("{}\n{}", max_dist, inside.len()); +} \ No newline at end of file diff --git a/2023/11/11.py b/2023/11/11.py new file mode 100644 index 0000000..31ed3bf --- /dev/null +++ b/2023/11/11.py @@ -0,0 +1,28 @@ +from sys import stdin +from itertools import combinations, product + +lines = stdin.read().strip().split('\n') + +Ys, Xs = len(lines), len(lines[0]) +cols = [0] * Ys +rows = [0] * Xs + +for y, line in enumerate(lines): + if line.count('.') == len(line): + rows[y] += 1 +for x in range(Xs): + if all(lines[y][x] != '#' for y in range(Ys)): + cols[x] += 1 + +galaxies = [(y, x) for y, x in product(range(Ys), range(Xs)) if lines[y][x] == '#'] + +def solve(multiplier=1, s=0): + for (y, x), (Y, X) in combinations(galaxies, r=2): + y, Y = sorted([y, Y]) + x, X = sorted([x, X]) + s += Y - y + X - x + (sum(rows[y:Y]) + sum(cols[x:X])) * multiplier + return s + +print(solve()) +print(solve(1000000-1)) + diff --git a/2023/12/12.py b/2023/12/12.py new file mode 100644 index 0000000..7207734 --- /dev/null +++ b/2023/12/12.py @@ -0,0 +1,29 @@ +from sys import stdin +from functools import cache + +@cache +def decide(line, curr, needed, s=0): + if not line: + return (needed or (0,)) == (curr,) + + match line[0]: + case '?': + s += decide('.' + line[1:], curr, needed) + s += decide('#' + line[1:], curr, needed) + case '#' if needed and curr < needed[0]: + s += decide(line[1:], curr+1, needed) + case '.' if not needed or curr == 0: + s += decide(line[1:], 0, needed) + case '.' if curr == needed[0]: + s += decide(line[1:], 0, needed[1:]) + return s + +s1 = s2 = 0 +for line in stdin: + chars, needed = line.split() + needed = tuple(int(n) for n in needed.split(",")) + + s1 += decide(chars, 0, needed) + s2 += decide('?'.join([chars] * 5), 0, needed * 5) + +print(s1, s2, sep='\n') diff --git a/2023/13/13.py b/2023/13/13.py new file mode 100644 index 0000000..0d624f2 --- /dev/null +++ b/2023/13/13.py @@ -0,0 +1,28 @@ +from sys import stdin +import re +from collections import defaultdict, Counter, deque +from itertools import permutations, combinations + +fields = stdin.read().strip().split('\n\n') + +def count_wrong_reflections(field, x): + wrong = 0 + for y in range(len(field)): + wrong += sum(a != b for a, b in zip(field[y][:x][::-1], field[y][x:])) + return wrong + +s1 = s2 = 0 +for field in fields: + field = field.split('\n') + for x in range(1, len(field[0])): + reflections = count_wrong_reflections(field, x) + s1 += x if reflections == 0 else 0 + s2 += x if reflections == 1 else 0 + + transposed = list(zip(*field)) + for y in range(1, len(transposed[0])): + reflections = count_wrong_reflections(transposed, y) + s1 += y*100 if reflections == 0 else 0 + s2 += y*100 if reflections == 1 else 0 + +print(s1, s2, sep="\n") diff --git a/2023/14/14.py b/2023/14/14.py new file mode 100644 index 0000000..5262321 --- /dev/null +++ b/2023/14/14.py @@ -0,0 +1,34 @@ +from sys import stdin + +DIRS = [(-1, 0), (0, -1), (1, 0), (0, 1)] + +lines = [list(line.strip()) for line in stdin] + +Y, X = len(lines), len(lines[0]) +coords = [(y, x) for y in range(Y) for x in range(X)] + +def find_o_coords(): + return [(y, x) for y, x in coords if lines[y][x] == 'O'] + +seen = {} + +for i in range(1, 10000): + for yd, xd in DIRS: + for y, x in find_o_coords(): + ybest, xbest = yo, xo = y, x + while 0 <= y < Y and 0 <= x < X and lines[y][x] != '#': + if lines[y][x] == '.': + ybest, xbest = y, x + y, x = y+yd, x+xd + lines[yo][xo], lines[ybest][xbest] = lines[ybest][xbest], lines[yo][xo] + + load_on_beams = sum(Y-y for y, _ in find_o_coords()) + if i == 1 and (yd, xd) == DIRS[0]: + print(load_on_beams) + + if str(lines) in seen: + repeat_interval = i - seen[str(lines)] + if (1_000_000_000 - i) % repeat_interval == 0: + print(load_on_beams) + exit() + seen[str(lines)] = i diff --git a/2023/15/15.py b/2023/15/15.py new file mode 100644 index 0000000..0380aec --- /dev/null +++ b/2023/15/15.py @@ -0,0 +1,20 @@ +from sys import stdin + +def hash(s, val=0): + return hash(s[1:], (val + ord(s[0])) * 17 % 256) if s else val + +boxes = [{} for _ in range(256)] +s1 = s2 = 0 +for step in stdin.read().strip().split(','): + s1 += hash(step) + match step.replace('-', '=').partition("="): + case [label, "=", ""]: + boxes[hash(label)].pop(label, None) + case [label, "=", num]: + boxes[hash(label)][label] = int(num) + +for i, box in enumerate(boxes, 1): + for j, num in enumerate(box.values(), 1): + s2 += i * j * num + +print(s1, s2, sep='\n') diff --git a/2023/16/16.py b/2023/16/16.py new file mode 100644 index 0000000..9ce73b8 --- /dev/null +++ b/2023/16/16.py @@ -0,0 +1,37 @@ +import sys +sys.setrecursionlimit(10000000) + +lines = sys.stdin.read().strip().split('\n') + +dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)] +Y, X = len(lines), len(lines[0]) + +def go(y, x, d, visited, return_energized=True): + if 0 <= y < Y and 0 <= x < X and (y, x, d) not in visited: + visited.add((y, x, d)) + go_dir = lambda d: go(y+d[0], x+d[1], d, visited, False) + match lines[y][x]: + case '/': + go_dir((-d[1], -d[0])) + case '\\': + go_dir((d[1], d[0])) + case '|': + go_dir(dirs[1]) + go_dir(dirs[3]) + case '-': + go_dir(dirs[0]) + go_dir(dirs[2]) + case _: + go_dir(d) + if return_energized: + return len({(y, x) for y, x, _ in visited}) + +p2 = [] +for y in range(Y): + for x in range(X): + for is_edge, (dy, dx) in zip((x == 0, y == 0, x == X-1, y == Y-1), dirs): + if is_edge: + p2 += [go(y, x, (dy, dx), set())] + +print(go(0, 0, dirs[0], set())) +print(max(p2)) diff --git a/2023/17/17.py b/2023/17/17.py new file mode 100644 index 0000000..ffafef7 --- /dev/null +++ b/2023/17/17.py @@ -0,0 +1,37 @@ +from sys import stdin +from queue import PriorityQueue + +lines = stdin.read().splitlines() +Y, X = len(lines), len(lines[0]) +dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)] + +def solve(min_straight, max_straight): + q = PriorityQueue() + q.put((0, 0, 0, 0, 0)) + visited = set() + while not q.empty(): + dist, y, x, movedy, movedx = tup = q.get() + if y == Y-1 and x == X-1: + return dist + if tup[1:] in visited: + continue + visited.add(tup[1:]) + for dy, dx in dirs: + ay, ax = y+dy, x+dx + if movedy * dy < 0 or movedx * dx < 0: + continue # prevent reversing + movedy2 = movedy + dy + movedx2 = movedx + dx + straight = max(abs(movedy2), abs(movedx2)) + if abs(movedy2) > 0 and abs(movedx2) > 0: + if straight < min_straight: + continue # prevent turning if not at least n straight + movedy2 *= abs(dy) + movedx2 *= abs(dx) + + new_tup = (ay, ax, movedy2, movedx2) + if 0 <= ay < Y and 0 <= ax < X and straight <= max_straight and new_tup not in visited: + q.put((dist+int(lines[ay][ax]), ay, ax, movedy2, movedx2)) + +print(solve(0, 3)) +print(solve(4, 10)) diff --git a/2023/18/18.py b/2023/18/18.py new file mode 100644 index 0000000..39f673b --- /dev/null +++ b/2023/18/18.py @@ -0,0 +1,9 @@ +def solve(instructions, s=2, xy=0.): + for d in instructions: + s += abs(d.real+d.imag) + d.imag*xy.real - d.real*xy.imag + xy += d + print(int(s // 2)) + +split = [line.split() for line in open(0)] +solve(1j**"RDLU".index(d) * int(num) for d, num, _ in split) +solve(1j**int(c[7]) * int(c[2:7], 16) for *_, c in split) diff --git a/2023/18/18_non-complex.py b/2023/18/18_non-complex.py new file mode 100644 index 0000000..68c9047 --- /dev/null +++ b/2023/18/18_non-complex.py @@ -0,0 +1,13 @@ +dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)] + +def solve(instructions, s=0, y=0, x=0): + for d, num in instructions: + y2 = y + num * dirs[d][0] + x2 = x + num * dirs[d][1] + s += num + (y2*x - x2*y) # Border + Shoelace formula + y, x = y2, x2 + print(s // 2 + 1) + +split = [line.split() for line in open(0)] +solve(("RDLU".index(d), int(num)) for d, num, _ in split) +solve((int(c[7]), int(c[2:7], 16)) for *_, c in split) diff --git a/2023/18/18scanline.py b/2023/18/18scanline.py new file mode 100644 index 0000000..49f1d96 --- /dev/null +++ b/2023/18/18scanline.py @@ -0,0 +1,43 @@ +from sys import stdin +from collections import defaultdict + +lines = stdin.read().splitlines() +dirs = {"R": (0, 1), "D": (1, 0), "L": (0, -1), "U": (-1, 0)} + +def solve(instructions): + y = x = s = 0 + y_vis = defaultdict(list) + x_vis = defaultdict(list) + for d, num in instructions: + if d in "RL": + x_prev = x + x += num * dirs[d][1] + s += abs(x_prev - x) - 1 + x_vis[y].append(sorted([x_prev, x])) + else: + ynext = y + num * dirs[d][0] + for ya in range(min(ynext, y), max(ynext, y)+1): + y_vis[ya].append((x, d)) + y = ynext + + for y, xs in y_vis.items(): + xs.sort() + curr, d = xs[0] + indices = [0] + for i, ((_, d1), (_, d2)) in enumerate(zip(xs, xs[1:])): + if d1 != d2 and d2 == xs[0][1]: + indices.append(i+1) + indices.append(len(xs)) + for i1, i2 in zip(indices, indices[1:]): + x1, d1 = xs[i1] + x2, d2 = xs[i2-1] + for a1, a2 in x_vis[y]: + if x1 <= a1 < a2 <= x2: + s -= a2 - a1 - 1 # Remove x line which were counted twice + s += x2 - x1 + 1 + return s + + +split = [line.split() for line in lines] +print(solve([(d, int(num)) for d, num, _ in split])) +print(solve([("RDLU"[int(c[-2])], int(c[2:-2], 16)) for *_, c in split])) diff --git a/2023/19/19.py b/2023/19/19.py new file mode 100644 index 0000000..477a135 --- /dev/null +++ b/2023/19/19.py @@ -0,0 +1,45 @@ +import re +import math +instructions, queries = open(0).read().split('\n\n') + +rules = {} + +def is_accepted(x, m, a, s, rule): + if len(rule) == 1: + if rule[0][0] in rules: + return is_accepted(x, m, a, s, rules[rule[0][0]]) + return rule[0][0] == 'A' + condition, trueval = rule[0] + if eval(condition): + return is_accepted(x, m, a, s, [[trueval]]) + return is_accepted(x, m, a, s, rule[1:]) + +def range_combinations(ranges, rule): + if len(rule) == 1: + if (curr := rule[0][0]) in rules: + return range_combinations(ranges, rules[curr]) + return math.prod(map(len, ranges.values())) * (curr == 'A') + (var, op, *digits), trueval = rule[0] + num = int(''.join(digits)) + (op == '>') + lower = range(ranges[var].start, num) + upper = range(num, ranges[var].stop) + + rtrue = ranges | {var: lower if op == '<' else upper} + rfalse = ranges | {var: upper if op == '<' else lower} + return range_combinations(rtrue, [[trueval]]) \ + + range_combinations(rfalse, rule[1:]) + + +for inst in instructions.splitlines(): + name, conditions = inst.strip("}").split("{") + rules[name] = [rule.split(":") for rule in conditions.split(',')] + +s = 0 +for query in queries.splitlines(): + xmas = [int(a) for a in re.findall("(\d+)", query)] + if is_accepted(*xmas, rules["in"]): + s += sum(xmas) + +print(s) +ranges = {key: range(1, 4001) for key in "xmas"} +print(range_combinations(ranges, rules['in'])) diff --git a/2023/20/20.py b/2023/20/20.py new file mode 100644 index 0000000..1ffb405 --- /dev/null +++ b/2023/20/20.py @@ -0,0 +1,61 @@ +from collections import deque +import math + +modules = {} +flipflops = {} +conjunctions = {} +rx_parent = '' + +for line in open(0): + name, destinations = line.strip().split(" -> ") + pure_name = name.strip("&%") + modules[pure_name] = destinations.split(', ') + if name[0] == '%': + flipflops[pure_name] = False + elif name[0] == '&': + conjunctions[pure_name] = {} + +for name, destinations in modules.items(): + for dest in destinations: + if dest in conjunctions: + conjunctions[dest][name] = False + if dest == 'rx': + rx_parent = name + +q = deque() +counts = [0, 0] +rx_repeats = [False] * len(conjunctions[rx_parent]) + +def push(name, i, send=False): + if name in flipflops: + send = flipflops[name] + elif name in conjunctions: + send = not all(conjunctions[name].values()) + + if name == rx_parent: + for j, is_good in enumerate(conjunctions[rx_parent].values()): + if is_good: + rx_repeats[j] = i + + for dest in modules.get(name, []): + counts[send] += 1 + if dest in flipflops: + if not send: + flipflops[dest] = not flipflops[dest] + q.append(dest) + elif dest in conjunctions: + conjunctions[dest][name] = send + q.append(dest) + +for i in range(1, 100000): + q.append("broadcaster") + counts[0] += 1 + while q: + push(q.popleft(), i) + + if i == 1000: + print(counts[0] * counts[1]) + + if all(rx_repeats): + print(math.prod(rx_repeats)) + break diff --git a/2023/21/21.py b/2023/21/21.py new file mode 100644 index 0000000..f299463 --- /dev/null +++ b/2023/21/21.py @@ -0,0 +1,32 @@ +from collections import deque + +lines = open(0).read().splitlines() +Y, X = len(lines), len(lines[0]) +dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)] + +q = deque() +dists = {} + +for y, line in enumerate(lines): + if 'S' in line: + q.append((y, line.index('S'))) + +while q: + y, x = q.popleft() + for dy, dx in dirs: + ya, xa = y + dy, x + dx + if 0 <= ya < Y and 0 <= xa < X and lines[ya][xa] != '#' and (ya, xa) not in dists: + dists[(ya, xa)] = dists.get((y, x), 0)+1 + q.append((ya, xa)) + +n = 26501365 // X + +even_full = sum(d % 2 == 0 for d in dists.values()) +odd_full = sum(d % 2 == 1 for d in dists.values()) +even_edges = sum(d % 2 == 0 and d > 65 for d in dists.values()) +odd_edges = sum(d % 2 == 1 and d > 65 for d in dists.values()) + +print(even_full - even_edges) + +p2 = (n+1)**2 * odd_full + n**2 * even_full - (n+1) * odd_edges + n * even_edges +print(p2) diff --git a/2023/22/22.py b/2023/22/22.py new file mode 100644 index 0000000..4d3f0c1 --- /dev/null +++ b/2023/22/22.py @@ -0,0 +1,63 @@ +from copy import deepcopy +from itertools import product + +s1 = s2 = 0 +X, Y, Z = 10, 10, 400 +stack = [[[-1] * Z for _ in range(Y)] for _ in range(X)] +bricks = [] + +for i, line in enumerate(open(0)): + x1, y1, z1, x2, y2, z2 = map(int, line.replace("~", ",").split(",")) + bricks.append([]) + for x, y, z in product(range(x1, x2+1), range(y1, y2+1), range(z1, z2+1)): + stack[x][y][z] = i + bricks[-1].append((x, y, z)) + +def z_lower(coords): + return [(x, y, z-1) for x,y,z in coords] + +def at_z_lower(coords, stack): + return {stack[x][y][z-1] for x,y,z in coords} + +def at_z_upper(coords, stack): + return {stack[x][y][z+1] for x,y,z in coords} + +def drop_all(stack, bricks): + changed = True + dropped = set() + while changed: + changed = False + for z, y, x in product(range(2, Z), range(Y), range(X)): + if (brick_id := stack[x][y][z]) != -1: + brick = bricks[brick_id] + if all(z > 1 for _, _, z in brick): + if len(at_z_lower(brick, stack) - {-1, brick_id}) == 0: + for x,y,z in brick: + stack[x][y][z] = -1 + brick = bricks[brick_id] = z_lower(brick) + for x,y,z in brick: + stack[x][y][z] = brick_id + dropped.add(brick_id) + changed = True + return dropped + +drop_all(stack, bricks) + +for i, brick in enumerate(bricks): + ids_above = at_z_upper(brick, stack) - {-1, i} + can_remove = True + for id_above in ids_above: + supporting_ids = at_z_lower(bricks[id_above], stack) - {-1, id_above} + if len(supporting_ids) == 1: + can_remove = False + stack2 = deepcopy(stack) + bricks2 = deepcopy(bricks) + for x,y,z in bricks2[i]: + stack2[x][y][z] = -1 + bricks2[i] = [] + s2 += len(drop_all(stack2, bricks2) - {i}) + break + + s1 += can_remove + +print(s1, s2, sep='\n') diff --git a/2023/23/23.py b/2023/23/23.py new file mode 100644 index 0000000..e3f6343 --- /dev/null +++ b/2023/23/23.py @@ -0,0 +1,34 @@ +import sys +sys.setrecursionlimit(1000000000) +from collections import deque + +lines = open(0).read().splitlines() +Y, X = len(lines), len(lines[0]) +dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)] + +max_dist = 0 +def dfs(y, x, dist, visited, part2=False): + global max_dist + if (y, x) == (Y-1, X-2): + if dist > max_dist: + # Prints all current largest paths. After a couple minutes it finds the correct answer + # However it does not finish within half an hour. + print(dist) + max_dist = dist + + adj = [] + for i, (dy, dx) in enumerate(dirs): + ya, xa = y+dy, x+dx + if 0 <= ya < Y and 0 <= xa < X and lines[ya][xa] != '#' and (ya, xa) not in visited: + adj.append((ya, xa)) + if not part2 and lines[ya][xa] in '>v<^' and '>v<^'.index(lines[ya][xa]) == i: + continue + if len(adj) == 1: + visited.add(adj[0]) + dfs(adj[0][0], adj[0][1], dist+1, visited) + elif len(adj) > 1: + for a in adj: + dfs(a[0], a[1], dist+1, visited | {a}) + +dfs(0, 1, 0, {(0, 1)}) +dfs(0, 1, 0, {(0, 1)}, part2=True) diff --git a/2023/24/24.py b/2023/24/24.py new file mode 100644 index 0000000..bdd93c9 --- /dev/null +++ b/2023/24/24.py @@ -0,0 +1,41 @@ + +import z3 + +lines = open(0).read().splitlines() + +sx, sy, sz = z3.Real('x'), z3.Real('y'), z3.Real('z') +sdx, sdy, sdz = z3.Real('dx'), z3.Real('dy'), z3.Real('dz') +solver = z3.Solver() + +coords = [] +for i, line in enumerate(lines): + x, y, z, dx, dy, dz = map(int, line.replace("@", ",").split(",")) + coords.append((x, y, z, dx, dy, dz)) + if i < 3: + t = z3.Real(f't{i}') + solver.add(sx + sdx * t == x + dx * t) + solver.add(sy + sdy * t == y + dy * t) + solver.add(sz + sdz * t == z + dz * t) + + +s1 = 0 +for i, (x1, y1, z1, dx1, dy1, dz1) in enumerate(coords): + for x2, y2, z2, dx2, dy2, dz2 in coords[i+1:]: + slope1 = dy1 / dx1 + slope2 = dy2 / dx2 + b1 = y1 - slope1 * x1 + b2 = y2 - slope2 * x2 + if slope1 != slope2: + ix = (b2 - b1) / (slope1 - slope2) + iy = slope1 * ix + b1 + + if 2e14 <= ix <= 4e14 and 2e14 <= iy <= 4e14: + if (x1 - ix) * dx1 < 0 and (x2 - ix) * dx2 < 0: + if (y1 - iy) * dy1 < 0 and (y2 - iy) * dy2 < 0: + s1 += 1 + +print(s1) +assert solver.check() == z3.sat +model = solver.model() +get = lambda var: model.eval(var).as_long() +print(get(sx) + get(sy) + get(sz)) diff --git a/2023/25/25.py b/2023/25/25.py new file mode 100644 index 0000000..5a7de1c --- /dev/null +++ b/2023/25/25.py @@ -0,0 +1,17 @@ +from collections import defaultdict +import random +import networkx as nx + +g = nx.Graph() +for line in open(0): + at, tos = line.split(":") + for to in tos.strip().split(' '): + g.add_edge(at, to, capacity=1) + +while True: + start = random.choice(list(g.nodes)) + end = random.choice(list(g.nodes)) + cut, part = nx.minimum_cut(g, start, end) + if cut == 3: + print(len(part[0])*len(part[1])) + break diff --git a/2023/Cargo.lock b/2023/Cargo.lock new file mode 100644 index 0000000..90b98d9 --- /dev/null +++ b/2023/Cargo.lock @@ -0,0 +1,70 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "aho-corasick" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0" +dependencies = [ + "memchr", +] + +[[package]] +name = "aoc2023" +version = "0.1.0" +dependencies = [ + "itertools", + "regex", +] + +[[package]] +name = "either" +version = "1.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07" + +[[package]] +name = "itertools" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "284f18f85651fe11e8a991b2adb42cb078325c996ed026d994719efcfca1d54b" +dependencies = [ + "either", +] + +[[package]] +name = "memchr" +version = "2.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f665ee40bc4a3c5590afb1e9677db74a508659dfd71e126420da8274909a0167" + +[[package]] +name = "regex" +version = "1.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "380b951a9c5e80ddfd6136919eef32310721aa4aacd4889a8d39124b026ab343" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f804c7828047e88b2d32e2d7fe5a105da8ee3264f01902f796c8e067dc2483f" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f" diff --git a/2023/Cargo.toml b/2023/Cargo.toml new file mode 100644 index 0000000..e3a6db9 --- /dev/null +++ b/2023/Cargo.toml @@ -0,0 +1,110 @@ +[package] +name = "aoc2023" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +regex = "1.10.2" +itertools = "0.9.0" + +[[bin]] +name = "01" +path = "01/01.rs" + +[[bin]] +name = "02" +path = "02/02.rs" + +[[bin]] +name = "03" +path = "03/03.rs" + +[[bin]] +name = "04" +path = "04/04.rs" + +[[bin]] +name = "05" +path = "05/05.rs" + +[[bin]] +name = "06" +path = "06/06.rs" + +[[bin]] +name = "07" +path = "07/07.rs" + +[[bin]] +name = "08" +path = "08/08.rs" + +[[bin]] +name = "09" +path = "09/09.rs" + +[[bin]] +name = "10" +path = "10/10.rs" + +[[bin]] +name = "11" +path = "11/11.rs" + +[[bin]] +name = "12" +path = "12/12.rs" + +[[bin]] +name = "13" +path = "13/13.rs" + +[[bin]] +name = "14" +path = "14/14.rs" + +[[bin]] +name = "15" +path = "15/15.rs" + +[[bin]] +name = "16" +path = "16/16.rs" + +[[bin]] +name = "17" +path = "17/17.rs" + +[[bin]] +name = "18" +path = "18/18.rs" + +[[bin]] +name = "19" +path = "19/19.rs" + +[[bin]] +name = "20" +path = "20/20.rs" + +[[bin]] +name = "21" +path = "21/21.rs" + +[[bin]] +name = "22" +path = "22/22.rs" + +[[bin]] +name = "23" +path = "23/23.rs" + +[[bin]] +name = "24" +path = "24/24.rs" + +[[bin]] +name = "25" +path = "25/25.rs" diff --git a/2024/01/01.py b/2024/01/01.py new file mode 100644 index 0000000..6a55352 --- /dev/null +++ b/2024/01/01.py @@ -0,0 +1,7 @@ +n = [int(a) for a in open(0).read().split()] + +s1 = s2 = 0 +for a, b in zip(sorted(n[::2]), sorted(n[1::2])): + s1 += abs(a - b) + s2 += a * n[1::2].count(a) +print(s1, s2, sep="\n") diff --git a/2024/02/02.py b/2024/02/02.py new file mode 100644 index 0000000..1b69b9c --- /dev/null +++ b/2024/02/02.py @@ -0,0 +1,9 @@ +is_safe = lambda n: sorted(n) in (n, n[::-1]) and all(1 <= abs(a - b) <= 3 for a, b in zip(n, n[1:])) + +s1 = s2 = 0 +for line in open(0): + n = [int(a) for a in line.split()] + s1 += is_safe(n) + s2 += any(is_safe(n[:i] + n[i+1:]) for i in range(len(n))) +print(s1, s2, sep="\n") + diff --git a/2024/03/03.py b/2024/03/03.py new file mode 100644 index 0000000..cd06c33 --- /dev/null +++ b/2024/03/03.py @@ -0,0 +1,10 @@ +import re +s1, s2, enabled = 0, 0, True + +for a, b, dont in re.findall(r"mul\((\d+),(\d+)\)|do(n't)?", open(0).read()): + if a or b: + s1 += int(a) * int(b) + s2 += int(a) * int(b) * enabled + else: + enabled = dont == '' +print(s1, s2, sep="\n") diff --git a/2024/04/04.py b/2024/04/04.py new file mode 100644 index 0000000..74ff791 --- /dev/null +++ b/2024/04/04.py @@ -0,0 +1,11 @@ +coords = {x+1j*y: c for y, r in enumerate(open(0)) for x, c in enumerate(r)} +g = lambda c: coords.get(c, "") + +s1 = s2 = 0 +for c in coords: + for d in [1, 1j, 1+1j, 1-1j, -1, -1j, -1+1j, -1-1j]: + s1 += g(c) + g(c+d) + g(c+d*2) + g(c+d*3) == "XMAS" + if d.imag and d.real: + s2 += g(c+d) + g(c) + g(c-d) == "MAS" and g(c+d*1j) + g(c-d*1j) == "MS" + +print(s1, s2, sep="\n") diff --git a/2024/05/05.py b/2024/05/05.py new file mode 100644 index 0000000..bb86d53 --- /dev/null +++ b/2024/05/05.py @@ -0,0 +1,13 @@ +rules, pages = open(0).read().split("\n\n") +rules = {tuple(r.split("|")) for r in rules.splitlines()} + +s = [0, 0] +for row in pages.splitlines(): + old, new = row.split(","), [] + for o in old * 100: + if o in new: continue + if all(b in new for b, a in rules if o == a and b in old): + new.append(o) + s[new != old] += int(new[len(new)//2]) + +print(*s, sep="\n") diff --git a/2024/06/06.py b/2024/06/06.py new file mode 100644 index 0000000..42cd478 --- /dev/null +++ b/2024/06/06.py @@ -0,0 +1,21 @@ +coords = {x+1j*y: c for y, r in enumerate(open(0)) for x, c in enumerate(r) if c != '\n'} + +for pos, c in coords.items(): + if c == "^": + start = pos + +def solve(obstruction, pos=start, d=-1j): + seen = set() + while pos in coords: + seen.add((pos, d)) + while coords.get(pos + d, "#") != '#' and pos + d != obstruction: + pos += d + seen.add((pos, d)) + if pos + d not in coords: + return {p for p, _ in seen} + d *= 1j + if (pos, d) in seen: + return True + +seen = solve(-1) +print(len(seen), sum(solve(coord) is True for coord in seen)) diff --git a/2024/07/07.py b/2024/07/07.py new file mode 100644 index 0000000..b8086e0 --- /dev/null +++ b/2024/07/07.py @@ -0,0 +1,27 @@ +from operator import * + +def concat(a, b): + return int(str(a) + str(b)) + +s1 = s2 = 0 +for line in open(0): + first, rest = line.split(": ") + n = [int(a) for a in rest.split()] + first = int(first) + repeat = len(n) - 1 + for mask in range(3**repeat): + s = n[0] + for_part1 = True + for i in range(repeat): + mask, index = divmod(mask, 3) + for_part1 &= index != 2 + op = [add, mul, concat][index] + s = op(s, n[i+1]) + if s > first: + break + if s == first: + s1 += first * for_part1 + s2 += first + break + +print(s1, s2, sep="\n") diff --git a/2024/08/08.py b/2024/08/08.py new file mode 100644 index 0000000..e731df5 --- /dev/null +++ b/2024/08/08.py @@ -0,0 +1,18 @@ +from itertools import * + +coords = {x+1j*y: c for y, r in enumerate(open(0)) for x, c in enumerate(r.strip())} + +by = lambda v: v[1] +order = groupby(sorted(coords.items(), key=by), by) + +p1, p2 = set(), set() + +for char, coord in order: + if char == '.': continue + for (a, _), (b, _) in combinations(coord, r=2): + diff = a - b + p1 |= {a + diff*i for i in (-2, 1)} + p2 |= {a + diff*i for i in range(-100, 100)} + +print(len(p1 & coords.keys())) +print(len(p2 & coords.keys())) diff --git a/2024/09/09.py b/2024/09/09.py new file mode 100644 index 0000000..3f96a31 --- /dev/null +++ b/2024/09/09.py @@ -0,0 +1,39 @@ +def solve1(files, s=0, index=-1, f=-1): + while f+1 < len(files): + file = files[f := f + 1] + is_file = f%2 == 0 + for _ in range(file): + i = f//2 if is_file else len(files) // 2 + s += i * (index := index + 1) + if not is_file: + files[-1] -= 1 + while files[-1] == 0 or len(files) % 2 == 0 and len(files)-1 != f: + files.pop() + if len(files)-1 == f: + break + return s + +def solve2(files, free_spaces, s=0, index=-1): + spaces = [[] for j in free_spaces] + files = list(enumerate(files)) + + for i, file in reversed(files): + for j, empty in enumerate(free_spaces): + if i <= j: + break + if empty >= file: + spaces[j].append((i, file)) + files[i] = (0, file) + free_spaces[j] -= file + break + + for file, space, empty in zip(files, spaces, free_spaces): + for i, count in [file] + space + [(0, empty)]: + while count: + s += i * (index := index + 1) + count -= 1 + return s + +filesystem = [int(a) for a in input()] +print(solve1(filesystem[:])) +print(solve2(filesystem[::2], filesystem[1::2])) diff --git a/2024/10/10.py b/2024/10/10.py new file mode 100644 index 0000000..4420f68 --- /dev/null +++ b/2024/10/10.py @@ -0,0 +1,18 @@ +coords = {x+1j*y: int(h) for y, r in enumerate(open(0)) for x, h in enumerate(r.strip())} + +def hike(c, peaks, paths=0): + if coords[c] == 9: + peaks.add(c) + return 1 + for d in [1, 1j, -1, -1j]: + if coords.get(c+d) == coords[c] + 1: + paths += hike(c+d, peaks) + return paths + +p1, s2 = {c: set() for c in coords}, 0 +for c in coords: + if coords[c] == 0: + s2 += hike(c, p1[c]) + +print(sum(map(len, p1.values()))) +print(s2) diff --git a/2024/11/11.py b/2024/11/11.py new file mode 100644 index 0000000..7a60324 --- /dev/null +++ b/2024/11/11.py @@ -0,0 +1,14 @@ +from collections import Counter + +counts = Counter([int(a) for a in input().split()]) + +for i in range(75): + for n, occ in list(counts.items()): + if (l := len(str(n))) % 2 == 0: + counts[n // 10**(l//2)] += occ + counts[n % 10**(l//2)] += occ + else: + counts[n * 2024 or 1] += occ + counts[n] -= occ + if i in (24, 74): + print(sum(counts.values())) diff --git a/2024/12/12.py b/2024/12/12.py new file mode 100644 index 0000000..9166f75 --- /dev/null +++ b/2024/12/12.py @@ -0,0 +1,35 @@ +coords = {x+1j*y: c for y, r in enumerate(open(0)) for x, c in enumerate(r.strip())} +dir_corners = [.5+.5j, .5-.5j, -.5+.5j, -.5-.5j] +visited = set() + +def adjacent(coord, dirs=[1, 1j, -1, -1j]): + return [coord + d for d in dirs] + +def fill_region(c): + visited.add(c) + region = [c] + for adj in adjacent(c): + if coords.get(adj) == coords[c] and adj not in visited: + region += fill_region(adj) + return region + +s1 = s2 = 0 +for c, char in coords.items(): + if c in visited: continue + + perimeter, corners = 0, set() + + for r in (region := fill_region(c)): + perimeter += sum(adj not in region for adj in adjacent(r)) + + for corner in adjacent(r, dir_corners): + k = [adj for adj in adjacent(corner, dir_corners) if adj in region] + if len(k) in [1, 3]: + corners.add(corner) + elif abs(k[0] - k[1]) != 1: + corners |= {corner, corner+0.1} + + s1 += perimeter * len(region) + s2 += len(corners) * len(region) + +print(s1, s2, sep="\n") diff --git a/2024/13/13.py b/2024/13/13.py new file mode 100644 index 0000000..ef9a5ac --- /dev/null +++ b/2024/13/13.py @@ -0,0 +1,19 @@ +import re +import z3 + +s = [0, 0] +for machine in open(0).read().split("\n\n"): + (ax,ay), (bx,by), (px,py) = [map(int, x) for x in re.findall(r"(\d+).*?(\d+)", machine)] + + for i, add in enumerate([0, 10000000000000]): + a, b = z3.Int('a'), z3.Int('b') + + solver = z3.Optimize() + solver.add(px + add == a * ax + b * bx) + solver.add(py + add == a * ay + b * by) + solver.minimize(a * 3 + b) + + if solver.check() == z3.sat: + model = solver.model() + s[i] += model.eval(a).as_long() * 3 + model.eval(b).as_long() +print(*s, sep="\n") diff --git a/2024/14/14.py b/2024/14/14.py new file mode 100644 index 0000000..a8b89a8 --- /dev/null +++ b/2024/14/14.py @@ -0,0 +1,21 @@ +import re + +X, Y = 101, 103 +nums = [list(map(int, re.findall(r"-?\d+", line))) for line in open(0)] + +for i in range(X * Y): + quadrant = [0, 0, 0, 0] + picture = [" "] * (X * Y) + for x, y, vx, vy in nums: + nx = (x + vx * i) % X + ny = (y + vy * i) % Y + picture[ny * X + nx] = "#" + if nx != X//2 and ny != Y//2: + quadrant[(nx > X//2) + (ny > Y//2) * 2] += 1 + + if i == 100: + print(quadrant[0] * quadrant[1] * quadrant[2] * quadrant[3]) + + if ("#" * 20) in ''.join(picture): + print(i) + break diff --git a/2024/15/15.py b/2024/15/15.py new file mode 100644 index 0000000..48eb599 --- /dev/null +++ b/2024/15/15.py @@ -0,0 +1,32 @@ +def solve(field): + coords = {x+1j*y: c for y, r in enumerate(field.split("\n")) for x, c in enumerate(r)} + + pos = [c for c in coords if coords[c] == "@"][0] + coords[pos] = "." + + def find_boxes(c): + if coords[c] not in "]O[": + return {} + c_adj = c + ("]O[".index(coords[c]) - 1 if dir.imag else 0) + return {c: coords[c], c_adj: coords[c_adj]} \ + | find_boxes(c+dir) \ + | find_boxes(c_adj+dir) + + for move in moves.replace("\n", ""): + dir = {'>': 1, 'v': 1j, '<': -1, '^': -1j}[move] + if coords[pos+dir] == '#': continue + + boxes = find_boxes(pos+dir) + if all(coords[box+dir] != "#" for box in boxes): + coords |= {box: '.' for box in boxes} + coords |= {box+dir: boxes[box] for box in boxes} + pos += dir + + print(int(sum(c.imag*100 + c.real for c in coords if coords[c] in '[O'))) + +field, moves = open(0).read().split("\n\n") + +solve(field) +for r1, r2 in [("#", "##"), ("O", "[]"), (".", ".."), ("@", "@.")]: + field = field.replace(r1, r2) +solve(field) diff --git a/2024/16/16.py b/2024/16/16.py new file mode 100644 index 0000000..a8184c0 --- /dev/null +++ b/2024/16/16.py @@ -0,0 +1,17 @@ +import networkx as nx +coords = {x+1j*y: c for y, r in enumerate(open(0)) for x, c in enumerate(r.strip())} + +G = nx.DiGraph() +for c in coords: + for d in [1, 1j, -1, -1j]: + G.add_edge((c, d), (c, 0), weight=0) + G.add_edge((c, 0), (c, d), weight=1000) + if coords[c] != '#' != coords[c+d]: + G.add_edge((c, d), (c+d, d), weight=1) + +E, S = [c for c in coords if coords[c] in 'SE'] + +paths = list(nx.all_shortest_paths(G, (S, 1), (E, 0), "weight")) + +print(sum(G.edges[e]["weight"] for e in zip(paths[0], paths[0][1:]))) +print(len({p[0] for p in sum(paths, [])})) diff --git a/2024/17/17.py b/2024/17/17.py new file mode 100644 index 0000000..c7862de --- /dev/null +++ b/2024/17/17.py @@ -0,0 +1,31 @@ +import re +a, b, c, *nums = map(int, re.findall(r"\d+", open(0).read())) + +def compute(A=a, B=b, C=c, pointer=0): + out = [] + while pointer < len(nums): + num = nums[pointer+1] + combo = {4:A, 5:B, 6:C}.get(num, num) + match nums[pointer]: + case 0: A = A // 2**combo + case 1: B ^= num + case 2: B = combo % 8 + case 3 if A != 0: pointer = num - 2 + case 4: B ^= C + case 5: out.append(combo % 8) + case 6: B = A // 2**combo + case 7: C = A // 2**combo + pointer += 2 + return out + +print(*compute(), sep=",") + +def find_A(A, at=15): + if at == -1: + print(A) + exit(0) + while True: + if nums[at:] == compute(A)[at:]: + find_A(A, at-1) + A += 8**at +find_A(8**15) diff --git a/2024/18/18.py b/2024/18/18.py new file mode 100644 index 0000000..af63de8 --- /dev/null +++ b/2024/18/18.py @@ -0,0 +1,14 @@ +import networkx as nx +from bisect import bisect + +def solve(bad, S=70): + G = nx.grid_graph((S+1, S+1)) + G.remove_nodes_from(bad) + return nx.has_path(G, (0,0), (S,S)) \ + and nx.shortest_path_length(G, (0,0), (S,S)) + +bad = [tuple(map(int, line.split(","))) for line in open(0)] +print(solve(bad[:1024])) + +i = bisect(range(len(bad)), 0, key=lambda x: not solve(bad[:x])) +print(*bad[i-1], sep=",") diff --git a/2024/19/19.py b/2024/19/19.py new file mode 100644 index 0000000..353a36b --- /dev/null +++ b/2024/19/19.py @@ -0,0 +1,14 @@ +patterns, designs = open(0).read().split("\n\n") +patterns = patterns.split(", ") + +def arrangements(design): + dp = [1] + [0] * len(design) + for i in range(len(design)): + for pattern in patterns: + if design[i:].startswith(pattern): + dp[i+len(pattern)] += dp[i] + return dp[-1] + +p = [arrangements(d) for d in designs.split()] +print(sum(map(bool, p))) +print(sum(p)) diff --git a/2024/20/20.py b/2024/20/20.py new file mode 100644 index 0000000..3eec314 --- /dev/null +++ b/2024/20/20.py @@ -0,0 +1,22 @@ +import networkx as nx + +coords = {x+1j*y: c for y, r in enumerate(open(0)) for x, c in enumerate(r.strip())} + +G = nx.Graph() +for c in coords: + for d in [1, 1j, -1, -1j]: + if coords[c] != '#' != coords[c+d]: + G.add_edge(c, c+d) + +S = [c for c in coords if coords[c] in 'S'][0] +coord_to_dist = nx.shortest_path_length(G, S).items() + +s1 = s2 = 0 +for c1, dist1 in coord_to_dist: + for c2, dist2 in coord_to_dist: + diff = int(abs((c2-c1).real) + abs((c2-c1).imag)) + if dist2 - dist1 - diff >= 100: + s1 += diff <= 2 + s2 += diff <= 20 + +print(s1, s2, sep="\n") # use pypy instead of python diff --git a/2024/21/21.py b/2024/21/21.py new file mode 100644 index 0000000..93d2684 --- /dev/null +++ b/2024/21/21.py @@ -0,0 +1,28 @@ +from functools import cache + +N = {'7':0, '8':1, '9':2, '4':1j, '5':1+1j, '6':2+1j, + '1':2j, '2':1+2j, '3':2+2j, ' ':3j, '0':1+3j, 'A':2+3j} +R = {' ':0, '^':1, 'A':2, '<':1j, 'v':1+1j, '>':2+1j} + +@cache +def path(start, end): + pad = N if (start in N and end in N) else R + diff = pad[end] - pad[start] + dx, dy = int(diff.real), int(diff.imag) + yy = ("^"*-dy) + ("v"*dy) + xx = ("<"*-dx) + (">"*dx) + + bad = pad[" "] - pad[start] + prefer_yy_first = (dx>0 or bad==dx) and bad!=dy*1j + return (yy+xx if prefer_yy_first else xx+yy) + "A" + +@cache +def length(code, depth, s=0): + if depth == 0: return len(code) + for i, c in enumerate(code): + s += length(path(code[i-1], c), depth-1) + return s + +codes = open(0).read().split() +print(sum(int(code[:-1]) * length(code, 3) for code in codes)) +print(sum(int(code[:-1]) * length(code, 26) for code in codes)) diff --git a/2024/22/22.py b/2024/22/22.py new file mode 100644 index 0000000..148be74 --- /dev/null +++ b/2024/22/22.py @@ -0,0 +1,17 @@ +s1, s2 = 0, {} +for num in map(int, open(0)): + seen = set() + last4 = (10, 10, 10, 10) + for _ in range(2000): + prev = num%10 + num ^= num*64 % 16777216 + num ^= num//32 + num ^= num*2048 % 16777216 + last4 = last4[1:] + (num%10 - prev,) + if last4 not in seen: + seen.add(last4) + s2[last4] = s2.get(last4, 0) + num%10 + s1 += num + +print(s1) +print(max(s2.values())) diff --git a/2024/23/23.py b/2024/23/23.py new file mode 100644 index 0000000..685e56c --- /dev/null +++ b/2024/23/23.py @@ -0,0 +1,7 @@ +import networkx as nx + +G = nx.Graph(line.strip().split("-") for line in open(0)) +cliques = list(nx.enumerate_all_cliques(G)) + +print(sum(any(a[0]=='t' for a in c) for c in cliques if len(c) == 3)) +print(','.join(sorted(cliques[-1]))) diff --git a/2024/24/24.py b/2024/24/24.py new file mode 100644 index 0000000..a05b455 --- /dev/null +++ b/2024/24/24.py @@ -0,0 +1,212 @@ +from collections import * +from itertools import * +from functools import * +import numpy as np +import networkx as nx +from operator import * +import operator +import z3 +import re +import sys +sys.setrecursionlimit(1000000) + +s1 = s2 = 0 +# coords = {x+1j*y: c for y, r in enumerate(open(0)) for x, c in enumerate(r.strip())} + +# d4 = [1, 1j, -1, -1j] +# d8 = d4 + [1+1j, 1-1j, -1+1j, -1-1j] +# d4half = [i/2 for i in d4] +# d8half = [i/2 for i in d8] +# def adjacent(coord, dirs=d4): +# return [coord + d for d in dirs] + + + +initial, instructions = open(0).read().split("\n\n") +initial = initial.split("\n") +instructions = instructions.strip().splitlines() +instructions = [a.split() for a in instructions] +import random +# random.seed(42) + +def solve(modify=None): + states = {} + XX = [] + YY = [] + for line in sorted(initial): + a,b = line.split(":") + # b = "0" if a[0] == "x" else "1" + # b = "1" + if modify == "flip": + b = str(1-int(b)) + if modify == "one": + b = "1" + if modify == "random": + b = str(random.randint(0, 1)) + states[a] = int(b) + if line[0] == 'x': + XX.append(b.strip()) + if line[0] == 'y': + YY.append(b.strip()) + + XX = ''.join(XX[::-1]) + YY = ''.join(YY[::-1]) + X = int(XX, 2) + Y = int(YY, 2) + Z = bin(X + Y)[2:] + + to_op = { + "AND": and_, + "XOR": xor, + "OR": or_, + } + + target_to_op = defaultdict(list) + G = nx.DiGraph() + + prev_z = set() + for a, op, b, _, target in instructions: + if target in swap: + target = swap[target] + target_to_op[target].append((a,op,b)) + G.add_edge(a, target) + G.add_edge(b, target) + if target[0] == 'z': + prev_z |= {a,b} + + # G.add_edge(a, (a, op, b)) + # G.add_edge(b, (a, op, b)) + # G.add_edge((a, op, b), target) + # if a in states and b in states and target not in seen: + # assert target not in states + # states[target] = to_op[op](states[a], states[b]) + # print(target, len(seen)) + # seen.add(target) + + + + # "kth", "tgs", + + seen = set() + last = 0 + while len(seen) != len(instructions): + for a, op, b, _, target in instructions: + if target in swap: + target = swap[target] + if a in states and b in states and target not in states: + # assert target not in states + states[target] = to_op[op](states[a], states[b]) + # print(target, len(seen)) + seen.add(target) + if last == len(seen): + return list(range(46)) + last = len(seen) + + # print(states) + z = [] + for var, state in sorted(states.items()): + if var.startswith("z"): + # print(var, state) + z.append(str(int(state))) + + + #70364449079294 too high + Z_real = ''.join(z[::-1]) + ans = int(Z_real, 2) + # print(ans) + + + wrong = [] + for i, (z1, z2) in enumerate(zip(Z[::-1], Z_real[::-1])): + if z1 != z2: + # print(i) + wrong.append(i) + + + if True: + + xy = sorted({i.split(":")[0] for i in initial}, key=lambda x: 1000*int(x[1:])+ord(x[0])) + print(xy) + pos = nx.bfs_layout(G, xy) + print(pos) + + colors = [] + for node in G.nodes: + + if node in "fgt,fpq,nqk,pcp,srn,z07,z24,z32".split(","): + colors.append("red") + # G.nodes[node]["color"] = "red" + # G.nodes[node]["c"] = "red" + else: + colors.append("blue") + + for key, p in pos.items(): + if key[0] in "xyz": + p += np.array([0.001, 0]) + + if key in prev_z: + p -= np.array([0.001, 0]) + + print(len(colors)) + print(len(G.nodes)) + nx.draw_networkx(G, pos=pos, node_color=colors) + from matplotlib import pyplot as plt + plt.show() + exit(0) + return wrong + + # for line in open(0): + # n = [int(a) for a in line.split()] + # re.findall(r"\d+", line) + + + print(s1, s2, sep="\n") + + + + +nodes = set() +for a, op, b, _, target in instructions: + nodes |= {a, b, target} + +nodes = list(nodes) +for n in list(nodes): + if n[0] in 'xy': + nodes.remove(n) +# print(nodes) +best = [] +from tqdm import tqdm +for a,b in tqdm(list(combinations(nodes, r=2))): + # (0, 0, 0, 0, ('btq', 'jss')), + # (0, 0, 0, 0, ('nqk', 'jss')), + # (0, 0, 0, 0, ('nqk', 'z07')) + swap = { + "fpq": "z24", # GOOD + "srn": "z32", # PROBABLY + 'nqk': 'z07', # MAYBE + "pcp": "fgt", + # a: b, + # "nmq": "pcp", + # 'jnv': 'dpm', + } + swap = {} + ans = [] + + for a_,b_ in list(swap.items()): + ans.append(a) + ans.append(b) + swap[b_] = a_ + print(','.join(sorted(swap))) + s = solve() + s2 = solve("flip") + s3 = solve("one") + s4 = max([solve("random")] for _ in range(50)) + print(a,b, s, s2, s3, s4) + exit() + if len(s) > 10: continue + best.append((len(s), len(s2), len(s3), len(s4), (a,b))) + best.sort() + print(best[:10]) + +print(sorted(best)[:20]) + diff --git a/2024/25/25.py b/2024/25/25.py new file mode 100644 index 0000000..016f363 --- /dev/null +++ b/2024/25/25.py @@ -0,0 +1,9 @@ +occ = {".": [], "#": []} + +for schematic in open(0).read().split("\n\n"): + counts = tuple(c.count("#") for c in zip(*schematic.split())) + occ[schematic[0]].append(counts) + +print(sum(all(k+l<=7 for k,l in zip(key,lock)) + for key in occ['.'] + for lock in occ["#"])) diff --git a/AoCTiles/README.md b/AoCTiles/README.md index fc7021e..75681dd 100644 --- a/AoCTiles/README.md +++ b/AoCTiles/README.md @@ -1,55 +1,3 @@ # AoC Tiles -This script creates a graphic for each day for each year of the Advent of Code. -A tile is an image which represents both parts of a day, it looks like this: - -![AoC Tiles](examples/basic.png) - -It uses the personal [AoC Leaderboard](https://adventofcode.com/2021/leaderboard/self) to get the data for each day using your cookie. - -Set the `SHOW_CHECKMARK_INSTEAD_OF_TIME_RANK` flag to True to get this instead: - -![AoC Tiles Checkmark](examples/checkmarks.png) - -## Installation - -Feel free to use it, here is a short description of how to get it working: - -Copy this entire folder into your AoC repository. Then install the requirements. - -### Requirements - -Install at least Python 3.10 (because of the new typing union `|`, if you cannot do so you can -change the `type1 | type2` annotations to `Union[type1, type2]`). - -Install the requirements (`pillow` for creating images, `requests` for the leaderboard data and `pyyaml` to parse the language config): - -``` -pip install -r requirements.txt -``` - -### Configuration - -To use this script, you need to have a file named "session.cookie" in the same folder as this script. -It should contain a single line, the "session" cookie -when logged in to https://adventofcode.com. Just -paste it in there. - -Now add `` and `` in your README, everything between these 2 tags -will always be replaced by the script, so do not add additional information there. Note that these are HTML comments, -so they will not be visible in the rendered README. - -Your year/day script structure likely looks different. You can change the patterns for years and days in the -[create_aoc_tiles.py](create_aoc_tiles.py) file. - -The variables at the top of the script have comments to explain what they do. - -To try whether it works you can run the script directly: - -``` -python3 create_aoc_tiles.py -``` - -### Pre-commit hook - -Add [.pre-commit-config.yaml](/.pre-commit-config.yaml) to your repository and run `pre-commit install` to install the hook. +This script has moved to [LiquidFun/aoc_tiles](https://github.com/LiquidFun/aoc_tiles). It has been improved and can now easily be run as a pre-commit hook. See the link for more details. diff --git a/AoCTiles/create_aoc_tiles.py b/AoCTiles/create_aoc_tiles.py deleted file mode 100644 index 54c7c3f..0000000 --- a/AoCTiles/create_aoc_tiles.py +++ /dev/null @@ -1,393 +0,0 @@ -""" -Author: LiquidFun -Source: https://github.com/LiquidFun/adventofcode - -To use this script, you need to have a file named -"session.cookie" in the same folder as this script. - -It should contain a single line, the "session" cookie -when logged in to https://adventofcode.com. Just -paste it in there. - -Then install the requirements as listed in the requirements.txt: - pip install -r requirements.txt - -Then run the script: - python create_aoc_tiles.py -""" -import functools -import itertools -import math -from collections import namedtuple -from functools import cache -from pathlib import Path -import re - -import requests -from PIL import Image, ImageColor -import yaml -from PIL.ImageDraw import ImageDraw -from PIL import ImageFont - -# This results in the parent directory of the script directory, the year directories should be here -AOC_DIR = Path(__file__).absolute().parent.parent - -# The directory where the image files for the tiles are stored. This should be committed to git. -# Year directories are created in this directory, then each day is saved as 01.png, 02.png, etc. -IMAGE_DIR = AOC_DIR / "Media" - -# Path to the README file where the tiles should be added -README_PATH = AOC_DIR / "README.md" - -# Path to the README file where the tiles should be added -SESSION_COOKIE_PATH = AOC_DIR / "session.cookie" - -# Whether the graphic should be created for days that have not been completed yet. Note that missing days between -# completed days will still be created. -CREATE_ALL_DAYS = False - -# Instead of showing the time and rank you achieved this just shows whether -# it was completed with a checkmark -SHOW_CHECKMARK_INSTEAD_OF_TIME_RANK = False - -# The year and day pattern to detect directories. For example, if your day folders are -# called "day1" to "day25" then set the pattern to r"day\d{1,2}". The script extracts -# a number from the folder and tries to guess its day that way. -YEAR_PATTERN = r"\d{4}" -DAY_PATTERN = r"\d{2}" - - -# You can change this code entirely, or just change patterns above. You get more control if you change the code. -def get_solution_paths_dict_for_years() -> dict[int, dict[int, list[str]]]: - """Returns a dictionary which maps years to days to a list of solution paths, - - E.g.: {2022: {1: [Path("2022/01/01.py"), Path("2022/01/01.kt")], ...}} - - This functions gives you more control of which solutions should be shown in the tiles. For example, you - can filter by extension, or only show a single solution, or show tiles for days that have been completed - but do not have a solution. - - These can also be links to external solutions, e.g. if you want to show a solution from a different repository. - (Untested however) - - """ - solution_paths_dict: dict[int, dict[int, list[str]]] = {} - - # If you use a new repo for years you might just remove this if, and assign the year manually - for year_dir in sorted(get_paths_matching_regex(AOC_DIR, YEAR_PATTERN), reverse=True): - year = find_first_number(year_dir.name) - solution_paths_dict[year] = {} - # If you have a deep structure then you can adjust the year dir as well: - # year_dir = year_dir / "src/main/kotlin/com/example/aoc" - for day_dir in get_paths_matching_regex(year_dir, DAY_PATTERN): - day = find_first_number(day_dir.name) - solutions = sorted(find_recursive_solution_files(day_dir)) - - # To filter by extension: - # solutions = [s for s in solutions if s.suffix == ".py"] - - # To only show a single solution: - # solutions = [solutions[0]] - - # To show tiles for days that have been completed but do not have a solution: - # if len(solutions) == 0: - # solutions = [Path("dummy.kt")] - - solutions = [solution.relative_to(AOC_DIR) for solution in solutions] - - solution_paths_dict[year][day] = [str(s) for s in solutions] - return solution_paths_dict - - -# ====================================================== -# === The following likely do not need to be changed === -# ====================================================== - -# Color if a part is not completed -NOT_COMPLETED_COLOR = ImageColor.getrgb("#333333") - -# Width of each tile in the README.md. -# 161px is a rather specific number, with it exactly 5 tiles fit into a row. It is possible to go -# to 162px, however then 1080p displays show 4 tiles in a row, and phone displays show 1 tile -# instead of 2 in a row. Therefore, 161px is used here. -TILE_WIDTH_PX = "161px" - -# This results in the parent folder of the script file -AOC_TILES_SCRIPT_DIR = Path(__file__).absolute().parent - -# Cache path is a subfolder of the AOC folder, it includes the personal leaderboards for each year -CACHE_DIR = AOC_TILES_SCRIPT_DIR / ".aoc_tiles_cache" - -# Overrides day 24 part 2 and day 25 both parts to be unsolved -DEBUG = False - -# URL for the personal leaderboard (same for everyone) -PERSONAL_LEADERBOARD_URL = "https://adventofcode.com/{year}/leaderboard/self" - -# Location of yaml file where file extensions are mapped to colors -GITHUB_LANGUAGES_PATH = AOC_TILES_SCRIPT_DIR / "github_languages.yml" - - -@cache -def get_font(size: int, path: str): - return ImageFont.truetype(str(AOC_DIR / path), size) - - -# Fonts, note that the fonts sizes are specifically adjusted to the following fonts, if you change the fonts -# you might need to adjust the font sizes and text locations in the rest of the script. -main_font = functools.partial(get_font, path=AOC_TILES_SCRIPT_DIR / "fonts/PaytoneOne.ttf") -secondary_font = functools.partial(get_font, path=AOC_TILES_SCRIPT_DIR / "fonts/SourceCodePro-Regular.otf") - -DayScores = namedtuple("DayScores", ["time1", "rank1", "score1", "time2", "rank2", "score2"], defaults=[None] * 3) - - -def get_extension_to_colors(): - extension_to_color = {} - with open(GITHUB_LANGUAGES_PATH) as file: - github_languages = yaml.load(file, Loader=yaml.FullLoader) - for language, data in github_languages.items(): - if "color" in data and "extensions" in data and data["type"] == "programming": - for extension in data["extensions"]: - extension_to_color[extension.lower()] = data["color"] - return extension_to_color - - -extension_to_color: dict[str, str] = get_extension_to_colors() - - -def get_paths_matching_regex(path: Path, pattern: str): - return sorted([p for p in path.iterdir() if re.fullmatch(pattern, p.name)]) - - -def find_recursive_solution_files(directory: Path) -> list[Path]: - solution_paths = [] - for path in directory.rglob('*'): - if path.is_file() and path.suffix in extension_to_color: - solution_paths.append(path) - return solution_paths - - -def parse_leaderboard(leaderboard_path: Path) -> dict[int, DayScores]: - no_stars = "You haven't collected any stars... yet." - start = ' *Time *Rank *Score\n' - end = "" - with open(leaderboard_path) as file: - html = file.read() - if no_stars in html: - return {} - matches = re.findall(rf"{start}(.*?){end}", html, re.DOTALL | re.MULTILINE) - assert len(matches) == 1, f"Found {'no' if len(matches) == 0 else 'more than one'} leaderboard?!" - table_rows = matches[0].strip().split("\n") - leaderboard = {} - for line in table_rows: - day, *scores = re.split(r"\s+", line.strip()) - # replace "-" with None to be able to handle the data later, like if no score existed for the day - scores = [s if s != "-" else None for s in scores] - assert len(scores) in ( - 3, 6), f"Number scores for {day=} ({scores}) are not 3 or 6." - leaderboard[int(day)] = DayScores(*scores) - return leaderboard - - -def request_leaderboard(year: int) -> dict[int, DayScores]: - leaderboard_path = CACHE_DIR / f"leaderboard{year}.html" - if leaderboard_path.exists(): - leaderboard = parse_leaderboard(leaderboard_path) - has_no_none_values = all(itertools.chain(map(list, leaderboard.values()))) - if has_no_none_values: - return leaderboard - with open(SESSION_COOKIE_PATH) as cookie_file: - session_cookie = cookie_file.read().strip() - data = requests.get(PERSONAL_LEADERBOARD_URL.format(year=year), cookies={"session": session_cookie}).text - leaderboard_path.parent.mkdir(exist_ok=True, parents=True) - with open(leaderboard_path, "w") as file: - file.write(data) - return parse_leaderboard(leaderboard_path) - - -class HTMLTag: - def __init__(self, parent: "HTML", tag: str, closing: bool = True, **kwargs): - self.parent = parent - self.tag = tag - self.closing = closing - self.kwargs = kwargs - attributes = "".join(f' {k}="{v}"' for k, v in self.kwargs.items()) - self.parent.push(f"<{self.tag}{attributes}>", depth=self.closing) - - def __enter__(self): - pass - - def __exit__(self, *args): - if self.closing: - self.parent.push(f"", depth=-self.closing) - - -class HTML: - tags: list[str] = [] - depth = 0 - - def push(self, tag: str, depth=0): - if depth < 0: - self.depth += depth - self.tags.append(" " * self.depth + tag) - if depth > 0: - self.depth += depth - - def tag(self, tag: str, closing: bool = True, **kwargs): - return HTMLTag(self, tag, closing, **kwargs) - - def __str__(self): - return "\n".join(self.tags) - - -def darker_color(c: tuple[int, int, int, int]) -> tuple[int, int, int, int]: - return c[0] - 10, c[1] - 10, c[2] - 10, 255 - - -def get_alternating_background(languages, both_parts_completed=True, *, stripe_width=20): - colors = [ImageColor.getrgb(extension_to_color[language]) for language in languages] - if len(colors) == 1: - colors.append(darker_color(colors[0])) - image = Image.new("RGB", (200, 100), NOT_COMPLETED_COLOR) - - def fill_with_colors(colors, fill_only_half): - for x in range(image.width): - for y in range(image.height): - if fill_only_half and x / image.width + y / image.height > 1: - continue - image.load()[x, y] = colors[((x + y) // stripe_width) % len(colors)] - - fill_with_colors([NOT_COMPLETED_COLOR, darker_color(NOT_COMPLETED_COLOR)], False) - if colors: - fill_with_colors(colors, not both_parts_completed) - return image - - -def format_time(time: str) -> str: - """Formats time as mm:ss if the time is below 1 hour, otherwise it returns >1h to a max of >24h""" - time = time.replace(">", ">") - if ">" in time: - formatted = time - else: - h, m, s = time.split(":") - formatted = f">{h}h" if int(h) >= 1 else f"{m:02}:{s:02}" - return f"{formatted:>5}" - - -def draw_star(drawer: ImageDraw, at: tuple[int, int], size=9, color="#ffff0022", num_points=5): - """Draws a star at the given position""" - diff = math.pi * 2 / num_points / 2 - points: list[tuple[float, float]] = [] - for angle in [diff * i - math.pi / 2 for i in range(num_points * 2)]: - factor = size if len(points) % 2 == 0 else size * 0.4 - points.append((at[0] + math.cos(angle) * factor, at[1] + math.sin(angle) * factor)) - drawer.polygon(points, fill=color) - - -def generate_day_tile_image(day: str, year: str, languages: list[str], day_scores: DayScores | None) -> Path: - """Saves a graphic for a given day and year. Returns the path to it.""" - image = get_alternating_background(languages, not (day_scores is None or day_scores.time2 is None)) - drawer = ImageDraw(image) - font_color = "white" - - # === Left side === - drawer.text((3, -5), "Day", fill=font_color, align="left", font=main_font(20)) - drawer.text((1, -10), str(day), fill=font_color, align="center", font=main_font(75)) - # Calculate font size based on number of characters, because it might overflow - lang_as_str = " ".join(languages) - lang_font_size = max(6, int(18 - max(0, len(lang_as_str) - 8) * 1.3)) - drawer.text((0, 74), lang_as_str, fill=font_color, align="left", font=secondary_font(lang_font_size)) - - # === Right side (P1 & P2) === - for part in (1, 2): - y = 50 if part == 2 else 0 - time, rank = getattr(day_scores, f"time{part}", None), getattr(day_scores, f"rank{part}", None) - if day_scores is not None and time is not None: - drawer.text((104, -5 + y), f"P{part} ", fill=font_color, align="left", font=main_font(25)) - if SHOW_CHECKMARK_INSTEAD_OF_TIME_RANK: - drawer.line((160, 35 + y, 150, 25 + y), fill=font_color, width=2) - drawer.line((160, 35 + y, 180, 15 + y), fill=font_color, width=2) - continue - drawer.text((105, 25 + y), "time", fill=font_color, align="right", font=secondary_font(10)) - drawer.text((105, 35 + y), "rank", fill=font_color, align="right", font=secondary_font(10)) - drawer.text((143, 3 + y), format_time(time), fill=font_color, align="right", font=secondary_font(18)) - drawer.text((133, 23 + y), f"{rank:>6}", fill=font_color, align="right", font=secondary_font(18)) - else: - drawer.line((140, 15 + y, 160, 35 + y), fill=font_color, width=2) - drawer.line((140, 35 + y, 160, 15 + y), fill=font_color, width=2) - - if day_scores is None: - drawer.line((15, 85, 85, 85), fill=font_color, width=2) - - # === Divider lines === - drawer.line((100, 5, 100, 95), fill=font_color, width=1) - drawer.line((105, 50, 195, 50), fill=font_color, width=1) - - path = IMAGE_DIR / f"{year}/{day}.png" - path.parent.mkdir(parents=True, exist_ok=True) - image.save(path) - return path - - -def handle_day(day: int, year: int, solutions: list[str], html: HTML, day_scores: DayScores | None): - languages = [] - for solution in solutions: - extension = "." + solution.split(".")[-1] - if extension in extension_to_color and extension not in languages: - languages.append(extension) - solution_link = solutions[0] if solutions else None - if DEBUG: - if day == 25: - languages = [] - day_graphic_path = generate_day_tile_image(f"{day:02}", f"{year:04}", languages, day_scores) - day_graphic_path = day_graphic_path.relative_to(AOC_DIR) - with html.tag("a", href=str(solution_link)): - html.tag("img", closing=False, src=str(day_graphic_path), width=TILE_WIDTH_PX) - - -def find_first_number(string: str) -> int: - return int(re.findall(r"\d+", string)[0]) - - -def fill_empty_days_in_dict(day_to_solutions: dict[int, list[str]], max_day) -> None: - if not CREATE_ALL_DAYS and len(day_to_solutions) == 0: - print(f"Current year has no solutions!") - for day in range(1, max_day + 1): - if day not in day_to_solutions: - day_to_solutions[day] = [] - - -def handle_year(year: int, day_to_solutions: dict[int, list[str]]): - leaderboard = request_leaderboard(year) - if DEBUG: - leaderboard[25] = None - leaderboard[24] = DayScores("22:22:22", "12313", "0") - day_to_solutions[23] = [] - html = HTML() - with html.tag("h1", align="center"): - stars = sum((ds.time1 is not None) + (ds.time2 is not None) for ds in leaderboard.values() if ds is not None) - html.push(f"{year} - {stars} ⭐") - max_day = 25 if CREATE_ALL_DAYS else max(*day_to_solutions, *leaderboard) - fill_empty_days_in_dict(day_to_solutions, max_day) - for day, solutions in day_to_solutions.items(): - handle_day(day, year, solutions, html, leaderboard.get(day, None)) - - with open(README_PATH, "r") as file: - text = file.read() - begin = "" - end = "" - pattern = re.compile(rf"{begin}.*{end}", re.DOTALL | re.MULTILINE) - new_text = pattern.sub(f"{begin}\n{html}\n{end}", text) - - with open(README_PATH, "w") as file: - file.write(str(new_text)) - - -def main(): - for year, day_to_solutions_list in get_solution_paths_dict_for_years().items(): - print(f"=== Generating table for year {year} ===") - handle_year(year, day_to_solutions_list) - - -if __name__ == "__main__": - main() diff --git a/AoCTiles/examples/checkmarks.png b/AoCTiles/examples/checkmarks.png deleted file mode 100644 index 04d077a..0000000 Binary files a/AoCTiles/examples/checkmarks.png and /dev/null differ diff --git a/AoCTiles/fonts/PaytoneOne.ttf b/AoCTiles/fonts/PaytoneOne.ttf deleted file mode 100644 index 5cb0bbb..0000000 Binary files a/AoCTiles/fonts/PaytoneOne.ttf and /dev/null differ diff --git a/AoCTiles/fonts/SourceCodePro-Regular.otf b/AoCTiles/fonts/SourceCodePro-Regular.otf deleted file mode 100644 index f32e6bd..0000000 Binary files a/AoCTiles/fonts/SourceCodePro-Regular.otf and /dev/null differ diff --git a/AoCTiles/github_languages.yml b/AoCTiles/github_languages.yml deleted file mode 100644 index 3a41c5a..0000000 --- a/AoCTiles/github_languages.yml +++ /dev/null @@ -1,7981 +0,0 @@ -# SOURCE: https://raw.githubusercontent.com/github/linguist/master/lib/linguist/languages.yml - -# Defines all Languages known to GitHub. -# -# fs_name - Optional field. Only necessary as a replacement for the sample directory name if the -# language name is not a valid filename under the Windows filesystem (e.g., if it -# contains an asterisk). -# type - Either data, programming, markup, prose, or nil -# aliases - An Array of additional aliases (implicitly -# includes name.downcase) -# ace_mode - A String name of the Ace Mode used for highlighting whenever -# a file is edited. This must match one of the filenames in http://git.io/3XO_Cg. -# Use "text" if a mode does not exist. -# codemirror_mode - A String name of the CodeMirror Mode used for highlighting whenever a file is edited. -# This must match a mode from https://git.io/vi9Fx -# codemirror_mime_type - A String name of the file mime type used for highlighting whenever a file is edited. -# This should match the `mime` associated with the mode from https://git.io/f4SoQ -# wrap - Boolean wrap to enable line wrapping (default: false) -# extensions - An Array of associated extensions (the first one is -# considered the primary extension, the others should be -# listed alphabetically) -# filenames - An Array of filenames commonly associated with the language -# interpreters - An Array of associated interpreters -# language_id - Integer used as a language-name-independent indexed field so that we can rename -# languages in Linguist without reindexing all the code on GitHub. Must not be -# changed for existing languages without the explicit permission of GitHub staff. -# color - CSS hex color to represent the language. Only used if type is "programming" or "markup". -# tm_scope - The TextMate scope that represents this programming -# language. This should match one of the scopes listed in -# the grammars.yml file. Use "none" if there is no grammar -# for this language. -# group - Name of the parent language. Languages in a group are counted -# in the statistics as the parent language. -# -# Any additions or modifications (even trivial) should have corresponding -# test changes in `test/test_blob.rb`. -# -# Please keep this list alphabetized. Capitalization comes before lowercase. ---- -1C Enterprise: - type: programming - color: "#814CCC" - extensions: - - ".bsl" - - ".os" - tm_scope: source.bsl - ace_mode: text - language_id: 0 -2-Dimensional Array: - type: data - color: "#38761D" - extensions: - - ".2da" - tm_scope: source.2da - ace_mode: text - language_id: 387204628 -4D: - type: programming - color: "#004289" - extensions: - - ".4dm" - tm_scope: source.4dm - ace_mode: text - language_id: 577529595 -ABAP: - type: programming - color: "#E8274B" - extensions: - - ".abap" - tm_scope: source.abap - ace_mode: abap - language_id: 1 -ABAP CDS: - type: programming - color: "#555e25" - extensions: - - ".asddls" - tm_scope: source.abapcds - language_id: 452681853 - ace_mode: text -ABNF: - type: data - ace_mode: text - extensions: - - ".abnf" - tm_scope: source.abnf - language_id: 429 -AGS Script: - type: programming - color: "#B9D9FF" - aliases: - - ags - extensions: - - ".asc" - - ".ash" - tm_scope: source.c++ - ace_mode: c_cpp - codemirror_mode: clike - codemirror_mime_type: text/x-c++src - language_id: 2 -AIDL: - type: programming - color: "#34EB6B" - tm_scope: source.aidl - extensions: - - ".aidl" - ace_mode: text - interpreters: - - aidl - language_id: 451700185 -AL: - type: programming - color: "#3AA2B5" - extensions: - - ".al" - tm_scope: source.al - ace_mode: text - language_id: 658971832 -AMPL: - type: programming - color: "#E6EFBB" - extensions: - - ".ampl" - - ".mod" - tm_scope: source.ampl - ace_mode: text - language_id: 3 -ANTLR: - type: programming - color: "#9DC3FF" - extensions: - - ".g4" - tm_scope: source.antlr - ace_mode: text - language_id: 4 -API Blueprint: - type: markup - color: "#2ACCA8" - ace_mode: markdown - extensions: - - ".apib" - tm_scope: text.html.markdown.source.gfm.apib - language_id: 5 -APL: - type: programming - color: "#5A8164" - extensions: - - ".apl" - - ".dyalog" - interpreters: - - apl - - aplx - - dyalog - tm_scope: source.apl - ace_mode: text - codemirror_mode: apl - codemirror_mime_type: text/apl - language_id: 6 -ASL: - type: programming - ace_mode: text - extensions: - - ".asl" - - ".dsl" - tm_scope: source.asl - language_id: 124996147 -ASN.1: - type: data - extensions: - - ".asn" - - ".asn1" - tm_scope: source.asn - ace_mode: text - codemirror_mode: asn.1 - codemirror_mime_type: text/x-ttcn-asn - language_id: 7 -ASP.NET: - type: programming - tm_scope: text.html.asp - color: "#9400ff" - aliases: - - aspx - - aspx-vb - extensions: - - ".asax" - - ".ascx" - - ".ashx" - - ".asmx" - - ".aspx" - - ".axd" - ace_mode: text - codemirror_mode: htmlembedded - codemirror_mime_type: application/x-aspx - language_id: 564186416 -ATS: - type: programming - color: "#1ac620" - aliases: - - ats2 - extensions: - - ".dats" - - ".hats" - - ".sats" - tm_scope: source.ats - ace_mode: ocaml - language_id: 9 -ActionScript: - type: programming - tm_scope: source.actionscript.3 - color: "#882B0F" - aliases: - - actionscript 3 - - actionscript3 - - as3 - extensions: - - ".as" - ace_mode: actionscript - language_id: 10 -Ada: - type: programming - color: "#02f88c" - extensions: - - ".adb" - - ".ada" - - ".ads" - aliases: - - ada95 - - ada2005 - tm_scope: source.ada - ace_mode: ada - language_id: 11 -Adblock Filter List: - type: data - color: "#800000" - ace_mode: text - extensions: - - ".txt" - aliases: - - ad block filters - - ad block - - adb - - adblock - tm_scope: text.adblock - language_id: 884614762 -Adobe Font Metrics: - type: data - color: "#fa0f00" - tm_scope: source.afm - extensions: - - ".afm" - aliases: - - acfm - - adobe composite font metrics - - adobe multiple font metrics - - amfm - ace_mode: text - language_id: 147198098 -Agda: - type: programming - color: "#315665" - extensions: - - ".agda" - tm_scope: source.agda - ace_mode: text - language_id: 12 -Alloy: - type: programming - color: "#64C800" - extensions: - - ".als" - tm_scope: source.alloy - ace_mode: text - language_id: 13 -Alpine Abuild: - type: programming - color: "#0D597F" - group: Shell - aliases: - - abuild - - apkbuild - filenames: - - APKBUILD - tm_scope: source.shell - ace_mode: sh - codemirror_mode: shell - codemirror_mime_type: text/x-sh - language_id: 14 -Altium Designer: - type: data - color: "#A89663" - aliases: - - altium - extensions: - - ".OutJob" - - ".PcbDoc" - - ".PrjPCB" - - ".SchDoc" - tm_scope: source.ini - ace_mode: ini - language_id: 187772328 -AngelScript: - type: programming - color: "#C7D7DC" - extensions: - - ".as" - - ".angelscript" - tm_scope: source.angelscript - ace_mode: text - codemirror_mode: clike - codemirror_mime_type: text/x-c++src - language_id: 389477596 -Ant Build System: - type: data - color: "#A9157E" - tm_scope: text.xml.ant - filenames: - - ant.xml - - build.xml - ace_mode: xml - codemirror_mode: xml - codemirror_mime_type: application/xml - language_id: 15 -Antlers: - type: markup - color: "#ff269e" - extensions: - - ".antlers.html" - - ".antlers.php" - - ".antlers.xml" - tm_scope: text.html.statamic - ace_mode: text - language_id: 1067292663 -ApacheConf: - type: data - color: "#d12127" - aliases: - - aconf - - apache - extensions: - - ".apacheconf" - - ".vhost" - filenames: - - ".htaccess" - - apache2.conf - - httpd.conf - tm_scope: source.apache-config - ace_mode: apache_conf - language_id: 16 -Apex: - type: programming - color: "#1797c0" - extensions: - - ".cls" - tm_scope: source.java - ace_mode: java - codemirror_mode: clike - codemirror_mime_type: text/x-java - language_id: 17 -Apollo Guidance Computer: - type: programming - color: "#0B3D91" - group: Assembly - extensions: - - ".agc" - tm_scope: source.agc - ace_mode: assembly_x86 - language_id: 18 -AppleScript: - type: programming - aliases: - - osascript - extensions: - - ".applescript" - - ".scpt" - interpreters: - - osascript - tm_scope: source.applescript - ace_mode: applescript - color: "#101F1F" - language_id: 19 -Arc: - type: programming - color: "#aa2afe" - extensions: - - ".arc" - tm_scope: none - ace_mode: text - language_id: 20 -AsciiDoc: - type: prose - color: "#73a0c5" - ace_mode: asciidoc - wrap: true - extensions: - - ".asciidoc" - - ".adoc" - - ".asc" - tm_scope: text.html.asciidoc - language_id: 22 -AspectJ: - type: programming - color: "#a957b0" - extensions: - - ".aj" - tm_scope: source.aspectj - ace_mode: text - language_id: 23 -Assembly: - type: programming - color: "#6E4C13" - aliases: - - asm - - nasm - extensions: - - ".asm" - - ".a51" - - ".i" - - ".inc" - - ".nas" - - ".nasm" - tm_scope: source.assembly - ace_mode: assembly_x86 - language_id: 24 -Astro: - type: markup - color: "#ff5a03" - extensions: - - ".astro" - tm_scope: source.astro - ace_mode: html - codemirror_mode: jsx - codemirror_mime_type: text/jsx - language_id: 578209015 -Asymptote: - type: programming - color: "#ff0000" - extensions: - - ".asy" - interpreters: - - asy - tm_scope: source.c++ - ace_mode: c_cpp - codemirror_mode: clike - codemirror_mime_type: text/x-kotlin - language_id: 591605007 -Augeas: - type: programming - color: "#9CC134" - extensions: - - ".aug" - tm_scope: none - ace_mode: text - language_id: 25 -AutoHotkey: - type: programming - color: "#6594b9" - aliases: - - ahk - extensions: - - ".ahk" - - ".ahkl" - tm_scope: source.ahk - ace_mode: autohotkey - language_id: 26 -AutoIt: - type: programming - color: "#1C3552" - aliases: - - au3 - - AutoIt3 - - AutoItScript - extensions: - - ".au3" - tm_scope: source.autoit - ace_mode: autohotkey - language_id: 27 -Avro IDL: - type: data - color: "#0040FF" - extensions: - - ".avdl" - tm_scope: source.avro - ace_mode: text - language_id: 785497837 -Awk: - type: programming - color: "#c30e9b" - extensions: - - ".awk" - - ".auk" - - ".gawk" - - ".mawk" - - ".nawk" - interpreters: - - awk - - gawk - - mawk - - nawk - tm_scope: source.awk - ace_mode: text - language_id: 28 -BASIC: - type: programming - extensions: - - ".bas" - tm_scope: source.basic - ace_mode: text - color: "#ff0000" - language_id: 28923963 -Ballerina: - type: programming - extensions: - - ".bal" - tm_scope: source.ballerina - ace_mode: text - color: "#FF5000" - language_id: 720859680 -Batchfile: - type: programming - aliases: - - bat - - batch - - dosbatch - - winbatch - extensions: - - ".bat" - - ".cmd" - tm_scope: source.batchfile - ace_mode: batchfile - color: "#C1F12E" - language_id: 29 -Beef: - type: programming - color: "#a52f4e" - extensions: - - ".bf" - tm_scope: source.cs - ace_mode: csharp - codemirror_mode: clike - codemirror_mime_type: text/x-csharp - language_id: 545626333 -Befunge: - type: programming - extensions: - - ".befunge" - - ".bf" - tm_scope: source.befunge - ace_mode: text - language_id: 30 -Berry: - type: programming - extensions: - - ".be" - tm_scope: source.berry - ace_mode: text - color: "#15A13C" - aliases: - - be - language_id: 121855308 -BibTeX: - type: markup - color: "#778899" - group: TeX - extensions: - - ".bib" - - ".bibtex" - tm_scope: text.bibtex - ace_mode: tex - codemirror_mode: stex - codemirror_mime_type: text/x-stex - language_id: 982188347 -Bicep: - type: programming - color: "#519aba" - extensions: - - ".bicep" - tm_scope: source.bicep - ace_mode: text - language_id: 321200902 -Bikeshed: - type: markup - color: "#5562ac" - extensions: - - ".bs" - tm_scope: source.csswg - ace_mode: html - codemirror_mode: htmlmixed - codemirror_mime_type: text/html - language_id: 1055528081 -Bison: - type: programming - color: "#6A463F" - group: Yacc - tm_scope: source.yacc - extensions: - - ".bison" - ace_mode: text - language_id: 31 -BitBake: - type: programming - color: "#00bce4" - tm_scope: none - extensions: - - ".bb" - ace_mode: text - language_id: 32 -Blade: - type: markup - color: "#f7523f" - extensions: - - ".blade" - - ".blade.php" - tm_scope: text.html.php.blade - ace_mode: text - language_id: 33 -BlitzBasic: - type: programming - color: "#00FFAE" - aliases: - - b3d - - blitz3d - - blitzplus - - bplus - extensions: - - ".bb" - - ".decls" - tm_scope: source.blitzmax - ace_mode: text - language_id: 34 -BlitzMax: - type: programming - color: "#cd6400" - extensions: - - ".bmx" - aliases: - - bmax - tm_scope: source.blitzmax - ace_mode: text - language_id: 35 -Bluespec: - type: programming - color: "#12223c" - extensions: - - ".bsv" - tm_scope: source.bsv - ace_mode: verilog - language_id: 36 -Boo: - type: programming - color: "#d4bec1" - extensions: - - ".boo" - ace_mode: text - tm_scope: source.boo - language_id: 37 -Boogie: - type: programming - color: "#c80fa0" - extensions: - - ".bpl" - interpreters: - - boogie - tm_scope: source.boogie - ace_mode: text - language_id: 955017407 -Brainfuck: - type: programming - color: "#2F2530" - extensions: - - ".b" - - ".bf" - tm_scope: source.bf - ace_mode: text - codemirror_mode: brainfuck - codemirror_mime_type: text/x-brainfuck - language_id: 38 -BrighterScript: - type: programming - color: "#66AABB" - extensions: - - ".bs" - tm_scope: source.brs - ace_mode: text - language_id: 943571030 -Brightscript: - type: programming - color: "#662D91" - extensions: - - ".brs" - tm_scope: source.brs - ace_mode: text - language_id: 39 -Browserslist: - type: data - color: "#ffd539" - filenames: - - ".browserslistrc" - - browserslist - tm_scope: text.browserslist - ace_mode: text - language_id: 153503348 -C: - type: programming - color: "#555555" - extensions: - - ".c" - - ".cats" - - ".h" - - ".idc" - interpreters: - - tcc - tm_scope: source.c - ace_mode: c_cpp - codemirror_mode: clike - codemirror_mime_type: text/x-csrc - language_id: 41 -C#: - type: programming - ace_mode: csharp - codemirror_mode: clike - codemirror_mime_type: text/x-csharp - tm_scope: source.cs - color: "#178600" - aliases: - - csharp - - cake - - cakescript - extensions: - - ".cs" - - ".cake" - - ".csx" - - ".linq" - language_id: 42 -C++: - type: programming - tm_scope: source.c++ - ace_mode: c_cpp - codemirror_mode: clike - codemirror_mime_type: text/x-c++src - color: "#f34b7d" - aliases: - - cpp - extensions: - - ".cpp" - - ".c++" - - ".cc" - - ".cp" - - ".cxx" - - ".h" - - ".h++" - - ".hh" - - ".hpp" - - ".hxx" - - ".inc" - - ".inl" - - ".ino" - - ".ipp" - - ".ixx" - - ".re" - - ".tcc" - - ".tpp" - language_id: 43 -C-ObjDump: - type: data - extensions: - - ".c-objdump" - tm_scope: objdump.x86asm - ace_mode: assembly_x86 - language_id: 44 -C2hs Haskell: - type: programming - group: Haskell - aliases: - - c2hs - extensions: - - ".chs" - tm_scope: source.haskell - ace_mode: haskell - codemirror_mode: haskell - codemirror_mime_type: text/x-haskell - language_id: 45 -CAP CDS: - type: programming - tm_scope: source.cds - color: "#0092d1" - aliases: - - cds - extensions: - - ".cds" - ace_mode: text - language_id: 390788699 -CIL: - type: data - tm_scope: source.cil - extensions: - - ".cil" - ace_mode: text - language_id: 29176339 -CLIPS: - type: programming - color: "#00A300" - extensions: - - ".clp" - tm_scope: source.clips - ace_mode: text - language_id: 46 -CMake: - type: programming - color: "#DA3434" - extensions: - - ".cmake" - - ".cmake.in" - filenames: - - CMakeLists.txt - tm_scope: source.cmake - ace_mode: text - codemirror_mode: cmake - codemirror_mime_type: text/x-cmake - language_id: 47 -COBOL: - type: programming - extensions: - - ".cob" - - ".cbl" - - ".ccp" - - ".cobol" - - ".cpy" - tm_scope: source.cobol - ace_mode: cobol - codemirror_mode: cobol - codemirror_mime_type: text/x-cobol - language_id: 48 -CODEOWNERS: - type: data - filenames: - - CODEOWNERS - tm_scope: text.codeowners - ace_mode: gitignore - language_id: 321684729 -COLLADA: - type: data - color: "#F1A42B" - extensions: - - ".dae" - tm_scope: text.xml - ace_mode: xml - codemirror_mode: xml - codemirror_mime_type: text/xml - language_id: 49 -CSON: - type: data - color: "#244776" - tm_scope: source.coffee - ace_mode: coffee - codemirror_mode: coffeescript - codemirror_mime_type: text/x-coffeescript - extensions: - - ".cson" - language_id: 424 -CSS: - type: markup - tm_scope: source.css - ace_mode: css - codemirror_mode: css - codemirror_mime_type: text/css - color: "#563d7c" - extensions: - - ".css" - language_id: 50 -CSV: - type: data - color: "#237346" - ace_mode: text - tm_scope: none - extensions: - - ".csv" - language_id: 51 -CUE: - type: programming - extensions: - - ".cue" - tm_scope: source.cue - ace_mode: text - color: "#5886E1" - language_id: 356063509 -CWeb: - type: programming - color: "#00007a" - extensions: - - ".w" - tm_scope: none - ace_mode: text - language_id: 657332628 -Cabal Config: - type: data - color: "#483465" - aliases: - - Cabal - extensions: - - ".cabal" - filenames: - - cabal.config - - cabal.project - ace_mode: haskell - codemirror_mode: haskell - codemirror_mime_type: text/x-haskell - tm_scope: source.cabal - language_id: 677095381 -Cadence: - type: programming - color: "#00ef8b" - ace_mode: text - tm_scope: source.cadence - extensions: - - ".cdc" - language_id: 270184138 -Cairo: - type: programming - color: "#ff4a48" - ace_mode: text - tm_scope: source.cairo - extensions: - - ".cairo" - language_id: 620599567 -CameLIGO: - type: programming - color: "#3be133" - extensions: - - ".mligo" - tm_scope: source.mligo - ace_mode: ocaml - codemirror_mode: mllike - codemirror_mime_type: text/x-ocaml - group: LigoLANG - language_id: 829207807 -Cap'n Proto: - type: programming - color: "#c42727" - tm_scope: source.capnp - extensions: - - ".capnp" - ace_mode: text - language_id: 52 -CartoCSS: - type: programming - aliases: - - Carto - extensions: - - ".mss" - ace_mode: text - tm_scope: source.css.mss - language_id: 53 -Ceylon: - type: programming - color: "#dfa535" - extensions: - - ".ceylon" - tm_scope: source.ceylon - ace_mode: text - language_id: 54 -Chapel: - type: programming - color: "#8dc63f" - aliases: - - chpl - extensions: - - ".chpl" - tm_scope: source.chapel - ace_mode: text - language_id: 55 -Charity: - type: programming - extensions: - - ".ch" - tm_scope: none - ace_mode: text - language_id: 56 -Checksums: - type: data - tm_scope: text.checksums - aliases: - - checksum - - hash - - hashes - - sum - - sums - filenames: - - MD5SUMS - - SHA1SUMS - - SHA256SUMS - - SHA256SUMS.txt - - SHA512SUMS - - checksums.txt - - cksums - - md5sum.txt - extensions: - - ".crc32" - - ".md2" - - ".md4" - - ".md5" - - ".sha1" - - ".sha2" - - ".sha224" - - ".sha256" - - ".sha256sum" - - ".sha3" - - ".sha384" - - ".sha512" - ace_mode: text - language_id: 372063053 -ChucK: - type: programming - color: "#3f8000" - extensions: - - ".ck" - tm_scope: source.java - ace_mode: java - codemirror_mode: clike - codemirror_mime_type: text/x-java - language_id: 57 -Cirru: - type: programming - color: "#ccccff" - tm_scope: source.cirru - ace_mode: cirru - extensions: - - ".cirru" - language_id: 58 -Clarion: - type: programming - color: "#db901e" - ace_mode: text - extensions: - - ".clw" - tm_scope: source.clarion - language_id: 59 -Clarity: - type: programming - color: "#5546ff" - ace_mode: lisp - extensions: - - ".clar" - tm_scope: source.clar - language_id: 91493841 -Classic ASP: - type: programming - color: "#6a40fd" - tm_scope: text.html.asp - aliases: - - asp - extensions: - - ".asp" - ace_mode: text - language_id: 8 -Clean: - type: programming - color: "#3F85AF" - extensions: - - ".icl" - - ".dcl" - tm_scope: source.clean - ace_mode: text - language_id: 60 -Click: - type: programming - color: "#E4E6F3" - extensions: - - ".click" - tm_scope: source.click - ace_mode: text - language_id: 61 -Clojure: - type: programming - tm_scope: source.clojure - ace_mode: clojure - codemirror_mode: clojure - codemirror_mime_type: text/x-clojure - color: "#db5855" - extensions: - - ".clj" - - ".bb" - - ".boot" - - ".cl2" - - ".cljc" - - ".cljs" - - ".cljs.hl" - - ".cljscm" - - ".cljx" - - ".hic" - filenames: - - riemann.config - interpreters: - - bb - language_id: 62 -Closure Templates: - type: markup - color: "#0d948f" - ace_mode: soy_template - codemirror_mode: soy - codemirror_mime_type: text/x-soy - aliases: - - soy - extensions: - - ".soy" - tm_scope: text.html.soy - language_id: 357046146 -Cloud Firestore Security Rules: - type: data - color: "#FFA000" - ace_mode: less - codemirror_mode: css - codemirror_mime_type: text/css - tm_scope: source.firestore - filenames: - - firestore.rules - language_id: 407996372 -CoNLL-U: - type: data - extensions: - - ".conllu" - - ".conll" - tm_scope: text.conllu - ace_mode: text - aliases: - - CoNLL - - CoNLL-X - language_id: 421026389 -CodeQL: - type: programming - color: "#140f46" - extensions: - - ".ql" - - ".qll" - tm_scope: source.ql - ace_mode: text - language_id: 424259634 - aliases: - - ql -CoffeeScript: - type: programming - tm_scope: source.coffee - ace_mode: coffee - codemirror_mode: coffeescript - codemirror_mime_type: text/x-coffeescript - color: "#244776" - aliases: - - coffee - - coffee-script - extensions: - - ".coffee" - - "._coffee" - - ".cake" - - ".cjsx" - - ".iced" - filenames: - - Cakefile - interpreters: - - coffee - language_id: 63 -ColdFusion: - type: programming - ace_mode: coldfusion - color: "#ed2cd6" - aliases: - - cfm - - cfml - - coldfusion html - extensions: - - ".cfm" - - ".cfml" - tm_scope: text.html.cfm - language_id: 64 -ColdFusion CFC: - type: programming - color: "#ed2cd6" - group: ColdFusion - ace_mode: coldfusion - aliases: - - cfc - extensions: - - ".cfc" - tm_scope: source.cfscript - language_id: 65 -Common Lisp: - type: programming - tm_scope: source.lisp - color: "#3fb68b" - aliases: - - lisp - extensions: - - ".lisp" - - ".asd" - - ".cl" - - ".l" - - ".lsp" - - ".ny" - - ".podsl" - - ".sexp" - interpreters: - - lisp - - sbcl - - ccl - - clisp - - ecl - ace_mode: lisp - codemirror_mode: commonlisp - codemirror_mime_type: text/x-common-lisp - language_id: 66 -Common Workflow Language: - aliases: - - cwl - type: programming - ace_mode: yaml - codemirror_mode: yaml - codemirror_mime_type: text/x-yaml - extensions: - - ".cwl" - interpreters: - - cwl-runner - color: "#B5314C" - tm_scope: source.cwl - language_id: 988547172 -Component Pascal: - type: programming - color: "#B0CE4E" - extensions: - - ".cp" - - ".cps" - tm_scope: source.pascal - ace_mode: pascal - codemirror_mode: pascal - codemirror_mime_type: text/x-pascal - language_id: 67 -Cool: - type: programming - extensions: - - ".cl" - tm_scope: source.cool - ace_mode: text - language_id: 68 -Coq: - type: programming - color: "#d0b68c" - extensions: - - ".coq" - - ".v" - tm_scope: source.coq - ace_mode: text - language_id: 69 -Cpp-ObjDump: - type: data - extensions: - - ".cppobjdump" - - ".c++-objdump" - - ".c++objdump" - - ".cpp-objdump" - - ".cxx-objdump" - tm_scope: objdump.x86asm - aliases: - - c++-objdump - ace_mode: assembly_x86 - language_id: 70 -Creole: - type: prose - wrap: true - extensions: - - ".creole" - tm_scope: text.html.creole - ace_mode: text - language_id: 71 -Crystal: - type: programming - color: "#000100" - extensions: - - ".cr" - ace_mode: ruby - codemirror_mode: crystal - codemirror_mime_type: text/x-crystal - tm_scope: source.crystal - interpreters: - - crystal - language_id: 72 -Csound: - type: programming - color: "#1a1a1a" - aliases: - - csound-orc - extensions: - - ".orc" - - ".udo" - tm_scope: source.csound - ace_mode: csound_orchestra - language_id: 73 -Csound Document: - type: programming - color: "#1a1a1a" - aliases: - - csound-csd - extensions: - - ".csd" - tm_scope: source.csound-document - ace_mode: csound_document - language_id: 74 -Csound Score: - type: programming - color: "#1a1a1a" - aliases: - - csound-sco - extensions: - - ".sco" - tm_scope: source.csound-score - ace_mode: csound_score - language_id: 75 -Cuda: - type: programming - extensions: - - ".cu" - - ".cuh" - tm_scope: source.cuda-c++ - ace_mode: c_cpp - codemirror_mode: clike - codemirror_mime_type: text/x-c++src - color: "#3A4E3A" - language_id: 77 -Cue Sheet: - type: data - extensions: - - ".cue" - tm_scope: source.cuesheet - ace_mode: text - language_id: 942714150 -Curry: - type: programming - color: "#531242" - extensions: - - ".curry" - tm_scope: source.curry - ace_mode: haskell - language_id: 439829048 -Cycript: - type: programming - extensions: - - ".cy" - tm_scope: source.js - ace_mode: javascript - codemirror_mode: javascript - codemirror_mime_type: text/javascript - language_id: 78 -Cypher: - type: programming - color: "#34c0eb" - extensions: - - ".cyp" - - ".cypher" - tm_scope: source.cypher - ace_mode: text - language_id: 850806976 -Cython: - type: programming - color: "#fedf5b" - extensions: - - ".pyx" - - ".pxd" - - ".pxi" - aliases: - - pyrex - tm_scope: source.cython - ace_mode: text - codemirror_mode: python - codemirror_mime_type: text/x-cython - language_id: 79 -D: - type: programming - color: "#ba595e" - aliases: - - Dlang - extensions: - - ".d" - - ".di" - tm_scope: source.d - ace_mode: d - codemirror_mode: d - codemirror_mime_type: text/x-d - language_id: 80 -D-ObjDump: - type: data - extensions: - - ".d-objdump" - tm_scope: objdump.x86asm - ace_mode: assembly_x86 - language_id: 81 -DIGITAL Command Language: - type: programming - aliases: - - dcl - extensions: - - ".com" - tm_scope: none - ace_mode: text - language_id: 82 -DM: - type: programming - color: "#447265" - extensions: - - ".dm" - aliases: - - byond - tm_scope: source.dm - ace_mode: c_cpp - language_id: 83 -DNS Zone: - type: data - extensions: - - ".zone" - - ".arpa" - tm_scope: text.zone_file - ace_mode: text - language_id: 84 -DTrace: - type: programming - aliases: - - dtrace-script - extensions: - - ".d" - interpreters: - - dtrace - tm_scope: source.c - ace_mode: c_cpp - codemirror_mode: clike - codemirror_mime_type: text/x-csrc - language_id: 85 -Dafny: - type: programming - color: "#FFEC25" - extensions: - - ".dfy" - interpreters: - - dafny - tm_scope: text.dfy.dafny - ace_mode: text - language_id: 969323346 -Darcs Patch: - type: data - color: "#8eff23" - aliases: - - dpatch - extensions: - - ".darcspatch" - - ".dpatch" - tm_scope: none - ace_mode: text - language_id: 86 -Dart: - type: programming - color: "#00B4AB" - extensions: - - ".dart" - interpreters: - - dart - tm_scope: source.dart - ace_mode: dart - codemirror_mode: dart - codemirror_mime_type: application/dart - language_id: 87 -DataWeave: - type: programming - color: "#003a52" - extensions: - - ".dwl" - ace_mode: text - tm_scope: source.data-weave - language_id: 974514097 -Debian Package Control File: - type: data - color: "#D70751" - extensions: - - ".dsc" - tm_scope: source.deb-control - ace_mode: text - language_id: 527438264 -DenizenScript: - type: programming - color: "#FBEE96" - ace_mode: yaml - codemirror_mode: yaml - codemirror_mime_type: text/x-yaml - extensions: - - ".dsc" - tm_scope: source.denizenscript - language_id: 435000929 -Dhall: - type: programming - color: "#dfafff" - extensions: - - ".dhall" - tm_scope: source.haskell - ace_mode: haskell - codemirror_mode: haskell - codemirror_mime_type: text/x-haskell - language_id: 793969321 -Diff: - type: data - extensions: - - ".diff" - - ".patch" - aliases: - - udiff - tm_scope: source.diff - ace_mode: diff - codemirror_mode: diff - codemirror_mime_type: text/x-diff - language_id: 88 -DirectX 3D File: - type: data - color: "#aace60" - extensions: - - ".x" - ace_mode: text - tm_scope: none - language_id: 201049282 -Dockerfile: - type: programming - aliases: - - Containerfile - color: "#384d54" - tm_scope: source.dockerfile - extensions: - - ".dockerfile" - filenames: - - Containerfile - - Dockerfile - ace_mode: dockerfile - codemirror_mode: dockerfile - codemirror_mime_type: text/x-dockerfile - language_id: 89 -Dogescript: - type: programming - color: "#cca760" - extensions: - - ".djs" - tm_scope: none - ace_mode: text - language_id: 90 -Dylan: - type: programming - color: "#6c616e" - extensions: - - ".dylan" - - ".dyl" - - ".intr" - - ".lid" - tm_scope: source.dylan - ace_mode: text - codemirror_mode: dylan - codemirror_mime_type: text/x-dylan - language_id: 91 -E: - type: programming - color: "#ccce35" - extensions: - - ".e" - interpreters: - - rune - tm_scope: none - ace_mode: text - language_id: 92 -E-mail: - type: data - aliases: - - email - - eml - - mail - - mbox - extensions: - - ".eml" - - ".mbox" - tm_scope: text.eml.basic - ace_mode: text - codemirror_mode: mbox - codemirror_mime_type: application/mbox - language_id: 529653389 -EBNF: - type: data - extensions: - - ".ebnf" - tm_scope: source.ebnf - ace_mode: text - codemirror_mode: ebnf - codemirror_mime_type: text/x-ebnf - language_id: 430 -ECL: - type: programming - color: "#8a1267" - extensions: - - ".ecl" - - ".eclxml" - tm_scope: source.ecl - ace_mode: text - codemirror_mode: ecl - codemirror_mime_type: text/x-ecl - language_id: 93 -ECLiPSe: - type: programming - color: "#001d9d" - group: prolog - extensions: - - ".ecl" - tm_scope: source.prolog.eclipse - ace_mode: prolog - language_id: 94 -EJS: - type: markup - color: "#a91e50" - extensions: - - ".ejs" - - ".ect" - - ".ejs.t" - - ".jst" - tm_scope: text.html.js - ace_mode: ejs - language_id: 95 -EQ: - type: programming - color: "#a78649" - extensions: - - ".eq" - tm_scope: source.cs - ace_mode: csharp - codemirror_mode: clike - codemirror_mime_type: text/x-csharp - language_id: 96 -Eagle: - type: data - extensions: - - ".sch" - - ".brd" - tm_scope: text.xml - ace_mode: xml - codemirror_mode: xml - codemirror_mime_type: text/xml - language_id: 97 -Earthly: - type: programming - aliases: - - Earthfile - color: "#2af0ff" - tm_scope: source.earthfile - ace_mode: text - filenames: - - Earthfile - language_id: 963512632 -Easybuild: - type: data - color: "#069406" - group: Python - ace_mode: python - codemirror_mode: python - codemirror_mime_type: text/x-python - tm_scope: source.python - extensions: - - ".eb" - language_id: 342840477 -Ecere Projects: - type: data - color: "#913960" - group: JavaScript - extensions: - - ".epj" - tm_scope: source.json - ace_mode: json - codemirror_mode: javascript - codemirror_mime_type: application/json - language_id: 98 -Ecmarkup: - type: markup - color: "#eb8131" - group: HTML - extensions: - - ".html" - tm_scope: text.html.ecmarkup - ace_mode: html - codemirror_mode: htmlmixed - codemirror_mime_type: text/html - aliases: - - ecmarkdown - language_id: 844766630 -EditorConfig: - type: data - color: "#fff1f2" - group: INI - extensions: - - ".editorconfig" - filenames: - - ".editorconfig" - aliases: - - editor-config - ace_mode: ini - codemirror_mode: properties - codemirror_mime_type: text/x-properties - tm_scope: source.editorconfig - language_id: 96139566 -Edje Data Collection: - type: data - extensions: - - ".edc" - tm_scope: source.c++ - ace_mode: c_cpp - codemirror_mode: clike - codemirror_mime_type: text/x-c++src - language_id: 342840478 -Eiffel: - type: programming - color: "#4d6977" - extensions: - - ".e" - tm_scope: source.eiffel - ace_mode: eiffel - codemirror_mode: eiffel - codemirror_mime_type: text/x-eiffel - language_id: 99 -Elixir: - type: programming - color: "#6e4a7e" - extensions: - - ".ex" - - ".exs" - tm_scope: source.elixir - ace_mode: elixir - filenames: - - mix.lock - interpreters: - - elixir - language_id: 100 -Elm: - type: programming - color: "#60B5CC" - extensions: - - ".elm" - tm_scope: source.elm - ace_mode: elm - codemirror_mode: elm - codemirror_mime_type: text/x-elm - language_id: 101 -Elvish: - type: programming - ace_mode: text - extensions: - - ".elv" - interpreters: - - elvish - tm_scope: source.elvish - color: "#55BB55" - language_id: 570996448 -Emacs Lisp: - type: programming - tm_scope: source.emacs.lisp - color: "#c065db" - aliases: - - elisp - - emacs - filenames: - - ".abbrev_defs" - - ".emacs" - - ".emacs.desktop" - - ".gnus" - - ".spacemacs" - - ".viper" - - Cask - - Project.ede - - _emacs - - abbrev_defs - extensions: - - ".el" - - ".emacs" - - ".emacs.desktop" - ace_mode: lisp - codemirror_mode: commonlisp - codemirror_mime_type: text/x-common-lisp - language_id: 102 -EmberScript: - type: programming - color: "#FFF4F3" - extensions: - - ".em" - - ".emberscript" - tm_scope: source.coffee - ace_mode: coffee - codemirror_mode: coffeescript - codemirror_mime_type: text/x-coffeescript - language_id: 103 -Erlang: - type: programming - color: "#B83998" - extensions: - - ".erl" - - ".app.src" - - ".es" - - ".escript" - - ".hrl" - - ".xrl" - - ".yrl" - filenames: - - Emakefile - - rebar.config - - rebar.config.lock - - rebar.lock - tm_scope: source.erlang - ace_mode: erlang - codemirror_mode: erlang - codemirror_mime_type: text/x-erlang - interpreters: - - escript - language_id: 104 -Euphoria: - type: programming - color: "#FF790B" - extensions: - - ".e" - - ".ex" - interpreters: - - eui - - euiw - ace_mode: text - tm_scope: source.euphoria - language_id: 880693982 -F#: - type: programming - color: "#b845fc" - aliases: - - fsharp - extensions: - - ".fs" - - ".fsi" - - ".fsx" - tm_scope: source.fsharp - ace_mode: text - codemirror_mode: mllike - codemirror_mime_type: text/x-fsharp - language_id: 105 -F*: - fs_name: Fstar - type: programming - color: "#572e30" - aliases: - - fstar - extensions: - - ".fst" - - ".fsti" - tm_scope: source.fstar - ace_mode: text - language_id: 336943375 -FIGlet Font: - type: data - color: "#FFDDBB" - aliases: - - FIGfont - extensions: - - ".flf" - tm_scope: source.figfont - ace_mode: text - language_id: 686129783 -FLUX: - type: programming - color: "#88ccff" - extensions: - - ".fx" - - ".flux" - tm_scope: none - ace_mode: text - language_id: 106 -Factor: - type: programming - color: "#636746" - extensions: - - ".factor" - filenames: - - ".factor-boot-rc" - - ".factor-rc" - tm_scope: source.factor - ace_mode: text - codemirror_mode: factor - codemirror_mime_type: text/x-factor - language_id: 108 -Fancy: - type: programming - color: "#7b9db4" - extensions: - - ".fy" - - ".fancypack" - filenames: - - Fakefile - tm_scope: source.fancy - ace_mode: text - language_id: 109 -Fantom: - type: programming - color: "#14253c" - extensions: - - ".fan" - tm_scope: source.fan - ace_mode: text - language_id: 110 -Faust: - type: programming - color: "#c37240" - extensions: - - ".dsp" - tm_scope: source.faust - ace_mode: text - language_id: 622529198 -Fennel: - type: programming - tm_scope: source.fnl - ace_mode: text - color: "#fff3d7" - interpreters: - - fennel - extensions: - - ".fnl" - language_id: 239946126 -Filebench WML: - type: programming - color: "#F6B900" - extensions: - - ".f" - tm_scope: none - ace_mode: text - language_id: 111 -Filterscript: - type: programming - group: RenderScript - extensions: - - ".fs" - tm_scope: none - ace_mode: text - language_id: 112 -Fluent: - type: programming - color: "#ffcc33" - extensions: - - ".ftl" - tm_scope: source.ftl - ace_mode: text - language_id: 206353404 -Formatted: - type: data - extensions: - - ".for" - - ".eam.fs" - tm_scope: none - ace_mode: text - language_id: 113 -Forth: - type: programming - color: "#341708" - extensions: - - ".fth" - - ".4th" - - ".f" - - ".for" - - ".forth" - - ".fr" - - ".frt" - - ".fs" - tm_scope: source.forth - ace_mode: forth - codemirror_mode: forth - codemirror_mime_type: text/x-forth - language_id: 114 -Fortran: - group: Fortran - type: programming - color: "#4d41b1" - extensions: - - ".f" - - ".f77" - - ".for" - - ".fpp" - tm_scope: source.fortran - ace_mode: text - codemirror_mode: fortran - codemirror_mime_type: text/x-fortran - language_id: 107 -Fortran Free Form: - group: Fortran - color: "#4d41b1" - type: programming - extensions: - - ".f90" - - ".f03" - - ".f08" - - ".f95" - tm_scope: source.fortran.modern - ace_mode: text - codemirror_mode: fortran - codemirror_mime_type: text/x-fortran - language_id: 761352333 -FreeBasic: - type: programming - color: "#867db1" - extensions: - - ".bi" - - ".bas" - tm_scope: source.vbnet - aliases: - - fb - ace_mode: text - codemirror_mode: vb - codemirror_mime_type: text/x-vb - language_id: 472896659 -FreeMarker: - type: programming - color: "#0050b2" - aliases: - - ftl - extensions: - - ".ftl" - tm_scope: text.html.ftl - ace_mode: ftl - language_id: 115 -Frege: - type: programming - color: "#00cafe" - extensions: - - ".fr" - tm_scope: source.haskell - ace_mode: haskell - language_id: 116 -Futhark: - type: programming - color: "#5f021f" - extensions: - - ".fut" - tm_scope: source.futhark - ace_mode: text - language_id: 97358117 -G-code: - type: programming - color: "#D08CF2" - extensions: - - ".g" - - ".cnc" - - ".gco" - - ".gcode" - tm_scope: source.gcode - ace_mode: gcode - language_id: 117 -GAML: - type: programming - color: "#FFC766" - extensions: - - ".gaml" - tm_scope: none - ace_mode: text - language_id: 290345951 -GAMS: - type: programming - color: "#f49a22" - extensions: - - ".gms" - tm_scope: none - ace_mode: text - language_id: 118 -GAP: - type: programming - color: "#0000cc" - extensions: - - ".g" - - ".gap" - - ".gd" - - ".gi" - - ".tst" - tm_scope: source.gap - ace_mode: text - language_id: 119 -# Collides with markdown, so commented out until someone actually needs it -#GCC Machine Description: -# type: programming -# color: "#FFCFAB" -# extensions: -# - ".md" -# tm_scope: source.lisp -# ace_mode: lisp -# codemirror_mode: commonlisp -# codemirror_mime_type: text/x-common-lisp -# language_id: 121 -GDB: - type: programming - extensions: - - ".gdb" - - ".gdbinit" - tm_scope: source.gdb - ace_mode: text - language_id: 122 -GDScript: - type: programming - color: "#355570" - extensions: - - ".gd" - tm_scope: source.gdscript - ace_mode: text - language_id: 123 -GEDCOM: - type: data - color: "#003058" - ace_mode: text - extensions: - - ".ged" - tm_scope: source.gedcom - language_id: 459577965 -GLSL: - type: programming - color: "#5686a5" - extensions: - - ".glsl" - - ".fp" - - ".frag" - - ".frg" - - ".fs" - - ".fsh" - - ".fshader" - - ".geo" - - ".geom" - - ".glslf" - - ".glslv" - - ".gs" - - ".gshader" - - ".rchit" - - ".rmiss" - - ".shader" - - ".tesc" - - ".tese" - - ".vert" - - ".vrx" - - ".vsh" - - ".vshader" - tm_scope: source.glsl - ace_mode: glsl - language_id: 124 -GN: - type: data - extensions: - - ".gn" - - ".gni" - interpreters: - - gn - filenames: - - ".gn" - tm_scope: source.gn - ace_mode: python - codemirror_mode: python - codemirror_mime_type: text/x-python - language_id: 302957008 -GSC: - type: programming - color: "#FF6800" - extensions: - - ".gsc" - - ".csc" - - ".gsh" - tm_scope: source.gsc - ace_mode: c_cpp - codemirror_mode: clike - codemirror_mime_type: text/x-csrc - language_id: 257856279 -Game Maker Language: - type: programming - color: "#71b417" - extensions: - - ".gml" - tm_scope: source.c++ - ace_mode: c_cpp - codemirror_mode: clike - codemirror_mime_type: text/x-c++src - language_id: 125 -Gemfile.lock: - type: data - color: "#701516" - searchable: false - tm_scope: source.gemfile-lock - ace_mode: text - filenames: - - Gemfile.lock - language_id: 907065713 -Gemini: - type: prose - color: "#ff6900" - ace_mode: text - extensions: - - ".gmi" - aliases: - - gemtext - wrap: true - tm_scope: source.gemini - language_id: 310828396 -Genero: - type: programming - color: "#63408e" - extensions: - - ".4gl" - tm_scope: source.genero - ace_mode: text - language_id: 986054050 -Genero Forms: - type: markup - color: "#d8df39" - extensions: - - ".per" - tm_scope: source.genero-forms - ace_mode: text - language_id: 902995658 -Genie: - type: programming - ace_mode: text - extensions: - - ".gs" - color: "#fb855d" - tm_scope: none - language_id: 792408528 -Genshi: - type: programming - color: "#951531" - extensions: - - ".kid" - tm_scope: text.xml.genshi - aliases: - - xml+genshi - - xml+kid - ace_mode: xml - codemirror_mode: xml - codemirror_mime_type: text/xml - language_id: 126 -Gentoo Ebuild: - type: programming - color: "#9400ff" - group: Shell - extensions: - - ".ebuild" - tm_scope: source.shell - ace_mode: sh - codemirror_mode: shell - codemirror_mime_type: text/x-sh - language_id: 127 -Gentoo Eclass: - type: programming - color: "#9400ff" - group: Shell - extensions: - - ".eclass" - tm_scope: source.shell - ace_mode: sh - codemirror_mode: shell - codemirror_mime_type: text/x-sh - language_id: 128 -Gerber Image: - type: data - color: "#d20b00" - aliases: - - rs-274x - extensions: - - ".gbr" - - ".cmp" - - ".gbl" - - ".gbo" - - ".gbp" - - ".gbs" - - ".gko" - - ".gml" - - ".gpb" - - ".gpt" - - ".gtl" - - ".gto" - - ".gtp" - - ".gts" - - ".ncl" - - ".sol" - interpreters: - - gerbv - - gerbview - tm_scope: source.gerber - ace_mode: text - language_id: 404627610 -Gettext Catalog: - type: prose - aliases: - - pot - extensions: - - ".po" - - ".pot" - tm_scope: source.po - ace_mode: text - language_id: 129 -Gherkin: - type: programming - extensions: - - ".feature" - - ".story" - tm_scope: text.gherkin.feature - aliases: - - cucumber - ace_mode: text - color: "#5B2063" - language_id: 76 -Git Attributes: - type: data - color: "#F44D27" - group: INI - aliases: - - gitattributes - filenames: - - ".gitattributes" - tm_scope: source.gitattributes - ace_mode: gitignore - codemirror_mode: shell - codemirror_mime_type: text/x-sh - language_id: 956324166 -Git Config: - type: data - color: "#F44D27" - group: INI - aliases: - - gitconfig - - gitmodules - extensions: - - ".gitconfig" - filenames: - - ".gitconfig" - - ".gitmodules" - ace_mode: ini - codemirror_mode: properties - codemirror_mime_type: text/x-properties - tm_scope: source.gitconfig - language_id: 807968997 -Git Revision List: - type: data - color: "#F44D27" - aliases: - - Git Blame Ignore Revs - filenames: - - ".git-blame-ignore-revs" - tm_scope: source.git-revlist - ace_mode: text - language_id: 461881235 -Gleam: - type: programming - color: "#ffaff3" - ace_mode: text - extensions: - - ".gleam" - tm_scope: source.gleam - language_id: 1054258749 -Glyph: - type: programming - color: "#c1ac7f" - extensions: - - ".glf" - tm_scope: source.tcl - ace_mode: tcl - codemirror_mode: tcl - codemirror_mime_type: text/x-tcl - language_id: 130 -Glyph Bitmap Distribution Format: - type: data - extensions: - - ".bdf" - tm_scope: source.bdf - ace_mode: text - language_id: 997665271 -Gnuplot: - type: programming - color: "#f0a9f0" - extensions: - - ".gp" - - ".gnu" - - ".gnuplot" - - ".p" - - ".plot" - - ".plt" - interpreters: - - gnuplot - tm_scope: source.gnuplot - ace_mode: text - language_id: 131 -Go: - type: programming - color: "#00ADD8" - aliases: - - golang - extensions: - - ".go" - tm_scope: source.go - ace_mode: golang - codemirror_mode: go - codemirror_mime_type: text/x-go - language_id: 132 -Go Checksums: - type: data - color: "#00ADD8" - aliases: - - go.sum - - go sum - filenames: - - go.sum - tm_scope: go.sum - ace_mode: text - language_id: 1054391671 -Go Module: - type: data - color: "#00ADD8" - aliases: - - go.mod - - go mod - filenames: - - go.mod - tm_scope: go.mod - ace_mode: text - language_id: 947461016 -Golo: - type: programming - color: "#88562A" - extensions: - - ".golo" - tm_scope: source.golo - ace_mode: text - language_id: 133 -Gosu: - type: programming - color: "#82937f" - extensions: - - ".gs" - - ".gst" - - ".gsx" - - ".vark" - tm_scope: source.gosu.2 - ace_mode: text - language_id: 134 -Grace: - type: programming - color: "#615f8b" - extensions: - - ".grace" - tm_scope: source.grace - ace_mode: text - language_id: 135 -Gradle: - type: data - color: "#02303a" - extensions: - - ".gradle" - tm_scope: source.groovy.gradle - ace_mode: text - language_id: 136 -Grammatical Framework: - type: programming - aliases: - - gf - extensions: - - ".gf" - color: "#ff0000" - tm_scope: source.gf - ace_mode: haskell - codemirror_mode: haskell - codemirror_mime_type: text/x-haskell - language_id: 137 -Graph Modeling Language: - type: data - extensions: - - ".gml" - tm_scope: none - ace_mode: text - language_id: 138 -GraphQL: - type: data - color: "#e10098" - extensions: - - ".graphql" - - ".gql" - - ".graphqls" - tm_scope: source.graphql - ace_mode: text - language_id: 139 -Graphviz (DOT): - type: data - color: "#2596be" - tm_scope: source.dot - extensions: - - ".dot" - - ".gv" - ace_mode: text - language_id: 140 -Groovy: - type: programming - tm_scope: source.groovy - ace_mode: groovy - codemirror_mode: groovy - codemirror_mime_type: text/x-groovy - color: "#4298b8" - extensions: - - ".groovy" - - ".grt" - - ".gtpl" - - ".gvy" - interpreters: - - groovy - filenames: - - Jenkinsfile - language_id: 142 -Groovy Server Pages: - type: programming - color: "#4298b8" - group: Groovy - aliases: - - gsp - - java server page - extensions: - - ".gsp" - tm_scope: text.html.jsp - ace_mode: jsp - codemirror_mode: htmlembedded - codemirror_mime_type: application/x-jsp - language_id: 143 -HAProxy: - type: data - color: "#106da9" - extensions: - - ".cfg" - filenames: - - haproxy.cfg - tm_scope: source.haproxy-config - ace_mode: text - language_id: 366607477 -HCL: - type: programming - extensions: - - ".hcl" - - ".nomad" - - ".tf" - - ".tfvars" - - ".workflow" - aliases: - - HashiCorp Configuration Language - - terraform - ace_mode: ruby - codemirror_mode: ruby - codemirror_mime_type: text/x-ruby - tm_scope: source.terraform - language_id: 144 -HLSL: - type: programming - color: "#aace60" - extensions: - - ".hlsl" - - ".cginc" - - ".fx" - - ".fxh" - - ".hlsli" - ace_mode: text - tm_scope: source.hlsl - language_id: 145 -HOCON: - type: data - color: "#9ff8ee" - extensions: - - ".hocon" - tm_scope: source.hocon - ace_mode: text - language_id: 679725279 -HTML: - type: markup - tm_scope: text.html.basic - ace_mode: html - codemirror_mode: htmlmixed - codemirror_mime_type: text/html - color: "#e34c26" - aliases: - - xhtml - extensions: - - ".html" - - ".hta" - - ".htm" - - ".html.hl" - - ".inc" - - ".xht" - - ".xhtml" - language_id: 146 -HTML+ECR: - type: markup - color: "#2e1052" - tm_scope: text.html.ecr - group: HTML - aliases: - - ecr - extensions: - - ".ecr" - ace_mode: text - codemirror_mode: htmlmixed - codemirror_mime_type: text/html - language_id: 148 -HTML+EEX: - type: markup - color: "#6e4a7e" - tm_scope: text.html.elixir - group: HTML - aliases: - - eex - - heex - - leex - extensions: - - ".eex" - - ".html.heex" - - ".html.leex" - ace_mode: text - codemirror_mode: htmlmixed - codemirror_mime_type: text/html - language_id: 149 -HTML+ERB: - type: markup - color: "#701516" - tm_scope: text.html.erb - group: HTML - aliases: - - erb - - rhtml - - html+ruby - extensions: - - ".erb" - - ".erb.deface" - - ".rhtml" - ace_mode: text - codemirror_mode: htmlembedded - codemirror_mime_type: application/x-erb - language_id: 150 -HTML+PHP: - type: markup - color: "#4f5d95" - tm_scope: text.html.php - group: HTML - extensions: - - ".phtml" - ace_mode: php - codemirror_mode: php - codemirror_mime_type: application/x-httpd-php - language_id: 151 -HTML+Razor: - type: markup - color: "#512be4" - tm_scope: text.html.cshtml - group: HTML - aliases: - - razor - extensions: - - ".cshtml" - - ".razor" - ace_mode: razor - codemirror_mode: htmlmixed - codemirror_mime_type: text/html - language_id: 479039817 -HTTP: - type: data - color: "#005C9C" - extensions: - - ".http" - tm_scope: source.httpspec - ace_mode: text - codemirror_mode: http - codemirror_mime_type: message/http - language_id: 152 -HXML: - type: data - color: "#f68712" - ace_mode: text - extensions: - - ".hxml" - tm_scope: source.hxml - language_id: 786683730 -Hack: - type: programming - ace_mode: php - codemirror_mode: php - codemirror_mime_type: application/x-httpd-php - extensions: - - ".hack" - - ".hh" - - ".hhi" - - ".php" - tm_scope: source.hack - color: "#878787" - language_id: 153 -Haml: - type: markup - color: "#ece2a9" - extensions: - - ".haml" - - ".haml.deface" - tm_scope: text.haml - ace_mode: haml - codemirror_mode: haml - codemirror_mime_type: text/x-haml - language_id: 154 -Handlebars: - type: markup - color: "#f7931e" - aliases: - - hbs - - htmlbars - extensions: - - ".handlebars" - - ".hbs" - tm_scope: text.html.handlebars - ace_mode: handlebars - language_id: 155 -Harbour: - type: programming - color: "#0e60e3" - extensions: - - ".hb" - tm_scope: source.harbour - ace_mode: text - language_id: 156 -Haskell: - type: programming - color: "#5e5086" - extensions: - - ".hs" - - ".hs-boot" - - ".hsc" - interpreters: - - runghc - - runhaskell - - runhugs - tm_scope: source.haskell - ace_mode: haskell - codemirror_mode: haskell - codemirror_mime_type: text/x-haskell - language_id: 157 -Haxe: - type: programming - ace_mode: haxe - codemirror_mode: haxe - codemirror_mime_type: text/x-haxe - color: "#df7900" - extensions: - - ".hx" - - ".hxsl" - tm_scope: source.hx - language_id: 158 -HiveQL: - type: programming - extensions: - - ".q" - - ".hql" - color: "#dce200" - tm_scope: source.hql - ace_mode: sql - language_id: 931814087 -HolyC: - type: programming - color: "#ffefaf" - extensions: - - ".hc" - tm_scope: source.hc - ace_mode: c_cpp - codemirror_mode: clike - codemirror_mime_type: text/x-csrc - language_id: 928121743 -Hy: - type: programming - ace_mode: text - color: "#7790B2" - extensions: - - ".hy" - interpreters: - - hy - aliases: - - hylang - tm_scope: source.hy - language_id: 159 -HyPhy: - type: programming - ace_mode: text - extensions: - - ".bf" - tm_scope: none - language_id: 160 -IDL: - type: programming - color: "#a3522f" - extensions: - - ".pro" - - ".dlm" - tm_scope: source.idl - ace_mode: text - codemirror_mode: idl - codemirror_mime_type: text/x-idl - language_id: 161 -IGOR Pro: - type: programming - color: "#0000cc" - extensions: - - ".ipf" - aliases: - - igor - - igorpro - tm_scope: source.igor - ace_mode: text - language_id: 162 -INI: - type: data - color: "#d1dbe0" - extensions: - - ".ini" - - ".cfg" - - ".dof" - - ".lektorproject" - - ".prefs" - - ".pro" - - ".properties" - - ".url" - filenames: - - ".coveragerc" - - ".flake8" - - ".pylintrc" - - buildozer.spec - - pylintrc - tm_scope: source.ini - aliases: - - dosini - ace_mode: ini - codemirror_mode: properties - codemirror_mime_type: text/x-properties - language_id: 163 -IRC log: - type: data - aliases: - - irc - - irc logs - extensions: - - ".irclog" - - ".weechatlog" - tm_scope: none - ace_mode: text - codemirror_mode: mirc - codemirror_mime_type: text/mirc - language_id: 164 -Idris: - type: programming - color: "#b30000" - extensions: - - ".idr" - - ".lidr" - ace_mode: text - tm_scope: source.idris - language_id: 165 -Ignore List: - type: data - color: "#000000" - group: INI - aliases: - - ignore - - gitignore - - git-ignore - extensions: - - ".gitignore" - filenames: - - ".atomignore" - - ".babelignore" - - ".bzrignore" - - ".coffeelintignore" - - ".cvsignore" - - ".dockerignore" - - ".eleventyignore" - - ".eslintignore" - - ".gitignore" - - ".markdownlintignore" - - ".nodemonignore" - - ".npmignore" - - ".prettierignore" - - ".stylelintignore" - - ".vercelignore" - - ".vscodeignore" - - gitignore-global - - gitignore_global - ace_mode: gitignore - tm_scope: source.gitignore - codemirror_mode: shell - codemirror_mime_type: text/x-sh - language_id: 74444240 -ImageJ Macro: - type: programming - color: "#99AAFF" - aliases: - - ijm - extensions: - - ".ijm" - ace_mode: text - tm_scope: none - language_id: 575143428 -Imba: - type: programming - color: "#16cec6" - extensions: - - ".imba" - ace_mode: text - tm_scope: source.imba - language_id: 1057618448 -Inform 7: - type: programming - wrap: true - extensions: - - ".ni" - - ".i7x" - tm_scope: source.inform7 - aliases: - - i7 - - inform7 - ace_mode: text - language_id: 166 -Ink: - type: programming - wrap: true - extensions: - - ".ink" - tm_scope: source.ink - ace_mode: text - language_id: 838252715 -Inno Setup: - type: programming - color: "#264b99" - extensions: - - ".iss" - - ".isl" - tm_scope: source.inno - ace_mode: text - language_id: 167 -Io: - type: programming - color: "#a9188d" - extensions: - - ".io" - interpreters: - - io - tm_scope: source.io - ace_mode: io - language_id: 168 -Ioke: - type: programming - color: "#078193" - extensions: - - ".ik" - interpreters: - - ioke - tm_scope: source.ioke - ace_mode: text - language_id: 169 -Isabelle: - type: programming - color: "#FEFE00" - extensions: - - ".thy" - tm_scope: source.isabelle.theory - ace_mode: text - language_id: 170 -Isabelle ROOT: - type: programming - color: "#FEFE00" - group: Isabelle - filenames: - - ROOT - tm_scope: source.isabelle.root - ace_mode: text - language_id: 171 -J: - type: programming - color: "#9EEDFF" - extensions: - - ".ijs" - interpreters: - - jconsole - tm_scope: source.j - ace_mode: text - language_id: 172 -JAR Manifest: - type: data - color: "#b07219" - filenames: - - MANIFEST.MF - tm_scope: source.yaml - ace_mode: text - language_id: 447261135 -JFlex: - type: programming - color: "#DBCA00" - group: Lex - extensions: - - ".flex" - - ".jflex" - tm_scope: source.jflex - ace_mode: text - language_id: 173 -JSON: - type: data - color: "#292929" - tm_scope: source.json - ace_mode: json - codemirror_mode: javascript - codemirror_mime_type: application/json - aliases: - - geojson - - jsonl - - topojson - extensions: - - ".json" - - ".4DForm" - - ".4DProject" - - ".avsc" - - ".geojson" - - ".gltf" - - ".har" - - ".ice" - - ".JSON-tmLanguage" - - ".jsonl" - - ".mcmeta" - - ".tfstate" - - ".tfstate.backup" - - ".topojson" - - ".webapp" - - ".webmanifest" - - ".yy" - - ".yyp" - filenames: - - ".all-contributorsrc" - - ".arcconfig" - - ".auto-changelog" - - ".c8rc" - - ".htmlhintrc" - - ".imgbotconfig" - - ".nycrc" - - ".tern-config" - - ".tern-project" - - ".watchmanconfig" - - Pipfile.lock - - composer.lock - - mcmod.info - language_id: 174 -JSON with Comments: - type: data - color: "#292929" - group: JSON - tm_scope: source.js - ace_mode: javascript - codemirror_mode: javascript - codemirror_mime_type: text/javascript - aliases: - - jsonc - extensions: - - ".jsonc" - - ".code-snippets" - - ".sublime-build" - - ".sublime-commands" - - ".sublime-completions" - - ".sublime-keymap" - - ".sublime-macro" - - ".sublime-menu" - - ".sublime-mousemap" - - ".sublime-project" - - ".sublime-settings" - - ".sublime-theme" - - ".sublime-workspace" - - ".sublime_metrics" - - ".sublime_session" - filenames: - - ".babelrc" - - ".devcontainer.json" - - ".eslintrc.json" - - ".jscsrc" - - ".jshintrc" - - ".jslintrc" - - api-extractor.json - - devcontainer.json - - jsconfig.json - - language-configuration.json - - tsconfig.json - - tslint.json - language_id: 423 -JSON5: - type: data - color: "#267CB9" - extensions: - - ".json5" - tm_scope: source.js - ace_mode: javascript - codemirror_mode: javascript - codemirror_mime_type: application/json - language_id: 175 -JSONLD: - type: data - color: "#0c479c" - extensions: - - ".jsonld" - tm_scope: source.js - ace_mode: javascript - codemirror_mode: javascript - codemirror_mime_type: application/json - language_id: 176 -JSONiq: - color: "#40d47e" - type: programming - ace_mode: jsoniq - codemirror_mode: javascript - codemirror_mime_type: application/json - extensions: - - ".jq" - tm_scope: source.jsoniq - language_id: 177 -Janet: - type: programming - color: "#0886a5" - extensions: - - ".janet" - tm_scope: source.janet - ace_mode: scheme - codemirror_mode: scheme - codemirror_mime_type: text/x-scheme - interpreters: - - janet - language_id: 1028705371 -Jasmin: - type: programming - color: "#d03600" - ace_mode: java - extensions: - - ".j" - tm_scope: source.jasmin - language_id: 180 -Java: - type: programming - tm_scope: source.java - ace_mode: java - codemirror_mode: clike - codemirror_mime_type: text/x-java - color: "#b07219" - extensions: - - ".java" - - ".jav" - - ".jsh" - language_id: 181 -Java Properties: - type: data - color: "#2A6277" - extensions: - - ".properties" - tm_scope: source.java-properties - ace_mode: properties - codemirror_mode: properties - codemirror_mime_type: text/x-properties - language_id: 519377561 -Java Server Pages: - type: programming - color: "#2A6277" - group: Java - aliases: - - jsp - extensions: - - ".jsp" - - ".tag" - tm_scope: text.html.jsp - ace_mode: jsp - codemirror_mode: htmlembedded - codemirror_mime_type: application/x-jsp - language_id: 182 -JavaScript: - type: programming - tm_scope: source.js - ace_mode: javascript - codemirror_mode: javascript - codemirror_mime_type: text/javascript - color: "#f1e05a" - aliases: - - js - - node - extensions: - - ".js" - - "._js" - - ".bones" - - ".cjs" - - ".es" - - ".es6" - - ".frag" - - ".gs" - - ".jake" - - ".javascript" - - ".jsb" - - ".jscad" - - ".jsfl" - - ".jslib" - - ".jsm" - - ".jspre" - - ".jss" - - ".jsx" - - ".mjs" - - ".njs" - - ".pac" - - ".sjs" - - ".ssjs" - - ".xsjs" - - ".xsjslib" - filenames: - - Jakefile - interpreters: - - chakra - - d8 - - gjs - - js - - node - - nodejs - - qjs - - rhino - - v8 - - v8-shell - language_id: 183 -JavaScript+ERB: - type: programming - color: "#f1e05a" - tm_scope: source.js - group: JavaScript - extensions: - - ".js.erb" - ace_mode: javascript - codemirror_mode: javascript - codemirror_mime_type: application/javascript - language_id: 914318960 -Jest Snapshot: - type: data - color: "#15c213" - tm_scope: source.jest.snap - extensions: - - ".snap" - ace_mode: javascript - codemirror_mode: javascript - codemirror_mime_type: application/javascript - language_id: 774635084 -JetBrains MPS: - type: programming - aliases: - - mps - color: "#21D789" - extensions: - - ".mps" - - ".mpl" - - ".msd" - ace_mode: xml - codemirror_mode: xml - codemirror_mime_type: text/xml - tm_scope: none - language_id: 465165328 -Jinja: - type: markup - color: "#a52a22" - aliases: - - django - - html+django - - html+jinja - - htmldjango - extensions: - - ".jinja" - - ".j2" - - ".jinja2" - tm_scope: text.html.django - ace_mode: django - codemirror_mode: django - codemirror_mime_type: text/x-django - language_id: 147 -Jison: - type: programming - color: "#56b3cb" - group: Yacc - extensions: - - ".jison" - tm_scope: source.jison - ace_mode: text - language_id: 284531423 -Jison Lex: - type: programming - color: "#56b3cb" - group: Lex - extensions: - - ".jisonlex" - tm_scope: source.jisonlex - ace_mode: text - language_id: 406395330 -Jolie: - type: programming - extensions: - - ".ol" - - ".iol" - interpreters: - - jolie - color: "#843179" - ace_mode: text - tm_scope: source.jolie - language_id: 998078858 -Jsonnet: - color: "#0064bd" - type: programming - ace_mode: text - extensions: - - ".jsonnet" - - ".libsonnet" - tm_scope: source.jsonnet - language_id: 664885656 -Julia: - type: programming - extensions: - - ".jl" - interpreters: - - julia - color: "#a270ba" - tm_scope: source.julia - ace_mode: julia - codemirror_mode: julia - codemirror_mime_type: text/x-julia - language_id: 184 -Jupyter Notebook: - type: markup - ace_mode: json - codemirror_mode: javascript - codemirror_mime_type: application/json - tm_scope: source.json - color: "#DA5B0B" - extensions: - - ".ipynb" - filenames: - - Notebook - aliases: - - IPython Notebook - language_id: 185 -KRL: - type: programming - color: "#28430A" - extensions: - - ".krl" - tm_scope: none - ace_mode: text - language_id: 186 -Kaitai Struct: - type: programming - aliases: - - ksy - ace_mode: yaml - codemirror_mode: yaml - codemirror_mime_type: text/x-yaml - color: "#773b37" - extensions: - - ".ksy" - tm_scope: source.yaml - language_id: 818804755 -KakouneScript: - type: programming - color: "#6f8042" - tm_scope: source.kakscript - aliases: - - kak - - kakscript - extensions: - - ".kak" - filenames: - - kakrc - ace_mode: text - language_id: 603336474 -KiCad Layout: - type: data - color: "#2f4aab" - aliases: - - pcbnew - extensions: - - ".kicad_pcb" - - ".kicad_mod" - - ".kicad_wks" - filenames: - - fp-lib-table - tm_scope: source.pcb.sexp - ace_mode: lisp - codemirror_mode: commonlisp - codemirror_mime_type: text/x-common-lisp - language_id: 187 -KiCad Legacy Layout: - type: data - color: "#2f4aab" - extensions: - - ".brd" - tm_scope: source.pcb.board - ace_mode: text - language_id: 140848857 -KiCad Schematic: - type: data - color: "#2f4aab" - aliases: - - eeschema schematic - extensions: - - ".kicad_sch" - - ".sch" - tm_scope: source.pcb.schematic - ace_mode: text - language_id: 622447435 -Kit: - type: markup - ace_mode: html - codemirror_mode: htmlmixed - codemirror_mime_type: text/html - extensions: - - ".kit" - tm_scope: text.html.basic - language_id: 188 -Kotlin: - type: programming - color: "#A97BFF" - extensions: - - ".kt" - - ".ktm" - - ".kts" - tm_scope: source.kotlin - ace_mode: text - codemirror_mode: clike - codemirror_mime_type: text/x-kotlin - language_id: 189 -Kusto: - type: data - extensions: - - ".csl" - - ".kql" - tm_scope: source.kusto - ace_mode: text - language_id: 225697190 -LFE: - type: programming - color: "#4C3023" - extensions: - - ".lfe" - tm_scope: source.lisp - ace_mode: lisp - codemirror_mode: commonlisp - codemirror_mime_type: text/x-common-lisp - language_id: 190 -LLVM: - type: programming - extensions: - - ".ll" - tm_scope: source.llvm - ace_mode: text - color: "#185619" - language_id: 191 -LOLCODE: - type: programming - extensions: - - ".lol" - color: "#cc9900" - tm_scope: none - ace_mode: text - language_id: 192 -LSL: - type: programming - tm_scope: source.lsl - ace_mode: lsl - extensions: - - ".lsl" - - ".lslp" - interpreters: - - lsl - color: "#3d9970" - language_id: 193 -LTspice Symbol: - type: data - extensions: - - ".asy" - tm_scope: source.ltspice.symbol - ace_mode: text - codemirror_mode: spreadsheet - codemirror_mime_type: text/x-spreadsheet - language_id: 1013566805 -LabVIEW: - type: programming - color: "#fede06" - extensions: - - ".lvproj" - - ".lvclass" - - ".lvlib" - tm_scope: text.xml - ace_mode: xml - codemirror_mode: xml - codemirror_mime_type: text/xml - language_id: 194 -Lark: - type: data - color: "#2980B9" - extensions: - - ".lark" - tm_scope: source.lark - ace_mode: text - codemirror_mode: ebnf - codemirror_mime_type: text/x-ebnf - language_id: 758480799 -Lasso: - type: programming - color: "#999999" - extensions: - - ".lasso" - - ".las" - - ".lasso8" - - ".lasso9" - tm_scope: file.lasso - aliases: - - lassoscript - ace_mode: text - language_id: 195 -Latte: - type: markup - color: "#f2a542" - extensions: - - ".latte" - tm_scope: text.html.smarty - ace_mode: smarty - codemirror_mode: smarty - codemirror_mime_type: text/x-smarty - language_id: 196 -Lean: - type: programming - extensions: - - ".lean" - - ".hlean" - tm_scope: source.lean - ace_mode: text - language_id: 197 -Less: - type: markup - color: "#1d365d" - aliases: - - less-css - extensions: - - ".less" - tm_scope: source.css.less - ace_mode: less - codemirror_mode: css - codemirror_mime_type: text/css - language_id: 198 -Lex: - type: programming - color: "#DBCA00" - aliases: - - flex - extensions: - - ".l" - - ".lex" - filenames: - - Lexer.x - - lexer.x - tm_scope: source.lex - ace_mode: text - language_id: 199 -LigoLANG: - type: programming - color: "#0e74ff" - extensions: - - ".ligo" - tm_scope: source.ligo - ace_mode: pascal - codemirror_mode: pascal - codemirror_mime_type: text/x-pascal - group: LigoLANG - language_id: 1040646257 -LilyPond: - type: programming - color: "#9ccc7c" - extensions: - - ".ly" - - ".ily" - tm_scope: source.lilypond - ace_mode: text - language_id: 200 -Limbo: - type: programming - extensions: - - ".b" - - ".m" - tm_scope: none - ace_mode: text - language_id: 201 -Linker Script: - type: data - extensions: - - ".ld" - - ".lds" - - ".x" - filenames: - - ld.script - tm_scope: none - ace_mode: text - language_id: 202 -Linux Kernel Module: - type: data - extensions: - - ".mod" - tm_scope: none - ace_mode: text - language_id: 203 -Liquid: - type: markup - color: "#67b8de" - extensions: - - ".liquid" - tm_scope: text.html.liquid - ace_mode: liquid - language_id: 204 -Literate Agda: - type: programming - color: "#315665" - group: Agda - extensions: - - ".lagda" - tm_scope: none - ace_mode: text - language_id: 205 -Literate CoffeeScript: - type: programming - color: "#244776" - tm_scope: source.litcoffee - group: CoffeeScript - ace_mode: text - wrap: true - aliases: - - litcoffee - extensions: - - ".litcoffee" - - ".coffee.md" - language_id: 206 -Literate Haskell: - type: programming - color: "#5e5086" - group: Haskell - aliases: - - lhaskell - - lhs - extensions: - - ".lhs" - tm_scope: text.tex.latex.haskell - ace_mode: text - codemirror_mode: haskell-literate - codemirror_mime_type: text/x-literate-haskell - language_id: 207 -LiveScript: - type: programming - color: "#499886" - aliases: - - live-script - - ls - extensions: - - ".ls" - - "._ls" - filenames: - - Slakefile - tm_scope: source.livescript - ace_mode: livescript - codemirror_mode: livescript - codemirror_mime_type: text/x-livescript - language_id: 208 -Logos: - type: programming - extensions: - - ".xm" - - ".x" - - ".xi" - ace_mode: text - tm_scope: source.logos - language_id: 209 -Logtalk: - type: programming - color: "#295b9a" - extensions: - - ".lgt" - - ".logtalk" - tm_scope: source.logtalk - ace_mode: text - language_id: 210 -LookML: - type: programming - ace_mode: yaml - codemirror_mode: yaml - codemirror_mime_type: text/x-yaml - color: "#652B81" - extensions: - - ".lookml" - - ".model.lkml" - - ".view.lkml" - tm_scope: source.yaml - language_id: 211 -LoomScript: - type: programming - extensions: - - ".ls" - tm_scope: source.loomscript - ace_mode: text - language_id: 212 -Lua: - type: programming - tm_scope: source.lua - ace_mode: lua - codemirror_mode: lua - codemirror_mime_type: text/x-lua - color: "#000080" - extensions: - - ".lua" - - ".fcgi" - - ".nse" - - ".p8" - - ".pd_lua" - - ".rbxs" - - ".rockspec" - - ".wlua" - filenames: - - ".luacheckrc" - interpreters: - - lua - language_id: 213 -M: - type: programming - aliases: - - mumps - extensions: - - ".mumps" - - ".m" - ace_mode: text - codemirror_mode: mumps - codemirror_mime_type: text/x-mumps - language_id: 214 - tm_scope: none -M4: - type: programming - extensions: - - ".m4" - - ".mc" - tm_scope: source.m4 - ace_mode: text - language_id: 215 -M4Sugar: - type: programming - group: M4 - aliases: - - autoconf - extensions: - - ".m4" - filenames: - - configure.ac - tm_scope: source.m4 - ace_mode: text - language_id: 216 -MATLAB: - type: programming - color: "#e16737" - aliases: - - octave - extensions: - - ".matlab" - - ".m" - tm_scope: source.matlab - ace_mode: matlab - codemirror_mode: octave - codemirror_mime_type: text/x-octave - language_id: 225 -MAXScript: - type: programming - color: "#00a6a6" - extensions: - - ".ms" - - ".mcr" - tm_scope: source.maxscript - ace_mode: text - language_id: 217 -MLIR: - type: programming - color: "#5EC8DB" - extensions: - - ".mlir" - tm_scope: source.mlir - ace_mode: text - language_id: 448253929 -MQL4: - type: programming - color: "#62A8D6" - extensions: - - ".mq4" - - ".mqh" - tm_scope: source.mql5 - ace_mode: c_cpp - language_id: 426 -MQL5: - type: programming - color: "#4A76B8" - extensions: - - ".mq5" - - ".mqh" - tm_scope: source.mql5 - ace_mode: c_cpp - language_id: 427 -MTML: - type: markup - color: "#b7e1f4" - extensions: - - ".mtml" - tm_scope: text.html.basic - ace_mode: html - codemirror_mode: htmlmixed - codemirror_mime_type: text/html - language_id: 218 -MUF: - type: programming - group: Forth - extensions: - - ".muf" - - ".m" - tm_scope: none - ace_mode: forth - codemirror_mode: forth - codemirror_mime_type: text/x-forth - language_id: 219 -Macaulay2: - type: programming - extensions: - - ".m2" - aliases: - - m2 - interpreters: - - M2 - ace_mode: text - tm_scope: source.m2 - color: "#d8ffff" - language_id: 34167825 -Makefile: - type: programming - color: "#427819" - aliases: - - bsdmake - - make - - mf - extensions: - - ".mak" - - ".d" - - ".make" - - ".makefile" - - ".mk" - - ".mkfile" - filenames: - - BSDmakefile - - GNUmakefile - - Kbuild - - Makefile - - Makefile.am - - Makefile.boot - - Makefile.frag - - Makefile.in - - Makefile.inc - - Makefile.wat - - makefile - - makefile.sco - - mkfile - interpreters: - - make - tm_scope: source.makefile - ace_mode: makefile - codemirror_mode: cmake - codemirror_mime_type: text/x-cmake - language_id: 220 -Mako: - type: programming - color: "#7e858d" - extensions: - - ".mako" - - ".mao" - tm_scope: text.html.mako - ace_mode: text - language_id: 221 -Markdown: - type: prose - color: "#083fa1" - aliases: - - pandoc - ace_mode: markdown - codemirror_mode: gfm - codemirror_mime_type: text/x-gfm - wrap: true - extensions: - - ".md" - - ".livemd" - - ".markdown" - - ".mdown" - - ".mdwn" - - ".mdx" - - ".mkd" - - ".mkdn" - - ".mkdown" - - ".ronn" - - ".scd" - - ".workbook" - filenames: - - contents.lr - tm_scope: source.gfm - language_id: 222 -Marko: - type: markup - color: "#42bff2" - tm_scope: text.marko - extensions: - - ".marko" - aliases: - - markojs - ace_mode: text - codemirror_mode: htmlmixed - codemirror_mime_type: text/html - language_id: 932782397 -Mask: - type: markup - color: "#f97732" - ace_mode: mask - extensions: - - ".mask" - tm_scope: source.mask - language_id: 223 -Mathematica: - type: programming - color: "#dd1100" - extensions: - - ".mathematica" - - ".cdf" - - ".m" - - ".ma" - - ".mt" - - ".nb" - - ".nbp" - - ".wl" - - ".wlt" - aliases: - - mma - - wolfram - - wolfram language - - wolfram lang - - wl - tm_scope: source.mathematica - ace_mode: text - codemirror_mode: mathematica - codemirror_mime_type: text/x-mathematica - language_id: 224 -Maven POM: - type: data - group: XML - tm_scope: text.xml.pom - filenames: - - pom.xml - ace_mode: xml - codemirror_mode: xml - codemirror_mime_type: text/xml - language_id: 226 -Max: - type: programming - color: "#c4a79c" - aliases: - - max/msp - - maxmsp - extensions: - - ".maxpat" - - ".maxhelp" - - ".maxproj" - - ".mxt" - - ".pat" - tm_scope: source.json - ace_mode: json - codemirror_mode: javascript - codemirror_mime_type: application/json - language_id: 227 -Mercury: - type: programming - color: "#ff2b2b" - ace_mode: prolog - interpreters: - - mmi - extensions: - - ".m" - - ".moo" - tm_scope: source.mercury - language_id: 229 -Mermaid: - type: markup - color: "#ff3670" - aliases: - - mermaid example - extensions: - - ".mmd" - - ".mermaid" - tm_scope: source.mermaid - ace_mode: text - language_id: 385992043 -Meson: - type: programming - color: "#007800" - filenames: - - meson.build - - meson_options.txt - tm_scope: source.meson - ace_mode: text - language_id: 799141244 -Metal: - type: programming - color: "#8f14e9" - extensions: - - ".metal" - tm_scope: source.c++ - ace_mode: c_cpp - codemirror_mode: clike - codemirror_mime_type: text/x-c++src - language_id: 230 -Microsoft Developer Studio Project: - type: data - extensions: - - ".dsp" - tm_scope: none - ace_mode: text - language_id: 800983837 -Microsoft Visual Studio Solution: - type: data - extensions: - - ".sln" - tm_scope: source.solution - ace_mode: text - language_id: 849523096 -MiniD: - type: programming - extensions: - - ".minid" - tm_scope: none - ace_mode: text - language_id: 231 -MiniYAML: - type: data - color: "#ff1111" - tm_scope: source.miniyaml - extensions: - - ".yaml" - - ".yml" - ace_mode: yaml - codemirror_mode: yaml - codemirror_mime_type: text/x-yaml - language_id: 4896465 -Mint: - type: programming - extensions: - - ".mint" - ace_mode: text - color: "#02b046" - tm_scope: source.mint - language_id: 968740319 -Mirah: - type: programming - color: "#c7a938" - extensions: - - ".druby" - - ".duby" - - ".mirah" - tm_scope: source.ruby - ace_mode: ruby - codemirror_mode: ruby - codemirror_mime_type: text/x-ruby - language_id: 232 -Modelica: - type: programming - color: "#de1d31" - extensions: - - ".mo" - tm_scope: source.modelica - ace_mode: text - codemirror_mode: modelica - codemirror_mime_type: text/x-modelica - language_id: 233 -Modula-2: - type: programming - color: "#10253f" - extensions: - - ".mod" - tm_scope: source.modula2 - ace_mode: text - language_id: 234 -Modula-3: - type: programming - extensions: - - ".i3" - - ".ig" - - ".m3" - - ".mg" - color: "#223388" - ace_mode: text - tm_scope: source.modula-3 - language_id: 564743864 -Module Management System: - type: programming - extensions: - - ".mms" - - ".mmk" - filenames: - - descrip.mmk - - descrip.mms - tm_scope: none - ace_mode: text - language_id: 235 -Monkey: - type: programming - extensions: - - ".monkey" - - ".monkey2" - ace_mode: text - tm_scope: source.monkey - language_id: 236 -Monkey C: - type: programming - color: "#8D6747" - extensions: - - ".mc" - tm_scope: source.mc - ace_mode: c_cpp - codemirror_mode: clike - codemirror_mime_type: text/x-csrc - language_id: 231751931 -Moocode: - type: programming - extensions: - - ".moo" - tm_scope: none - ace_mode: text - language_id: 237 -MoonScript: - type: programming - color: "#ff4585" - extensions: - - ".moon" - interpreters: - - moon - tm_scope: source.moonscript - ace_mode: text - language_id: 238 -Motoko: - type: programming - color: "#fbb03b" - extensions: - - ".mo" - tm_scope: source.mo - ace_mode: text - language_id: 202937027 -Motorola 68K Assembly: - type: programming - color: "#005daa" - group: Assembly - aliases: - - m68k - extensions: - - ".asm" - - ".i" - - ".inc" - - ".s" - - ".x68" - tm_scope: source.m68k - ace_mode: assembly_x86 - language_id: 477582706 -Move: - type: programming - color: "#4a137a" - extensions: - - ".move" - tm_scope: source.move - ace_mode: text - language_id: 638334599 -Muse: - type: prose - extensions: - - ".muse" - tm_scope: text.muse - ace_mode: text - wrap: true - language_id: 474864066 - aliases: - - amusewiki - - emacs muse -Mustache: - type: markup - color: "#724b3b" - extensions: - - ".mustache" - tm_scope: text.html.smarty - ace_mode: smarty - codemirror_mode: smarty - codemirror_mime_type: text/x-smarty - language_id: 638334590 -Myghty: - type: programming - extensions: - - ".myt" - tm_scope: none - ace_mode: text - language_id: 239 -NASL: - type: programming - extensions: - - ".nasl" - - ".inc" - tm_scope: source.nasl - ace_mode: text - language_id: 171666519 -NCL: - type: programming - color: "#28431f" - extensions: - - ".ncl" - tm_scope: source.ncl - ace_mode: text - language_id: 240 -NEON: - type: data - extensions: - - ".neon" - tm_scope: source.neon - ace_mode: text - aliases: - - nette object notation - - ne-on - language_id: 481192983 -NL: - type: data - extensions: - - ".nl" - tm_scope: none - ace_mode: text - language_id: 241 -NPM Config: - type: data - color: "#cb3837" - group: INI - aliases: - - npmrc - filenames: - - ".npmrc" - tm_scope: source.ini.npmrc - ace_mode: text - language_id: 685022663 -NSIS: - type: programming - extensions: - - ".nsi" - - ".nsh" - tm_scope: source.nsis - ace_mode: text - codemirror_mode: nsis - codemirror_mime_type: text/x-nsis - language_id: 242 -NWScript: - type: programming - color: "#111522" - extensions: - - ".nss" - tm_scope: source.c.nwscript - ace_mode: c_cpp - codemirror_mode: clike - codemirror_mime_type: text/x-csrc - language_id: 731233819 -Nasal: - type: programming - color: "#1d2c4e" - extensions: - - ".nas" - tm_scope: none - ace_mode: text - language_id: 178322513 -Nearley: - type: programming - ace_mode: text - color: "#990000" - extensions: - - ".ne" - - ".nearley" - tm_scope: source.ne - language_id: 521429430 -Nemerle: - type: programming - color: "#3d3c6e" - extensions: - - ".n" - tm_scope: source.nemerle - ace_mode: text - language_id: 243 -NetLinx: - type: programming - color: "#0aa0ff" - extensions: - - ".axs" - - ".axi" - tm_scope: source.netlinx - ace_mode: text - language_id: 244 -NetLinx+ERB: - type: programming - color: "#747faa" - extensions: - - ".axs.erb" - - ".axi.erb" - tm_scope: source.netlinx.erb - ace_mode: text - language_id: 245 -NetLogo: - type: programming - color: "#ff6375" - extensions: - - ".nlogo" - tm_scope: source.lisp - ace_mode: lisp - codemirror_mode: commonlisp - codemirror_mime_type: text/x-common-lisp - language_id: 246 -NewLisp: - type: programming - color: "#87AED7" - extensions: - - ".nl" - - ".lisp" - - ".lsp" - interpreters: - - newlisp - tm_scope: source.lisp - ace_mode: lisp - codemirror_mode: commonlisp - codemirror_mime_type: text/x-common-lisp - language_id: 247 -Nextflow: - type: programming - ace_mode: groovy - tm_scope: source.nextflow - color: "#3ac486" - extensions: - - ".nf" - filenames: - - nextflow.config - interpreters: - - nextflow - language_id: 506780613 -Nginx: - type: data - color: "#009639" - extensions: - - ".nginx" - - ".nginxconf" - - ".vhost" - filenames: - - nginx.conf - tm_scope: source.nginx - aliases: - - nginx configuration file - ace_mode: text - codemirror_mode: nginx - codemirror_mime_type: text/x-nginx-conf - language_id: 248 -Nim: - type: programming - color: "#ffc200" - extensions: - - ".nim" - - ".nim.cfg" - - ".nimble" - - ".nimrod" - - ".nims" - filenames: - - nim.cfg - ace_mode: text - tm_scope: source.nim - language_id: 249 -Ninja: - type: data - tm_scope: source.ninja - extensions: - - ".ninja" - ace_mode: text - language_id: 250 -Nit: - type: programming - color: "#009917" - extensions: - - ".nit" - tm_scope: source.nit - ace_mode: text - language_id: 251 -Nix: - type: programming - color: "#7e7eff" - extensions: - - ".nix" - aliases: - - nixos - tm_scope: source.nix - ace_mode: nix - language_id: 252 -Nu: - type: programming - color: "#c9df40" - aliases: - - nush - extensions: - - ".nu" - filenames: - - Nukefile - tm_scope: source.nu - ace_mode: scheme - codemirror_mode: scheme - codemirror_mime_type: text/x-scheme - interpreters: - - nush - language_id: 253 -NumPy: - type: programming - color: "#9C8AF9" - group: Python - extensions: - - ".numpy" - - ".numpyw" - - ".numsc" - tm_scope: none - ace_mode: text - codemirror_mode: python - codemirror_mime_type: text/x-python - language_id: 254 -Nunjucks: - type: markup - color: "#3d8137" - extensions: - - ".njk" - aliases: - - njk - tm_scope: text.html.nunjucks - ace_mode: nunjucks - language_id: 461856962 -OASv2-json: - type: data - color: "#85ea2d" - extensions: - - ".json" - group: OpenAPI Specification v2 - tm_scope: source.json - ace_mode: json - codemirror_mode: javascript - codemirror_mime_type: application/json - language_id: 834374816 -OASv2-yaml: - type: data - color: "#85ea2d" - extensions: - - ".yaml" - - ".yml" - group: OpenAPI Specification v2 - tm_scope: source.yaml - ace_mode: yaml - codemirror_mode: yaml - codemirror_mime_type: text/x-yaml - language_id: 105187618 -OASv3-json: - type: data - color: "#85ea2d" - extensions: - - ".json" - group: OpenAPI Specification v3 - tm_scope: source.json - ace_mode: json - codemirror_mode: javascript - codemirror_mime_type: application/json - language_id: 980062566 -OASv3-yaml: - type: data - color: "#85ea2d" - extensions: - - ".yaml" - - ".yml" - group: OpenAPI Specification v3 - tm_scope: source.yaml - ace_mode: yaml - codemirror_mode: yaml - codemirror_mime_type: text/x-yaml - language_id: 51239111 -OCaml: - type: programming - ace_mode: ocaml - codemirror_mode: mllike - codemirror_mime_type: text/x-ocaml - color: "#3be133" - extensions: - - ".ml" - - ".eliom" - - ".eliomi" - - ".ml4" - - ".mli" - - ".mll" - - ".mly" - interpreters: - - ocaml - - ocamlrun - - ocamlscript - tm_scope: source.ocaml - language_id: 255 -ObjDump: - type: data - extensions: - - ".objdump" - tm_scope: objdump.x86asm - ace_mode: assembly_x86 - language_id: 256 -Object Data Instance Notation: - type: data - extensions: - - ".odin" - tm_scope: source.odin-ehr - ace_mode: text - language_id: 985227236 -ObjectScript: - type: programming - extensions: - - ".cls" - language_id: 202735509 - tm_scope: source.objectscript - color: "#424893" - ace_mode: text -Objective-C: - type: programming - tm_scope: source.objc - color: "#438eff" - aliases: - - obj-c - - objc - - objectivec - extensions: - - ".m" - - ".h" - ace_mode: objectivec - codemirror_mode: clike - codemirror_mime_type: text/x-objectivec - language_id: 257 -Objective-C++: - type: programming - tm_scope: source.objc++ - color: "#6866fb" - aliases: - - obj-c++ - - objc++ - - objectivec++ - extensions: - - ".mm" - ace_mode: objectivec - codemirror_mode: clike - codemirror_mime_type: text/x-objectivec - language_id: 258 -Objective-J: - type: programming - color: "#ff0c5a" - aliases: - - obj-j - - objectivej - - objj - extensions: - - ".j" - - ".sj" - tm_scope: source.js.objj - ace_mode: text - language_id: 259 -Odin: - type: programming - color: "#60AFFE" - aliases: - - odinlang - - odin-lang - extensions: - - ".odin" - tm_scope: source.odin - ace_mode: text - language_id: 889244082 -Omgrofl: - type: programming - extensions: - - ".omgrofl" - color: "#cabbff" - tm_scope: none - ace_mode: text - language_id: 260 -Opa: - type: programming - extensions: - - ".opa" - tm_scope: source.opa - ace_mode: text - language_id: 261 -Opal: - type: programming - color: "#f7ede0" - extensions: - - ".opal" - tm_scope: source.opal - ace_mode: text - language_id: 262 -Open Policy Agent: - type: programming - color: "#7d9199" - ace_mode: text - extensions: - - ".rego" - language_id: 840483232 - tm_scope: source.rego -OpenAPI Specification v2: - aliases: - - oasv2 - type: data - color: "#85ea2d" - tm_scope: none - ace_mode: text - language_id: 848295328 -OpenAPI Specification v3: - aliases: - - oasv3 - type: data - color: "#85ea2d" - tm_scope: none - ace_mode: text - language_id: 557959099 -OpenCL: - type: programming - color: "#ed2e2d" - group: C - extensions: - - ".cl" - - ".opencl" - tm_scope: source.c - ace_mode: c_cpp - codemirror_mode: clike - codemirror_mime_type: text/x-csrc - language_id: 263 -OpenEdge ABL: - type: programming - color: "#5ce600" - aliases: - - progress - - openedge - - abl - extensions: - - ".p" - - ".cls" - - ".w" - tm_scope: source.abl - ace_mode: text - language_id: 264 -OpenQASM: - type: programming - extensions: - - ".qasm" - color: "#AA70FF" - tm_scope: source.qasm - ace_mode: text - language_id: 153739399 -OpenRC runscript: - type: programming - group: Shell - aliases: - - openrc - interpreters: - - openrc-run - tm_scope: source.shell - ace_mode: sh - codemirror_mode: shell - codemirror_mime_type: text/x-sh - language_id: 265 -OpenSCAD: - type: programming - color: "#e5cd45" - extensions: - - ".scad" - tm_scope: source.scad - ace_mode: scad - language_id: 266 -OpenStep Property List: - type: data - extensions: - - ".plist" - - ".glyphs" - tm_scope: source.plist - ace_mode: text - language_id: 598917541 -OpenType Feature File: - type: data - aliases: - - AFDKO - extensions: - - ".fea" - tm_scope: source.opentype - ace_mode: text - language_id: 374317347 -Option List: - type: data - color: "#476732" - aliases: - - opts - - ackrc - filenames: - - ".ackrc" - - ackrc - - mocha.opts - tm_scope: source.opts - ace_mode: sh - codemirror_mode: shell - codemirror_mime_type: text/x-sh - language_id: 723589315 -Org: - type: prose - color: "#77aa99" - wrap: true - extensions: - - ".org" - tm_scope: none - ace_mode: text - language_id: 267 -Ox: - type: programming - extensions: - - ".ox" - - ".oxh" - - ".oxo" - tm_scope: source.ox - ace_mode: text - language_id: 268 -Oxygene: - type: programming - color: "#cdd0e3" - extensions: - - ".oxygene" - tm_scope: none - ace_mode: text - language_id: 269 -Oz: - type: programming - color: "#fab738" - extensions: - - ".oz" - tm_scope: source.oz - ace_mode: text - codemirror_mode: oz - codemirror_mime_type: text/x-oz - language_id: 270 -P4: - type: programming - color: "#7055b5" - extensions: - - ".p4" - tm_scope: source.p4 - ace_mode: text - language_id: 348895984 -PDDL: - type: programming - color: "#0d00ff" - extensions: - - ".pddl" - tm_scope: source.pddl - ace_mode: text - language_id: 736235603 -PEG.js: - type: programming - color: "#234d6b" - extensions: - - ".pegjs" - tm_scope: source.pegjs - ace_mode: javascript - codemirror_mode: javascript - codemirror_mime_type: text/javascript - language_id: 81442128 -PHP: - type: programming - tm_scope: text.html.php - ace_mode: php - codemirror_mode: php - codemirror_mime_type: application/x-httpd-php - color: "#4F5D95" - extensions: - - ".php" - - ".aw" - - ".ctp" - - ".fcgi" - - ".inc" - - ".php3" - - ".php4" - - ".php5" - - ".phps" - - ".phpt" - filenames: - - ".php" - - ".php_cs" - - ".php_cs.dist" - - Phakefile - interpreters: - - php - aliases: - - inc - language_id: 272 -PLSQL: - type: programming - ace_mode: sql - codemirror_mode: sql - codemirror_mime_type: text/x-plsql - tm_scope: none - color: "#dad8d8" - extensions: - - ".pls" - - ".bdy" - - ".ddl" - - ".fnc" - - ".pck" - - ".pkb" - - ".pks" - - ".plb" - - ".plsql" - - ".prc" - - ".spc" - - ".sql" - - ".tpb" - - ".tps" - - ".trg" - - ".vw" - language_id: 273 -PLpgSQL: - type: programming - color: "#336790" - ace_mode: pgsql - codemirror_mode: sql - codemirror_mime_type: text/x-sql - tm_scope: source.sql - extensions: - - ".pgsql" - - ".sql" - language_id: 274 -POV-Ray SDL: - type: programming - color: "#6bac65" - aliases: - - pov-ray - - povray - extensions: - - ".pov" - - ".inc" - tm_scope: source.pov-ray sdl - ace_mode: text - language_id: 275 -Pan: - type: programming - color: "#cc0000" - extensions: - - ".pan" - tm_scope: source.pan - ace_mode: text - language_id: 276 -Papyrus: - type: programming - color: "#6600cc" - extensions: - - ".psc" - tm_scope: source.papyrus.skyrim - ace_mode: text - language_id: 277 -Parrot: - type: programming - color: "#f3ca0a" - extensions: - - ".parrot" - tm_scope: none - ace_mode: text - language_id: 278 -Parrot Assembly: - group: Parrot - type: programming - aliases: - - pasm - extensions: - - ".pasm" - interpreters: - - parrot - tm_scope: none - ace_mode: text - language_id: 279 -Parrot Internal Representation: - group: Parrot - tm_scope: source.parrot.pir - type: programming - aliases: - - pir - extensions: - - ".pir" - interpreters: - - parrot - ace_mode: text - language_id: 280 -Pascal: - type: programming - color: "#E3F171" - aliases: - - delphi - - objectpascal - extensions: - - ".pas" - - ".dfm" - - ".dpr" - - ".inc" - - ".lpr" - - ".pascal" - - ".pp" - interpreters: - - instantfpc - tm_scope: source.pascal - ace_mode: pascal - codemirror_mode: pascal - codemirror_mime_type: text/x-pascal - language_id: 281 -Pawn: - type: programming - color: "#dbb284" - extensions: - - ".pwn" - - ".inc" - - ".sma" - tm_scope: source.pawn - ace_mode: text - language_id: 271 -Pep8: - type: programming - color: "#C76F5B" - extensions: - - ".pep" - ace_mode: text - tm_scope: source.pep8 - language_id: 840372442 -Perl: - type: programming - tm_scope: source.perl - ace_mode: perl - codemirror_mode: perl - codemirror_mime_type: text/x-perl - color: "#0298c3" - extensions: - - ".pl" - - ".al" - - ".cgi" - - ".fcgi" - - ".perl" - - ".ph" - - ".plx" - - ".pm" - - ".psgi" - - ".t" - filenames: - - ".latexmkrc" - - Makefile.PL - - Rexfile - - ack - - cpanfile - - latexmkrc - interpreters: - - cperl - - perl - aliases: - - cperl - language_id: 282 -Pic: - type: markup - group: Roff - tm_scope: source.pic - extensions: - - ".pic" - - ".chem" - ace_mode: text - codemirror_mode: troff - codemirror_mime_type: text/troff - language_id: 425 -Pickle: - type: data - extensions: - - ".pkl" - tm_scope: none - ace_mode: text - language_id: 284 -PicoLisp: - type: programming - color: "#6067af" - extensions: - - ".l" - interpreters: - - picolisp - - pil - tm_scope: source.lisp - ace_mode: lisp - language_id: 285 -PigLatin: - type: programming - color: "#fcd7de" - extensions: - - ".pig" - tm_scope: source.pig_latin - ace_mode: text - language_id: 286 -Pike: - type: programming - color: "#005390" - extensions: - - ".pike" - - ".pmod" - interpreters: - - pike - tm_scope: source.pike - ace_mode: text - language_id: 287 -PlantUML: - type: data - extensions: - - ".puml" - - ".iuml" - - ".plantuml" - tm_scope: source.wsd - ace_mode: text - language_id: 833504686 -Pod: - type: prose - ace_mode: perl - codemirror_mode: perl - codemirror_mime_type: text/x-perl - wrap: true - extensions: - - ".pod" - interpreters: - - perl - tm_scope: none - language_id: 288 -Pod 6: - type: prose - ace_mode: perl - tm_scope: source.raku - wrap: true - extensions: - - ".pod" - - ".pod6" - interpreters: - - perl6 - language_id: 155357471 -PogoScript: - type: programming - color: "#d80074" - extensions: - - ".pogo" - tm_scope: source.pogoscript - ace_mode: text - language_id: 289 -Polar: - type: programming - color: "#ae81ff" - extensions: - - ".polar" - tm_scope: source.polar - ace_mode: text - language_id: 839112914 -Pony: - type: programming - extensions: - - ".pony" - tm_scope: source.pony - ace_mode: text - language_id: 290 -Portugol: - type: programming - color: "#f8bd00" - extensions: - - ".por" - tm_scope: source.portugol - ace_mode: text - language_id: 832391833 -PostCSS: - type: markup - color: "#dc3a0c" - tm_scope: source.postcss - group: CSS - extensions: - - ".pcss" - - ".postcss" - ace_mode: text - language_id: 262764437 -PostScript: - type: markup - color: "#da291c" - extensions: - - ".ps" - - ".eps" - - ".epsi" - - ".pfa" - tm_scope: source.postscript - aliases: - - postscr - ace_mode: text - language_id: 291 -PowerBuilder: - type: programming - color: "#8f0f8d" - extensions: - - ".pbt" - - ".sra" - - ".sru" - - ".srw" - tm_scope: none - ace_mode: text - language_id: 292 -PowerShell: - type: programming - color: "#012456" - tm_scope: source.powershell - ace_mode: powershell - codemirror_mode: powershell - codemirror_mime_type: application/x-powershell - aliases: - - posh - - pwsh - extensions: - - ".ps1" - - ".psd1" - - ".psm1" - interpreters: - - pwsh - language_id: 293 -Prisma: - type: data - color: "#0c344b" - extensions: - - ".prisma" - tm_scope: source.prisma - ace_mode: text - language_id: 499933428 -Processing: - type: programming - color: "#0096D8" - extensions: - - ".pde" - tm_scope: source.processing - ace_mode: text - language_id: 294 -Procfile: - type: programming - color: "#3B2F63" - filenames: - - Procfile - tm_scope: source.procfile - ace_mode: batchfile - language_id: 305313959 -Proguard: - type: data - extensions: - - ".pro" - tm_scope: none - ace_mode: text - language_id: 716513858 -Prolog: - type: programming - color: "#74283c" - extensions: - - ".pl" - - ".pro" - - ".prolog" - - ".yap" - interpreters: - - swipl - - yap - tm_scope: source.prolog - ace_mode: prolog - language_id: 295 -Promela: - type: programming - color: "#de0000" - tm_scope: source.promela - ace_mode: text - extensions: - - ".pml" - language_id: 441858312 -Propeller Spin: - type: programming - color: "#7fa2a7" - extensions: - - ".spin" - tm_scope: source.spin - ace_mode: text - language_id: 296 -Protocol Buffer: - type: data - aliases: - - protobuf - - Protocol Buffers - extensions: - - ".proto" - tm_scope: source.proto - ace_mode: protobuf - codemirror_mode: protobuf - codemirror_mime_type: text/x-protobuf - language_id: 297 -Protocol Buffer Text Format: - type: data - aliases: - - text proto - - protobuf text format - extensions: - - ".textproto" - - ".pbt" - - ".pbtxt" - tm_scope: source.textproto - ace_mode: text - language_id: 436568854 -Public Key: - type: data - extensions: - - ".asc" - - ".pub" - tm_scope: none - ace_mode: text - codemirror_mode: asciiarmor - codemirror_mime_type: application/pgp - language_id: 298 -Pug: - type: markup - color: "#a86454" - extensions: - - ".jade" - - ".pug" - tm_scope: text.jade - ace_mode: jade - codemirror_mode: pug - codemirror_mime_type: text/x-pug - language_id: 179 -Puppet: - type: programming - color: "#302B6D" - extensions: - - ".pp" - filenames: - - Modulefile - ace_mode: text - codemirror_mode: puppet - codemirror_mime_type: text/x-puppet - tm_scope: source.puppet - language_id: 299 -Pure Data: - type: data - extensions: - - ".pd" - tm_scope: none - ace_mode: text - language_id: 300 -PureBasic: - type: programming - color: "#5a6986" - extensions: - - ".pb" - - ".pbi" - tm_scope: none - ace_mode: text - language_id: 301 -PureScript: - type: programming - color: "#1D222D" - extensions: - - ".purs" - tm_scope: source.purescript - ace_mode: haskell - codemirror_mode: haskell - codemirror_mime_type: text/x-haskell - language_id: 302 -Python: - type: programming - tm_scope: source.python - ace_mode: python - codemirror_mode: python - codemirror_mime_type: text/x-python - color: "#3572A5" - extensions: - - ".py" - - ".cgi" - - ".fcgi" - - ".gyp" - - ".gypi" - - ".lmi" - - ".py3" - - ".pyde" - - ".pyi" - - ".pyp" - - ".pyt" - - ".pyw" - - ".rpy" - - ".smk" - - ".spec" - - ".tac" - - ".wsgi" - - ".xpy" - filenames: - - ".gclient" - - DEPS - - SConscript - - SConstruct - - Snakefile - - wscript - interpreters: - - python - - python2 - - python3 - aliases: - - python3 - - rusthon - language_id: 303 -Python console: - type: programming - color: "#3572A5" - group: Python - aliases: - - pycon - tm_scope: text.python.console - ace_mode: text - language_id: 428 -Python traceback: - type: data - color: "#3572A5" - group: Python - extensions: - - ".pytb" - tm_scope: text.python.traceback - ace_mode: text - language_id: 304 -Q#: - type: programming - extensions: - - ".qs" - aliases: - - qsharp - color: "#fed659" - ace_mode: text - tm_scope: source.qsharp - language_id: 697448245 -QML: - type: programming - color: "#44a51c" - extensions: - - ".qml" - - ".qbs" - tm_scope: source.qml - ace_mode: text - language_id: 305 -QMake: - type: programming - extensions: - - ".pro" - - ".pri" - interpreters: - - qmake - tm_scope: source.qmake - ace_mode: text - language_id: 306 -Qt Script: - type: programming - ace_mode: javascript - codemirror_mode: javascript - codemirror_mime_type: text/javascript - extensions: - - ".qs" - filenames: - - installscript.qs - - toolchain_installscript.qs - color: "#00b841" - tm_scope: source.js - language_id: 558193693 -Quake: - type: programming - filenames: - - m3makefile - - m3overrides - color: "#882233" - ace_mode: text - tm_scope: source.quake - language_id: 375265331 -R: - type: programming - color: "#198CE7" - aliases: - - R - - Rscript - - splus - extensions: - - ".r" - - ".rd" - - ".rsx" - filenames: - - ".Rprofile" - - expr-dist - interpreters: - - Rscript - tm_scope: source.r - ace_mode: r - codemirror_mode: r - codemirror_mime_type: text/x-rsrc - language_id: 307 -RAML: - type: markup - ace_mode: yaml - codemirror_mode: yaml - codemirror_mime_type: text/x-yaml - tm_scope: source.yaml - color: "#77d9fb" - extensions: - - ".raml" - language_id: 308 -RDoc: - type: prose - color: "#701516" - ace_mode: rdoc - wrap: true - extensions: - - ".rdoc" - tm_scope: text.rdoc - language_id: 309 -REALbasic: - type: programming - extensions: - - ".rbbas" - - ".rbfrm" - - ".rbmnu" - - ".rbres" - - ".rbtbar" - - ".rbuistate" - tm_scope: source.vbnet - ace_mode: text - language_id: 310 -REXX: - type: programming - color: "#d90e09" - aliases: - - arexx - extensions: - - ".rexx" - - ".pprx" - - ".rex" - interpreters: - - regina - - rexx - tm_scope: source.rexx - ace_mode: text - language_id: 311 -RMarkdown: - type: prose - color: "#198ce7" - wrap: true - ace_mode: markdown - codemirror_mode: gfm - codemirror_mime_type: text/x-gfm - extensions: - - ".qmd" - - ".rmd" - tm_scope: source.gfm - language_id: 313 -RPC: - type: programming - aliases: - - rpcgen - - oncrpc - - xdr - ace_mode: c_cpp - extensions: - - ".x" - tm_scope: source.c - language_id: 1031374237 -RPGLE: - type: programming - ace_mode: text - color: "#2BDE21" - aliases: - - ile rpg - - sqlrpgle - extensions: - - ".rpgle" - - ".sqlrpgle" - tm_scope: source.rpgle - language_id: 609977990 -RPM Spec: - type: data - tm_scope: source.rpm-spec - extensions: - - ".spec" - aliases: - - specfile - ace_mode: text - codemirror_mode: rpm - codemirror_mime_type: text/x-rpm-spec - language_id: 314 -RUNOFF: - type: markup - color: "#665a4e" - extensions: - - ".rnh" - - ".rno" - wrap: true - tm_scope: text.runoff - ace_mode: text - language_id: 315 -Racket: - type: programming - color: "#3c5caa" - extensions: - - ".rkt" - - ".rktd" - - ".rktl" - - ".scrbl" - interpreters: - - racket - tm_scope: source.racket - ace_mode: lisp - language_id: 316 -Ragel: - type: programming - color: "#9d5200" - extensions: - - ".rl" - aliases: - - ragel-rb - - ragel-ruby - tm_scope: none - ace_mode: text - language_id: 317 -Raku: - type: programming - color: "#0000fb" - extensions: - - ".6pl" - - ".6pm" - - ".nqp" - - ".p6" - - ".p6l" - - ".p6m" - - ".pl" - - ".pl6" - - ".pm" - - ".pm6" - - ".raku" - - ".rakumod" - - ".t" - interpreters: - - perl6 - - raku - - rakudo - aliases: - - perl6 - - perl-6 - tm_scope: source.raku - ace_mode: perl - codemirror_mode: perl - codemirror_mime_type: text/x-perl - language_id: 283 -Rascal: - type: programming - color: "#fffaa0" - extensions: - - ".rsc" - tm_scope: source.rascal - ace_mode: text - language_id: 173616037 -Raw token data: - type: data - aliases: - - raw - extensions: - - ".raw" - tm_scope: none - ace_mode: text - language_id: 318 -ReScript: - type: programming - color: "#ed5051" - ace_mode: rust - codemirror_mode: rust - codemirror_mime_type: text/x-rustsrc - extensions: - - ".res" - interpreters: - - ocaml - tm_scope: source.rescript - language_id: 501875647 -Readline Config: - type: data - group: INI - aliases: - - inputrc - - readline - filenames: - - ".inputrc" - - inputrc - tm_scope: source.inputrc - ace_mode: text - language_id: 538732839 -Reason: - type: programming - color: "#ff5847" - ace_mode: rust - codemirror_mode: rust - codemirror_mime_type: text/x-rustsrc - extensions: - - ".re" - - ".rei" - tm_scope: source.reason - language_id: 869538413 -ReasonLIGO: - type: programming - color: "#ff5847" - ace_mode: rust - codemirror_mode: rust - codemirror_mime_type: text/x-rustsrc - group: LigoLANG - extensions: - - ".religo" - tm_scope: source.religo - language_id: 319002153 -Rebol: - type: programming - color: "#358a5b" - extensions: - - ".reb" - - ".r" - - ".r2" - - ".r3" - - ".rebol" - ace_mode: text - tm_scope: source.rebol - language_id: 319 -Record Jar: - type: data - filenames: - - language-subtag-registry.txt - tm_scope: source.record-jar - codemirror_mode: properties - codemirror_mime_type: text/x-properties - ace_mode: text - color: "#0673ba" - language_id: 865765202 -Red: - type: programming - color: "#f50000" - extensions: - - ".red" - - ".reds" - aliases: - - red/system - tm_scope: source.red - ace_mode: text - language_id: 320 -Redcode: - type: programming - extensions: - - ".cw" - tm_scope: none - ace_mode: text - language_id: 321 -Redirect Rules: - type: data - aliases: - - redirects - filenames: - - _redirects - tm_scope: source.redirects - ace_mode: text - language_id: 1020148948 -Regular Expression: - type: data - color: "#009a00" - extensions: - - ".regexp" - - ".regex" - aliases: - - regexp - - regex - ace_mode: text - tm_scope: source.regexp - language_id: 363378884 -Ren'Py: - type: programming - aliases: - - renpy - color: "#ff7f7f" - extensions: - - ".rpy" - tm_scope: source.renpy - ace_mode: python - language_id: 322 -RenderScript: - type: programming - extensions: - - ".rs" - - ".rsh" - tm_scope: none - ace_mode: text - language_id: 323 -Rich Text Format: - type: markup - extensions: - - ".rtf" - tm_scope: text.rtf - ace_mode: text - language_id: 51601661 -Ring: - type: programming - color: "#2D54CB" - extensions: - - ".ring" - tm_scope: source.ring - ace_mode: text - language_id: 431 -Riot: - type: markup - color: "#A71E49" - ace_mode: html - extensions: - - ".riot" - tm_scope: text.html.riot - language_id: 878396783 -RobotFramework: - type: programming - color: "#00c0b5" - extensions: - - ".robot" - tm_scope: text.robot - ace_mode: text - language_id: 324 -Roff: - type: markup - color: "#ecdebe" - extensions: - - ".roff" - - ".1" - - ".1in" - - ".1m" - - ".1x" - - ".2" - - ".3" - - ".3in" - - ".3m" - - ".3p" - - ".3pm" - - ".3qt" - - ".3x" - - ".4" - - ".5" - - ".6" - - ".7" - - ".8" - - ".9" - - ".l" - - ".man" - - ".mdoc" - - ".me" - - ".ms" - - ".n" - - ".nr" - - ".rno" - - ".tmac" - filenames: - - eqnrc - - mmn - - mmt - - troffrc - - troffrc-end - tm_scope: text.roff - aliases: - - groff - - man - - manpage - - man page - - man-page - - mdoc - - nroff - - troff - wrap: true - ace_mode: text - codemirror_mode: troff - codemirror_mime_type: text/troff - language_id: 141 -Roff Manpage: - type: markup - color: "#ecdebe" - group: Roff - extensions: - - ".1" - - ".1in" - - ".1m" - - ".1x" - - ".2" - - ".3" - - ".3in" - - ".3m" - - ".3p" - - ".3pm" - - ".3qt" - - ".3x" - - ".4" - - ".5" - - ".6" - - ".7" - - ".8" - - ".9" - - ".man" - - ".mdoc" - wrap: true - tm_scope: text.roff - ace_mode: text - codemirror_mode: troff - codemirror_mime_type: text/troff - language_id: 612669833 -Rouge: - type: programming - ace_mode: clojure - codemirror_mode: clojure - codemirror_mime_type: text/x-clojure - color: "#cc0088" - extensions: - - ".rg" - tm_scope: source.clojure - language_id: 325 -RouterOS Script: - type: programming - ace_mode: text - extensions: - - ".rsc" - interpreters: - - RouterOS - color: "#DE3941" - tm_scope: none - language_id: 592853203 -Ruby: - type: programming - tm_scope: source.ruby - ace_mode: ruby - codemirror_mode: ruby - codemirror_mime_type: text/x-ruby - color: "#701516" - aliases: - - jruby - - macruby - - rake - - rb - - rbx - extensions: - - ".rb" - - ".builder" - - ".eye" - - ".fcgi" - - ".gemspec" - - ".god" - - ".jbuilder" - - ".mspec" - - ".pluginspec" - - ".podspec" - - ".prawn" - - ".rabl" - - ".rake" - - ".rbi" - - ".rbuild" - - ".rbw" - - ".rbx" - - ".ru" - - ".ruby" - - ".spec" - - ".thor" - - ".watchr" - interpreters: - - ruby - - macruby - - rake - - jruby - - rbx - filenames: - - ".irbrc" - - ".pryrc" - - ".simplecov" - - Appraisals - - Berksfile - - Brewfile - - Buildfile - - Capfile - - Dangerfile - - Deliverfile - - Fastfile - - Gemfile - - Guardfile - - Jarfile - - Mavenfile - - Podfile - - Puppetfile - - Rakefile - - Snapfile - - Steepfile - - Thorfile - - Vagrantfile - - buildfile - language_id: 326 -Rust: - type: programming - aliases: - - rs - color: "#dea584" - extensions: - - ".rs" - - ".rs.in" - tm_scope: source.rust - ace_mode: rust - codemirror_mode: rust - codemirror_mime_type: text/x-rustsrc - language_id: 327 -SAS: - type: programming - color: "#B34936" - extensions: - - ".sas" - tm_scope: source.sas - ace_mode: text - codemirror_mode: sas - codemirror_mime_type: text/x-sas - language_id: 328 -SCSS: - type: markup - color: "#c6538c" - tm_scope: source.css.scss - ace_mode: scss - codemirror_mode: css - codemirror_mime_type: text/x-scss - extensions: - - ".scss" - language_id: 329 -SELinux Policy: - aliases: - - SELinux Kernel Policy Language - - sepolicy - type: data - tm_scope: source.sepolicy - extensions: - - ".te" - filenames: - - file_contexts - - genfs_contexts - - initial_sids - - port_contexts - - security_classes - ace_mode: text - language_id: 880010326 -SMT: - type: programming - extensions: - - ".smt2" - - ".smt" - interpreters: - - boolector - - cvc4 - - mathsat5 - - opensmt - - smtinterpol - - smt-rat - - stp - - verit - - yices2 - - z3 - tm_scope: source.smt - ace_mode: text - language_id: 330 -SPARQL: - type: data - color: "#0C4597" - tm_scope: source.sparql - ace_mode: text - codemirror_mode: sparql - codemirror_mime_type: application/sparql-query - extensions: - - ".sparql" - - ".rq" - language_id: 331 -SQF: - type: programming - color: "#3F3F3F" - extensions: - - ".sqf" - - ".hqf" - tm_scope: source.sqf - ace_mode: text - language_id: 332 -SQL: - type: data - color: "#e38c00" - tm_scope: source.sql - ace_mode: sql - codemirror_mode: sql - codemirror_mime_type: text/x-sql - extensions: - - ".sql" - - ".cql" - - ".ddl" - - ".inc" - - ".mysql" - - ".prc" - - ".tab" - - ".udf" - - ".viw" - language_id: 333 -SQLPL: - type: programming - color: "#e38c00" - ace_mode: sql - codemirror_mode: sql - codemirror_mime_type: text/x-sql - tm_scope: source.sql - extensions: - - ".sql" - - ".db2" - language_id: 334 -SRecode Template: - type: markup - color: "#348a34" - tm_scope: source.lisp - ace_mode: lisp - codemirror_mode: commonlisp - codemirror_mime_type: text/x-common-lisp - extensions: - - ".srt" - language_id: 335 -SSH Config: - type: data - group: INI - filenames: - - ssh-config - - ssh_config - - sshconfig - - sshconfig.snip - - sshd-config - - sshd_config - ace_mode: text - tm_scope: source.ssh-config - language_id: 554920715 -STAR: - type: data - extensions: - - ".star" - tm_scope: source.star - ace_mode: text - language_id: 424510560 -STL: - type: data - color: "#373b5e" - aliases: - - ascii stl - - stla - extensions: - - ".stl" - tm_scope: source.stl - ace_mode: text - language_id: 455361735 -STON: - type: data - group: Smalltalk - extensions: - - ".ston" - tm_scope: source.smalltalk - ace_mode: text - language_id: 336 -SVG: - type: data - color: "#ff9900" - extensions: - - ".svg" - tm_scope: text.xml.svg - ace_mode: xml - codemirror_mode: xml - codemirror_mime_type: text/xml - language_id: 337 -SWIG: - type: programming - extensions: - - ".i" - tm_scope: source.c++ - ace_mode: c_cpp - codemirror_mode: clike - codemirror_mime_type: text/x-c++src - language_id: 1066250075 -Sage: - type: programming - extensions: - - ".sage" - - ".sagews" - tm_scope: source.python - ace_mode: python - codemirror_mode: python - codemirror_mime_type: text/x-python - language_id: 338 -SaltStack: - type: programming - color: "#646464" - aliases: - - saltstate - - salt - extensions: - - ".sls" - tm_scope: source.yaml.salt - ace_mode: yaml - codemirror_mode: yaml - codemirror_mime_type: text/x-yaml - language_id: 339 -Sass: - type: markup - color: "#a53b70" - tm_scope: source.sass - extensions: - - ".sass" - ace_mode: sass - codemirror_mode: sass - codemirror_mime_type: text/x-sass - language_id: 340 -Scala: - type: programming - tm_scope: source.scala - ace_mode: scala - codemirror_mode: clike - codemirror_mime_type: text/x-scala - color: "#c22d40" - extensions: - - ".scala" - - ".kojo" - - ".sbt" - - ".sc" - interpreters: - - scala - language_id: 341 -Scaml: - type: markup - color: "#bd181a" - extensions: - - ".scaml" - tm_scope: source.scaml - ace_mode: text - language_id: 342 -Scenic: - type: programming - color: "#fdc700" - extensions: - - ".scenic" - tm_scope: source.scenic - ace_mode: text - interpreters: - - scenic - language_id: 619814037 -Scheme: - type: programming - color: "#1e4aec" - extensions: - - ".scm" - - ".sch" - - ".sld" - - ".sls" - - ".sps" - - ".ss" - interpreters: - - scheme - - guile - - bigloo - - chicken - - csi - - gosh - - r6rs - tm_scope: source.scheme - ace_mode: scheme - codemirror_mode: scheme - codemirror_mime_type: text/x-scheme - language_id: 343 -Scilab: - type: programming - color: "#ca0f21" - extensions: - - ".sci" - - ".sce" - - ".tst" - tm_scope: source.scilab - ace_mode: text - language_id: 344 -Self: - type: programming - color: "#0579aa" - extensions: - - ".self" - tm_scope: none - ace_mode: text - language_id: 345 -ShaderLab: - type: programming - color: "#222c37" - extensions: - - ".shader" - ace_mode: text - tm_scope: source.shaderlab - language_id: 664257356 -Shell: - type: programming - color: "#89e051" - aliases: - - sh - - shell-script - - bash - - zsh - extensions: - - ".sh" - - ".bash" - - ".bats" - - ".cgi" - - ".command" - - ".env" - - ".fcgi" - - ".ksh" - - ".sh.in" - - ".tmux" - - ".tool" - - ".zsh" - - ".zsh-theme" - filenames: - - ".bash_aliases" - - ".bash_history" - - ".bash_logout" - - ".bash_profile" - - ".bashrc" - - ".cshrc" - - ".env" - - ".env.example" - - ".flaskenv" - - ".kshrc" - - ".login" - - ".profile" - - ".zlogin" - - ".zlogout" - - ".zprofile" - - ".zshenv" - - ".zshrc" - - 9fs - - PKGBUILD - - bash_aliases - - bash_logout - - bash_profile - - bashrc - - cshrc - - gradlew - - kshrc - - login - - man - - profile - - zlogin - - zlogout - - zprofile - - zshenv - - zshrc - interpreters: - - ash - - bash - - dash - - ksh - - mksh - - pdksh - - rc - - sh - - zsh - tm_scope: source.shell - ace_mode: sh - codemirror_mode: shell - codemirror_mime_type: text/x-sh - language_id: 346 -ShellCheck Config: - type: data - color: "#cecfcb" - filenames: - - ".shellcheckrc" - aliases: - - shellcheckrc - tm_scope: source.shellcheckrc - ace_mode: ini - codemirror_mode: properties - codemirror_mime_type: text/x-properties - language_id: 687511714 -ShellSession: - type: programming - extensions: - - ".sh-session" - aliases: - - bash session - - console - tm_scope: text.shell-session - ace_mode: sh - codemirror_mode: shell - codemirror_mime_type: text/x-sh - language_id: 347 -Shen: - type: programming - color: "#120F14" - extensions: - - ".shen" - tm_scope: source.shen - ace_mode: text - language_id: 348 -Sieve: - type: programming - tm_scope: source.sieve - ace_mode: text - extensions: - - ".sieve" - codemirror_mode: sieve - codemirror_mime_type: application/sieve - language_id: 208976687 -Simple File Verification: - type: data - group: Checksums - color: "#C9BFED" - extensions: - - ".sfv" - aliases: - - sfv - tm_scope: source.sfv - ace_mode: ini - codemirror_mode: properties - codemirror_mime_type: text/x-properties - language_id: 735623761 -Singularity: - type: programming - color: "#64E6AD" - tm_scope: source.singularity - filenames: - - Singularity - ace_mode: text - language_id: 987024632 -Slash: - type: programming - color: "#007eff" - extensions: - - ".sl" - tm_scope: text.html.slash - ace_mode: text - language_id: 349 -Slice: - type: programming - color: "#003fa2" - tm_scope: source.slice - ace_mode: text - extensions: - - ".ice" - language_id: 894641667 -Slim: - type: markup - color: "#2b2b2b" - extensions: - - ".slim" - tm_scope: text.slim - ace_mode: text - codemirror_mode: slim - codemirror_mime_type: text/x-slim - language_id: 350 -SmPL: - type: programming - extensions: - - ".cocci" - aliases: - - coccinelle - ace_mode: text - tm_scope: source.smpl - color: "#c94949" - language_id: 164123055 -Smali: - type: programming - extensions: - - ".smali" - ace_mode: text - tm_scope: source.smali - language_id: 351 -Smalltalk: - type: programming - color: "#596706" - extensions: - - ".st" - - ".cs" - aliases: - - squeak - tm_scope: source.smalltalk - ace_mode: text - codemirror_mode: smalltalk - codemirror_mime_type: text/x-stsrc - language_id: 352 -Smarty: - type: programming - color: "#f0c040" - extensions: - - ".tpl" - ace_mode: smarty - codemirror_mode: smarty - codemirror_mime_type: text/x-smarty - tm_scope: text.html.smarty - language_id: 353 -Smithy: - type: programming - ace_mode: text - codemirror_mode: clike - codemirror_mime_type: text/x-csrc - tm_scope: source.smithy - color: "#c44536" - extensions: - - ".smithy" - language_id: 1027892786 -Solidity: - type: programming - color: "#AA6746" - ace_mode: text - tm_scope: source.solidity - extensions: - - ".sol" - language_id: 237469032 -Soong: - type: data - tm_scope: source.bp - ace_mode: text - filenames: - - Android.bp - language_id: 222900098 -SourcePawn: - type: programming - color: "#f69e1d" - aliases: - - sourcemod - extensions: - - ".sp" - - ".inc" - tm_scope: source.sourcepawn - ace_mode: text - language_id: 354 -Spline Font Database: - type: data - extensions: - - ".sfd" - tm_scope: text.sfd - ace_mode: yaml - language_id: 767169629 -Squirrel: - type: programming - color: "#800000" - extensions: - - ".nut" - tm_scope: source.nut - ace_mode: c_cpp - codemirror_mode: clike - codemirror_mime_type: text/x-c++src - language_id: 355 -Stan: - type: programming - color: "#b2011d" - extensions: - - ".stan" - ace_mode: text - tm_scope: source.stan - language_id: 356 -Standard ML: - type: programming - color: "#dc566d" - aliases: - - sml - extensions: - - ".ml" - - ".fun" - - ".sig" - - ".sml" - tm_scope: source.ml - ace_mode: text - codemirror_mode: mllike - codemirror_mime_type: text/x-ocaml - language_id: 357 -Starlark: - type: programming - tm_scope: source.python - ace_mode: python - codemirror_mode: python - codemirror_mime_type: text/x-python - color: "#76d275" - extensions: - - ".bzl" - - ".star" - filenames: - - BUCK - - BUILD - - BUILD.bazel - - Tiltfile - - WORKSPACE - - WORKSPACE.bazel - aliases: - - bazel - - bzl - language_id: 960266174 -Stata: - type: programming - color: "#1a5f91" - extensions: - - ".do" - - ".ado" - - ".doh" - - ".ihlp" - - ".mata" - - ".matah" - - ".sthlp" - tm_scope: source.stata - ace_mode: text - language_id: 358 -StringTemplate: - type: markup - color: "#3fb34f" - extensions: - - ".st" - tm_scope: source.string-template - ace_mode: html - codemirror_mode: htmlmixed - codemirror_mime_type: text/html - language_id: 89855901 -Stylus: - type: markup - color: "#ff6347" - extensions: - - ".styl" - tm_scope: source.stylus - ace_mode: stylus - language_id: 359 -SubRip Text: - type: data - color: "#9e0101" - extensions: - - ".srt" - ace_mode: text - tm_scope: text.srt - language_id: 360 -SugarSS: - type: markup - color: "#2fcc9f" - tm_scope: source.css.postcss.sugarss - extensions: - - ".sss" - ace_mode: text - language_id: 826404698 -SuperCollider: - type: programming - color: "#46390b" - extensions: - - ".sc" - - ".scd" - interpreters: - - sclang - - scsynth - tm_scope: source.supercollider - ace_mode: text - language_id: 361 -Svelte: - type: markup - color: "#ff3e00" - tm_scope: source.svelte - ace_mode: html - codemirror_mode: htmlmixed - codemirror_mime_type: text/html - extensions: - - ".svelte" - language_id: 928734530 -Swift: - type: programming - color: "#F05138" - extensions: - - ".swift" - tm_scope: source.swift - ace_mode: text - codemirror_mode: swift - codemirror_mime_type: text/x-swift - language_id: 362 -SystemVerilog: - type: programming - color: "#DAE1C2" - extensions: - - ".sv" - - ".svh" - - ".vh" - tm_scope: source.systemverilog - ace_mode: verilog - codemirror_mode: verilog - codemirror_mime_type: text/x-systemverilog - language_id: 363 -TI Program: - type: programming - ace_mode: text - color: "#A0AA87" - extensions: - - ".8xp" - - ".8xk" - - ".8xk.txt" - - ".8xp.txt" - language_id: 422 - tm_scope: none -TLA: - type: programming - color: "#4b0079" - extensions: - - ".tla" - tm_scope: source.tla - ace_mode: text - language_id: 364 -TOML: - type: data - color: "#9c4221" - extensions: - - ".toml" - filenames: - - Cargo.lock - - Gopkg.lock - - Pipfile - - pdm.lock - - poetry.lock - tm_scope: source.toml - ace_mode: toml - codemirror_mode: toml - codemirror_mime_type: text/x-toml - language_id: 365 -TSQL: - type: programming - color: "#e38c00" - extensions: - - ".sql" - ace_mode: sql - tm_scope: source.tsql - language_id: 918334941 -TSV: - type: data - color: "#237346" - ace_mode: text - tm_scope: source.generic-db - extensions: - - ".tsv" - language_id: 1035892117 -TSX: - type: programming - color: "#3178c6" - group: TypeScript - extensions: - - ".tsx" - tm_scope: source.tsx - ace_mode: javascript - codemirror_mode: jsx - codemirror_mime_type: text/jsx - language_id: 94901924 -TXL: - type: programming - color: "#0178b8" - extensions: - - ".txl" - tm_scope: source.txl - ace_mode: text - language_id: 366 -Talon: - type: programming - ace_mode: text - color: "#333333" - extensions: - - ".talon" - tm_scope: source.talon - language_id: 959889508 -Tcl: - type: programming - color: "#e4cc98" - extensions: - - ".tcl" - - ".adp" - - ".sdc" - - ".tcl.in" - - ".tm" - - ".xdc" - aliases: - - sdc - - xdc - filenames: - - owh - - starfield - interpreters: - - tclsh - - wish - tm_scope: source.tcl - ace_mode: tcl - codemirror_mode: tcl - codemirror_mime_type: text/x-tcl - language_id: 367 -Tcsh: - type: programming - group: Shell - extensions: - - ".tcsh" - - ".csh" - interpreters: - - tcsh - - csh - tm_scope: source.shell - ace_mode: sh - codemirror_mode: shell - codemirror_mime_type: text/x-sh - language_id: 368 -TeX: - type: markup - color: "#3D6117" - ace_mode: tex - codemirror_mode: stex - codemirror_mime_type: text/x-stex - tm_scope: text.tex.latex - wrap: true - aliases: - - latex - extensions: - - ".tex" - - ".aux" - - ".bbx" - - ".cbx" - - ".cls" - - ".dtx" - - ".ins" - - ".lbx" - - ".ltx" - - ".mkii" - - ".mkiv" - - ".mkvi" - - ".sty" - - ".toc" - language_id: 369 -Tea: - type: markup - extensions: - - ".tea" - tm_scope: source.tea - ace_mode: text - language_id: 370 -Terra: - type: programming - extensions: - - ".t" - color: "#00004c" - tm_scope: source.terra - ace_mode: lua - codemirror_mode: lua - codemirror_mime_type: text/x-lua - interpreters: - - lua - language_id: 371 -Texinfo: - type: prose - wrap: true - extensions: - - ".texinfo" - - ".texi" - - ".txi" - ace_mode: text - tm_scope: text.texinfo - interpreters: - - makeinfo - language_id: 988020015 -Text: - type: prose - wrap: true - aliases: - - fundamental - - plain text - extensions: - - ".txt" - - ".fr" - - ".nb" - - ".ncl" - - ".no" - filenames: - - CITATION - - CITATIONS - - COPYING - - COPYING.regex - - COPYRIGHT.regex - - FONTLOG - - INSTALL - - INSTALL.mysql - - LICENSE - - LICENSE.mysql - - NEWS - - README.me - - README.mysql - - README.nss - - click.me - - delete.me - - keep.me - - package.mask - - package.use.mask - - package.use.stable.mask - - read.me - - readme.1st - - test.me - - use.mask - - use.stable.mask - tm_scope: none - ace_mode: text - language_id: 372 -TextMate Properties: - type: data - color: "#df66e4" - aliases: - - tm-properties - filenames: - - ".tm_properties" - ace_mode: properties - codemirror_mode: properties - codemirror_mime_type: text/x-properties - tm_scope: source.tm-properties - language_id: 981795023 -Textile: - type: prose - color: "#ffe7ac" - ace_mode: textile - codemirror_mode: textile - codemirror_mime_type: text/x-textile - wrap: true - extensions: - - ".textile" - tm_scope: none - language_id: 373 -Thrift: - type: programming - color: "#D12127" - tm_scope: source.thrift - extensions: - - ".thrift" - ace_mode: text - language_id: 374 -Turing: - type: programming - color: "#cf142b" - extensions: - - ".t" - - ".tu" - tm_scope: source.turing - ace_mode: text - language_id: 375 -Turtle: - type: data - extensions: - - ".ttl" - tm_scope: source.turtle - ace_mode: text - codemirror_mode: turtle - codemirror_mime_type: text/turtle - language_id: 376 -Twig: - type: markup - color: "#c1d026" - extensions: - - ".twig" - tm_scope: text.html.twig - ace_mode: twig - codemirror_mode: twig - codemirror_mime_type: text/x-twig - language_id: 377 -Type Language: - type: data - aliases: - - tl - extensions: - - ".tl" - tm_scope: source.tl - ace_mode: text - language_id: 632765617 -TypeScript: - type: programming - color: "#3178c6" - aliases: - - ts - interpreters: - - deno - - ts-node - extensions: - - ".ts" - - ".cts" - - ".mts" - tm_scope: source.ts - ace_mode: typescript - codemirror_mode: javascript - codemirror_mime_type: application/typescript - language_id: 378 -Unified Parallel C: - type: programming - color: "#4e3617" - group: C - ace_mode: c_cpp - codemirror_mode: clike - codemirror_mime_type: text/x-csrc - extensions: - - ".upc" - tm_scope: source.c - language_id: 379 -Unity3D Asset: - type: data - color: "#222c37" - ace_mode: yaml - codemirror_mode: yaml - codemirror_mime_type: text/x-yaml - extensions: - - ".anim" - - ".asset" - - ".mask" - - ".mat" - - ".meta" - - ".prefab" - - ".unity" - tm_scope: source.yaml - language_id: 380 -Unix Assembly: - type: programming - group: Assembly - extensions: - - ".s" - - ".ms" - aliases: - - gas - - gnu asm - - unix asm - tm_scope: source.x86 - ace_mode: assembly_x86 - language_id: 120 -Uno: - type: programming - color: "#9933cc" - extensions: - - ".uno" - ace_mode: csharp - codemirror_mode: clike - codemirror_mime_type: text/x-csharp - tm_scope: source.cs - language_id: 381 -UnrealScript: - type: programming - color: "#a54c4d" - extensions: - - ".uc" - tm_scope: source.java - ace_mode: java - codemirror_mode: clike - codemirror_mime_type: text/x-java - language_id: 382 -UrWeb: - type: programming - color: "#ccccee" - aliases: - - Ur/Web - - Ur - extensions: - - ".ur" - - ".urs" - tm_scope: source.ur - ace_mode: text - language_id: 383 -V: - type: programming - color: "#4f87c4" - aliases: - - vlang - extensions: - - ".v" - tm_scope: source.v - ace_mode: golang - codemirror_mode: go - codemirror_mime_type: text/x-go - language_id: 603371597 -VBA: - type: programming - color: "#867db1" - extensions: - - ".bas" - - ".cls" - - ".frm" - - ".vba" - tm_scope: source.vbnet - aliases: - - visual basic for applications - ace_mode: text - codemirror_mode: vb - codemirror_mime_type: text/x-vb - language_id: 399230729 -VBScript: - type: programming - color: "#15dcdc" - extensions: - - ".vbs" - tm_scope: source.vbnet - ace_mode: text - codemirror_mode: vbscript - codemirror_mime_type: text/vbscript - language_id: 408016005 -VCL: - type: programming - color: "#148AA8" - extensions: - - ".vcl" - tm_scope: source.varnish.vcl - ace_mode: text - language_id: 384 -VHDL: - type: programming - color: "#adb2cb" - extensions: - - ".vhdl" - - ".vhd" - - ".vhf" - - ".vhi" - - ".vho" - - ".vhs" - - ".vht" - - ".vhw" - tm_scope: source.vhdl - ace_mode: vhdl - codemirror_mode: vhdl - codemirror_mime_type: text/x-vhdl - language_id: 385 -Vala: - type: programming - color: "#a56de2" - extensions: - - ".vala" - - ".vapi" - tm_scope: source.vala - ace_mode: vala - language_id: 386 -Valve Data Format: - type: data - color: "#f26025" - aliases: - - keyvalues - - vdf - extensions: - - ".vdf" - ace_mode: text - tm_scope: source.keyvalues - language_id: 544060961 -Velocity Template Language: - type: markup - color: "#507cff" - aliases: - - vtl - - velocity - extensions: - - ".vtl" - ace_mode: velocity - tm_scope: source.velocity - codemirror_mode: velocity - codemirror_mime_type: text/velocity - language_id: 292377326 -Verilog: - type: programming - color: "#b2b7f8" - extensions: - - ".v" - - ".veo" - tm_scope: source.verilog - ace_mode: verilog - codemirror_mode: verilog - codemirror_mime_type: text/x-verilog - language_id: 387 -Vim Help File: - type: prose - color: "#199f4b" - aliases: - - help - - vimhelp - extensions: - - ".txt" - tm_scope: text.vim-help - ace_mode: text - language_id: 508563686 -Vim Script: - type: programming - color: "#199f4b" - tm_scope: source.viml - aliases: - - vim - - viml - - nvim - extensions: - - ".vim" - - ".vba" - - ".vimrc" - - ".vmb" - filenames: - - ".exrc" - - ".gvimrc" - - ".nvimrc" - - ".vimrc" - - _vimrc - - gvimrc - - nvimrc - - vimrc - ace_mode: text - language_id: 388 -Vim Snippet: - type: markup - color: "#199f4b" - aliases: - - SnipMate - - UltiSnip - - UltiSnips - - NeoSnippet - extensions: - - ".snip" - - ".snippet" - - ".snippets" - tm_scope: source.vim-snippet - ace_mode: text - language_id: 81265970 -Visual Basic .NET: - type: programming - color: "#945db7" - extensions: - - ".vb" - - ".vbhtml" - aliases: - - visual basic - - vbnet - - vb .net - - vb.net - tm_scope: source.vbnet - ace_mode: text - codemirror_mode: vb - codemirror_mime_type: text/x-vb - language_id: 389 -Visual Basic 6.0: - type: programming - color: "#2c6353" - extensions: - - ".cls" - - ".ctl" - - ".Dsr" - - ".frm" - tm_scope: source.vbnet - aliases: - - vb6 - - vb 6 - - visual basic 6 - - visual basic classic - - classic visual basic - ace_mode: text - codemirror_mode: vb - codemirror_mime_type: text/x-vb - language_id: 679594952 -Volt: - type: programming - color: "#1F1F1F" - extensions: - - ".volt" - tm_scope: source.d - ace_mode: d - codemirror_mode: d - codemirror_mime_type: text/x-d - language_id: 390 -Vue: - type: markup - color: "#41b883" - extensions: - - ".vue" - tm_scope: text.html.vue - ace_mode: html - language_id: 391 -Vyper: - type: programming - extensions: - - ".vy" - color: "#2980b9" - ace_mode: text - tm_scope: source.vyper - language_id: 1055641948 -Wavefront Material: - type: data - extensions: - - ".mtl" - tm_scope: source.wavefront.mtl - ace_mode: text - language_id: 392 -Wavefront Object: - type: data - extensions: - - ".obj" - tm_scope: source.wavefront.obj - ace_mode: text - language_id: 393 -Web Ontology Language: - type: data - color: "#5b70bd" - extensions: - - ".owl" - tm_scope: text.xml - ace_mode: xml - language_id: 394 -WebAssembly: - type: programming - color: "#04133b" - extensions: - - ".wast" - - ".wat" - aliases: - - wast - - wasm - tm_scope: source.webassembly - ace_mode: lisp - codemirror_mode: commonlisp - codemirror_mime_type: text/x-common-lisp - language_id: 956556503 -WebIDL: - type: programming - extensions: - - ".webidl" - tm_scope: source.webidl - ace_mode: text - codemirror_mode: webidl - codemirror_mime_type: text/x-webidl - language_id: 395 -WebVTT: - type: data - wrap: true - aliases: - - vtt - extensions: - - ".vtt" - tm_scope: text.vtt - ace_mode: text - language_id: 658679714 -Wget Config: - type: data - group: INI - aliases: - - wgetrc - filenames: - - ".wgetrc" - tm_scope: source.wgetrc - ace_mode: text - language_id: 668457123 -Whiley: - type: programming - color: "#d5c397" - extensions: - - ".whiley" - tm_scope: source.whiley - ace_mode: text - language_id: 888779559 -Wikitext: - type: prose - color: "#fc5757" - wrap: true - aliases: - - mediawiki - - wiki - extensions: - - ".mediawiki" - - ".wiki" - - ".wikitext" - tm_scope: text.html.mediawiki - ace_mode: text - language_id: 228 -Win32 Message File: - type: data - extensions: - - ".mc" - tm_scope: source.win32-messages - ace_mode: ini - codemirror_mode: properties - codemirror_mime_type: text/x-properties - language_id: 950967261 -Windows Registry Entries: - type: data - color: "#52d5ff" - extensions: - - ".reg" - tm_scope: source.reg - ace_mode: ini - codemirror_mode: properties - codemirror_mime_type: text/x-properties - language_id: 969674868 -Witcher Script: - type: programming - color: "#ff0000" - extensions: - - ".ws" - ace_mode: text - tm_scope: source.witcherscript - language_id: 686821385 -Wollok: - type: programming - color: "#a23738" - extensions: - - ".wlk" - ace_mode: text - tm_scope: source.wollok - language_id: 632745969 -World of Warcraft Addon Data: - type: data - color: "#f7e43f" - extensions: - - ".toc" - tm_scope: source.toc - ace_mode: text - language_id: 396 -Wren: - type: programming - color: "#383838" - aliases: - - wrenlang - extensions: - - ".wren" - tm_scope: source.wren - ace_mode: text - language_id: 713580619 -X BitMap: - type: data - group: C - aliases: - - xbm - extensions: - - ".xbm" - ace_mode: c_cpp - tm_scope: source.c - codemirror_mode: clike - codemirror_mime_type: text/x-csrc - language_id: 782911107 -X Font Directory Index: - type: data - filenames: - - encodings.dir - - fonts.alias - - fonts.dir - - fonts.scale - tm_scope: source.fontdir - ace_mode: text - language_id: 208700028 -X PixMap: - type: data - group: C - aliases: - - xpm - extensions: - - ".xpm" - - ".pm" - ace_mode: c_cpp - tm_scope: source.c - codemirror_mode: clike - codemirror_mime_type: text/x-csrc - language_id: 781846279 -X10: - type: programming - aliases: - - xten - ace_mode: text - extensions: - - ".x10" - color: "#4B6BEF" - tm_scope: source.x10 - language_id: 397 -XC: - type: programming - color: "#99DA07" - extensions: - - ".xc" - tm_scope: source.xc - ace_mode: c_cpp - codemirror_mode: clike - codemirror_mime_type: text/x-csrc - language_id: 398 -XCompose: - type: data - filenames: - - ".XCompose" - - XCompose - - xcompose - tm_scope: config.xcompose - ace_mode: text - language_id: 225167241 -XML: - type: data - color: "#0060ac" - tm_scope: text.xml - ace_mode: xml - codemirror_mode: xml - codemirror_mime_type: text/xml - aliases: - - rss - - xsd - - wsdl - extensions: - - ".xml" - - ".adml" - - ".admx" - - ".ant" - - ".axaml" - - ".axml" - - ".builds" - - ".ccproj" - - ".ccxml" - - ".clixml" - - ".cproject" - - ".cscfg" - - ".csdef" - - ".csl" - - ".csproj" - - ".ct" - - ".depproj" - - ".dita" - - ".ditamap" - - ".ditaval" - - ".dll.config" - - ".dotsettings" - - ".filters" - - ".fsproj" - - ".fxml" - - ".glade" - - ".gml" - - ".gmx" - - ".grxml" - - ".gst" - - ".hzp" - - ".iml" - - ".ivy" - - ".jelly" - - ".jsproj" - - ".kml" - - ".launch" - - ".mdpolicy" - - ".mjml" - - ".mm" - - ".mod" - - ".mxml" - - ".natvis" - - ".ncl" - - ".ndproj" - - ".nproj" - - ".nuspec" - - ".odd" - - ".osm" - - ".pkgproj" - - ".pluginspec" - - ".proj" - - ".props" - - ".ps1xml" - - ".psc1" - - ".pt" - - ".qhelp" - - ".rdf" - - ".res" - - ".resx" - - ".rs" - - ".rss" - - ".sch" - - ".scxml" - - ".sfproj" - - ".shproj" - - ".srdf" - - ".storyboard" - - ".sublime-snippet" - - ".targets" - - ".tml" - - ".ts" - - ".tsx" - - ".ui" - - ".urdf" - - ".ux" - - ".vbproj" - - ".vcxproj" - - ".vsixmanifest" - - ".vssettings" - - ".vstemplate" - - ".vxml" - - ".wixproj" - - ".workflow" - - ".wsdl" - - ".wsf" - - ".wxi" - - ".wxl" - - ".wxs" - - ".x3d" - - ".xacro" - - ".xaml" - - ".xib" - - ".xlf" - - ".xliff" - - ".xmi" - - ".xml.dist" - - ".xmp" - - ".xproj" - - ".xsd" - - ".xspec" - - ".xul" - - ".zcml" - filenames: - - ".classpath" - - ".cproject" - - ".project" - - App.config - - NuGet.config - - Settings.StyleCop - - Web.Debug.config - - Web.Release.config - - Web.config - - packages.config - language_id: 399 -XML Property List: - type: data - color: "#0060ac" - group: XML - extensions: - - ".plist" - - ".stTheme" - - ".tmCommand" - - ".tmLanguage" - - ".tmPreferences" - - ".tmSnippet" - - ".tmTheme" - tm_scope: text.xml.plist - ace_mode: xml - codemirror_mode: xml - codemirror_mime_type: text/xml - language_id: 75622871 -XPages: - type: data - extensions: - - ".xsp-config" - - ".xsp.metadata" - tm_scope: text.xml - ace_mode: xml - codemirror_mode: xml - codemirror_mime_type: text/xml - language_id: 400 -XProc: - type: programming - extensions: - - ".xpl" - - ".xproc" - tm_scope: text.xml - ace_mode: xml - codemirror_mode: xml - codemirror_mime_type: text/xml - language_id: 401 -XQuery: - type: programming - color: "#5232e7" - extensions: - - ".xquery" - - ".xq" - - ".xql" - - ".xqm" - - ".xqy" - ace_mode: xquery - codemirror_mode: xquery - codemirror_mime_type: application/xquery - tm_scope: source.xq - language_id: 402 -XS: - type: programming - extensions: - - ".xs" - tm_scope: source.c - ace_mode: c_cpp - codemirror_mode: clike - codemirror_mime_type: text/x-csrc - language_id: 403 -XSLT: - type: programming - aliases: - - xsl - extensions: - - ".xslt" - - ".xsl" - tm_scope: text.xml.xsl - ace_mode: xml - codemirror_mode: xml - codemirror_mime_type: text/xml - color: "#EB8CEB" - language_id: 404 -Xojo: - type: programming - color: "#81bd41" - extensions: - - ".xojo_code" - - ".xojo_menu" - - ".xojo_report" - - ".xojo_script" - - ".xojo_toolbar" - - ".xojo_window" - tm_scope: source.xojo - ace_mode: text - language_id: 405 -Xonsh: - type: programming - color: "#285EEF" - extensions: - - ".xsh" - tm_scope: source.python - ace_mode: text - codemirror_mode: python - codemirror_mime_type: text/x-python - language_id: 614078284 -Xtend: - type: programming - color: "#24255d" - extensions: - - ".xtend" - tm_scope: source.xtend - ace_mode: text - language_id: 406 -YAML: - type: data - color: "#cb171e" - tm_scope: source.yaml - aliases: - - yml - extensions: - - ".yml" - - ".mir" - - ".reek" - - ".rviz" - - ".sublime-syntax" - - ".syntax" - - ".yaml" - - ".yaml-tmlanguage" - - ".yaml.sed" - - ".yml.mysql" - filenames: - - ".clang-format" - - ".clang-tidy" - - ".gemrc" - - CITATION.cff - - glide.lock - - yarn.lock - ace_mode: yaml - codemirror_mode: yaml - codemirror_mime_type: text/x-yaml - language_id: 407 -YANG: - type: data - extensions: - - ".yang" - tm_scope: source.yang - ace_mode: text - language_id: 408 -YARA: - type: programming - color: "#220000" - ace_mode: text - extensions: - - ".yar" - - ".yara" - tm_scope: source.yara - language_id: 805122868 -YASnippet: - type: markup - aliases: - - snippet - - yas - color: "#32AB90" - extensions: - - ".yasnippet" - tm_scope: source.yasnippet - ace_mode: text - language_id: 378760102 -Yacc: - type: programming - extensions: - - ".y" - - ".yacc" - - ".yy" - tm_scope: source.yacc - ace_mode: text - color: "#4B6C4B" - language_id: 409 -Yul: - type: programming - color: "#794932" - ace_mode: text - tm_scope: source.yul - extensions: - - ".yul" - language_id: 237469033 -ZAP: - type: programming - color: "#0d665e" - extensions: - - ".zap" - - ".xzap" - tm_scope: source.zap - ace_mode: text - language_id: 952972794 -ZIL: - type: programming - color: "#dc75e5" - extensions: - - ".zil" - - ".mud" - tm_scope: source.zil - ace_mode: text - language_id: 973483626 -Zeek: - type: programming - aliases: - - bro - extensions: - - ".zeek" - - ".bro" - tm_scope: source.zeek - ace_mode: text - language_id: 40 -ZenScript: - type: programming - color: "#00BCD1" - extensions: - - ".zs" - tm_scope: source.zenscript - ace_mode: text - language_id: 494938890 -Zephir: - type: programming - color: "#118f9e" - extensions: - - ".zep" - tm_scope: source.php.zephir - ace_mode: php - language_id: 410 -Zig: - type: programming - color: "#ec915c" - extensions: - - ".zig" - tm_scope: source.zig - ace_mode: text - language_id: 646424281 -Zimpl: - type: programming - color: "#d67711" - extensions: - - ".zimpl" - - ".zmpl" - - ".zpl" - tm_scope: none - ace_mode: text - language_id: 411 -cURL Config: - type: data - group: INI - aliases: - - curlrc - filenames: - - ".curlrc" - - _curlrc - tm_scope: source.curlrc - ace_mode: text - language_id: 992375436 -desktop: - type: data - extensions: - - ".desktop" - - ".desktop.in" - - ".service" - tm_scope: source.desktop - ace_mode: text - language_id: 412 -dircolors: - type: data - extensions: - - ".dircolors" - filenames: - - ".dir_colors" - - ".dircolors" - - DIR_COLORS - - _dir_colors - - _dircolors - - dir_colors - tm_scope: source.dircolors - ace_mode: text - language_id: 691605112 -eC: - type: programming - color: "#913960" - extensions: - - ".ec" - - ".eh" - tm_scope: source.c.ec - ace_mode: text - language_id: 413 -edn: - type: data - ace_mode: clojure - codemirror_mode: clojure - codemirror_mime_type: text/x-clojure - extensions: - - ".edn" - tm_scope: source.clojure - language_id: 414 -fish: - type: programming - color: "#4aae47" - group: Shell - interpreters: - - fish - extensions: - - ".fish" - tm_scope: source.fish - ace_mode: text - language_id: 415 -hoon: - type: programming - color: "#00b171" - tm_scope: source.hoon - ace_mode: text - extensions: - - ".hoon" - language_id: 560883276 -jq: - color: "#c7254e" - ace_mode: text - type: programming - extensions: - - ".jq" - tm_scope: source.jq - language_id: 905371884 -just: - type: programming - aliases: - - Justfile - color: "#384d54" - tm_scope: source.just - filenames: - - Justfile - ace_mode: text - language_id: 128447695 -kvlang: - type: markup - ace_mode: text - extensions: - - ".kv" - color: "#1da6e0" - tm_scope: source.python.kivy - language_id: 970675279 -mIRC Script: - type: programming - color: "#3d57c3" - extensions: - - ".mrc" - tm_scope: source.msl - ace_mode: text - language_id: 517654727 -mcfunction: - type: programming - color: "#E22837" - extensions: - - ".mcfunction" - tm_scope: source.mcfunction - ace_mode: text - language_id: 462488745 -mupad: - type: programming - color: "#244963" - extensions: - - ".mu" - tm_scope: source.mupad - ace_mode: text - language_id: 416 -nanorc: - type: data - color: "#2d004d" - group: INI - extensions: - - ".nanorc" - filenames: - - ".nanorc" - - nanorc - tm_scope: source.nanorc - ace_mode: text - language_id: 775996197 -nesC: - type: programming - color: "#94B0C7" - extensions: - - ".nc" - ace_mode: text - tm_scope: source.nesc - language_id: 417 -ooc: - type: programming - color: "#b0b77e" - extensions: - - ".ooc" - tm_scope: source.ooc - ace_mode: text - language_id: 418 -q: - type: programming - extensions: - - ".q" - tm_scope: source.q - ace_mode: text - color: "#0040cd" - language_id: 970539067 -reStructuredText: - type: prose - color: "#141414" - wrap: true - aliases: - - rst - extensions: - - ".rst" - - ".rest" - - ".rest.txt" - - ".rst.txt" - tm_scope: text.restructuredtext - ace_mode: text - codemirror_mode: rst - codemirror_mime_type: text/x-rst - language_id: 419 -robots.txt: - type: data - aliases: - - robots - - robots txt - filenames: - - robots.txt - ace_mode: text - tm_scope: text.robots-txt - language_id: 674736065 -sed: - type: programming - color: "#64b970" - extensions: - - ".sed" - interpreters: - - gsed - - minised - - sed - - ssed - ace_mode: text - tm_scope: source.sed - language_id: 847830017 -wdl: - type: programming - color: "#42f1f4" - extensions: - - ".wdl" - tm_scope: source.wdl - ace_mode: text - language_id: 374521672 -wisp: - type: programming - ace_mode: clojure - codemirror_mode: clojure - codemirror_mime_type: text/x-clojure - color: "#7582D1" - extensions: - - ".wisp" - tm_scope: source.clojure - language_id: 420 -xBase: - type: programming - color: "#403a40" - aliases: - - advpl - - clipper - - foxpro - extensions: - - ".prg" - - ".ch" - - ".prw" - tm_scope: source.harbour - ace_mode: text - language_id: 421 diff --git a/AoCTiles/requirements.txt b/AoCTiles/requirements.txt deleted file mode 100644 index 5ca9f4c..0000000 --- a/AoCTiles/requirements.txt +++ /dev/null @@ -1,4 +0,0 @@ -pillow -requests -pyyaml -pre-commit \ No newline at end of file diff --git a/Media/2020/01.png b/Media/2020/01.png new file mode 100644 index 0000000..5b25cbb Binary files /dev/null and b/Media/2020/01.png differ diff --git a/Media/2020/02.png b/Media/2020/02.png new file mode 100644 index 0000000..60343fe Binary files /dev/null and b/Media/2020/02.png differ diff --git a/Media/2020/03.png b/Media/2020/03.png new file mode 100644 index 0000000..103e09d Binary files /dev/null and b/Media/2020/03.png differ diff --git a/Media/2020/04.png b/Media/2020/04.png new file mode 100644 index 0000000..89acbdf Binary files /dev/null and b/Media/2020/04.png differ diff --git a/Media/2020/05.png b/Media/2020/05.png new file mode 100644 index 0000000..821cded Binary files /dev/null and b/Media/2020/05.png differ diff --git a/Media/2020/06.png b/Media/2020/06.png new file mode 100644 index 0000000..16e8bb6 Binary files /dev/null and b/Media/2020/06.png differ diff --git a/Media/2020/07.png b/Media/2020/07.png new file mode 100644 index 0000000..df3725c Binary files /dev/null and b/Media/2020/07.png differ diff --git a/Media/2020/08.png b/Media/2020/08.png new file mode 100644 index 0000000..da0cf8b Binary files /dev/null and b/Media/2020/08.png differ diff --git a/Media/2022/03.png b/Media/2022/03.png new file mode 100644 index 0000000..f36b1a8 Binary files /dev/null and b/Media/2022/03.png differ diff --git a/Media/2022/04.png b/Media/2022/04.png new file mode 100644 index 0000000..612aaba Binary files /dev/null and b/Media/2022/04.png differ diff --git a/Media/2022/05.png b/Media/2022/05.png new file mode 100644 index 0000000..809bb8e Binary files /dev/null and b/Media/2022/05.png differ diff --git a/Media/2022/06.png b/Media/2022/06.png new file mode 100644 index 0000000..703590a Binary files /dev/null and b/Media/2022/06.png differ diff --git a/Media/2022/07.png b/Media/2022/07.png new file mode 100644 index 0000000..066934d Binary files /dev/null and b/Media/2022/07.png differ diff --git a/Media/2022/08.png b/Media/2022/08.png new file mode 100644 index 0000000..286afb3 Binary files /dev/null and b/Media/2022/08.png differ diff --git a/Media/2022/09.png b/Media/2022/09.png new file mode 100644 index 0000000..b02492e Binary files /dev/null and b/Media/2022/09.png differ diff --git a/Media/2022/10.png b/Media/2022/10.png new file mode 100644 index 0000000..2132b21 Binary files /dev/null and b/Media/2022/10.png differ diff --git a/Media/2022/11.png b/Media/2022/11.png new file mode 100644 index 0000000..1bdfaaa Binary files /dev/null and b/Media/2022/11.png differ diff --git a/Media/2022/12.png b/Media/2022/12.png new file mode 100644 index 0000000..b694244 Binary files /dev/null and b/Media/2022/12.png differ diff --git a/Media/2022/13.png b/Media/2022/13.png new file mode 100644 index 0000000..2ff728e Binary files /dev/null and b/Media/2022/13.png differ diff --git a/Media/2022/14.png b/Media/2022/14.png new file mode 100644 index 0000000..0a52874 Binary files /dev/null and b/Media/2022/14.png differ diff --git a/Media/2022/15.png b/Media/2022/15.png new file mode 100644 index 0000000..e9fb998 Binary files /dev/null and b/Media/2022/15.png differ diff --git a/Media/2022/16.png b/Media/2022/16.png new file mode 100644 index 0000000..38c6a94 Binary files /dev/null and b/Media/2022/16.png differ diff --git a/Media/2022/17.png b/Media/2022/17.png new file mode 100644 index 0000000..d9bdbc6 Binary files /dev/null and b/Media/2022/17.png differ diff --git a/Media/2022/18.png b/Media/2022/18.png new file mode 100644 index 0000000..6705e02 Binary files /dev/null and b/Media/2022/18.png differ diff --git a/Media/2022/19.png b/Media/2022/19.png new file mode 100644 index 0000000..cd25e37 Binary files /dev/null and b/Media/2022/19.png differ diff --git a/Media/2022/20.png b/Media/2022/20.png new file mode 100644 index 0000000..e175778 Binary files /dev/null and b/Media/2022/20.png differ diff --git a/Media/2022/21.png b/Media/2022/21.png new file mode 100644 index 0000000..f8e6df0 Binary files /dev/null and b/Media/2022/21.png differ diff --git a/Media/2022/22.png b/Media/2022/22.png new file mode 100644 index 0000000..6786f93 Binary files /dev/null and b/Media/2022/22.png differ diff --git a/Media/2022/23.png b/Media/2022/23.png new file mode 100644 index 0000000..f84dab8 Binary files /dev/null and b/Media/2022/23.png differ diff --git a/Media/2022/24.png b/Media/2022/24.png new file mode 100644 index 0000000..be664db Binary files /dev/null and b/Media/2022/24.png differ diff --git a/Media/2022/25.png b/Media/2022/25.png new file mode 100644 index 0000000..bb15a9a Binary files /dev/null and b/Media/2022/25.png differ diff --git a/Media/2023/01.png b/Media/2023/01.png new file mode 100644 index 0000000..602cf34 Binary files /dev/null and b/Media/2023/01.png differ diff --git a/README.md b/README.md index 2c06b54..e45b12d 100644 --- a/README.md +++ b/README.md @@ -1,108 +1,459 @@ +

- My Advent of Code Solutions + Advent of Code - 260/500 ⭐

- -

- 2022 - 4 ⭐ + 2024 - 50 ⭐ - Python +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ 2023 - 50 ⭐ - Python +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ 2022 - 50 ⭐ - Kotlin

- + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

- 2021 - 50 ⭐ + 2021 - 50 ⭐ - Julia

- - + + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - - + + - + + +

+ 2020 - 50 ⭐ - Rust +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ 2019 - 10 ⭐ - OCaml +

+ + + + + + + + + + + + + + +*The above tiles are clickable, leading to the solution of the corresponding day.* + --- -The graphic above has been created with [AoCTiles/create_aoc_tiles.py](AoCTiles/create_aoc_tiles.py) script. Feel free to use it in your own repositories. See the [AoCTiles/README.md](AoCTiles/README.md) for instructions on how to use it. +The graphic above has been created using [aoc_tiles](https://github.com/LiquidFun/aoc_tiles). Feel free to use it, it's easy to set up! --- +My solutions: + +* are self-contained and use no util files and mostly no libraries. +* are written in a very concise and functional style (only 5/100 solutions have >=70 loc as calculated by `cloc`) +* try to be (too) clever, this is not code written for readability, but for pushing language expressibility. +* solve both parts of each problem at once. I believe structuring the code so that it solves both parts is often an interesting challenge. +* expect input via `stdin` and output (generally) 2 lines to `stdout` with the answer to part 1 and part 2. +* (generally) parse input as it is given without modifying or pasting it into the code as an array. Parsing the strings in as little code as possible is a huge part of AoC. + +and are written in a different programming language each year: + +* **2023**: Initially I wanted to use Rust for this year, but instead I focused on getting on the leaderboard with **Python** (successfully on day 18 and 25!). In the last days I even started using libraries (Z3/networkx). Python is my strongest language, so no surprises there. I did 5 days in Rust as well, but found it too frustrating and had too little time for 2 solutions per day. +* **2022**: Using **Kotlin** for the first time. Playing with streams a lot, many days are completed by only using streams. The first 15 days have **Python** solutions as well in order to be able to submit quicker and get better times on the leaderboard. +* **2021**: Using **Julia** for the first time. Because it supports numpy-like element-wise operations natively this was a great choice for AoC. If I used more Julia it would likely be my go to language for AoC right now. +* **2020**: Using **Rust** for the first time. Solved 8 days initially. Revisited in 2024 and solved all of them. This time I liked Rust much more. I ended up writing very concise and functional Rust. After getting used to it it was quite fun. All rust solutions are below 100 loc (as calculated by `cloc`). + +Not part of the repository yet, since these are incomplete and the code is not good (might revisit them later): + +* **2019**: First time participating, solved 5 days with **Python**. Trying OCaml in 2024. + +--- + +### Running + +* 2023: `python 01.py < input.in` with Python 3.12 +* 2022: `kotlinc 01.kt -include-runtime -d 01.jar && kotlin 01.jar < example.in` (or use intellij, kotlinc is very slow via CLI, 5+ seconds to compile) +* 2021: `julia 1.jl < input.in` +* 2020: `cargo run --release --bin 01 < input.in` or with autoresolve current dir, auto-refresh and time-taken: `cargo watch -s 'time cargo run --release --bin '$(basename $PWD)' < '$(basename $PWD)'/input.in'` with Rust version 1.80.1 +* 2019: `ocaml 01.ml < input.in` with OCaml 5.2.0 -All solutions expect the input via `stdin` and print to `stdout`. Each solution always prints part 1 and 2 at the same time on separate lines. In order to test the programs you can pipi the input to the program: `julia 1.jl < input.in`, which is then compared to `input.ans`. Instead of doing this manually, I use my `program-tester.sh` script (see [here](https://github.com/LiquidFun/misc-scripts)), which runs the given program on all `*.in` files in the directory, and tests whether the corresponding `*.ans` file matches the given output. I have mapped that program on `Enter` in vim, which makes testing programs easy. To validate a program manually, type `diff <(julia 1.jl < input.in) input.ans`. +In order to test the programs you can pipe the input to the program, for example: `julia 1.jl < input.in`. The correct output is saved in the `input.ans`. Instead of doing this manually, I use my `program-tester.sh` script (see [here](https://github.com/LiquidFun/misc-scripts)), which runs the given program on all `*.in` files in the directory, and tests whether the corresponding `*.ans` file matches the given output. I have mapped that program on `Enter` in vim, which makes testing programs easy. -Programs are initialized with the `init-day.sh` script. I.e. typing `init-day.sh 10` initializes the 10th day by creating a folder named `10`, downloading the input test case with the `session.cookie`, copying the `dummy.py` file and opening the solution file. +Programs are initialized with the `init-day.sh` script. I.e. typing `init-day.sh 10` initializes the 10th day by creating a folder named `10` and downloading the input test case with the `session.cookie`. -* 2021: There is a solution for each problem in Julia. Sometimes there is a Python or APL solution as well. I'm trying out Julia for the first time, mostly focusing on short and elegant code. +My favorite solution [2023/18](2023/18/18.py) diff --git a/init-day.sh b/init-day.sh index b61e3d6..296f751 100755 --- a/init-day.sh +++ b/init-day.sh @@ -1,43 +1,50 @@ #!/usr/bin/bash -year="2022" -cookie=$(cat session.cookie) +year="2024" +SCRIPT_DIR="$(dirname "$(realpath "$0")")" +cookie="$(cat $SCRIPT_DIR/.aoc_tiles/session.cookie)" input_prefix="input" sample_prefix="example" # Example comes before input alphabetically, so it shows up in front in the program-tester.sh if [[ "$1" ]]; then - if ! [[ -d "$1" ]]; then - echo "Creating folder for problem $1" - mkdir "$1" + dir=$(printf "%02d" "$1") + path="$SCRIPT_DIR/$year/$dir" + if ! [[ -d "$path" ]]; then + echo "Creating folder for problem $dir in $path" + mkdir "$path" fi - cd "$1" + cd "$path" # Download input from advent of code - input_file="${input_prefix}.in" + input_file="$path/${input_prefix}.in" + echo $input_file if ! [[ -f "$input_file" ]]; then - echo "Downloading input for problem $1" + echo "Downloading input for problem $dir" # Don't DDOS! So check if file exists already - curl "https://adventofcode.com/$year/day/$1/input" --cookie "session=$cookie" > "$input_file" + nozero=$(echo "$1" | awk '$0*=1') + curl "https://adventofcode.com/$year/day/$nozero/input" --cookie "session=$cookie" > "$input_file" + else + echo "Skipping $dir because input file exists $input_file" fi # Add empty file so there are not that many lines when showing input instead - input_ans_file="${input_prefix}.ans" - if ! [[ -f "$input_ans_file" ]]; then - echo "Create empty input answer file" - touch "$input_ans_file" - fi + # input_ans_file="${input_prefix}.ans" + # if ! [[ -f "$input_ans_file" ]]; then + # echo "Create empty input answer file" + # touch "$input_ans_file" + # fi # Prepare dummy python solution - # solution_file="$1.py" - # if ! [[ -f "$solution_file" ]]; then + # solution_file="$1.py" + # if ! [[ -f "$solution_file" ]]; then # echo "Create dummy python solution $solution_file" - # cp "../dummy.py" "$solution_file" - # fi + # cp "../../dummy.py" "$solution_file" + # fi - nvim "$solution_file" "${sample_prefix}.in" "${sample_prefix}.ans" -c "norm G$" + # nvim "$solution_file" "${sample_prefix}.in" "${sample_prefix}.ans" -c "norm G$" else echo "Supply some number as first argument to initialize a problem!" fi