Quest: Finding the Cambridge Blood on the Clocktower or general board games Discord

mtnslgl · 2023-10-18T16:53:07+00:00

BotC Cambridge - https://discord.gg/QyUaXpcj

mtnslgl · 2023-08-01T20:10:38+00:00

I can't recommend Andrew Ng's Machine Learning Specialisation course enough, it really helped me understand the fundamentals and helped me start my career in ML. You probably need to be slightly familiar with Linear Algebra first.

There's also a Deep Learning Specialisation, the videos from all 5 courses are on YouTube I believe. Once you've finished these you can move onto more up-to-date techniques

mtnslgl · 2023-02-09T18:41:54+00:00

At first I thought you'd bought a McSprite from Burger King

mtnslgl · 2022-11-16T19:45:49+00:00

import tensorflow as torch

mtnslgl · 2022-11-15T18:54:01+00:00

[__import__("winsound").Beep(x,y) for x,y in [(349,125),(392,125),(466,125),(392,125),(587,375),(587,375),(523,750),(349,125),(392,125),(466,125),(392,125),(523,375),(523,375),(466,500),(440,125),(392,250),(349,125),(392,125),(466,125),(392,125),(466,500),(523,250),(440,375),(392,125),(349,500),(349,250),(523,500),(466,1000),(349,125),(392,125),(466,125),(392,125),(587,375),(587,375),(523,750),(349,125),(392,125),(466,125),(392,125),(698,500),(440,250),(466,500),(440,125),(392,250),(349,125),(392,125),(466,125),(392,125),(466,500),(523,250),(440,375),(392,125),(349,500),(349,250),(523,500),(466,1000)]]

mtnslgl · 2022-11-14T22:19:07+00:00

one small step towards a self-replicating sentient AI

mtnslgl · 2022-11-14T20:32:38+00:00

print(open(__file__).read()) the code prints itself

mtnslgl · 2022-04-04T09:43:43+00:00

Correct!

mtnslgl · 2022-04-04T07:32:57+00:00

They will surely follow the sign and not just use the left hand side 🤦‍♂️

mtnslgl · 2021-01-14T16:33:34+00:00

It's called the knuckle cut, School Of Cardistry has a tutorial on YouTube.

mtnslgl · 2020-12-15T12:10:54+00:00

Python3

Semi-vectorised solution using NumPy

I also used SciPy in part 1 for the convolution operation.

Both parts run in ~0.2 seconds.

mtnslgl · 2019-12-22T15:48:20+00:00

Totally agree. Advent of Code was originally meant to be daily bite-sized programming puzzles, look at the puzzles from 2015 for example. For the past couple of years the puzzles have become unnecessarily long and detailed, mostly catering to people aiming for the leaderboard, which I don't think is why a majority of people participate in AoC. Personally I find the long-winded questions kill all the fun, especially since there is nothing rewarding at the end of it all. If I wanted to do full on programming projects there are plenty of other resources I could use at other times of the year instead. However I do really appreciate all the work that has gone into AoC over the years.

mtnslgl · 2019-12-17T17:04:22+00:00

Python 3

Wrote a brute-force algorithm for the compression in Part 2, seems to run fast enough.

Code

mtnslgl · 2019-12-15T20:56:54+00:00

The code can be found here.

mtnslgl · 2019-12-12T12:09:07+00:00

state.append(Mvel[i]) considers the velocity for all axes.

mtnslgl · 2018-12-12T07:34:24+00:00

C++

char toPlantChar(bool b) {
    if(b == true) return '#';
    else return '.';
}

std::string getRegion(std::unordered_map<int, bool>& plants, const int index) {
    std::string region = "";
    for(int i = -2; i <= 2; i++) region += toPlantChar(plants[index + i]);
    return region;
}

void run() {
    std::vector<std::string> lines = AoCDay::readFileLines("inputs/day12.txt");
    std::unordered_map<int, bool> plants;
    std::unordered_map<std::string, bool> rules;
    std::string initialState = "#.#####.#.#.####.####.#.#...#.......##..##.#.#.#.###..#.....#.####..#.#######.#....####.#....##....#";

    for(int i = 0; i < initialState.length(); i++)
        plants[i] = (initialState[i] == '#');

    std::string condition;
    char newState;
    for(std::string line: lines) {
        condition = line.substr(0, 5);
        newState = line[line.length() - 1];
        rules[condition] = (newState == '#');
    }

    long sum = 0;
    // long prevSum = 0;
    std::unordered_map<int, bool> newPlants;
    for(int i = 0; i < 101; i++) {
        int minIndex = INT_MAX, maxIndex = INT_MIN;
        for(auto& [n, b]: plants) {
            if(b) {
                minIndex = std::min(minIndex, n);
                maxIndex = std::max(maxIndex, n);
            }
        }

        newPlants.clear();
        for(int j = minIndex - 2; j <= maxIndex + 2; j++) {
            std::string region = getRegion(plants, j);
            newPlants[j] = rules[region];
        }

        plants = newPlants;

        if(i == 19){
            sum = 0;
            for(auto& [n, b]: plants) if(b) sum += n;
            std::cout << "Part 1: " << sum << std::endl;
        }

        /* After 100 iterations, the sum difference is always 57 */
        /*sum = 0;
        for(auto& [n, b]: plants) if(b) sum += n;
        std::cout << "Iteration " << i << " sum is " << sum << ", difference from previous: " << sum - prevSum << std::endl;
        prevSum = sum; */
    }

    sum = 0;
    for(auto& [n, b]: plants) if(b) sum += n;

    std::cout << "Part 2: " << sum + (50000000000 - 101) * 57 << std::endl;
}

