Solutions till day6

Author: Abhishek Sunkum Rammurthy

day1.py

@@ -0,0 +1,45 @@
+#!/usr/bin/python3
+import pandas as pd
+import numpy as np
+import re
+
+filename="/home/abhi/repos/aoc/inputs/trebuchet_input.txt"
+with open(filename) as f:
+    lines = [line.rstrip() for line in f]
+
+word2int = {
+        'one':'1',
+        'two':'2',
+        'three':'3',
+        'four':'4',
+        'five':'5',
+        'six':'6',
+        'seven':'7',
+        'eight':'8',
+        'nine':'9'
+            }
+
+total = 0
+for l in lines:
+    df = pd.DataFrame(
+        {
+            'words':word2int.keys(),
+            'id':-1,
+            'len':0
+        }
+    )
+    print(l, end=', ')
+    temp_l = list(l)
+    for w in word2int:
+        ids = [m.start() for m in re.finditer(w, l)]
+        for id in ids:
+            temp_l[id] = word2int[w]
+    l = ''.join(temp_l)
+    n = ''.join(re.findall(r'\d+', l))
+    print(n, end = ', ')
+    calib_val = int(n[0])*10 + int(n[-1])
+    print(calib_val)
+    if len(n):
+        total = total + calib_val
+print(f'total calibration value = {total}')
+

day2.py

@@ -0,0 +1,37 @@
+#!/usr/bin/python3
+import pandas as pd
+import numpy as np
+import sys
+import re
+
+argc = len(sys.argv)
+if argc != 2:
+    print("Provide filename of the input")
+    quit()
+
+filename = sys.argv[1]
+print(f'input used {filename}')
+
+with open(filename) as f:
+    lines = [line.rstrip() for line in f]
+
+num_games = len(lines)
+df = pd.DataFrame(
+    {
+        'id' : np.arange(0, num_games, dtype=int)+1,
+        'red': np.zeros(num_games, dtype=int),
+        'green': np.zeros(num_games, dtype=int),
+        'blue': np.zeros(num_games, dtype=int)
+    }
+)
+
+power_of_set = 0
+for i, l in enumerate(lines):
+    for c in ['red', 'green', 'blue']:
+        num_cubes = [int(re.match(r'\d+', m).group(0)) for m in re.findall(r'\d+ '+c, l)]
+        df.at[i, c] = max(num_cubes)
+    df_part1 = df[(df['red'] <= 12) & (df['green'] <= 13) & (df['blue'] <= 14)]
+    power_of_set = power_of_set + (df['red'][i] * df['green'][i] * df['blue'][i])
+
+print(df_part1['id'].sum())
+print(f'{power_of_set=}')

day3.py

@@ -0,0 +1,77 @@
+#!/usr/bin/python3
+import pandas as pd
+import numpy as np
+import sys
+import re
+
+argc = len(sys.argv)
+if argc != 2:
+    print("Provide filename of the input")
+    quit()
+
+filename = sys.argv[1]
+print(f'input used {filename}')
+
+with open(filename) as f:
+    lines = [line.rstrip() for line in f]
+
+line_count = len(lines)
+total = 0
+for line_num, l in enumerate(lines):
+    matches = [m for m in re.finditer(r'\d+', l)]
+    boundary = len(l)
+    for m in matches:
+        search_str = ''
+        start = m.start()
+        end = m.end()
+        if end < boundary:
+            end = end + 1
+        if start > 0:
+            start = start -1
+        search_str = search_str + l[start:end] #current line
+        if line_num > 0:
+            search_str = search_str + lines[line_num - 1][start:end]
+        if line_num < (line_count - 1):
+            search_str = search_str + lines[line_num + 1][start:end]
+        
+        if symbol_match := re.search(r'[^\d\.]', search_str):
+            # print(symbol_match[0], m[0])
+            total = total + int(m[0])
+print(total)
+
+gear_ratio = 0
+for line_num, l in enumerate(lines):
+    matches = [m for m in re.finditer(r'\*', l)]
+    boundary = len(l)
+    for m in matches:
+        start = m.start()
+        end = m.end() - 1
+        if end < boundary:
+            end = end + 1
+        if start > 0:
+            start = start -1
+
+        digit_matches = []
+        digit_matches = digit_matches +  [m for m in re.finditer(r'\d+', l)]
+        if line_num > 0:
+            search_str = lines[line_num - 1]
+            digit_matches = digit_matches +  [m for m in re.finditer(r'\d+', search_str)]
+        if line_num < (line_count - 1):
+            search_str = lines[line_num + 1]
+            digit_matches = digit_matches +  [m for m in re.finditer(r'\d+', search_str)]
+        # print(f'symbol {start=},{end=}')
+        adjacent_numbers=[]
+        for dm in digit_matches:
+            dm_start,dm_end = dm.span()
+            ids = list(range(dm_start, dm_end))
+            # print(ids)
+            if start in ids or end in ids:
+                adjacent_numbers.append(int(dm[0]))
+        if len(adjacent_numbers) == 2:
+            gear_ratio = gear_ratio + np.prod(adjacent_numbers)
+        
+print(f'{gear_ratio=}')
+
+
+    
+

day4.py

