## Re-approaching the Project Euler Problems: Uh-oh

This all happened one quiet Friday evening.

I was at my laptop happily working away on my new system for tackling the Project Euler problems, and had just got both PHP and JavaScript playing nicely with the Python script (one of many) that I had created, which takes all the data of the language, version, machine specs (OS, memory, that sort of thing). Success! Naturally I had written scripts in each of the 3 languages to tackle – where else to start? Problem 1.

Problem 1 asks you to find the sum of all the multiples of 3 or 5 below 1000, of course for this project I am taking it a bit further and finding the sum of all said multiples below x, but it defaults to 1000 if no value of x is provided.

When I hit enter on the JavaScript file for the first successful time my heart leapt with joy as it reported no errors. Then just as quickly that joy turned to suspicion, “that answer looks different to the one Python has been giving me, oh please don’t be”.

This could well mean that all the data I have been collecting thus far is useless. I mean, what good is knowing how long it took a particular script to give you the wrong answer?

And here I was thinking I’d get away without automated testing! *Sigh* yet another bit to add! One of these days I might actually start solving the problems themselves!

The much older and wiser Gavin from 20 minutes in the future: Get away without automated testing? What on earth were you thinking, Gavin? You go ahead and do what you want but I’m going to bed ðŸ’¤.

## Re-approaching the Project Euler Problems – an Introduction

Avid readers of this blog (of which I’m sure there are many, I mean, there are 14 whole posts on here at the time of writing!) will remember that back in 2019 I started solving the Project Euler Problems, I set myself the task of solving 1 problem a week, writing a bit about it, and posting it every Sunday at 3PM without fail.

Needless to say, I failed. The few posts that did manage to see the light of day are now available under the project euler 2019 tag in all their glory. I started doing the first few in PHP then switched to Python, then wondered why I shouldn’t do them all in both of those languages, then thought about other languages such as JavaScript, C, Rust and C++, then tried to build all sorts of tools to help me manage all of this. Plus how would I store the code to display it? It took me quite a while to settle on Gists which with hindsight really should have been my first port of call. Can I really be sure I’ll be at my desk at 3PM on a Sunday every week for 749 weeks? No, of course I can’t, I’d better automate that part. 749 weeks is just under 14 and a half years. Meaning that if I had kept up with it from the latter half of 2019, it would run to about the end of 2033. My 28-year-old self would then be 42, my newborn infant would be about to start his GCSEs, you see where this is going, it’s a commitment. One way to combat this is to construct some tools around it to help automate it – as well as adding a few supplementary features – such as:

• First of all, I want to make sure my code works, so automatic compilers for the languages that need compilation. These will also need to be tailored to the platform I happen to be running them on, especially given that back in 2019 I only had a clunky old laptop running Ubuntu. I now still have that same laptop, but also a much newer, smaller, Windows laptop, and now a MacBook from my new job. On the plus side this does now give me all 3 of Linux, MacOS and Windows!
• I wonder if there’s a way to get these running on Android/iOS as well! Maybe save that for another day.
• A tool to turn Markdown posts into nicely-formatted blog posts suitable for WordPress.
• A way to automate their publishing for 3PM each Sunday – this is actually the easy part, just write them ahead of time and set their publish dates accordingly. Then again, who’s to say I won’t decide to alter this?
• A tool to upload my code files into Gists (as well as maintaining the whole thing as a Git repo anyway).
• This one is quite troublesome because at the time of writing my way of making sure a Gist for a given problem and language doesn’t already exist is a bit hit-and-miss.
• A WordPress block to pull down all the Gists relating to the problem being viewed.
• This has the same issue, however, as my Gist-uploading tool above. When I was going through the posts to add the project euler 2019 tag, problem 1 believed I’d only written it in C++ and Java!
• A way to manage and maintain all of this, including making updates where necessary.
• Additional feature: It would be nice to include a D3-based scatter plot of how long each language takes to solve each problem given different input values. This in itself is a huge data collection project, meaning I need to store the language, values, results, time taken and machine specs in a CSV for each problem. The latest version of the design for this can be seen on VizHub, and treat yourself to a screenshot below! This may give some insights beyond just “which languages are faster?” such as “does a particular language work better on a certain machine?”, “how do various language cope with higher inputs?” And so on.