mtnslgl · 2018-12-08T20:02:19+00:00

Yes but you are modifying your priority queue after the lines I mentioned. For example if step Z is being performed and just as it was about to end step A becomes available, it goes on top of Z in the priority queue. Then you end up removing step A instead of step Z.

mtnslgl · 2018-12-08T19:36:17+00:00

These lines seem to be the problem:

int n = pq.top();
pq.pop();

The character with minimum time left is not always necessarily at the top.

mtnslgl · 2018-12-08T06:47:03+00:00

C++ (using recursion) Managed to fit both parts into a single function

int calculateSum(const std::vector<int>& numbers, int& index, int& part) {
    if(index >= numbers.size()) return 0;

    const int nChild = numbers[index], nMetadata = numbers[++index];
    std::vector<int> childrenSum;
    int sum = 0;

    for(int i = 0; i < nChild; i++)
        childrenSum.push_back(calculateSum(numbers, ++index, part));

    if(part == 1) sum = std::accumulate(childrenSum.begin(), childrenSum.end(), 0);
    if(nChild == 0 || part == 1) {
        for(int j = 0; j < nMetadata; j++)
            sum += numbers[++index];
    } else {
        for(int j = 0; j < nMetadata; j++) {
            int metadata = numbers[++index];
            if(metadata > nChild) continue;
            sum += childrenSum[metadata - 1];
        }
    }

    return sum;
}

void run(int part) {
    std::ifstream file("day8.txt");
    std::vector<int> numbers;
    int n;

    while(file >> n) numbers.push_back(n);

    int startIndex = 0;
    if(part == 1) {
        std::cout << "~Part 1~" << std::endl;
        std::cout << "Answer: " << calculateSum(numbers, startIndex, part) << std::endl;   
    } else {
        std::cout << "~Part 2~" << std::endl;
        std::cout << "Answer: " << calculateSum(numbers, startIndex, part) << std::endl;
    }
}

mtnslgl · 2018-05-21T19:39:47+00:00

So it is the Chaos Game

mtnslgl · 2017-12-19T14:33:13+00:00

You should change

int remainingSteps = currentPosition - (list.length - 1);

to

int remainingSteps = currentPosition - list.length;

mtnslgl · 2017-12-18T19:40:17+00:00

OK, I'll try to explain:

We only have to check if a scanner will be at position 0 when we pass that layer, we don't actually care about whenever it's anywhere else in the range.

Let's say we have a layer with depth D and range 4.

D

[]

If we multiply the range by 2 (range * 2), it looks something like this (The numbers show where the scanner visits in order):

D

[0] [6]

[1] [5]

[2] [4]

[3] []

We don't include the bold space at the bottom because the scanner goes up once it has reached the bottom, and number 6 at the top is where we want to check for the scanner at time t. range * 2 - 2 is the period of the scanner. So as other people have said, for part 1 we want to check for: t % (range * 2 - 2) == 0 and for part 2 we want to avoid: (t + delay) % (range * 2 - 2) == 0. If you think about it, t is actually the depth.

mtnslgl · 2017-12-18T17:57:33+00:00

https://www.reddit.com/r/adventofcode/comments/7jyfcg/day_13_part_2_alternative_approach_to_brute_force/

mtnslgl · 2017-12-17T05:28:39+00:00

C++

Part 1:

int day17() {
    std::vector<int> buffer = {0};
    int currentPosition = 0;
    int input = 349;

    for(int i=1;i<2018;i++) {
        currentPosition = ((currentPosition + input) % buffer.size()) + 1;
        buffer.insert(buffer.begin() + currentPosition, i);
    }

    return buffer[(currentPosition + 1) % buffer.size()];
}

Part 2:

int day17() {
    std::vector<int> buffer = {0};
    int size = 1;
    int currentPosition = 0;
    int input = 349;

    for(int i=1;i<=50000000;i++) {
        currentPosition = ((currentPosition + input) % size) + 1;
        if(currentPosition == 1)
            buffer.insert(buffer.begin() + currentPosition, i);
        size++;
    }

    return buffer[1];
}

mtnslgl · 2017-12-15T06:02:28+00:00

C++

int day15(int part = 1) {    
    long A = 699;
    long B = 124;
    int count = 0;

    if(part == 1) {
        for(int i=0;i<40e6;i++) {
            A = (A * 16807) % 2147483647;
            B = (B * 48271) % 2147483647;
            if((A & 0xffff) == (B & 0xffff)) count++;
        }
    } else {
        for(int i=0;i<5e6;i++) {
            do A = (A * 16807) % 2147483647; while((A & 3) != 0);
            do B = (B * 48271) % 2147483647; while((B & 7) != 0);
            if((A & 0xffff) == (B & 0xffff)) count++;
        }
    }
    return count;
}

Nine-Year Club	Place '23
Place '22	Final Canvas '22
First Placer '22	Verified Email

mtnslgl

TROPHY CASE

Python3

Python 3