add some AOC leaderboards, aoc solutions

Author: VitamintK

.gitignore

@@ -262,3 +262,5 @@ acm-practice/2017-11-30/*.ans
 facebook-hacker-cup/**/*.txt
 facebook-hacker-cup/**/*.zip
 
+**/advent-of-code/**/*.html
+**/advent-of-code/**/*.answer

miscellaneous/advent-of-code/2018/day5.py

@@ -0,0 +1,27 @@
+if False:
+    x = input()
+    # copilot wrote this. It does the trick for part 2, but not part 2:
+    while True:
+        for i in range(len(x)-1):
+            if x[i].lower() == x[i+1].lower() and x[i] != x[i+1]:
+                x = x[:i] + x[i+2:]
+                break
+        else:
+            break
+    print(len(x))
+else:
+    y = input()
+    import string
+    ans = 100000000000000000
+    for letter in string.ascii_lowercase:
+        x = y
+        x = x.replace(letter, '')
+        x = x.replace(letter.upper(), '')
+        stack = []
+        for c in x:
+            if stack and stack[-1].lower() == c.lower() and stack[-1] != c:
+                stack.pop()
+            else:
+                stack.append(c)
+        ans = min(len(stack), ans)
+    print(ans)

miscellaneous/advent-of-code/2022/ldrbrd.jpg

@@ -0,0 +1,114 @@
+from collections import defaultdict, deque, Counter
+# d = deque()
+# d.append(5)
+# x = d.popleft()
+import re
+# m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist") 
+# # or re.search
+# >>> m.group(0)       # The entire match
+# 'Isaac Newton'
+# >>> m.group(1)       # The first parenthesized subgroup.
+# 'Isaac'
+# >>> m.group(2)       # The second parenthesized subgroup.
+# 'Newton'
+# >>> m.group(1, 2)    # Multiple arguments give us a tuple.
+# ('Isaac', 'Newton')
+from heapq import heappush, heappop
+# >>> heap = []
+# >>> data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
+# >>> for item in data:
+# ...     heappush(heap, item)
+# heap[0] is the smallest item
+import string
+# string.ascii_lowercase == 'abcde...'
+# string.ascii_uppercase == 'ABCDE...'
+from functools import lru_cache
+# @lru_cache(maxsize=None)
+import numpy as np
+
+import sys
+
+sys.setrecursionlimit(100000)
+
+def get_ints(s):
+    return list(map(int, re.findall(r"-?\d+", s)))  # copied from mcpower from mserrano on betaveros' recommendation
+dirs = [(0,1), (1,0), (0,-1), (-1,0)]
+directions = 'RDLU'
+octs = [(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1),(-1,0),(-1,1)]
+def is_grid_valid(n,m, r,c,):
+    return (0<=r<n) and (0<=c<m)
+def sign_of(x):
+    if x==0:
+        return 0
+    return x/abs(x)
+####################################
+
+PART = 1
+PART = 2
+if PART == 1:
+    ans = 0
+    inps = []
+    while True:
+        try:
+            inps.append(input())
+        except EOFError:
+            break
+    r, c = 0,0
+    grid = set()
+    for inp in inps:
+        d, x, _ = inp.split()
+        x = int(x)
+        dr, dc = dirs[directions.index(d)]
+        for _ in range(x):
+            r += dr
+            c += dc
+            grid.add((r,c))
+    def dfs(r,c):
+        for dr, dc in dirs:
+            nr, nc = r+dr, c+dc
+            if (nr,nc) not in grid:
+                grid.add((nr, nc))
+                dfs(nr, nc)
+    dfs(1,1)
+
+    print(len(grid))
+else:
+    ans = 0
+    inps = []
+    while True:
+        try:
+            inps.append(input())
+        except EOFError:
+            break
+    r, c = 0,0
+    grid = set()
+    prev_d = None
+    for i in range(len(inps)):
+        inp = inps[i]
+        def get_d_x(inp):
+            _,_,y = inp.split()
+            y = y[1:-1]
+            x = y[1:-1]
+            d = int(y[-1])
+            # print(x)
+            x = int(x, 16)
+            return d, x
+        # def get_d_x(inp):
+        #     d, x, _ = inp.split()
+        #     x = int(x)
+        #     return directions.index(d), x
+        
+        d, x = get_d_x(inp)
+        nd, nx = get_d_x(inps[(i+1)%len(inps)])
+        pd, px = get_d_x(inps[(i-1)%len(inps)])
+        dr, dc = dirs[d]
+
+        if (d+1)%4 == nd:
+            x += 1
+        if (d-1)%4 != pd:
+            x -= 1
+
+        nr, nc = r+dr*x, c+dc*x
+        ans += (nr + r) * (nc - c)
+        r, c = nr, nc
+    print(abs(ans // 2))

miscellaneous/advent-of-code/2023/day18.py

@@ -5,4 +5,6 @@ Still on the east coast this year, and furthermore I'm back in school, with an 8
 I started using Github Copilot (AI autocomplete) a few months ago, and I've used it for these problems. Sometimes it helps greatly, saving me tons of keystrokes and dozens of seconds. It's also allowed me to avoid activating my brain or pencil/paper to figure out how exactly some repeated rules should be: if I just write a rule once, copilot usually infers how to mechanically repeat the rule for the other cases. However, this has bitten me in the ass a few times when it did a bad job, I assumed it was correct without checking, and had to waste much more time debugging due to it.
 
 I also started writing my own AOC CLI tool: https://github.com/VitamintK/wang-aoc-cli  
-I really could have just used one that someone else wrote, like https://github.com/wimglenn/advent-of-code-wim, but it's been satisfying to make my own. So far, I haven't implemented any real time-savers yet (like running on example and real at the same time, and submitting from the CLI), but the command to download the input directly instead of copy-pasting saves me ~2 seconds every day, and the command to automatically create the files (.py, .in) that I use have been nice quality-of-life changes that mean that I only have to get to my computer by 11:59 instead of 11:57.
+I really could have just used one that someone else wrote, like https://github.com/wimglenn/advent-of-code-wim, but it's been satisfying to make my own. Up until and including Day 16, I haven't implemented any real time-savers yet (like running on example and real at the same time, and submitting from the CLI), but the command to download the input directly instead of copy-pasting saves me ~2 seconds every day, and the command to automatically create the files (.py, .in) that I use have been nice quality-of-life changes that mean that I only have to get to my computer by 11:59 instead of 11:57.  
+For Day 17, I did implement those real time-savers, which I imagine will shave off one to two dozen seconds every day. 
+

miscellaneous/advent-of-code/2023/readme.md

@@ -1 +1,20 @@
-2017 is here: https://github.com/VitamintK/FrivolousStuffs/tree/master/advent_of_code/2017
+2017 is here: https://github.com/VitamintK/FrivolousStuffs/tree/master/advent_of_code/2017
+
+![summary of my stars](my_star_summary.jpg)
+
+Results per year:
+
+2018  
+![2018](2018/ldrbrd.png)
+
+2019  
+![2019](2019/ldrbrd.png)
+
+2020  
+![2020](2020/ldrbrd.png)
+
+2021  
+![2021](2021/ldrbrd.png)
+
+2022  
+![2022](2022/ldrbrd.jpg)