‎ on jonah vairon

cencry - encryption

Thu, 26 Mar 2026 00:00:00 +0000

problem

Marko is going to write a secret letter to a friend. He thought it is better to encrypt letter so that no other person can read it. After long thought he came up with an encryption scheme which was lame but he thought it will work anyways.

To encrypt a text he first wrote two infinite strings of characters first string consists only of vowels and second string consists of consonants only.

employee db

Tue, 24 Mar 2026 00:00:00 +0000

background

The final section of the eighth chapter of the rust book ends with some suggested exercises. The last of which is to write a program that:

Using a hash map and vectors, create a text interface to allow a user to add employee names to a department in a company; for example, “Add Sally to Engineering” or “Add Amir to Sales.” Then, let the user retrieve a list of all people in a department or all people in the company by department, sorted alphabetically.

intest - enormous input test

Tue, 24 Mar 2026 00:00:00 +0000

problem

The purpose of this problem is to verify whether the method you are using to read input data is sufficiently fast to handle problems branded with the enormous Input/Output warning. You are expected to be able to process at least 2.5MB of input data per second at runtime.

Input: The input begins with two positive integers n k (n, k<=107). The next n lines of input contain one positive integer ti, not greater than 109, each.

pig latin

Fri, 20 Mar 2026 00:00:00 +0000

background

The final section of the eighth chapter of the rust book ends with some suggested exercises. The second of which is to write a program that:

Convert strings to Pig Latin. The first consonant of each word is moved to the end of the word and ay is added, so first becomes irst-fay. Words that start with a vowel have hay added to the end instead (apple becomes apple-hay). Keep in mind the details about UTF-8 encoding!

christmas carol

Wed, 18 Mar 2026 00:00:00 +0000

background

The final section of the third chapter of the rust book ends with some suggested exercises. The last of which is to write a program to: “Print the lyrics to the Christmas carol “The Twelve Days of Christmas,” taking advantage of the repetition in the song.”

solution

This was more fun that it looked. Especially trying to identify patterns in the lyrics.

Is this the most optimised version?

Probably not.

fibonacci

Wed, 18 Mar 2026 00:00:00 +0000

background

The final section of the third chapter of the rust book ends with some suggested exercises. The second of which is to write a program to: “Generate the nth Fibonacci number.”

solution

I’m not going to implement the best fibonacci implementation?. Just the bog standard recursive approach with no memoisation. Reusing the input code from the guessing game again:

use std::io;

fn main() {
    loop {
        println!("Which Fibonacci number would you like?");

        let mut n = String::new();

        io::stdin()
            .read_line(&mut n)
            .expect("Failed to read line");

        let n: i32 = match n.trim().parse() {
            Ok(num) => num,
            Err(_) => continue
        };

        let nth_fib = fib(n);

        println!("Fibonacci {n} is: {nth_fib}");
    }
}

fn fib(n: i32) -> i64 {
    if n == 0 {
        return 1;
    } else if n == 1 {
        return 1;
    } else {
        return fib(n-1) + fib(n-2);
    }
}

median and mode

Tue, 17 Mar 2026 00:00:00 +0000

background

The final section of the eighth chapter of the rust book ends with some suggested exercises. The first of which is to write a program that:

Given a list of integers, use a vector and return the median (when sorted, the value in the middle position) and mode (the value that occurs most often; a hash map will be helpful here) of the list.

solution

While straightforward on paper, calculating the median posed a bit of challenge with even lists of numbers. The problem being, when there’s no clear “middle” value the tendency is to take the mean of the 2 middle values. But, Rust being strongly typed, this meant potentially returning a float (i.e. f32) in a function that would otherwise return an integer (i.e. i32).

fahrenheit to celsius

Sun, 15 Mar 2026 00:00:00 +0000

background

The final section of the third chapter of the rust book ends with some suggested exercises. The first of which is to write a program to: “Convert temperatures between Fahrenheit and Celsius.”

solution

Reusing code from the guessing game chapter, we can read input, cast it to a 32 bit float through a type hint and perform the conversion:

use std::io;

fn main() {
    loop {
        println!("Degrees in Farenheit:");

        let mut degrees_f = String::new();

        io::stdin()
            .read_line(&mut degrees_f)
            .expect("Failed to read line");

        let degrees_f: f32 = match degrees_f.trim().parse() {
            Ok(num) => num,
            Err(_) => continue
        };

        let degrees_c = (degrees_f - 32.0) * 5.0/9.0;

        println!("is {degrees_c} degrees Celsius.");
    }
}

python workout: exercise 19

Fri, 30 Jan 2026 00:00:00 +0000

problem

Write a function, passwd_to_dict, that reads from a Unix-style “password file”, commonly stored as /etc/passwd, and returns a dict. The function should return a dict based on /etc/passwd in which the dict’s keys are usernames and the values are the users’ IDs (i.e the first and third fields in the comma-separated fields of an /etc/passwd entry).

attempts

This should be straightforward. We can split each line on colons and extract the first and third fields:

python workout: exercise 18

Wed, 28 Jan 2026 00:00:00 +0000

problem

Write a function (get_final_line) that takes a filename as an argument. The function should return that file’s final line on the screen.

attempts

first

My first thought is to just readlines() and index into the last element with -1. But that seems to defeat the implied purpose of the exercise – to explore hte possibility that “I’m only interested in a single line”.

Maybe it’s worth looking at the docs.

python workout: exercise 17

Tue, 27 Jan 2026 00:00:00 +0000

problem

Write a function, called how_many_different_numbers, that takes a single list of integers and returns the number of different integers it contains.

attempts

The first thing that comes to mind is to just use a set and get its length/size:

def how_many_different_numbers(numbers: list[int]) -> int:
    return len(set(numbers))

numbers = [1, 2, 3, 1, 2, 3, 4, 1]

print(how_many_different_numbers(numbers))

solution

The book’s implementation:

def how_many_different_numbers(numbers):
    unique_numbers = set(numbers)
    return len(unique_numbers)

Pretty much the same thing.

beyond the exercise

server log ip addresses

problem

about

Fri, 12 Dec 2025 00:00:00 +0000

Hi, I’m Jonah Vairon. I enjoy solving complex problems with software and data.

Over the years, I’ve worked as a backend engineer in a finance startup, an AI engineer in business and technology consultancies, and a research assistant at UCL’s Institute of Education (IoE) working on applications of ML and AI to research/evidence synthesis.

When I’m not working, you can find me on a walk, weightlifting, running, practicing yoga and karate, trying to play through my Steam library, or catching up on film and tv.