@@ -0,0 +1,43 @@
+#!/usr/bin/python3
+import pandas as pd
+import numpy as np
+
+filename="/home/abhi/repos/aoc/inputs/scratchcards_input.txt"
+with open(filename) as f:
+    lines = [line.rstrip() for line in f]
+
+
+def get_matching_count(l):
+    _,_,all_numbers = l.partition(":")
+    winning,_,you_have = all_numbers.partition("|")
+    all_numbers = winning.strip().replace('  ', ' ').split(' ') + you_have.strip().replace('  ', ' ').split(' ')
+    complete_count = len(all_numbers) # total count of winning + you_have numbers
+    get_matching_count = complete_count - len(set(all_numbers))
+    return  get_matching_count
+
+def get_points(num_matching):
+    if num_matching:
+        return pow(2, num_matching - 1)
+    else:
+        return 0
+
+total_points = 0
+for l in lines:
+    total_points = total_points + get_points(get_matching_count(l))
+print(f'{total_points=}')
+
+# part two -> find number of cards which will we end up with
+cards_points = pd.DataFrame({
+    'index':np.arange(len(lines)),
+    'count':1,
+    'points':0
+})
+
+for i, l in enumerate(lines):
+    points = cards_points['points'][i] = get_matching_count(l)
+    count = cards_points['count'][i]
+    if points == 0:
+        continue
+    for j in range(i+1, points+i+1):
+        cards_points['count'][j] = cards_points['count'][j] + count
+print(f"{cards_points['count'].sum()}")

day5.py

@@ -0,0 +1,105 @@
+#!/usr/bin/python3
+import pandas as pd
+import numpy as np
+import sys
+import re
+from multiprocessing import  Pool
+argc = len(sys.argv)
+if argc != 2:
+    print("Provide filename of the input")
+    quit()
+
+filename = sys.argv[1]
+print(f'input used {filename}')
+
+with open(filename) as f:
+    lines = [line.rstrip() for line in f]
+
+line_count = len(lines)
+boundary = len(lines[0])
+
+seeds_ranges = [int(m) for m in re.findall(r'\d+', lines[0])]
+seeds = pd.DataFrame(
+    {
+        'source':np.zeros(len(seeds_ranges)//2, dtype=int),
+        'offset':np.zeros(len(seeds_ranges)//2, dtype=int)
+    }
+)
+
+for i in range(int(len(seeds_ranges)/2)):
+    # print(seeds_ranges)
+    seeds.at[i, 'source'] = int(seeds_ranges[i*2])
+    seeds.at[i, 'offset'] = int(seeds_ranges[(i*2)+1])
+# print(seeds)
+
+maps = []
+map_started = False
+for i, l in enumerate(lines):
+    if 'map' in l:
+        map_started = True
+        index = 0
+        d2s = pd.DataFrame({
+            'destination':np.empty( 1, dtype=int),
+            'source':np.empty( 1, dtype=int),
+            'offset':np.empty( 1, dtype=int)
+        })
+        continue
+    if (len(l)==0 or i == line_count -1) and map_started:
+        map_started = False
+        maps.append(d2s)
+        # print(d2s)
+
+    if map_started:
+        numbers = [int(m) for m in re.findall(r'\d+', l)]
+        d2s.at[index, 'destination'] = numbers[0]
+        d2s.at[index, 'source'] = numbers[1]
+        d2s.at[index, 'offset'] = numbers[2]
+        index = index + 1
+
+def get_destination(df : pd.DataFrame, s):
+    for _, row in df.iterrows():
+        start = row['source']
+        end = start + row['offset']
+        if s >= start and s<= end:
+            offset = s - start
+            offset_remaining = end -s
+            return row['destination']+offset , offset_remaining
+    return s, 0
+
+locations = []
+new_seeds = []
+def get_seeds(seed):
+    start = seed[0]
+    end = start + seed[1]
+    return [s for s in range(start, end + 1)]
+
+def get_mini_loc(seed):
+    print(f'working on {seed[0]=}')
+    min_loc = 10000000000
+    for source in get_seeds(seed):
+        # print(source, end= ' ')
+        for m in maps:
+            dest, _ = get_destination(m, source)
+            source = dest
+        min_loc = min(dest, min_loc)
+        # print(dest, min_loc)
+    print(f"{min_loc=} for {seed[0]=}")
+    return min_loc
+
+def split_ranges():
+    seeds_list=[]
+    for _, s in  seeds.iterrows():
+        start = s['source']
+        offset = s['offset']
+        range_size = 10000
+        num_ranges = offset // range_size
+        last_offset = offset % range_size
+        for i in range(num_ranges):
+            seeds_list.append((start + i*range_size, range_size))
+        seeds_list.append((start + num_ranges*range_size, last_offset))
+    return seeds_list
+
+with Pool(processes=6) as pool:
+    seeds_list = split_ranges()
+    locs = pool.map(get_mini_loc, seeds_list)
+    print(min(locs))

day6.py

@@ -0,0 +1,29 @@
+#!/usr/bin/python3
+import pandas as pd
+import numpy as np
+import sys
+
+with open(sys.argv[1]) as f:
+    lines = [line.rstrip() for line in f]
+
+time = [ t.strip() for t in lines[0].split()][1:]
+distance = [ t.strip() for t in lines[1].split()][1:]
+
+time = [ int(t) for t in time]
+distance = [ int(t) for t in distance]
+
+total_ways = 1
+for t, d in zip(time, distance):
+    stop_val = 0
+    unpossible_ways = 0
+    possible_ways = t - 1
+    for i in range(1, t//2):
+        if ((t-i) * i) > d:
+            break
+        unpossible_ways += 2
+    ways = possible_ways - unpossible_ways
+    print(ways)
+    total_ways *=ways
+
+print(f'{total_ways=}')
+