Forem: gleroux

Using Node.js to steal £10,000: Putting it into code

gleroux — Mon, 05 Dec 2022 19:37:27 +0000

Formulas to functions

To generate a list of daily transfer amounts, we need a few things:

A savings goal and a savings period (to calculate F)
Our totalSaved formula from earlier
- totalSaved = (dayNumber * (dayNumber + 1)) * F
Our transferAmount formula from earlier
- transferAmount(today) = totalSaved(today) -totalSaved(yesterday)

const generateDailyTransferAmounts = (savingsGoal, savingsPeriod) => {

    //multiplication factor
    const factor = savingsGoal / savingsPeriod / (savingsPeriod + 1)

    //totalSaved formula
    const calculateTotalSavedByDay = (dayNum) => {
        return dayNum * (dayNum+1) * factor
    }

    //transferAmount formula
    const calculateTransferAmount = (dayNum) => {
        return calculateTotalSavedByDay(dayNum) - calculateTotalSavedByDay(dayNum-1)     
    }

    ...

}

We also need an array containing the numbers 1 to savingsPeriod to iterate over.

To populate an array with the numbers 1 to savingsPeriod, we first pass the Array constructor savingsPeriod + 1, as we know the array will be zero indexed, and we don't want "Day 0". We can make use of the keys() method, which returns a new array containing the keys for each index of the array, and the spread operator, which allows us to use slice() on the returned array, removing the leading 0 and giving us an array of length savingsPeriod containing the numbers 1 to savingsPeriod.

const days = [...Array(savingsPeriod+1).keys()].slice(1)

We can now use map() on the days array, calling our calculateTransferAmount() function on each day number to calculate the amount to be transferred on each day. We assign the resulting array to transferAmounts.

const transferAmounts = days.map(dayNum => parseFloat(calculateTransferAmount(dayNum).toFixed(2)))

So far our code looks likes this:

const generateDailyTransferAmounts = (savingsGoal, savingsPeriod) => {

    const factor = savingsGoal/savingsPeriod/(savingsPeriod+1)

    const calculateTotalSaved = (dayNum) => {
        return dayNum * factor * (dayNum+1)
    }

    const calculateTransferAmount = (dayNum) => {
        return calculateTotalSaved(dayNum) - calculateTotalSaved(dayNum-1)     
    }

    //Array of numbers from 1 to savingsPeriod
    const days = [...Array(savingsPeriod+1).keys()].slice(1)

    //Array of transfer amounts for each day of the savingsPeriod
    const transferAmounts = days.map(dayNum => parseFloat(calculateTransferAmount(dayNum).toFixed(2)))

    ...

}

Making things 'random' (not quite)

As it stands we have an array, transferAmounts, that is sorted in ascending order — our first transfer will be the smallest, and our last the biggest.

To get the feeling of 'random' amounts leaving our account in the middle of night, we need to shuffle our transferAmounts. Shuffling – or truly shuffling — appears to be a contentious topic 😅

Mar 15 '10 Comments: 1 Answers: 58

2068

I have an array like this:

var arr1 = ["a", "b", "c", "d"];

How can I randomize / shuffle it?

Open Full Question

As we don't really need the ultimate shuffle here – just enough for it to feel random – we can use a nice clean implementation of the Durstenfeld shuffle (credit to Laurens Holst on Stackoverflow).

const shuffleArray = (array) => {
    for (let i = array.length - 1; i > 0; i--) {
        const j = Math.floor(Math.random() * (i + 1));
        [array[i], array[j]] = [array[j], array[i]];
    }
}

Our final code, then, for generating a shuffled list of daily transfer amounts, for our chosen savings goal and savings period is as follows:

const generateDailyTransferAmounts = (goal, period) => {

    const savingsGoal = goal
    const savingsPeriod = period

    const factor = savingsGoal/savingsPeriod/(savingsPeriod+1)

    const calculateTotalSaved = (dayNum) => {
        return dayNum * factor * (dayNum+1)
    }

    const calculateTransferAmount = (dayNum) => {
        return calculateTotalSaved(dayNum) - calculateTotalSaved(dayNum-1)     
    }

    const days = [...Array(savingsPeriod+1).keys()].slice(1)

    const transferAmounts = days.map(dayNum => parseFloat(calculateTransferAmount(dayNum).toFixed(2)))

    const shuffleArray = (array) => {
        for (let i = array.length - 1; i > 0; i--) {
            const j = Math.floor(Math.random() * (i + 1));
            [array[i], array[j]] = [array[j], array[i]];
        }
    }

    return shuffleArray(transferAmounts)    

}

