projecteuler.net #8 & #11 in JavaScript
I recently had a job interview which had me complete several problems from the project euler website. These problems are great practice for anyone, whether you need some practice for a technical interview, or just want to have some fun, and you have a 10 to 15 hour lunch break. All of the questions can be found at projecteuler.net.
Two of my favorites were problems #8 and #11, and I wanted to walk through my solutions for both problems, mainly because my solution for both problems was pretty similar. But I would love to have some feedback, and any alternative solutions you used to get the answer.
Problem #8 goes like this:
The four adjacent digits in the 1000-digit number that have the greatest product are 9 × 9 × 8 × 9 = 5832.
73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450
Find the thirteen adjacent digits in the 1000-digit number that have the greatest product. What is the value of this product?
My thought process on this was to convert the entire Number into an array. To do so, I first converted the entire thing into a string, and then did string split, and then looped through all the individual string and converted each one to a number.
let numStr = "7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450";let strSplt = numStr.split('');
console.log(strSplt);let longArr = [];
for (var i = 0; i < strSplt.length; i++) {
let number = parseInt(strSplt[i]);
longArr.push(number);
}
console.log(longArr);
Next, I set up an array I’m calling a comparison Array. I know I only need to compare 13 digits from the array at once, so I loop through longArr, and push a series of arrays into longArr, consisting of 13 adjacent digits to the current digit.
let comparisonArr = [];
for (var i = 0; i < longArr.length; i++) {
comparisonArr.push([longArr[i-6],longArr[i-5],longArr[i-4],longArr[i-3],longArr[i-2],longArr[i-1],longArr[i],longArr[i+1],longArr[i+2],longArr[i+3],longArr[i+4],longArr[i+5],longArr[i+6],])
}Next, I’m creating a “total” array, where I’ll calculate the product of each array item in the comparisonArr. That way I can compare the totals, and return the largest. So I loop through
let total = [];
for (var i = 0; i < comparisonArr.length; i++) {
let totalA = comparisonArr[i].reduce(function(a,b){return a*b;});
total.push([totalA, comparisonArr[i]])
}Here, my reduce and multiply function is included inside my for loop.
Next I get the largest product of the total array by looping through the total array. I compare each iteration against the a test number which I set to 100. If the current iteration is larger than 100, then I set the thest number to the value of that iteration, and continue with the next iteration. I end up with the product, and the 13 numbers that made that product.
let testNum = 100;
let finalArr = [];
for (var i = 0; i < total.length; i++) {
if(total[i][0] > testNum) {
testNum = total[i][0];
finalArr = total[i];
}
}
console.log(testNum); //final product
console.log(finalArr); //numbers that made that product, productThe Solution: 23514624000
Problem # 11:
It’s easy to see the similarities between #8 and #11. Number 11 is basically the same, but with 1 caveat. You’re only looking for 4 adjacent numbers to get the product of, but the numbers can be adjacent horizontally, vertically or diagonally. Here’s how the problem reads:
In the 20×20 grid below, four numbers along a diagonal line have been marked in red.
08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 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 03 45 02 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 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48
The product of these numbers is 26 × 63 × 78 × 14 = 1788696.
What is the greatest product of four adjacent numbers in the same direction (up, down, left, right, or diagonally) in the 20×20 grid?
I started off this problem in a similar way, eventually converting the grid into an array. although instead of doing the split between each value, I did the split between each space, since they are groups of 2 digit numbers.
Once you have the grid as an array, the next part is pretty simple. I wanted to push an array of adjacent numbers into a new array. Each time I push a number, it would be a series of four digits:
So from here, I simply looped through the array and pushed the current iteration, along with that iteration +1, +2, +3, etc, to get each of the iteration sets I needed.
let compareArr = []
for (var i = 0; i < ridArr.length; i++) {
compareArr.push([ridArr[i], ridArr[i+1], ridArr[i+2], ridArr[i+3]]);
compareArr.push([ridArr[i], ridArr[i-1], ridArr[i-2], ridArr[i-3]]);
compareArr.push([ridArr[i], ridArr[i-1], ridArr[i+1], ridArr[i+2]]);
compareArr.push([ridArr[i], ridArr[i-2], ridArr[i-1], ridArr[i+1]]);This gives me all of the horizontally adjacent digits. And I can do the same thing vertically, but modifying the +1, +2, +3 etc to +20, +40, +60, etc.
compareArr.push([ridArr[i], ridArr[i+20], ridArr[i+40], ridArr[i+60]]);
compareArr.push([ridArr[i], ridArr[i-20], ridArr[i-40], ridArr[i-60]]);
compareArr.push([ridArr[i], ridArr[i-20], ridArr[i+20], ridArr[i+40]]);
compareArr.push([ridArr[i], ridArr[i-40], ridArr[i-20], ridArr[i+20]]);diagonally was a little tricker to figure out the correct index, since you need to grab diagonal in two directions:
compareArr.push([ridArr[i], ridArr[i+21], ridArr[i+42], ridArr[i+63]]);
compareArr.push([ridArr[i], ridArr[i-21], ridArr[i-42], ridArr[i-63]]);
compareArr.push([ridArr[i], ridArr[i-21], ridArr[i+21], ridArr[i+42]]);
compareArr.push([ridArr[i], ridArr[i-42], ridArr[i-21], ridArr[i+21]]);compareArr.push([ridArr[i], ridArr[i+19], ridArr[i+38], ridArr[i+57]]);
compareArr.push([ridArr[i], ridArr[i-19], ridArr[i-38], ridArr[i-57]]);
compareArr.push([ridArr[i], ridArr[i-19], ridArr[i+19], ridArr[i+57]]);
compareArr.push([ridArr[i], ridArr[i-38], ridArr[i-19], ridArr[i+19]]);
}
After closing off my for loop, I use the exact same code I used in problem #8 to find and return the greatest product from the array of arrays.
let greatestSum = 0;
for (var i = 0; i < compareArr.length; i++) {
let tempSum = compareArr[i].reduce(function(a,b){return a*b;});
if (tempSum > greatestSum){
greatestSum = tempSum;
}
}
console.log(greatestSum);Thanks for reading, and again, I would love any feedback you have, especially if you solved it differently than I did. Thanks!
