Day 13 bit trouble with the overflows, also updated some utils

Author: Dym03

Advent_2022/2

@@ -0,0 +1,78 @@
+#include <set>
+
+#include "../../Utils/utils.cpp"
+
+std::pair<int, int> get_direction_from_enum(Direction dir) {
+    if (dir == UP) {
+        return {-1, 0};
+    } else if (dir == DOWN) {
+        return {1, 0};
+    } else if (dir == LEFT) {
+        return {0, -1};
+    } else if (dir == RIGHT) {
+        return {0, 1};
+    }
+    std::cout << "Invalid direction" << std::endl;
+    return {0, 0};
+}
+
+int travel_one_trail(Grid<int>& grid, std::pair<int, int> act_pos, Direction dir, int prev_value, std::set<std::pair<std::pair<int, int>, Direction>> visited, std::set<std::pair<int, int>>& visited_nines) {
+    if (visited.find({act_pos, dir}) != visited.end()) {
+        return 0;
+    }
+    std::pair<int, int> direction = get_direction_from_enum(dir);
+    visited.insert({act_pos, dir});
+    act_pos.first += direction.first;
+    act_pos.second += direction.second;
+    if (act_pos.first < 0 || act_pos.first > grid.get_row_size() - 1 || act_pos.second < 0 || act_pos.second > grid.get_col_size() - 1) {
+        return 0;
+    }
+    int act_value = grid.get(act_pos.first, act_pos.second);
+    if (act_value - prev_value != 1) {
+        return 0;
+    }
+    if (grid.get(act_pos.first, act_pos.second) == 9) {
+        visited_nines.insert(act_pos);
+        visited.insert({act_pos, dir});
+        return 1;
+    }
+
+    return travel_one_trail(grid, act_pos, UP, act_value, visited, visited_nines) + travel_one_trail(grid, act_pos, DOWN, act_value, visited, visited_nines) + travel_one_trail(grid, act_pos, LEFT, act_value, visited, visited_nines) + travel_one_trail(grid, act_pos, RIGHT, act_value, visited, visited_nines);
+}
+
+std::pair<int, int> get_trail_sizes(Grid<int>& grid, std::pair<int, int> trail_head) {
+    std::set<std::pair<std::pair<int, int>, Direction>> visited = {};
+    std::set<std::pair<int, int>> visited_nines = {};
+    int visited_nines_score = 0;
+    int total_score = travel_one_trail(grid, trail_head, UP, 0, visited, visited_nines);
+    total_score += travel_one_trail(grid, trail_head, DOWN, 0, visited, visited_nines);
+    total_score += travel_one_trail(grid, trail_head, LEFT, 0, visited, visited_nines);
+    total_score += travel_one_trail(grid, trail_head, RIGHT, 0, visited, visited_nines);
+    visited_nines_score += visited_nines.size();
+    return {visited_nines_score, total_score};
+}
+
+int main() {
+    std::vector<std::string> lines = read_lines();
+    std::vector<std::pair<int, int>> trail_heads = {};
+    Grid grid = Grid(lines.size(), lines[0].size(), 0);
+    for (int i = 0; i < lines.size(); i++) {
+        for (int j = 0; j < lines[i].size(); j++) {
+            grid.set(i, j, lines[i][j] - '0');
+            if (lines[i][j] == '0') {
+                trail_heads.push_back({i, j});
+            }
+        }
+    }
+    int part_1_score = 0;
+    int part_2_score = 0;
+    for (auto trail_head : trail_heads) {
+        auto scores = get_trail_sizes(grid, trail_head);
+        part_1_score += scores.first;
+        part_2_score += scores.second;
+    }
+    std::cout << "Part 1: " << part_1_score << '\n';
+    std::cout << "Part 2: " << part_2_score << '\n';
+
+    return 0;
+}

Advent_2022/3