module.exports = generateDailyTransferAmounts

We have included an export statement so this function can be used elsewhere.

Writing our transfer amounts to a file

As we will be using Serverless and AWS Lambda to run our program every day, we need to make our shuffled transfer amounts array accessible in the file system to any Starling API-based function we will write.

This is achieved through a new function, writeDailyTransferAmounts:

// this allows us to interact with the file system
const fs = require("fs");

//we import our function from earlier
const generateDailyAmounts = require('./generateDailyAmounts')


const writeDailyAmounts = (goal, period) => {

    const dailyTransferAmounts = JSON.stringify(generateDailyTransferAmounts(goal,period))

    ...

}

You'll notice that as well as calling generateDailyTransferAmounts with our savings goal and savings period, we are using JSON.stringify on the result. This is because when you try and write an array to a file, it is converted to a string in the process, and you end up with something like this.

var array = [1, 2, 3, 4];
console.log(array.toString());
// 1,2,3,4

And it loses its array functionality in the destination file.

Using JSON.stringify allows us to turn an array into a string in a way that means it stays functionally intact.

We can now use fs.writeFile() to write our array to a new file. As we want a Javascript file that can be accessed by our Starling transfer function, we use template literals to write our file content, substituting in our dailyTransferAmounts array:

const fileContent = 
    `const dailyAmounts = ${dailyTransferAmounts}
    module.exports = dailyAmounts`

Next we write that content to the file system, to a file called dailyAmounts.js:

fs.writeFile('../dailyTransferAmounts.js', content, function(err) {
    if(err) {
          console.log(err);
    } 
    else {
      console.log("Output saved to dailyAmounts.js");
    }
});

The full code for this step is as follows:

const fs = require("fs");

const generateDailyAmounts = require('./generateDailyAmounts')

const writeDailyAmounts = (goal, period) => {

    const dailyTransferAmounts = JSON.stringify(generateDailyTransferAmounts(goal,period))

    const fileContent = 
    `const dailyAmounts = ${dailyTransferAmounts}
    module.exports = dailyAmounts`

    fs.writeFile('./dailyTransferAmounts.js', fileContent, function(err) {
        if(err) {
            console.log(err);
        } 
        else {
            console.log("Output saved to dailyAmounts.js");
        }
    })
}

module.exports = writeDailyAmounts

Again we include an export statement so this function can be used elsewhere.

Using Node.js to steal £10,000: Doing the Math

gleroux — Mon, 05 Dec 2022 19:31:53 +0000

Meet Carl Friedrich Gauss

The traditional Penny Savings Challenge works by incrementing the amount saved by £0.01 each day, leaving you with £667.95 after 365 days. Programming this approach would be relatively easy — transferring 1p x the number of days since starting (or using the day of the year if starting on Jan 1).

But what should you do if you want to reach a set goal after 365 days, such as £2,000? Bear in mind that if you simply saved £5.48 (2000/365) each day, you would lose the characteristic incrementing of the savings challenge.

And what if you want to save your goal over a different time period, like 50 days? Or 500 days?

For this we turn to Carl Friedrich Gauss, who among other things kindly gave to us the formula for calculating the sum of numbers from 1 to n. While at primary school 🤯. I'll digress slightly with the tale here, as it's a good anecdote —

One day Gauss' teacher asked his class to add together all the numbers from 1 to 100, assuming that this task would occupy them for quite a while. He was shocked when young Gauss, after a few seconds thought, wrote down the answer 5050. The teacher couldn't understand how his pupil had calculated the sum so quickly in his head, but the eight year old Gauss pointed out that the problem was actually quite simple:

He had added the numbers in pairs - the first and the last, the second and the second to last and so on, observing that 1+100 = 101, 2+99 = 101, 3+98 = 101, 4+97 = 101 ...so the total would be 50 lots of 101, which is 5050.

Have a look here for more info — and a visualisation of the proof.

Gauss' shortcut gives us the following formula, which we can use as our starting point:

sum = N * (N + 1) / 2

Tweaking the Gauss formula

Returning to the 1p Savings Challenge, if we apply Gauss' formula the total amount of money saved by the end of one year is as we expect:

