diff --git a/challenges/euler/src/1 - Multiples of 3 or 5.ts b/challenges/euler/src/1 - Multiples of 3 or 5.ts
index face2b0..71850c3 100644
--- a/challenges/euler/src/1 - Multiples of 3 or 5.ts	
+++ b/challenges/euler/src/1 - Multiples of 3 or 5.ts	
@@ -1,7 +1,10 @@
+// If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.
+// Find the sum of all the multiples of 3 or 5 below 1000.
 export {};
 
-const calcSum = (numbers: number[]) => numbers.reduce((a, b) => a + b);
-
+/**
+ * Figure out the multiples of two numbers below a bound
+ */
 const multiplesOf = (numbers: number[], upperBound: number) => {
     const results: Set<number> = new Set();
 
@@ -12,4 +15,8 @@ const multiplesOf = (numbers: number[], upperBound: number) => {
     return Array.from(results);
 };
 
-console.log(calcSum(multiplesOf([3, 5], 1000)));
+// Output
+const multiples = multiplesOf([3, 5], 1000);
+const sum = multiples.reduce((a, b) => a + b);
+
+console.log(sum);
diff --git a/challenges/euler/src/10 - Sumation of primes.ts b/challenges/euler/src/10 - Sumation of primes.ts
index 46390bf..b6da33e 100644
--- a/challenges/euler/src/10 - Sumation of primes.ts	
+++ b/challenges/euler/src/10 - Sumation of primes.ts	
@@ -1,36 +1,39 @@
-// See https://github.com/newtykins/the-honk/tree/main/euler/thoughts/10%20-Summation%20of%29primes.md
+// The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.
+// Find the sum of all the primes below two million.
 export {};
 
-const calcSum = (numbers: number[]) => numbers.reduce((a, b) => a + b);
-
-// Sieve of Eratosthenes time!!!
-const sumOfPrimes = (upperBound: number) => {
+/**
+ * Use the Sieve of Eratosthenes to find the sum of primes up until a limit.
+ * @see https://github.com/newtykins/the-honk/tree/main/projects/euler/thoughts/10%20-Summation%20of%29primes.md
+ */
+const sumOfPrimes = (limit: number) => {
     let array: boolean[] = [];
-    let upperLimit = Math.sqrt(upperBound);
+    let upperLimit = Math.sqrt(limit);
     let output: number[] = [];
 
     // Make an array from 2 to (n - 1) of truthy values
-    for (var i = 0; i < upperBound; i++) {
+    for (var i = 0; i < limit; i++) {
         array.push(true);
     }
 
     // Remove multiples of primes starting from 2, 3, 5,...
     for (var i = 2; i <= upperLimit; i++) {
         if (array[i]) {
-            for (var j = i * i; j < upperBound; j += i) {
+            for (var j = i * i; j < limit; j += i) {
                 array[j] = false;
             }
         }
     }
 
     // All array[i] set to true are primes
-    for (var i = 2; i < upperBound; i++) {
+    for (var i = 2; i < limit; i++) {
         if (array[i]) {
             output.push(i);
         }
     }
 
-    return calcSum(output);
+    return output.reduce((a, b) => a + b);
 };
 
+// Output
 console.log(sumOfPrimes(2000000));
diff --git a/challenges/euler/src/11 - Largest product in a grid.ts b/challenges/euler/src/11 - Largest product in a grid.ts
index aafe102..8d935cd 100644
--- a/challenges/euler/src/11 - Largest product in a grid.ts	
+++ b/challenges/euler/src/11 - Largest product in a grid.ts	
@@ -50,30 +50,29 @@ const largestProductInGrid = (grid: number[][], adjacentDigits: number) => {
     return answer;
 };
 
-console.log(
-    largestProductInGrid(
-        [
-            [8, 2, 22, 97, 38, 15, 0, 40, 0, 75, 4, 5, 7, 78, 52, 12, 50, 77, 91, 8],
-            [49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 4, 56, 62, 0],
-            [81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 3, 49, 13, 36, 65],
-            [52, 70, 95, 23, 4, 60, 11, 42, 69, 24, 68, 56, 1, 32, 56, 71, 37, 2, 36, 91],
-            [22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80],
-            [24, 47, 32, 60, 99, 3, 45, 2, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50],
-            [32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70],
-            [67, 26, 20, 68, 2, 62, 12, 20, 95, 63, 94, 39, 63, 8, 40, 91, 66, 49, 94, 21],
-            [24, 55, 58, 5, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72],
-            [21, 36, 23, 9, 75, 0, 76, 44, 20, 45, 35, 14, 0, 61, 33, 97, 34, 31, 33, 95],
-            [78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 3, 80, 4, 62, 16, 14, 9, 53, 56, 92],
-            [16, 39, 5, 42, 96, 35, 31, 47, 55, 58, 88, 24, 0, 17, 54, 24, 36, 29, 85, 57],
-            [86, 56, 0, 48, 35, 71, 89, 7, 5, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58],
-            [19, 80, 81, 68, 5, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 4, 89, 55, 40],
-            [4, 52, 8, 83, 97, 35, 99, 16, 7, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66],
-            [88, 36, 68, 87, 57, 62, 20, 72, 3, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69],
-            [4, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 8, 46, 29, 32, 40, 62, 76, 36],
-            [20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 4, 36, 16],
-            [20, 73, 35, 29, 78, 31, 90, 1, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 5, 54],
-            [1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 1, 89, 19, 67, 48]
-        ],
-        4
-    )
-);
+// Output
+const grid = [
+    [8, 2, 22, 97, 38, 15, 0, 40, 0, 75, 4, 5, 7, 78, 52, 12, 50, 77, 91, 8],
+    [49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 4, 56, 62, 0],
+    [81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 3, 49, 13, 36, 65],
+    [52, 70, 95, 23, 4, 60, 11, 42, 69, 24, 68, 56, 1, 32, 56, 71, 37, 2, 36, 91],
+    [22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80],
+    [24, 47, 32, 60, 99, 3, 45, 2, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50],
+    [32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70],
+    [67, 26, 20, 68, 2, 62, 12, 20, 95, 63, 94, 39, 63, 8, 40, 91, 66, 49, 94, 21],
+    [24, 55, 58, 5, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72],
+    [21, 36, 23, 9, 75, 0, 76, 44, 20, 45, 35, 14, 0, 61, 33, 97, 34, 31, 33, 95],
+    [78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 3, 80, 4, 62, 16, 14, 9, 53, 56, 92],
+    [16, 39, 5, 42, 96, 35, 31, 47, 55, 58, 88, 24, 0, 17, 54, 24, 36, 29, 85, 57],
+    [86, 56, 0, 48, 35, 71, 89, 7, 5, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58],
+    [19, 80, 81, 68, 5, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 4, 89, 55, 40],
+    [4, 52, 8, 83, 97, 35, 99, 16, 7, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66],
+    [88, 36, 68, 87, 57, 62, 20, 72, 3, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69],
+    [4, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 8, 46, 29, 32, 40, 62, 76, 36],
+    [20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 4, 36, 16],
+    [20, 73, 35, 29, 78, 31, 90, 1, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 5, 54],
+    [1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 1, 89, 19, 67, 48]
+];
+const output = largestProductInGrid(grid, 4);
+
+console.log(output);
diff --git a/challenges/euler/src/12 - Highly divisible triangular number.ts b/challenges/euler/src/12 - Highly divisible triangular number.ts
index 91f6f1f..2b76e58 100644
--- a/challenges/euler/src/12 - Highly divisible triangular number.ts	
+++ b/challenges/euler/src/12 - Highly divisible triangular number.ts	
@@ -1,31 +1,51 @@
+// The sequence of triangle numbers is generated by adding the natural numbers. So the 7th triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. The first ten terms would be: 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...
+// Let us list the factors of the first seven triangle numbers:
+// 1: 1
+// 3: 1,3
+// 6: 1,2,3,6
+// 10: 1,2,5,10
+// 15: 1,3,5,15
+// 21: 1,3,7,21
+// 28: 1,2,4,7,14,28
+// We can see that 28 is the first triangle number to have over five divisors.
+// What is the value of the first triangle number to have over five hundred divisors?
 export {};
 
-const factorsOf = (num: number) => {
-    const isEven = num % 2 === 0;
-    const max = Math.sqrt(num);
+/**
+ * Find the factors of a n
+ */
+const factorsOf = (n: number) => {
+    const isEven = n % 2 === 0;
+    const max = Math.sqrt(n);
     const inc = isEven ? 1 : 2;
-    const factors = [1, num];
+    const factors = [1, n];
 
     for (let curFactor = isEven ? 2 : 3; curFactor <= max; curFactor += inc) {
-        if (num % curFactor !== 0) continue;
+        if (n % curFactor !== 0) continue;
         factors.push(curFactor);
 
-        let compliment = num / curFactor;
+        let compliment = n / curFactor;
         if (compliment !== curFactor) factors.push(compliment);
     }
 
     return factors;
 };
 
-// https://www.mathsisfun.com/algebra/triangular-numbers.html
-const nthTriangleNumber = (n: number) => (n * (n + 1)) / 2;
+/**
+ * Find the nth triangle number
+ * @see https://www.mathsisfun.com/algebra/triangular-numbers.html
+ */
+const triangleNumber = (n: number) => (n * (n + 1)) / 2;
 
+/**
+ * Find the first triangle number with over n divisors
+ */
 const firstTriangleWithOverNDivisors = (n: number) => {
     let divisorCountFound = false;
     let i = 1;
 
     while (!divisorCountFound) {
-        const triangle = nthTriangleNumber(i);
+        const triangle = triangleNumber(i);
         const factors = [...factorsOf(triangle)];
         i++;
 
@@ -36,4 +56,5 @@ const firstTriangleWithOverNDivisors = (n: number) => {
     }
 };
 
+// Output
 console.log(firstTriangleWithOverNDivisors(500));
diff --git a/challenges/euler/src/13 - Large sum.ts b/challenges/euler/src/13 - Large sum.ts
index a540231..c59d8de 100644
--- a/challenges/euler/src/13 - Large sum.ts	
+++ b/challenges/euler/src/13 - Large sum.ts	
@@ -1,113 +1,116 @@
+// Work out the first ten digits of the sum of the following one-hundred 50-digit numbers. (see numbers array for the numbers given)
 export {};
 
-const calcSum = (numbers: number[]) => numbers.reduce((a, b) => a + b);
-const firstXDigits = (number: number, x: number) =>
-    parseInt(BigInt(number).toString().substr(0, x));
+/**
+ * Get the first n digits of a number
+ */
+const firstDigits = (number: number, n: number) =>
+    parseInt(BigInt(number).toString().substring(0, n));
 
-console.log(
-    firstXDigits(
-        calcSum([
-            37107287533902102798797998220837590246510135740250,
-            46376937677490009712648124896970078050417018260538,
-            74324986199524741059474233309513058123726617309629,
-            91942213363574161572522430563301811072406154908250,
-            23067588207539346171171980310421047513778063246676,
-            89261670696623633820136378418383684178734361726757,
-            28112879812849979408065481931592621691275889832738,
-            44274228917432520321923589422876796487670272189318,
-            47451445736001306439091167216856844588711603153276,
-            70386486105843025439939619828917593665686757934951,
-            62176457141856560629502157223196586755079324193331,
-            64906352462741904929101432445813822663347944758178,
-            92575867718337217661963751590579239728245598838407,
-            58203565325359399008402633568948830189458628227828,
-            80181199384826282014278194139940567587151170094390,
-            35398664372827112653829987240784473053190104293586,
-            86515506006295864861532075273371959191420517255829,
-            71693888707715466499115593487603532921714970056938,
-            54370070576826684624621495650076471787294438377604,
-            53282654108756828443191190634694037855217779295145,
-            36123272525000296071075082563815656710885258350721,
-            45876576172410976447339110607218265236877223636045,
-            17423706905851860660448207621209813287860733969412,
-            81142660418086830619328460811191061556940512689692,
-            51934325451728388641918047049293215058642563049483,
-            62467221648435076201727918039944693004732956340691,
-            15732444386908125794514089057706229429197107928209,
-            55037687525678773091862540744969844508330393682126,
-            18336384825330154686196124348767681297534375946515,
-            80386287592878490201521685554828717201219257766954,
-            78182833757993103614740356856449095527097864797581,
-            16726320100436897842553539920931837441497806860984,
-            48403098129077791799088218795327364475675590848030,
-            87086987551392711854517078544161852424320693150332,
-            59959406895756536782107074926966537676326235447210,
-            69793950679652694742597709739166693763042633987085,
-            41052684708299085211399427365734116182760315001271,
-            65378607361501080857009149939512557028198746004375,
-            35829035317434717326932123578154982629742552737307,
-            94953759765105305946966067683156574377167401875275,
-            88902802571733229619176668713819931811048770190271,
-            25267680276078003013678680992525463401061632866526,
-            36270218540497705585629946580636237993140746255962,
-            24074486908231174977792365466257246923322810917141,
-            91430288197103288597806669760892938638285025333403,
-            34413065578016127815921815005561868836468420090470,
-            23053081172816430487623791969842487255036638784583,
-            11487696932154902810424020138335124462181441773470,
-            63783299490636259666498587618221225225512486764533,
-            67720186971698544312419572409913959008952310058822,
-            95548255300263520781532296796249481641953868218774,
-            76085327132285723110424803456124867697064507995236,
-            37774242535411291684276865538926205024910326572967,
-            23701913275725675285653248258265463092207058596522,
-            29798860272258331913126375147341994889534765745501,
-            18495701454879288984856827726077713721403798879715,
-            38298203783031473527721580348144513491373226651381,
-            34829543829199918180278916522431027392251122869539,
-            40957953066405232632538044100059654939159879593635,
-            29746152185502371307642255121183693803580388584903,
-            41698116222072977186158236678424689157993532961922,
-            62467957194401269043877107275048102390895523597457,
-            23189706772547915061505504953922979530901129967519,
-            86188088225875314529584099251203829009407770775672,
-            11306739708304724483816533873502340845647058077308,
-            82959174767140363198008187129011875491310547126581,
-            97623331044818386269515456334926366572897563400500,
-            42846280183517070527831839425882145521227251250327,
-            55121603546981200581762165212827652751691296897789,
-            32238195734329339946437501907836945765883352399886,
-            75506164965184775180738168837861091527357929701337,
-            62177842752192623401942399639168044983993173312731,
-            32924185707147349566916674687634660915035914677504,
-            99518671430235219628894890102423325116913619626622,
-            73267460800591547471830798392868535206946944540724,
-            76841822524674417161514036427982273348055556214818,
-            97142617910342598647204516893989422179826088076852,
-            87783646182799346313767754307809363333018982642090,
-            10848802521674670883215120185883543223812876952786,
-            71329612474782464538636993009049310363619763878039,
-            62184073572399794223406235393808339651327408011116,
-            66627891981488087797941876876144230030984490851411,
-            60661826293682836764744779239180335110989069790714,
-            85786944089552990653640447425576083659976645795096,
-            66024396409905389607120198219976047599490197230297,
-            64913982680032973156037120041377903785566085089252,
-            16730939319872750275468906903707539413042652315011,
-            94809377245048795150954100921645863754710598436791,
-            78639167021187492431995700641917969777599028300699,
-            15368713711936614952811305876380278410754449733078,
-            40789923115535562561142322423255033685442488917353,
-            44889911501440648020369068063960672322193204149535,
-            41503128880339536053299340368006977710650566631954,
-            81234880673210146739058568557934581403627822703280,
-            82616570773948327592232845941706525094512325230608,
-            22918802058777319719839450180888072429661980811197,
-            77158542502016545090413245809786882778948721859617,
-            72107838435069186155435662884062257473692284509516,
-            20849603980134001723930671666823555245252804609722,
-            53503534226472524250874054075591789781264330331690
-        ]),
-        10
-    )
-);
+// Output
+const numbers = [
+    37107287533902102798797998220837590246510135740250,
+    46376937677490009712648124896970078050417018260538,
+    74324986199524741059474233309513058123726617309629,
+    91942213363574161572522430563301811072406154908250,
+    23067588207539346171171980310421047513778063246676,
+    89261670696623633820136378418383684178734361726757,
+    28112879812849979408065481931592621691275889832738,
+    44274228917432520321923589422876796487670272189318,
+    47451445736001306439091167216856844588711603153276,
+    70386486105843025439939619828917593665686757934951,
+    62176457141856560629502157223196586755079324193331,
+    64906352462741904929101432445813822663347944758178,
+    92575867718337217661963751590579239728245598838407,
+    58203565325359399008402633568948830189458628227828,
+    80181199384826282014278194139940567587151170094390,
+    35398664372827112653829987240784473053190104293586,
+    86515506006295864861532075273371959191420517255829,
+    71693888707715466499115593487603532921714970056938,
+    54370070576826684624621495650076471787294438377604,
+    53282654108756828443191190634694037855217779295145,
+    36123272525000296071075082563815656710885258350721,
+    45876576172410976447339110607218265236877223636045,
+    17423706905851860660448207621209813287860733969412,
+    81142660418086830619328460811191061556940512689692,
+    51934325451728388641918047049293215058642563049483,
+    62467221648435076201727918039944693004732956340691,
+    15732444386908125794514089057706229429197107928209,
+    55037687525678773091862540744969844508330393682126,
+    18336384825330154686196124348767681297534375946515,
+    80386287592878490201521685554828717201219257766954,
+    78182833757993103614740356856449095527097864797581,
+    16726320100436897842553539920931837441497806860984,
+    48403098129077791799088218795327364475675590848030,
+    87086987551392711854517078544161852424320693150332,
+    59959406895756536782107074926966537676326235447210,
+    69793950679652694742597709739166693763042633987085,
+    41052684708299085211399427365734116182760315001271,
+    65378607361501080857009149939512557028198746004375,
+    35829035317434717326932123578154982629742552737307,
+    94953759765105305946966067683156574377167401875275,
+    88902802571733229619176668713819931811048770190271,
+    25267680276078003013678680992525463401061632866526,
+    36270218540497705585629946580636237993140746255962,
+    24074486908231174977792365466257246923322810917141,
+    91430288197103288597806669760892938638285025333403,
+    34413065578016127815921815005561868836468420090470,
+    23053081172816430487623791969842487255036638784583,
+    11487696932154902810424020138335124462181441773470,
+    63783299490636259666498587618221225225512486764533,
+    67720186971698544312419572409913959008952310058822,
+    95548255300263520781532296796249481641953868218774,
+    76085327132285723110424803456124867697064507995236,
+    37774242535411291684276865538926205024910326572967,
+    23701913275725675285653248258265463092207058596522,
+    29798860272258331913126375147341994889534765745501,
+    18495701454879288984856827726077713721403798879715,
+    38298203783031473527721580348144513491373226651381,
+    34829543829199918180278916522431027392251122869539,
+    40957953066405232632538044100059654939159879593635,
+    29746152185502371307642255121183693803580388584903,
+    41698116222072977186158236678424689157993532961922,
+    62467957194401269043877107275048102390895523597457,
+    23189706772547915061505504953922979530901129967519,
+    86188088225875314529584099251203829009407770775672,
+    11306739708304724483816533873502340845647058077308,
+    82959174767140363198008187129011875491310547126581,
+    97623331044818386269515456334926366572897563400500,
+    42846280183517070527831839425882145521227251250327,
+    55121603546981200581762165212827652751691296897789,
+    32238195734329339946437501907836945765883352399886,
+    75506164965184775180738168837861091527357929701337,
+    62177842752192623401942399639168044983993173312731,
+    32924185707147349566916674687634660915035914677504,
+    99518671430235219628894890102423325116913619626622,
+    73267460800591547471830798392868535206946944540724,
+    76841822524674417161514036427982273348055556214818,
+    97142617910342598647204516893989422179826088076852,
+    87783646182799346313767754307809363333018982642090,
+    10848802521674670883215120185883543223812876952786,
+    71329612474782464538636993009049310363619763878039,
+    62184073572399794223406235393808339651327408011116,
+    66627891981488087797941876876144230030984490851411,
+    60661826293682836764744779239180335110989069790714,
+    85786944089552990653640447425576083659976645795096,
+    66024396409905389607120198219976047599490197230297,
+    64913982680032973156037120041377903785566085089252,
+    16730939319872750275468906903707539413042652315011,
+    94809377245048795150954100921645863754710598436791,
+    78639167021187492431995700641917969777599028300699,
+    15368713711936614952811305876380278410754449733078,
+    40789923115535562561142322423255033685442488917353,
+    44889911501440648020369068063960672322193204149535,
+    41503128880339536053299340368006977710650566631954,
+    81234880673210146739058568557934581403627822703280,
+    82616570773948327592232845941706525094512325230608,
+    22918802058777319719839450180888072429661980811197,
+    77158542502016545090413245809786882778948721859617,
+    72107838435069186155435662884062257473692284509516,
+    20849603980134001723930671666823555245252804609722,
+    53503534226472524250874054075591789781264330331690
+];
+const sum = numbers.reduce((a, b) => a + b);
+const output = firstDigits(sum, 10);
+
+console.log(output);
diff --git a/challenges/euler/src/14 - Longest Collatz sequence.ts b/challenges/euler/src/14 - Longest Collatz sequence.ts
index 77451ee..e6f2ec1 100644
--- a/challenges/euler/src/14 - Longest Collatz sequence.ts	
+++ b/challenges/euler/src/14 - Longest Collatz sequence.ts	
@@ -1,18 +1,22 @@
-// n -> n/2 (if n is even)
-// n -> 3n + 1 (if n is odd)
-// Start at a number, iterate until 1
-// Which starting number under one million has the longest chain?
+// The following iterative sequence is defined for the set of positive integers:
+// n → n/2 (n is even)
+// n → 3n + 1 (n is odd)
 
+// Using the rule above and starting with 13, we generate the following sequence:
+// 13 → 40 → 20 → 10 → 5 → 16 → 8 → 4 → 2 → 1
+
+// It can be seen that this sequence (starting at 13 and finishing at 1) contains 10 terms. Although it has not been proved yet (Collatz Problem), it is thought that all starting numbers finish at 1.
+
+// Which starting number, under one million, produces the longest chain?
+// NOTE: Once the chain starts the terms are allowed to go above one million.
 export {};
 
-const isEven = (n: number) => n % 2 === 0;
-
-const collatzSequence = (startNumber: number) => {
+const calculateSequence = (startNumber: number) => {
     let currentNumber = startNumber;
     let sequence = [startNumber];
 
     while (currentNumber > 1) {
-        if (isEven(currentNumber)) currentNumber = currentNumber / 2;
+        if (currentNumber % 2 === 0) currentNumber = currentNumber / 2;
         else currentNumber = currentNumber * 3 + 1;
 
         sequence.push(currentNumber);
@@ -21,12 +25,12 @@ const collatzSequence = (startNumber: number) => {
     return sequence;
 };
 
-const longestCollatzUnderLimit = (limit: number) => {
+const longestSequenceUnderLimit = (limit: number) => {
     let longestStartingNumber = -1;
     let longestStartingNumberLength = -1;
 
     for (let i = 1; i < limit; i++) {
-        const sequence = collatzSequence(i);
+        const sequence = calculateSequence(i);
 
         if (sequence.length > longestStartingNumberLength) {
             longestStartingNumber = i;
@@ -37,4 +41,5 @@ const longestCollatzUnderLimit = (limit: number) => {
     return longestStartingNumberLength;
 };
 
-console.log(longestCollatzUnderLimit(1000000));
+// Output
+console.log(longestSequenceUnderLimit(1000000));
diff --git a/challenges/euler/src/15 - Lattice paths.ts b/challenges/euler/src/15 - Lattice paths.ts
index 3a4ebf6..876f9f8 100644
--- a/challenges/euler/src/15 - Lattice paths.ts	
+++ b/challenges/euler/src/15 - Lattice paths.ts	
@@ -1,12 +1,20 @@
-// See https://github.com/newtykins/the-honk/tree/main/euler/thoughts/15%20-Lattice%20paths.md
+// Starting in the top left corner of a 2×2 grid, and only being able to move to the right and down, there are exactly 6 routes to the bottom right corner.
+// How many such routes are there through a 20×20 grid?
 export {};
 
+/**
+ * Calculate n!
+ */
 const factorial = (n: number) => {
     if (n < 0) return -1;
     else if (n === 0) return 1;
     else return n * factorial(n - 1);
 };
 
+/**
+ * Count the lattice paths using the formula shown in the thoughts document.
+ * @see https://github.com/newtykins/the-honk/tree/main/projects/euler/thoughts/15%20-Lattice%20paths.md
+ */
 const countLatticePaths = (width: number, height: number) => {
     return factorial(width + height) / (factorial(width) * factorial(height));
 };
diff --git a/challenges/euler/src/16 - Power digit sum.ts b/challenges/euler/src/16 - Power digit sum.ts
index 382745a..044d26e 100644
--- a/challenges/euler/src/16 - Power digit sum.ts	
+++ b/challenges/euler/src/16 - Power digit sum.ts	
@@ -1,3 +1,5 @@
+// 2^15 = 32768 and the sum of its digits is 3 + 2 + 7 + 6 + 8 = 26.
+// What is the sum of the digits of the number 2^1000?
 export {};
 
 const powerDigitSum = (base: number, power: number) => {
diff --git a/challenges/euler/src/17 - Number letter counts.ts b/challenges/euler/src/17 - Number letter counts.ts
index 7485702..28a48e9 100644
--- a/challenges/euler/src/17 - Number letter counts.ts	
+++ b/challenges/euler/src/17 - Number letter counts.ts	
@@ -1,3 +1,7 @@
+// If the numbers 1 to 5 are written out in words: one, two, three, four, five, then there are 3 + 3 + 5 + 4 + 4 = 19 letters used in total.
+// If all the numbers from 1 to 1000 (one thousand) inclusive were written out in words, how many letters would be used?
+
+// NOTE: Do not count spaces or hyphens. For example, 342 (three hundred and forty-two) contains 23 letters and 115 (one hundred and fifteen) contains 20 letters. The use of "and" when writing out numbers is in compliance with British usage.
 export {};
 
 const translations = {
@@ -30,7 +34,9 @@ const translations = {
     90: 'ninety'
 };
 
-// works for what we need, could be improved
+/**
+ * Converts numbers to words, could be improved.
+ */
 const numberToWords = (n: number): string => {
     let out = '';
 
@@ -72,6 +78,7 @@ const numberToWords = (n: number): string => {
     return out;
 };
 
+// Output
 let sum = 0;
 
 for (let i = 1; i <= 1000; i++) {
diff --git a/challenges/euler/src/18 - Maximum path sum I.ts b/challenges/euler/src/18 - Maximum path sum I.ts
index 8501fb1..aa515ca 100644
--- a/challenges/euler/src/18 - Maximum path sum I.ts	
+++ b/challenges/euler/src/18 - Maximum path sum I.ts	
@@ -1,3 +1,10 @@
+// By starting at the top of the triangle below and moving to adjacent numbers on the row below, the maximum total from top to bottom is 23.
+//    3
+//   7 4
+//  2 4 6
+// 8 5 9 3
+// That is, 3 + 7 + 4 + 9 = 23.
+// Find the maximum total from top to bottom of the triangle below (see triangle variable)
 export {};
 
 const maximumPathSum = (triangle: number[][]) => {
@@ -13,22 +20,24 @@ const maximumPathSum = (triangle: number[][]) => {
     return triangle[0][0];
 };
 
-console.log(
-    maximumPathSum([
-        [75],
-        [95, 64],
-        [17, 47, 82],
-        [18, 35, 87, 10],
-        [20, 4, 82, 47, 65],
-        [19, 1, 23, 75, 3, 34],
-        [88, 2, 77, 73, 7, 63, 67],
-        [99, 65, 4, 28, 6, 16, 70, 92],
-        [41, 41, 26, 56, 83, 40, 80, 70, 33],
-        [41, 48, 72, 33, 47, 32, 37, 16, 94, 29],
-        [53, 71, 44, 65, 25, 43, 91, 52, 97, 51, 14],
-        [70, 11, 33, 28, 77, 73, 17, 78, 39, 68, 17, 57],
-        [91, 71, 52, 38, 17, 14, 91, 43, 58, 50, 27, 29, 48],
-        [63, 66, 4, 68, 89, 53, 67, 30, 73, 16, 69, 87, 40, 31],
-        [4, 62, 98, 27, 23, 9, 70, 98, 73, 93, 38, 53, 60, 4, 23]
-    ])
-);
+// Output
+const triangle = [
+    [75],
+    [95, 64],
+    [17, 47, 82],
+    [18, 35, 87, 10],
+    [20, 4, 82, 47, 65],
+    [19, 1, 23, 75, 3, 34],
+    [88, 2, 77, 73, 7, 63, 67],
+    [99, 65, 4, 28, 6, 16, 70, 92],
+    [41, 41, 26, 56, 83, 40, 80, 70, 33],
+    [41, 48, 72, 33, 47, 32, 37, 16, 94, 29],
+    [53, 71, 44, 65, 25, 43, 91, 52, 97, 51, 14],
+    [70, 11, 33, 28, 77, 73, 17, 78, 39, 68, 17, 57],
+    [91, 71, 52, 38, 17, 14, 91, 43, 58, 50, 27, 29, 48],
+    [63, 66, 4, 68, 89, 53, 67, 30, 73, 16, 69, 87, 40, 31],
+    [4, 62, 98, 27, 23, 9, 70, 98, 73, 93, 38, 53, 60, 4, 23]
+];
+const maximumSum = maximumPathSum(triangle);
+
+console.log(maximumSum);
diff --git a/challenges/euler/src/2 - Even Fibonacci numbers.ts b/challenges/euler/src/2 - Even Fibonacci numbers.ts
index 5a72fb4..e74ffbc 100644
--- a/challenges/euler/src/2 - Even Fibonacci numbers.ts	
+++ b/challenges/euler/src/2 - Even Fibonacci numbers.ts	
@@ -1,12 +1,15 @@
+// Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be: 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...
+// By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.
 export {};
 
-const calcSum = (numbers: number[]) => numbers.reduce((a, b) => a + b);
-
-const fibonacciNumbers = (upperBound: number) => {
+/**
+ * Calculate the Fibonacci sequence up until a limit
+ */
+const calculateFibonacci = (limit: number) => {
     const sequence = [1, 2];
 
     // Keep making new numbers in the sequence until we hit the upper bound
-    while (sequence[sequence.length - 1] < upperBound) {
+    while (sequence[sequence.length - 1] < limit) {
         const newValue = sequence[sequence.length - 1] + sequence[sequence.length - 2];
         sequence.push(newValue);
     }
@@ -14,11 +17,9 @@ const fibonacciNumbers = (upperBound: number) => {
     return sequence;
 };
 
-const evenFibonacciNumbers = (upperBound: number) => {
-    const sequence = fibonacciNumbers(upperBound);
-    const even = sequence.filter(n => n % 2 === 0);
+// Output
+const fibonacci = calculateFibonacci(4000000);
+const even = fibonacci.filter(n => n % 2 === 0);
+const evenSum = even.reduce((a, b) => a + b);
 
-    return even;
-};
-
-console.log(calcSum(evenFibonacciNumbers(4000000)));
+console.log(evenSum);
diff --git a/challenges/euler/src/3 - Largest prime factor.ts b/challenges/euler/src/3 - Largest prime factor.ts
index 30f085d..9251169 100644
--- a/challenges/euler/src/3 - Largest prime factor.ts	
+++ b/challenges/euler/src/3 - Largest prime factor.ts	
@@ -1,5 +1,10 @@
+// The prime factors of 13195 are 5, 7, 13 and 29.
+// What is the largest prime factor of the number 600851475143?
 export {};
 
+/**
+ * Work out the largest prime factor of a number
+ */
 const largestPrimeFactor = (number: number) => {
     let i = 2;
 
@@ -11,4 +16,5 @@ const largestPrimeFactor = (number: number) => {
     return number;
 };
 
+// Output
 console.log(largestPrimeFactor(600851475143));
diff --git a/challenges/euler/src/4 - Largest pallindrome product.ts b/challenges/euler/src/4 - Largest pallindrome product.ts
index 3169614..6044c49 100644
--- a/challenges/euler/src/4 - Largest pallindrome product.ts	
+++ b/challenges/euler/src/4 - Largest pallindrome product.ts	
@@ -1,6 +1,11 @@
+// A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 × 99.
+// Find the largest palindrome made from the product of two 3-digit numbers.
 export {};
 
-const largestPallidromeNumber = (lowerBound: number, upperBound: number) => {
+/**
+ * Work out the largest pallindromic number between a lower and upper bound.
+ */
+const largestPallindromicNumber = (lowerBound: number, upperBound: number) => {
     // Work out all of the products of 3 digit numbers
     const products: number[] = [];
 
@@ -20,4 +25,4 @@ const largestPallidromeNumber = (lowerBound: number, upperBound: number) => {
     return sorted[0];
 };
 
-console.log(largestPallidromeNumber(100, 999));
+console.log(largestPallindromicNumber(100, 999));
diff --git a/challenges/euler/src/5 - Smallest multiple.ts b/challenges/euler/src/5 - Smallest multiple.ts
index 6f68799..62b81fa 100644
--- a/challenges/euler/src/5 - Smallest multiple.ts	
+++ b/challenges/euler/src/5 - Smallest multiple.ts	
@@ -1,9 +1,8 @@
+// 2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.
+// What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?
 export {};
 
-/**
- * Is x disible to n?
- */
-const isDivisibleTo = (x: number, n: number) => {
+const canBeDivided = (x: number, n: number) => {
     for (; n > 0; n -= 1) {
         if (x % n !== 0) return false;
     }
@@ -14,8 +13,9 @@ const isDivisibleTo = (x: number, n: number) => {
 const divisibleTo = (n: number) => {
     if (n === 1) return 1;
 
-    for (var step = divisibleTo(n - 1), i = step; !isDivisibleTo(i, n); i += step);
+    for (var step = divisibleTo(n - 1), i = step; !canBeDivided(i, n); i += step);
     return i;
 };
 
+// Output
 console.log(divisibleTo(20));
diff --git a/challenges/euler/src/6 - Sum square difference.ts b/challenges/euler/src/6 - Sum square difference.ts
index ab3da59..996cfc4 100644
--- a/challenges/euler/src/6 - Sum square difference.ts	
+++ b/challenges/euler/src/6 - Sum square difference.ts	
@@ -1,7 +1,12 @@
+// The sum of the squares of the first ten natural numbers is 1^2 + 2^2 + ... + 10^2 = 385
+// The square of the sum of the first ten natural numbers is (1 + 2 + ... + 10)^2 = 55^2 = 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.
 export {};
 
-const calcSum = (numbers: number[]) => numbers.reduce((a, b) => a + b);
-
+/**
+ * Calculate the sum of the squares between a lower and upper bound.
+ */
 const sumOfSquares = (lowerBound: number, upperBound: number) => {
     // Calculate the square number of all the numbers between the bounds
     const squares: number[] = [];
@@ -11,9 +16,12 @@ const sumOfSquares = (lowerBound: number, upperBound: number) => {
     }
 
     // Return the sum
-    return calcSum(squares);
+    return squares.reduce((a, b) => a + b);
 };
 
+/**
+ * Square the sum of the numbers between a lower and upper bound, and return it.
+ */
 const squareOfSum = (lowerBound: number, upperBound: number) => {
     // Get the sum of all of the numbers between the bounds
     const numbers: number[] = [];
@@ -22,10 +30,9 @@ const squareOfSum = (lowerBound: number, upperBound: number) => {
         numbers.push(i);
     }
 
-    const sum = calcSum(numbers);
-
     // Square the sum
-    return sum ** 2;
+    return numbers.reduce((a, b) => a + b) ** 2;
 };
 
+// Output
 console.log(squareOfSum(1, 100) - sumOfSquares(1, 100));
diff --git a/challenges/euler/src/67 - Maximum path sum II.ts b/challenges/euler/src/67 - Maximum path sum II.ts
index 0f35cd1..9df1078 100644
--- a/challenges/euler/src/67 - Maximum path sum II.ts	
+++ b/challenges/euler/src/67 - Maximum path sum II.ts	
@@ -1,9 +1,17 @@
+// By starting at the top of the triangle below and moving to adjacent numbers on the row below, the maximum total from top to bottom is 23.
+//    3
+//   7 4
+//  2 4 6
+// 8 5 9 3
+// That is, 3 + 7 + 4 + 9 = 23.
+// Find the maximum total from top to bottom in p067_triangle.txt, a 15K text file containing a triangle with one-hundred rows.
+
 import fs from 'fs';
 import path from 'path';
 import { resources } from '../constants';
-
 export {};
 
+// Same method as 18 - Maximum path sum I
 const maximumPathSum = (triangle: number[][]) => {
     let row = triangle.length - 1;
 
@@ -17,13 +25,15 @@ const maximumPathSum = (triangle: number[][]) => {
     return triangle[0][0];
 };
 
+// Output
 const data = fs
-    .readFileSync(path.join(resources, 'p067_triangle.txt'))
+    .readFileSync(path.join(resources, 'p067_triangle.txt')) // https://github.com/newtykins/the-honk/tree/main/challenges/euler/resources/p067_triangle.txt
     .toString()
     .split('\n')
     .map(row => {
         const values = row.split(' ');
         return values.map(v => parseInt(v));
     });
+const maximumSum = maximumPathSum(data);
 
-console.log(maximumPathSum(data));
+console.log(maximumSum);
diff --git a/challenges/euler/src/7 - 10001st Prime.ts b/challenges/euler/src/7 - 10001st Prime.ts
index af09fc6..3fabe8c 100644
--- a/challenges/euler/src/7 - 10001st Prime.ts	
+++ b/challenges/euler/src/7 - 10001st Prime.ts	
@@ -1,5 +1,10 @@
+// By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.
+// What is the 10 001st prime number?
 export {};
 
+/**
+ * Is this number prime?
+ */
 const isPrime = (number: number) => {
     for (var i = 2; i < number; i++) {
         if (number % i === 0) return false;
@@ -8,6 +13,9 @@ const isPrime = (number: number) => {
     return true;
 };
 
+/**
+ * Calculate the nth prime number.
+ */
 const nthPrime = (n: number) => {
     const primes: number[] = [];
     let number = 2;
@@ -20,4 +28,5 @@ const nthPrime = (n: number) => {
     return primes[n - 1];
 };
 
+// Output
 console.log(nthPrime(10001));
diff --git a/challenges/euler/src/8 - Largest product in a series.ts b/challenges/euler/src/8 - Largest product in a series.ts
index 35ec683..e1f6448 100644
--- a/challenges/euler/src/8 - Largest product in a series.ts	
+++ b/challenges/euler/src/8 - Largest product in a series.ts	
@@ -1,3 +1,5 @@
+// The four adjacent digits in the 1000-digit number that have the greatest product are 9 × 9 × 8 × 9 = 5832.
+// Find the thirteen adjacent digits in the 1000-digit number that have the greatest product. What is the value of this product?
 export {};
 
 const largestProduct = (number: bigint | number, adjacentDigits: number) => {
@@ -31,6 +33,7 @@ const largestProduct = (number: bigint | number, adjacentDigits: number) => {
     return products.sort((a, b) => b - a)[0];
 };
 
+// Output
 const number = BigInt(
     '7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450'
 );
diff --git a/challenges/euler/src/9 - Special Pythagorean triplet.ts b/challenges/euler/src/9 - Special Pythagorean triplet.ts
index 8425d81..2e4bc93 100644
--- a/challenges/euler/src/9 - Special Pythagorean triplet.ts	
+++ b/challenges/euler/src/9 - Special Pythagorean triplet.ts	
@@ -1,6 +1,13 @@
-// See https://github.com/newtykins/the-honk/tree/main/euler/thoughts/9%20-Special%20Pythagorean%29triplet.md
+// A Pythagorean triplet is a set of three natural numbers, a < b < c, for which a^2 + b^2 = c^2
+// For example, 3^2 + 4^2 = 9 + 16 = 25 = 5^2
+// There exists exactly one Pythagorean triplet for which a + b + c = 1000.
+// Find the product abc.
 export {};
 
+/**
+ * Find a Pythagorean triplet based on its sum
+ * @see // See https://github.com/newtykins/the-honk/tree/main/projects/euler/thoughts/9%20-Special%20Pythagorean%29triplet.md
+ */
 const pythagoreanTriplet = (sum: number) => {
     let a: number,
         b = 1,
@@ -18,6 +25,6 @@ const pythagoreanTriplet = (sum: number) => {
     return { a, b, c };
 };
 
+// Output
 const triplet = pythagoreanTriplet(1000);
-console.log(triplet);
 console.log(triplet.a * triplet.b * triplet.c);