DEV Community: Jack Beresford

The 12 Days of Christmas - Programmed vs. Compressed

Jack Beresford — Tue, 23 Dec 2025 11:04:35 +0000

The famous 'Twelve days of Christmas' song has a cumulative nature, in that every day adds a gift, and therefore a line to the song.
The fact that there are only 12 unique gifts, the numbers 1 through 12, yet about 90 lines in the song, should tempt an exercise to shorten it.

The song can easily to be reproduced in a programming language, with the verbal ingredients as follows:

days = ["first","second","third","fourth",\
        "fifth","sixth","seventh","eighth",\
        "ninth","tenth","eleventh","twelth"]

gifts = ["A partridge in a pear tree.","Two turtle doves","Three French hens",\
         "Four calling birds","Five gold rings","Six geese a-laying",\
         "Seven swans a-swimming","Eight maids a-milking","Nine ladies dancing",\
         "Ten lords a-leaping","Eleven pipers piping","Twelve drummers drumming"]

onThe = "On the " 
gave = " day of Christmas my true love gave to me"

With some simple iteration in Python (working along the days/gifts), we can write the song in a new text file as follows:

with open("12Days.txt", "w") as file:
    for i in range(len(days)):

        # First line of every day
        file.write(f"\n{onThe}{days[i]}{gave}:\n{gifts[i]}\n")

        # Avoid operations for first day
        if i == 0:
            continue

        # iterate until no more gifts to give
        next = i-1
        while next > 0:
            file.write(f"{gifts[next]}\n")
            next -= 1
        file.write(f"And {gifts[next].lower()}\n")

The result is a text file ending like so:

Not bad. But one flaw of this reproduction is that it required understanding of the song's syntax and structure. Compression, which we see in zip files, jpegs, and so on, can 'shorten' without any understanding, as compression algorithms run on independent rules.

You can see this with the zlib compression algorithm, imported from Python https://docs.python.org/3/library/zlib.html. It is highly performant with files like this, as repeated lines can be replaced with 'pointers' to refer back to an original reference (e.g. the first utterance of 'a partridge in a pear tree').

Calling zlib.compress() with the original file will return a bytes object, looking like this:

This text might be incomprehensible, but at a size of 0.31 KB (just 13% of the size of the full song's 2.36 KB), the zlib algorithm shows its power and application for internet libraries and more.
Most importantly, it can decompress(), allowing the file to return to its original format.

To take this one step further, one can try the complete Works of Shakespeare: https://www.gutenberg.org/cache/epub/100/pg100.txt
I got this down to 2MB with a quick attempt, but I'm sure it can be made even smaller!

Text Based Games and How to Make Them

Jack Beresford — Sun, 29 Jun 2025 17:39:09 +0000

After frustration at modern TV and film, I have returned to the ever reliable written word, by which I mean crude text-based games in Python.

At its core the text based game is just conditional logic.
If this, then print this, otherwise, print something else.

choice1 = input("What's your name?")


if choice1 == 'Eggbert':
    print ("Hello!")
else:
    print("Invalid name")

All fun and games. But in a text based game we want 1 of 2 or more specific options. For example:

choice1 = input("Are you better at ENGLISH or FRENCH?")


if choice1 == 'ENGLISH':
    print ("Hello!")
elif choice1 == 'FRENCH':
    print("Bonjour!")
else:
    print("Invalid entry")

This is fine enough but two weaknesses we can see are:
Case sensitivity. Writing ‘french’ or ‘French’ seems an equally valid entry, but it would be rejected as it is not == (equal to) ‘FRENCH’
The else: statement doesn’t actually stop us, which is to say, we can get _past _choice1 by writing anything. In the case of text based games, there are right and wrong answers, so why let the player get past a stage by writing nonsense?

To solve this, we do the following:

choice1 = input("Are you better at ENGLISH or FRENCH?").upper()


while choice1 != 'ENGLISH' and choice1 != 'FRENCH':
    choice1 = input('Invalid entry. Are you better at ENGLISH or FRENCH?:   ')


if choice1 == 'ENGLISH':
    print ("Hello!")

elif choice1 == 'FRENCH':
    print("Bonjour!")

The upper() function converts the user input into all caps (even if the user writes in all caps). Doing this at the end of the input() function means all subsequent conditionals will work, no need to put upper on anything else.

Using a while loop with negative conditions keeps the user stuck until they have written 1 of these choices. What prevents this while loop from running indefinitely is that they have the chance to redefine the input.

It is with this logic that we make a common starting feature of games: a player choosing their name.

player_name = input("What is your name?:    ")
print(f"Hello, {player_name}")

Use of an f string i.e. f” allows the variable player_name to be invoked in a string, in this case a greeting. But let me show you a flaw of this simple approach:

What is your name?: aaaaaaaaaaaaaaaaaaaaaaaaaa1111111111111111111111111111111111111111 Hello, aaaaaaaaaaaaaaaaaaaaaaaaaa1111111111111111111111111111111111111111

Not much good this; if your cat walked across your keyboard and pressed Enter, the name would be stuck like this and printed in all subsequent f strings.

We should therefore insert some rules. I’ve decided 1) the name should not be more than 12 characters, and 2) made up of only letters (no numbers, punctuation or spaces).