totalSaved = (365 * 366) * 0.5
totalSaved = 133,590 * 0.5
totalSaved = 66,795p = £667.95

We know our goal is £2,000 and not £667.95, so let's play with this formula. If we remove the division by 2, we get a total of £1,335.90 (equivalent to saving £0.02 on day 1, £0.04 on day 2, £0.06 on day 3, etc.).

totalSaved = (365 * 366) * 1
totalSaved = 133,590 * 1
totalSaved = 133,590p = £1,335.90

Not quite there — but nearly. We need a factor >1 to multiply (365 * 366) by to get us to our £2,000 goal.

200,000 = (365 * 366) * F
200,000 = 133,590 * F

We can calculate this new factor (F) by flipping the above equation.

F = 200,000 / (365 * 366)
F = 200,000 / 133,590
F = 1.4971180478

So, for a given savings goal, we can now say that the multiplication factor (F) to include in the Gauss formula is calculated as follows:

F = savingsGoal / (savingsPeriod * (savingsPeriod + 1))

Where savingsPeriod is the total number of days after which you wish to reach your savingsGoal. Hang onto this formula — we'll need it later.

Double checking our work, when we use our new factor in the Gauss formula, the total saved in a one year period is as we expect:

totalSaved = (365 * 366) * F
totalSaved = (365 * 366) * 1.4971180478
totalSaved = 133,590 * 1.4971180478
totalSaved = 200,000p = £2,000

Calculating daily transfer amounts

Let's take another look at the first line of the above:

totalSaved = (365 * 366) * F

Until now, we have been using the formula to check the total saved after one year (365 days). But this formula can now be used to calculate how much we will have saved by any given day. We simply substitute in the day of interest:

totalSaved = (dayNumber * (dayNumber + 1)) * F

A few examples (where F = 1.4971180478)

By day 10, we will have saved a total of:

total saved = (10 * 11) * 1.4971180478
total saved = 165p = £1.65

By day 200, we will have saved a total of:

totalSaved = (200 * 201) * 1.4971180478
totalSaved = 60,184p = £601.84

By day 365, as we know, we will have saved a total of £2,000:

totalSaved = (dayNumber * (dayNumber + 1)) * 1.4971180478
totalSaved = (365 * 366) * 1.4971180478
totalSaved = 200,000p = £2,000

Great stuff. But how can this information be used to calculate the amount to transfer on a given day?

Well, using the same formula we simply take the total we will have saved after transferring today (day N) and subtract the total we had saved by yesterday (day N-1). This gives us the transfer amount for that day:

We can think of this as follows:

transferAmount(today) = totalSaved(today) - totalSaved(yesterday)

For example (again where F = 1.4971180478):

On day 10, we will transfer:

transferAmount = (10 * 11) * 1.4971180478 - (9 * 10) * 1.4971180478 
transferAmount = 30p = £0.30

On day 200, we will transfer:

transferAmount = (200 * 201) * 1.4971180478 - (199 * 200) * 1.4971180478 
transferAmount = 599p = £5.99

On day 365, we will make our final transfer:

transferAmount = (365 * 366) * 1.4971180478 - (364 * 365) * 1.4971180478 
transferAmount = 1093p = £10.93

Next we'll take what we've discovered here and give it the Javascript treatment.

Using Node.js to steal £10,000: Introduction

gleroux — Mon, 05 Dec 2022 19:30:09 +0000

*from yourself!

Last year I came across what's known as the 1p Savings Challenge. It's simple: on day 1 you save £0.01, then on day 2 £0.02, day 3 £0.03 and so on, for 365 days. The most you'll ever put aside on a single day is £3.65, but after you're finished you'll have saved £667.95. Pretty impressive.

Remembering to transfer tiny sums of money each day for a full year is, however, more effort than most people will bother with. So, automation of this process seemed like a perfect focus for a small programming project.

Rather than implementing the standard, predictable 1p Savings Challenge, I wanted to add some more interest to the end experience. I decided instead to build an app that would siphon unknown amounts of money from my bank account, in the middle of the night.

After one year, £2,000 would have gone 'missing'. After 5 years, I'd 'lose' £10,000.

To create this app I used Node.js — and worked with Serverless, AWS Lambda, and cron jobs for the first time.

First things first, we need to take a look at the math behind the 1p savings challenge...