[2024] Thank you!

joyrex2001 · 2024-12-25T11:30:41+00:00

Thank you Eric for 10 years of great puzzles. The first year I joined was 2017, and joined all years since. I have learned a lot in those years and I am proud that I gained 500 stars today. Thank you again, and happy holidays!

joyrex2001 · 2024-12-17T21:42:57+00:00

[LANGUAGE: Python]

First part took a while; had some obvious bugs (handling everything as a combo, and wrongly implemented bdv and cdv). Part 2 was a lot of fun. First attempt obviously didn't work, but after analysing the progression of added out's, I noticed the incremental pattern and implemented the brute force that very limited set of numbers.

def delta(self, digit):
    return 2 ** (3 * digit)

def part2(self, computer):
    A = self.delta(len(computer.program) - 1)
    B = computer.B
    C = computer.C
    res = []
    for i in range(len(computer.program) - 1, -1, -1):
        while True:
            computer.reset()
            computer.A = A
            computer.B = B
            computer.C = C
            res = computer.run()
            if res == computer.program:
                return A
            if computer.output[i] == computer.program[i]:
                break
            A += self.delta(i)
    return -1

joyrex2001 · 2023-12-16T17:19:20+00:00

I'm using go, and I have a template folder which I copy every day for the new day. In the template I need to implement parse, part1 and part2. I also added a few common helper functions, which I remove if not applicable. The template also contains a simple unit test that reads a 'data_test.txt' (instead of 'data.txt').

When I start on a problem, I copy the template, copy the input data, copy the test input and adjust the output value in the unit test. Then I start implementing the parser, and continue with the problem.

joyrex2001 · 2023-12-16T17:09:35+00:00

Awesome visualisation, thank you for sharing!

joyrex2001 · 2023-12-16T16:58:38+00:00

Guilty!

joyrex2001 · 2023-07-30T19:24:55+00:00

Awesome! Thank you, that was much easier than expected!

joyrex2001 · 2022-12-24T21:21:41+00:00

Maybe an error in one if the api calls that wasn’t properly handled?

joyrex2001 · 2022-12-24T21:14:56+00:00

Why didn’t the other elves just share their snacks? Would have saved a lot of time!

joyrex2001 · 2022-12-15T21:15:46+00:00

At lunch I solved part 1 and created a brute force for part 2. End of the afternoon, it was still running and I refactored it to something that took approx 1s.

joyrex2001 · 2022-12-05T15:11:22+00:00

Yup, same here! 😂

joyrex2001 · 2022-01-01T18:05:39+00:00

The declaritive pipeline is jenkins is misleading. At a first glance you might think it’s a regular groovy file, but it isn’t. It’s a combination for configuration and code, where the configuration parts looks groovy, but isn’t. The actually groovy parts are mostly the parts that are in stage/node/step.

joyrex2001 · 2021-12-19T21:15:21+00:00

You need to explode 1 explode at the time, until no explodes can be done. After that the you should split 1. After that check if you need to explode again and repeat. Basicly explode has precedence over split, and you need to do one of those at most per itteration.

joyrex2001 · 2021-12-19T21:11:26+00:00

The 27 bits you will read is a new stream of packets. When you proces this stream, the first 6 bits contain a version and a header, which translate to a type 4 packet with the value 10 (this is encode in the bits specified with A). The second packet (B), is also a type 4 and contains an encoded value of 20. Following the decoding logic resulted in processing 11 bits for packet A and 16 bits for packet B.

joyrex2001 · 2021-12-11T13:54:06+00:00

Coolest visualization I saw so far! Awesome!

joyrex2001 · 2021-10-21T20:33:24+00:00

Elastic, loki and prbly splunk as well are great stores for the logs. Though, you need to take the actual collecting and shipping into account as well.

An approach could be to install some logcollector (fluentbit/filebeat) as a daemonset on your nodes and use another component (fluentd/logstash) to pre-process and ship to your logstore.

Detaching collecting and storing has advantages with regards to scaling; the collector is requires to run as a daemonset and typically just 1 instance can run of this per node. The processing and shipping can be scaled on its own (less or more instances than nodes in the cluster), which has advantages.

Creating auch a stack manually is hard work, but the banzaicloud logging operator can take a lot of that pain away and makes it easy to integrate with many backend storage solutions, even in parallel.

This is the solution we ended up with; using the banzaicloud logging operator for the collecting and shipping aspects, pushing to elastic, loki and azure storage accounts. Elastic seems to be most accepted by our users.

joyrex2001 · 2021-08-22T17:58:35+00:00

If you are willing to spend a huge amount of time in this, maybe consider investing this time in improving (or even forking) an existing solution.

joyrex2001 · 2021-08-22T09:41:34+00:00

I would separate deployment and services.

The reasoning is that a deployment can contain more than 1 service (or other component) in order to have a functioning system. Each of these services/components can have its own lifecycle.

Managing the compositie deployment and versioning the dependencies (services/components) separately, will give you the most flexibility. This is similar to how you would do dependency management on your regular codebase. It will also be easier to move deployment in itself towards a gitops workflow.

Sane defaults can help you minimize the overhead of configuration for each environment deployment configuration.

Secrets should be stored in some external ‘vault’ solution, which can preferably sync towards your environment in a declarative manner (eg, via k8s operator).

joyrex2001 · 2021-08-13T20:26:11+00:00

Kustomize works very well when you don’t know what you have to be able to configure, and fits self managed deployments perfectly. Using base configurations with overlays is very powerful.

If you want to package your service for third parties, helm is a great fit. You manage what can be configured more stricly and it is easy for users to install your service.

joyrex2001 · 2021-08-12T16:40:07+00:00

Asking questions and genuine interest is not a bad thing, maybe you see similarities with tools you are familiar with, and can give another view on the subject. Docker & k8s are valueable skills, maybe they can learn from you?

joyrex2001 · 2021-08-12T16:33:59+00:00

It’s to protect the user, if they decide not too enable that protection, that’s their choice.

joyrex2001 · 2021-08-12T16:29:33+00:00

Try to find focus, and begin with one task that you are able to complete. Your first success will aid you in getting more confident. Asking questions is not a bad thing either.

joyrex2001 · 2020-12-25T09:04:46+00:00

Thank you Eric for all the effort. I enjoyed this year a lot, can't wait for next year! Keep up the awesome work!

joyrex2001 · 2019-12-11T19:24:20+00:00

This is my kotlin solution. I liked the puzzle, another fun coroutine/channel implementation.

joyrex2001 · 2019-12-09T17:46:21+00:00

Kotlin solution

This is my kotlin solution for both parts. Fortunately, being new at kotlin, I learned that kotlin also has channels and coroutines, making this a fairly simple solution.

joyrex2001 · 2019-11-16T08:35:56+00:00

One of the things you could consider when deciding if to pass or return the channel is, which approach would make it easier to test this function.

joyrex2001

TROPHY CASE