player_name = input("What is your name?:    ")
while not player_name.isalpha() or len(player_name) > 12:
player_name = input("Invalid entry. Must be <12 characters and only letters A-Z.\nTry again:  ")

I use a while not loop because it works well with isalpha(), a method of checking if a string is all letters (e.g. A-Z) or not.
len() > 12 is True when the string is more than 12 characters
Putting them together in an or loop, checks if 1, or both of these conditions is true.
We’ll test it now:

What is your name?: john1 Invalid entry. Must be <12 characters and only letters A-Z. Try again: johnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn Invalid entry. Must be <12 characters and only letters A-Z. Try again: john11111111111111111111111111111111111 Invalid entry. Must be <12 characters and only letters A-Z. Try again: john Hello, john

You’ll note that the logic governing this is similar to the logic governing what constitutes a ‘strong’ password, valid email addresses and so on.

You could probably make a decent text based game with just these features, but one thing I’ve learnt is that writing lines of text is the easy thing. Adding functionality, that’s the hard part.

*Note - this is the first time I use the \n new line character. It is very helpful for f strings, inputs and so on, ensuring you can keep lines printed out in a user-friendly way. Basically, write \n, and everything after will appear on a new line.

My final game (link below) uses 2 extra features:
1) writing out the script via the sys.stdout.writeout() method, the speed of which can be user-defined, and 2) Dungeons and Dragons style combat using the random.randint() method.

The combat is quite simple. Anyone who’s made a dice roll will have used it.

import random
dice_roll = random.randint(1,6)
print(f"You rolled a {dice_roll}!")

Import the random module. Random.randint(1,6) means, give me a random number between 1 and 6. Then print it.
This can also be done without the variable assignment (printed straight away), and it makes for a big difference. I’ll show you with a more combat based example.

import random

player_attack = random.randint(1,6)
enemy_health = 2
enemy_name = "Jeff"

print(f"{enemy_name} is on {enemy_health}health. Time to attack!")
print(f"You hit {enemy_name} for {player_attack} damage.")

Looks fine right? Well, a problem is that the random.randint() will not run again and again and again, when we loop through a fight sequence. It will run one time, i.e. to assign the variable player_attack with the value of a random integer between 1 and 6. This means if you wanted a combat sequence, you could be hitting the same amount of damage every time you attack. This is not the point at all.

That being said, smart code is lazy code, and you don’t want to write random.randint(1,6) every time. You may even want to modify the attack range if your player finds a brand new fancy weapon or something. This is where I came up with a ‘max damage’ for characters.