So where to even begin with all this? Well, luckily, I’m writing this partway through getting my system built up, so I already have something of an idea of what to do. One thing I have noticed copied across multiple files (most of this automation is being done in Python) is a duplication of the dictionary containing the language names and file extensions. It would be good to get a comprehensive list of the ones I’ll be working on in a separate file wouldn’t it? Luckily I have found this Gist from Peter Pisarczyk (in turned forked from Aymen Mouelhi) which contains what appears to be just about every programming language ever. I haven’t gone through the whole list but I reckon it’s a fairly safe bet that I haven’t even heard of more than half of them!

This then results in the following languages.json file – I never knew there were this many file extensions in the known universe!:

At each step I’ll be looking to see what our basic folder structure looks like, so at the moment:

project-euler
â”œget_working_language_extensions.py
â””working_language_extensions.json

Now as an example, let’s look at what I want each problem folder to look like:

project-euler
â”œproblem_x
â”‚â”œproblem_x_timings.csv // To store the info of how long each problem took to solve, also store the input value, language, and machine specs
â”‚â”œproblem_x.c
â”‚â”œproblem_x.cpp
â”‚â”œproblem_x.java
â”‚â”œproblem_x.js
â”‚â”œproblem_x.md // To be converted into the relevant blog post
â”‚â”œproblem_x.php
â”‚â”œproblem_x.py
â”‚â”œproblem_x.rs
â”‚â””problem_x.ts
â”œget_working_language_extensions.py
â””working_language_extensions.json

And for completeness and to allow me to make my next post in this series but still chronologically after this (albeit not by much), without leaving this one looking a bit short, here is the full file list (for now at least!) Along with a brief explanation, there will of course be full posts explaining these in due course!

project-euler
â”œproblem_x
â”‚â”œproblem_x_timings.csv // To store the info of how long each problem took to solve, also store the input value, language, and machine specs
â”‚â”œproblem_x.c
â”‚â”œproblem_x.cpp
â”‚â”œproblem_x.java
â”‚â”œproblem_x.js
â”‚â”œproblem_x.md // To be converted into the relevant blog post
â”‚â”œproblem_x.php
â”‚â”œproblem_x.py
â”‚â”œproblem_x.rs
â”‚â””problem_x.ts
â”œ.gitignore // (obviously!)
â”œc_functions.c // Functions to be imported into C scripts, not sure yet but this may need to be .h, once I dive properly into C I'll find out!
â”œcpp_functions.cpp // Functions to be imported into C# scripts
â”œenv_info.json // gitignored as it's machine specific
â”œfile_operations.py // All file-related operations
â”œfile_templates.py // Templates for files in each language, hopefully to prepopulate imports, boilerplate, etc. in each folder
â”œget_env.py // Run this to creat env_info.json above
â”œgithub_config.py // Generated tokens for working with my Gists
â”œgithub_credentials.json // gitignored as these are the API keys for github_config to use!
â”œjava_functions.java
â”œjs_functions.js
â”œlanguages.json // Renamed from working_language_extensions.json in the code block above
â”œlanguages.py // Renamed from get_working_language_extensions.py in the code block above
â”œmkdirs.py // Create all the directories for each problem, may merge this into file_operations.py
â”œphp_functions.php
â”œproblem_descriptions.json // I created this to allow the chart I'm designing to pull down a subtitle, may change how I do this
â”œpublish_to_wordpress.py
â”œpublish.py // A lot of duplicate code between these two, but the idea is that this automates creating the blog posts
â”œpyfuncs.py
â”œrust_functions.rs
â”œts_functions.ts
â”œupdategists.py // Functions for working with Gists
â”œwp_config.py // Much like github_config.py but for WordPress
â””wp_credentials.json // Again, like github_credentials, gitignored as these are keys

## Solving the Project Euler Problems – Problem 6

The sum of the squares of the first ten natural numbers is, 12 + 22 + … + 102 = 385.

The square of the sum of the first ten natural numbers is, (1 + 2 + … + 10)2 = 552 = 3025.

Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025 âˆ’ 385 = 2640.

Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.

No gists found

This one oddly seems relatively simple. simply take a number, work out the sum of 1 to that number then square it, work out the sum of the squares of 1 to that number and find the difference between your 2 results. Job done!