This problem is interesting because we aren't given an upper limit as to where we should end our search. So how about we find it?

I took the most straightforward solution I could think of (cause I'm a straightforward kind of guy)

The first thing to realize is that there are only two possibilities ✌️

I'll admit something: When I first solved this problem years ago, it almost broke me 😭.

This problem is interesting because it doesn't mention a scope. How do we know when to stop searching for numbers that can be written as the sum of the fourth/fifth power of their digits? I don't know myself, but I made some assumptions.

I decided to go with the most straight-forward solution. (Oy vey 💀)

Let's notice a few things: In the first 'ring,' the numbers 3, 5, 7, and 9 go up by two. In the second 'ring,' the numbers 13, 17, 21, and 25 go up by four.

Why does #3 use only positive primes? Actually, it doesn't have to, but from observing the output, only the positive prime numbers produce chains, so we can do away with trying the negative side.

This solution involved a bit of research, but here are three Wikipedia pages that I found helpful: Full Reptend Primes, Multiplicative Order, and Cyclic Number.

Nothing complicated here. (I say stuff like this a lot don't I? Trust me, me not that smaht 💀)

It ironically took more time to write this code than to get the answer from print(lex[999999]). Work hard to be lazy 😤

Phew, this problem is more involved than others, but manageable. Here are the steps I took to solve it.

A fairly straightforward solution. Boy, a lot of these aren't there? 😱

To complete this problem, I needed some new code that would perform factorization. I decided to have two functions: one that returns the prime factors of a number and one that returns the proper divisors of a number.

Another simple problem. 😁

Thank goodness for Python, as it makes this problem trivial. The question asks, 'How many Sundays fell on the first of the month during the twentieth century?'

It's easier to solve the problem by starting at the bottom and working towards the top. This allows us to have just one number at the end instead of a row of numbers. They say 'a picture is worth a thousand words,' so here's an animation of what the code will do.

The solutions is split into three sections. From there, it's combining these groups of words to make all the numbers from 1 to 999 (then appending one thousand to the end).

The solution I went for was fairly simple. 😁

We can use combinatorics to solve this question! If we look at the grid, we always make a total of four moves in some combination of moving right and moving down. Of the four possible moves, we should choose two of them to be in a particular direction, say, towards the right. With that, we get '4 choose 2.'

The solution is pretty straight-forward based on the problem description, but we can make an optimization.

This problem was very straight forward 😁

The problem asks us, 'What is the value of the first triangle number to have over five hundred divisors?'. This means we have to be able to find the number of divisors for any given number.

I start off by taking the number grid and turning it into a 2D array in Python. This way, I can access any number in the grid using [x][y] notation with x accessing the rows and y accessing the columns.

We can once again use the Sieve of Eratosthenesas seen in Problem 3. Since the sieve returns a list (array), we can just sum the returned list.

In order to generate Pythagorean Triples we can use Euclid's Formula

We have to multiply 13 adjacent digits and find the largest. To do this, we can use a “sliding window” to multiply an array of numbers.

Since we're generating primes, I'll be using the Sieve of Eratosthenes, which was seen and created in Problem 3.

The problem with this approach is that if we change the range, say from [1 - 100] to [1 - 1 000 000], it would take a much longer time to calculate. What if we could skip all this and have a much faster approach?

The solution involves what we have seen in previous problems: prime factorization. Let's look at the example given in the problem.

The solution here may not be the most efficient, but it works. The program loops through all 3-digit number products, converts them to a string, reverses the string, and then checks if the reversed and unreversed strings are equivalent.

Every natural number, ℕ, is either prime or can be created using prime numbers. For example, the number 2595 can be created using the prime numbers (factors) 3, 5, and 173.

If you understand how a Fibonacci sequence works, then the code below is understandable. The solution has been written in both Python and Rust, and either one will work.

Here, we write some simple programs in the course's HACK assembly language.

We have to find all the multiples of 3 or 5 below 1000 and get the sum. One thing to be careful of are multiples of 15, as they are multiples of both 3 and 5, and we want multiples of 3 or 5.

Here, we create the memory modules for the computer.

This is the continuation of the previous post, Project 2 - Boolean Arithmetic. In this post, only the Arithmetic Logic Unit (ALU) is created, but it is deserving of its own writeup as there is a lot packed into this section that needs examining.

If we're going to build a computer, we'll have to be able to perform some boolean arithmetic. This post is dedicated to the creation of four 'chips' that do just that, though all of them perform only addition is some way.

In an effort to design a simple computer from the ground up, we need to create the relevant hardware to make such a machine work.