player_max_damage = 6
print(
    f"You hit {enemy_name} for {random.randint(1, player_max_damage)} damage.")

The key difference is that the random number is generated within each attack (between 1 and the max damage), not before and throughout.

The next concern should be how to win or lose a battle? How do we make sure it continues until one or both of us is dead?

Well first, we need to reassign values to health, such as:
enemy_health -= 2
This will subtract 2 from the current enemy health and then reassign that value to the variable.

Then, we need to end the fight if the enemy’s or our health reaches 0 or less.

Here’s how I achieved this:

while True:
    print('--⚔--⚔--⚔--⚔--ATTACK--⚔--⚔--⚔--⚔--')
    input(f"You have {player_health} health. {mob_name} has {mob_healths[mob_name]} health")
    player_attack = random.randint(1, player_damage)
    mob_healths[mob_name] -= player_attack
    if mob_healths[mob_name] > 0:
        print(f"You hit the {mob_name} for {player_attack} damage.")
        print(f"{mob_name} is now on {mob_healths[mob_name]} health.\n")
    else:
        print(f"You hit the {mob_name} for {player_attack} damage and defeat it!\n")
        break

Putting this in a while loop ensures the conditions are checked, and that the only way we can leave is DEATH…

Jokes aside, most of these values are predefined, will show these later - they are easy to change.

In short, we have an if statement for if the enemy has more than 0 health, and an else if they don’t (we defeated it!)

Now within that same loop, we can put our defense (the enemy should get a turn to attack as well).

    print('--🛡--🛡--🛡--🛡--DEFEND--🛡--🛡--🛡--🛡--')
    input(f"You have {player_health} health. {mob_name} has {mob_healths[mob_name]} health")
    mob_attack = random.randint(1, mob_max_damages[mob_name])
    player_health -= mob_attack
    if player_health > 0:
        print(f"The {mob_name} hits you for {mob_attack} damage.")
        print(f"You are now on {player_health} health.\n")
    else:
        print(f"The {mob_name} hits you for {mob_attack} damage.")
        print("💀 You died! GAME OVER 💀\n")
        break

I wrap this all together, within a combat() function, needing only the variables:(mob_name, player_health). Player_health is not so much a concern, when we run future combat() functions we can just put the {player_health} curly braced inside. I wanted the option to ‘level up’ the character at some point and therefore increase += their health.

Anyway, what I think makes this combat function powerful is that the mob_name will reference an indexed position in 1 list and 2 dictionaries i.e. [0] or [2] in mob_name, mob_healths, and mob_damages:

    mob_names = ["Bug 🐛", "Wolf 🐺", "Goblin 👺"]


    mob_healths = {
        mob_names[0]: 6,
        mob_names[1]: 8,
        mob_names[2]: 10
    }


    mob_max_damages = {  # a random.randint() will run between 1 and these numbers
        mob_names[0]: 3,
        mob_names[1]: 5,
        mob_names[2]: 6
    }

These run independent of the combat() function, and if you want to change the theme of the game then all you have to do is change the name. Nothing else needs to change, everything will print out and run for you. Of course you can change the healths and damages but be sure to consider balance in your game.

Now for the text speed, which relates to parts of the sys and time module.
I did this all in one place at the top, along with the random module:

import time  # for time.sleep() printing text
import sys  # for text speed (optional)
import random  # for 'rolling' a dice etc.

Write an introduction, or scene description. Give it a name and try and keep it all in one string. This can be done by avoiding a long line as so:

    intro = (f"Welcome to {game_name}, a text-based adventure game.\n"
             f"{game_name} is set in {world}, in {time_or_setting}.\n"
             "Scenes will be read out for you, like this.\n"
             "Choices will be printed out in full and require you to type an answer.\n"
             "They will follow a ':' semicolon. You can only do 1 thing at a time. \n"
             "Let's begin with the first choice, your name.\n"
             )