@@ -47,13 +47,16 @@ int main() {
     print_vector(stones, ' ');
     int num_blinks = 25;
     std::vector<std::string> new_stones;
+    std::unordered_map<unsigned long long, unsigned long long> stone_to_stone_count;
 
     std::vector<unsigned long long> stones_long;
     for (auto stone : stones) {
         stones_long.push_back(std::stoull(stone));
+        stone_to_stone_count[std::stoull(stone)] = 1;
     }
     std::vector<unsigned long long> new_stones_long;
     std::unordered_map<std::pair<unsigned long long, int>, unsigned long long, hash_pair> stone_to_num_stones;
+
     new_stones.reserve(stones.size());
     // Part 1
     for (int i = 0; i < num_blinks; i++) {

Advent_2022/4

@@ -0,0 +1,146 @@
+#include <climits>
+#include <cmath>
+#include <numeric>
+
+#include "../../Utils/utils.cpp"
+
+struct Button {
+    int x;
+    int y;
+    int current_x;
+    int current_y;
+};
+
+struct Prize {
+    long long X;
+    long long Y;
+};
+
+Button get_button(std::vector<std::string> line) {
+    Button b = {};
+    b.current_x = 0;
+    b.current_y = 0;
+    std::vector<std::string> x_y = split(',', line[1]);
+    std::string x = x_y[0];
+    std::string y = x_y[1];
+    b.x = std::stoi(split('+', x)[1]);
+    b.y = std::stoi(split('+', y)[1]);
+    return b;
+}
+
+Prize get_prize(std::vector<std::string> line) {
+    Prize p = {};
+    p.X = 0;
+    p.Y = 0;
+    std::vector<std::string> x_y = split(',', line[1]);
+    std::string x = x_y[0];
+    std::string y = x_y[1];
+    p.X = std::stoi(split('=', x)[1]) + 10000000000000;
+    p.Y = std::stoi(split('=', y)[1]) + 10000000000000;
+    return p;
+}
+
+std::ostream& operator<<(std::ostream& os, Button b) {
+    os << b.x << " " << b.y << " Curr value " << b.current_x << "," << b.current_y;
+    return os;
+}
+
+std::ostream& operator<<(std::ostream& os, Prize p) {
+    os << p.X << " " << p.Y;
+    return os;
+}
+
+int find_lowest_token_win(Button A, Button B, Prize P) {
+    int lowest_token_count = INT_MAX;
+    for (int i = 0; i <= 100; i++) {
+        if (A.current_x > P.X || A.current_y > P.Y) {
+            break;
+        }
+        B.current_x = 0;
+        B.current_y = 0;
+        for (int j = 0; j <= 100; j++) {
+            if (A.current_x + B.current_x == P.X && A.current_y + B.current_y == P.Y) {
+                int token_count = i * 3 + j * 1;
+                lowest_token_count = std::min(token_count, lowest_token_count);
+            }
+            if (A.current_x + B.current_x > P.X || A.current_y + B.current_y > P.Y) {
+                break;
+            }
+            B.current_x += B.x;
+            B.current_y += B.y;
+        }
+        A.current_x += A.x;
+        A.current_y += A.y;
+    }
+    return lowest_token_count;
+}
+
+long long find_lowest_cramer(Button A, Button B, Prize P) {
+    long long lowest_token_count = LONG_LONG_MAX;
+    long long determinant = (long long)A.x * (long long)B.y - (long long)A.y * (long long)B.x;
+
+    if (determinant != 0) {
+        long long delta1 = (long long)P.X * B.y - (long long)B.x * P.Y;
+        long long delta2 = (long long)P.Y * A.x - (long long)P.X * A.y;
+
+        if (delta1 % determinant == 0 && delta2 % determinant == 0) {
+            long long x = delta1 / determinant;
+            long long y = delta2 / determinant;
+            long long token_count = x * 3 + y * 1;
+            lowest_token_count = std::min(token_count, lowest_token_count);
+        }
+    }
+
+    return lowest_token_count;
+}
+
+std::pair<double, double> get_button_press_count(Button A, Button B, Prize P) {
+    double ca = (P.X * B.y - P.Y * B.x) / (A.x * B.y - A.y * B.x);
+    double cb = (P.X - A.x * ca) / B.x;
+    double ipart;
+    double ipart_1;
+    if (std::modf(ca, &ipart) == 0 && std::modf(cb, &ipart_1) == 0) {
+        if (std::fmod(ca, 1.0) == 0 && std::fmod(cb, 1.0) == 0) {
+            if (trunc(ca) == ca && trunc(cb) == cb) {
+                return {ca, cb};
+            }
+        }
+    }
+
+    return {0, 0};
+}
+
+int main() {
+    std::vector<std::string> lines = read_lines();
+    long long total = 0;
+    long long cramer_total = 0;
+    for (int i = 0; i < lines.size(); i += 4) {
+        std::vector<std::string> line = split(':', lines[i]);
+        Button A = get_button(line);
+        std::vector<std::string> line_1 = split(':', lines[i + 1]);
+        Button B = get_button(line_1);
+        std::vector<std::string> line_2 = split(':', lines[i + 2]);
+        Prize P = get_prize(line_2);
+
+        // int token_count = find_lowest_token_win(A, B, P);
+        auto c = get_button_press_count(A, B, P);
+        auto cramer = find_lowest_cramer(A, B, P);
+        auto lin = c.first * 3 + c.second;
+        total += lin;
+        if (cramer != LONG_LONG_MAX) {
+            cramer_total += cramer;
+        }
+
+        if (lin != cramer && lin != 0) {
+            std::cout << A << " " << B << " " << P << std::endl;
+            std::cout << lin << " " << cramer << std::endl;
+        }
+        // Part 1
+        // if (token_count != INT_MAX) {
+        //     total += token_count;
+        // }
+    }
+    std::cout << "CRAMER TOTAL = " << cramer_total << "\n";
+    std::cout << "Total = " << total << std::endl;
+    return 0;
+}

Advent_2022/5

@@ -0,0 +1,100 @@
+import numpy as np
+
+
+class GameField:
+    def __init__(self, file):
+        with open(file, "r") as f:
+            x = f.read()
+        listed = []
+        for line in x.rsplit("\n"):
+            listed.append([char for char in line])
+        listed = np.array(listed)
+        self.game_field = listed
+        self.game_field_0 = self.game_field.copy()
+        self.loc_0 = np.where(self.game_field == "^")
+        self.loc_0 = [self.loc_0[0][0], self.loc_0[1][0]]
+        self.loc = self.loc_0.copy()
+        self.in_field = True
+        self.locations = []
+        self.options = 0
+
+    def turn(self):
+        if self.game_field[*self.loc] == "^":
+            self.game_field[*self.loc] = ">"
+        elif self.game_field[*self.loc] == ">":
+            self.game_field[*self.loc] = "v"
+        elif self.game_field[*self.loc] == "v":
+            self.game_field[*self.loc] = "<"
+        elif self.game_field[*self.loc] == "<":
+            self.game_field[*self.loc] = "^"
+
+    def move_ahead(self):
+        if self.game_field[*self.loc] == "^":
+            if self.loc[0] != 0:
+                if self.game_field[self.loc[0] - 1, self.loc[1]] == "#":
+                    self.turn()
+                else:
+                    self.game_field[*self.loc] = "X"
+                    self.loc[0] -= 1
+                    self.game_field[*self.loc] = "^"
+        elif self.game_field[*self.loc] == ">":
+            if self.loc[1] != self.game_field.shape[1] - 1:
+                if self.game_field[self.loc[0], self.loc[1] + 1] == "#":
+                    self.turn()
+                else:
+                    self.game_field[*self.loc] = "X"
+                    self.loc[1] += 1
+                    self.game_field[*self.loc] = ">"
+        elif self.game_field[*self.loc] == "v":
+            if self.loc[1] != self.game_field.shape[1] - 1:
+                if self.game_field[self.loc[0] + 1, self.loc[1]] == "#":
+                    self.turn()
+                else:
+                    self.game_field[*self.loc] = "X"
+                    self.loc[0] += 1
+                    self.game_field[*self.loc] = "v"
+        elif self.game_field[*self.loc] == "<":
+            if self.loc[1] != 0:
+                if self.game_field[self.loc[0], self.loc[1] - 1] == "#":
+                    self.turn()
+                else:
+                    self.game_field[*self.loc] = "X"
+                    self.loc[1] -= 1
+                    self.game_field[*self.loc] = "<"
+
+    def in_game_field(self):
+        return (
+            0 < self.loc[0] < self.game_field.shape[0] - 1
+            and 0 < self.loc[1] < self.game_field.shape[1] - 1
+        )
+
+    def play_game(self):
+        while self.in_game_field():
+            self.move_ahead()
+            if [self.loc[0], self.loc[1]] not in self.locations:
+                self.locations.append([self.loc[0], self.loc[1]])
+
+    def sol_2(self):
+        for i, loc in enumerate(self.locations):
+            if loc == self.loc_0:
+                continue
+            self.ocurance = np.zeros(shape=self.game_field.shape)
+            self.ocurance.fill(0)
+            self.game_field = self.game_field_0.copy()
+            self.game_field[*loc] = "#"
+            self.loc = self.loc_0.copy()
+            while self.in_game_field():
+                self.ocurance[*self.loc] += 1
+                if self.ocurance[*self.loc] > 4:
+                    self.options += 1
+                    # print(self.game_field)
+                    break
+                self.move_ahead()
+
+
+if __name__ == "__main__":
+    file = "test.txt"
+    x = GameField(file)
+    x.play_game()
+    x.sol_2()
+    print(x.options)

Advent_2022/6

@@ -4,57 +4,179 @@
 #include <vector>
 
 void ltrim(std::string &input) {
-  input = input.substr(input.find_first_not_of(" "));
+    input = input.substr(input.find_first_not_of(" "));
 }
 
 void rtrim(std::string &input) {
-  input = input.substr(0, input.find_last_not_of(" ") + 1);
+    input = input.substr(0, input.find_last_not_of(" ") + 1);
 }
 
 void trim(std::string &input) {
-  ltrim(input);
-  rtrim(input);
+    ltrim(input);
+    rtrim(input);
 }
 
 std::vector<std::string> read_lines() {
-  std::vector<std::string> lines;
-  std::string line;
-  while (getline(std::cin, line)) {
-    lines.push_back(line);
-  }
+    std::vector<std::string> lines;
+    std::string line;
+    while (getline(std::cin, line)) {
+        lines.push_back(line);
+    }
 
-  return lines;
+    return lines;
 }
 
 std::vector<std::string> split(char delim, std::string input) {
-  std::vector<std::string> tokens;
-  std::string token;
-  std::istringstream iss(input);
-  while (std::getline(iss, token, delim)) {
-    if (token.length() != 0) {
-      tokens.push_back(token);
+    std::vector<std::string> tokens;
+    std::string token;
+    std::istringstream iss(input);
+    while (std::getline(iss, token, delim)) {
+        if (token.length() != 0) {
+            tokens.push_back(token);
+        }
     }
-  }
-  return tokens;
+    return tokens;
 }
 
-template <typename T> void print_vector(std::vector<T> inp, char delim) {
-  for (auto a : inp) {
-    std::cout << a << delim;
-    // if (newline) {
-    // std::cout << '\n';
-    //} else {
-    // std::cout << ' ';
-    //}
-  }
-  std::cout << '\n';
+template <typename T>
+void print_vector(std::vector<T> inp, char delim) {
+    for (auto a : inp) {
+        std::cout << a << delim;
+    }
+    std::cout << '\n';
 }
 
 template <typename T>
 void print_grid(std::vector<std::vector<T>> grid, char delim) {
-  for (auto row : grid) {
-    print_vector(row, delim);
-    // std::cout << '\n';
-  }
-  std::cout << '\n';
+    for (auto row : grid) {
+        print_vector(row, delim);
+    }
+    std::cout << '\n';
 }
+
+struct Point {
+    int x;
+    int y;
+    Point(int x, int y) : x(x), y(y) {}
+
+    Point operator+(const Point &other) const {
+        return Point(this->x + other.x, this->y + other.y);
+    }
+
+    Point operator-(const Point &other) const {
+        return Point(this->x - other.x, this->y - other.y);
+    }
+
+    Point &operator+=(const Point &other) {
+        *this = *this + other;
+        return *this;
+    }
+
+    Point &operator-=(const Point &other) {
+        *this = *this - other;
+        return *this;
+    }
+
+    bool operator==(const Point &other) const {
+        return this->x == other.x && this->y == other.y;
+    }
+    bool operator!=(const Point &other) const { return !(*this == other); }
+
+    bool operator<(const Point &other) const {
+        return this->x < other.x || (this->x == other.x && this->y < other.y);
+    }
+
+    bool operator>(const Point &other) const {
+        return this->x > other.x || (this->x == other.x && this->y > other.y);
+    }
+};
+
+template <>
+struct std::hash<Point> {
+    size_t operator()(const Point &p) const {
+        size_t hash1 = std::hash<int>{}(p.x);
+        // Hash the second element
+        size_t hash2 = std::hash<int>{}(p.y);
+        return hash1 ^ (hash2 + 0x9e3779b9 + (hash1 << 6) + (hash1 >> 2));
+    }
+};
+
+struct hash_pair {
+    template <class T1, class T2>
+    size_t operator()(const std::pair<T1, T2> &p) const {
+        // Hash the first element
+        size_t hash1 = std::hash<T1>{}(p.first);
+        // Hash the second element
+        size_t hash2 = std::hash<T2>{}(p.second);
+        // Combine the two hash values
+        return hash1 ^ (hash2 + 0x9e3779b9 + (hash1 << 6) + (hash1 >> 2));
+    }
+};
+
+std::ostream &operator<<(std::ostream &os, const Point &point) {
+    os << "(" << point.x << ", " << point.y << ")";
+    return os;
+}
+
+enum Direction { UP,
+                 DOWN,
+                 LEFT,
+                 RIGHT };
+
+Point get_direction_from_enum(Direction dir) {
+    if (dir == UP) {
+        return {-1, 0};
+    } else if (dir == DOWN) {
+        return {1, 0};
+    } else if (dir == LEFT) {
+        return {0, -1};
+    } else if (dir == RIGHT) {
+        return {0, 1};
+    }
+    std::cout << "Invalid direction" << std::endl;
+    return {0, 0};
+}
+
+template <typename T>
+class Grid {
+   public:
+    std::vector<std::vector<T>> grid;
+    Grid(int rows, int cols, T fill_value) {
+        grid = std::vector<std::vector<T>>(rows, std::vector<T>(cols, fill_value));
+    }
+
+    void print(char delim) {
+        for (auto row : grid) {
+            print_vector(row, delim);
+        }
+    }
+
+    void print() {
+        for (auto row : grid) {
+            print_vector(row, ' ');
+        }
+    }
+
+    void add_row(std::vector<T> row) { grid.push_back(row); }
+
+    void set_row(int row, std::vector<T> values) { grid[row] = values; }
+
+    T get(int row, int col) { return grid[row][col]; }
+
+    void set(int row, int col, T value) { grid[row][col] = value; }
+
+    void set_col(int col, std::vector<T> values) {
+        for (int i = 0; i < grid.size(); i++) {
+            grid[i][col] = values[i];
+        }
+    }
+
+    int get_row_size() { return this->grid.size(); }
+
+    int get_col_size() {
+        if (grid.size() > 0) {
+            return this->grid[0].size();
+        }
+        return 0;
+    }
+};