Using \n line breaks and keeping the quotation marks at the same indentation as the previous, ‘intro’ can be several lines long while still belonging to the same variable. That is all we need to have it written out:

for char in intro:
        sys.stdout.write(char)
        sys.stdout.flush()
        time.sleep(text_speed)`

This works for with a for loop. We say that for every char in intro (for every character in intro)

Note that instead of char we could write anything, like ‘letter’, ‘thing’ and so on, as long as we correctly refer to it again in the sys.stdout.write() function. Anyway, char makes sense, and readability is important.

sys.stdout.write() is very similar to print(), only different insofar as it prints every character, and doesn’t add spaces. It’s basically a precise printing tool.

sys.stdout.flush() is very important here; it ensures that rerunning this loop still keeps the characters on the same line. Without it, the for loop would make each character print underneath itself.

time.sleep() is what we use as the time gap between each character being printed. I reference text_speed, which I put at the top of my program, allowing the user to define speed as they like (they may read faster or slower than me).

Wrapping up - I put the bulk of my game inside a main() function and indented the lot. This is a good idea because putting underneath the lot:

if __name__ == "__main__":
    main()

Will ensure that the program can only be run from the program directly; it’s best practice. I also like to hide the script this way and look at more ‘master’ items, such as:

import time  # for time.sleep() printing text
import sys  # for text speed (optional)
import random  # for 'rolling' a dice etc.


# User-defined items
game_name = "The Project"  # *changeable - will be reflected everywhere else
title = (f"-💾-⌨-💻---{game_name}---💻-⌨-💾-")  # modify emojis as you wish
world = "Procrastinationland"  
# be conscious of grammar when printed
time_or_setting = "2025"
# get a feel for how fast you like the text speed when you run the code
text_speed = 0.05

Voila. With those building blocks, more scenes, enemies, stories etc. can be fleshed out to make it more of a story.
Additional improvements I would make would be:
1) ‘dice rolls’ outside of combat to determine the possibility of doing things. I have made this before and it’s pretty easy - ‘if < 10, fail. If >10, pass. If == 1, spectacularly fail, etc.
2) consequences for decisions by storing a boolean that can be referred to later. For example, if you did choose to help the hungry villagers, then help_village = True. In your character’s return weeks later , the villagers could either be gone, or alive and willing to repay you, simply based on that boolean.
3) animations. While this technically contradicts the text based nature of the game, I am already using text read out, and a similar principle could do something like showing the character and an enemy get closer until they meet at crossed swords. There are lots of possibilities.

I plan to return to make other games in Python and I look forward to publishing here.

The full code for this project is on github for others to copy and change: https://gist.github.com/JBeresford94/285ec3dc58f694dca51a482cffc6a5fa

Compound Interest Calculator in Python

Jack Beresford — Mon, 02 Jun 2025 17:49:00 +0000

If you’ve ever compared the effect of slightly different interest rates over the long term, you’ll agree with Albert Einstein that “Compound interest is the eighth wonder of the world.”
Until recently, I had experimented with compound interest using websites and excel. But after using Python, I realised it would be superior to use for the following reasons:

Python is better for delivery of an output from an input, via a terminal like the one you get in Visual Studio. This way, you put a few numbers in, and a user-friendly result comes out. This makes it easily repeatable.
With well written code and comments, it is easy to understand and interrogate the calculation.
With an alternative like Excel, you may have to dig into the cell or read an adjacent line of text. With an app or a website, you run on trust since you are unable to interrogate the inner workings.

This blog details the considerations and building process. The final code is available on GitHub and at the end of this blog.

What does the code need to do?

Run a simple algebraic function using inputted variables
Successfully apply interest rate. E.g. 5% turns £1 into £1.05, not £5 or £0.05
Provide an easy User Interface (UI) that anyone can use

Function

In pseudocode:
Final sum = initial value x (interest rate x number of years)

In Python:

# This function calculates an output based on initial value /
# Interest rate and number of years. These are all to be inputted by the user.
def compound_interest(initial_value, interest_rate, years):
    output = initial_value*(1 + interest_rate)**years
    return output

Inputs

Now I need to define the variables: initial_value, interest_rate, years as all user-inputs, so that when we run the code, that is what the user is asked for.

initial_value = float(input("Enter the initial value without currency or commas e.g. 1000 or 1000.99:"))
interest_rate = float(input("Enter the interest rate, as a decimal, e.g. 5% = 0.05:"))
years = int(input("Enter the number of years:"))
#Initial value is best used as a float, so you can use decimal values like £120.52
#Interest rate is also best used as a float, for functional reasons

The input() functions ensure the user will be prompted to enter a value, and the strings in quotation marks tell the user how to do so.

Testing

Before improving the UI, I decided to test that this code actually works.

Running this code in the terminal we get the first input prompt:
“Enter the initial value:”
We type a figure. In this test we’ll use a float, because why go easy on it with an integer?
We type “15420.99” and hit enter.
Then we get the second input prompt:
“Enter the interest rate, as a decimal, e.g. 5% = 0.05:”
We type a figure. In this case we’ll use 8.5% or 0.085. Again, why be nice and use the example?
Then we get the third input prompt:
“Enter the number of years:”
We type 5, press enter, and the final value is given as:
23187.87478266996

Here’s how it looks in the terminal on completion:
Enter the initial value:15420.99
Enter the interest rate, as a decimal, e.g. 5% = 0.05:0.085
Enter the number of years:5
23187.87478266996

Did it work?
Let’s compare it to a compound interest calculator I found online: https://www.thecalculatorsite.com/finance/calculators/compoundinterestcalculator.php
Answer: £23,187.87

It works! 🙂

Ideas and improvements:

The function would still work if years had the float data type rather than integer. This way you could enter 6.5 for 6 and a half years, etc. I confirmed with a test that it works, but returned the code to its simplest integer form.
You don’t usually denote money with 11 decimal places… Using the round function I created the new output, adding an extra line to the function as so:

def compound_interest(initial_value, interest_rate, years):
    output = initial_value*(1 + interest_rate)**years
    rounded_output = round(output, 2)
    return rounded_output

Result: 23187.87
We can add some words and currency to make it look nice, by modifying the print() function to precede the output with words and a currency symbol

print("Initial + interest = £",compound_interest(initial_value, interest_rate, years))

Result: Initial + interest = £ 23187.87

Code (final):

# This function calculates an output based on initial value, interest rate, and number of years.
def compound_interest(initial_value, interest_rate, years):
    output = initial_value*(1 + interest_rate)**years
    rounded_output = round(output, 2)
    return rounded_output
initial_value = float(input("Enter the initial value:"))
interest_rate = float(
    input("Enter the interest rate, as a decimal, e.g. 5% = 0.05:"))
years = float(input("Enter the number of years:"))
#Initial value is best used as a float, so you can use decimal values like £120.52
#Interest rate is also best used as a float, for the function to work
print("Initial + interest = £",compound_interest(initial_value, interest_rate, years))

Terminal output (example):
Enter the initial value:15420.99
Enter the interest rate, as a decimal, e.g. 5% = 0.05:0.085
Enter the number of years:5
Initial + interest = £ 23187.87

Reflections:

I believe there is room to improve the UI. When I improve my skills I may return to this exercise and improve it; after all this is just project number 1!
Compound interest is usually done at annual intervals, as in this case, but it could easily be done with months, weeks, or days
AI tools like ChatGPT / Copilot were not used to make anything in this exercise. They would have saved time but would’ve deprived me of the learning experience and satisfaction. I did run the final code through ChatGPT at the end to see if I missed anything, and it was as agreeable as always. Crucially, if there’s any error here, it’s 100% human.