diff --git a/challenges/08-coding-interview-prep/project-euler.json b/challenges/08-coding-interview-prep/project-euler.json
index 684fdbc98..57eff801f 100644
--- a/challenges/08-coding-interview-prep/project-euler.json
+++ b/challenges/08-coding-interview-prep/project-euler.json
@@ -11,19 +11,25 @@
"tests": [
{
"text": "multiplesOf3and5(1000) should return 233168.",
- "testString": "assert.strictEqual(multiplesOf3and5(1000), 233168, 'multiplesOf3and5(1000) should return 233168.');"
+ "testString":
+ "assert.strictEqual(multiplesOf3and5(1000), 233168, 'multiplesOf3and5(1000) should return 233168.');"
},
{
"text": "multiplesOf3and5(49) should return 543.",
- "testString": "assert.strictEqual(multiplesOf3and5(49), 543, 'multiplesOf3and5(49) should return 543.');"
+ "testString":
+ "assert.strictEqual(multiplesOf3and5(49), 543, 'multiplesOf3and5(49) should return 543.');"
},
{
- "text": "multiplesOf3and5(19564) should return 89301183.",
- "testString": "assert.strictEqual(multiplesOf3and5(19564), 89301183, 'multiplesOf3and5(19564) should return 89301183.');"
+ "text":
+ "multiplesOf3and5(19564) should return 89301183.",
+ "testString":
+ "assert.strictEqual(multiplesOf3and5(19564), 89301183, 'multiplesOf3and5(19564) should return 89301183.');"
},
{
- "text": "Your function is not returning the correct result using our tests values.",
- "testString": "assert.strictEqual(multiplesOf3and5(8456), 16687353, 'Your function is not returning the correct result using our tests values.');"
+ "text":
+ "Your function is not returning the correct result using our tests values.",
+ "testString":
+ "assert.strictEqual(multiplesOf3and5(8456), 16687353, 'Your function is not returning the correct result using our tests values.');"
}
],
"solutions": [
@@ -59,23 +65,29 @@
"tests": [
{
"text": "fiboEvenSum(10) should return 188.",
- "testString": "assert.strictEqual(fiboEvenSum(10), 188, 'fiboEvenSum(10) should return 188.');"
+ "testString":
+ "assert.strictEqual(fiboEvenSum(10), 188, 'fiboEvenSum(10) should return 188.');"
},
{
"text": "fiboEvenSum(23) should return 60696.",
- "testString": "assert.strictEqual(fiboEvenSum(23), 60696, 'fiboEvenSum(23) should return 60696.');"
+ "testString":
+ "assert.strictEqual(fiboEvenSum(23), 60696, 'fiboEvenSum(23) should return 60696.');"
},
{
"text": "fiboEvenSum(43) should return 1485607536.",
- "testString": "assert.strictEqual(fiboEvenSum(43), 1485607536, 'fiboEvenSum(43) should return 1485607536.');"
+ "testString":
+ "assert.strictEqual(fiboEvenSum(43), 1485607536, 'fiboEvenSum(43) should return 1485607536.');"
},
{
- "text": "Your function is not returning the correct result using our tests values.",
- "testString": "assert.strictEqual(fiboEvenSum(18), 3382, 'Your function is not returning the correct result using our tests values.');"
+ "text":
+ "Your function is not returning the correct result using our tests values.",
+ "testString":
+ "assert.strictEqual(fiboEvenSum(18), 3382, 'Your function is not returning the correct result using our tests values.');"
},
{
"text": "Your function should return an even value.",
- "testString": "assert.equal(fiboEvenSum(31) % 2 === 0, true, 'Your function should return an even value.');"
+ "testString":
+ "assert.equal(fiboEvenSum(31) % 2 === 0, true, 'Your function should return an even value.');"
}
],
"solutions": [
@@ -112,27 +124,34 @@
"tests": [
{
"text": "largestPrimeFactor(2) should return 2.",
- "testString": "assert.strictEqual(largestPrimeFactor(2), 2, 'largestPrimeFactor(2) should return 2.');"
+ "testString":
+ "assert.strictEqual(largestPrimeFactor(2), 2, 'largestPrimeFactor(2) should return 2.');"
},
{
"text": "largestPrimeFactor(3) should return 3.",
- "testString": "assert.strictEqual(largestPrimeFactor(3), 3, 'largestPrimeFactor(3) should return 3.');"
+ "testString":
+ "assert.strictEqual(largestPrimeFactor(3), 3, 'largestPrimeFactor(3) should return 3.');"
},
{
"text": "largestPrimeFactor(5) should return 5.",
- "testString": "assert.strictEqual(largestPrimeFactor(5), 5, 'largestPrimeFactor(5) should return 5.');"
+ "testString":
+ "assert.strictEqual(largestPrimeFactor(5), 5, 'largestPrimeFactor(5) should return 5.');"
},
{
"text": "largestPrimeFactor(7) should return 7.",
- "testString": "assert.strictEqual(largestPrimeFactor(7), 7, 'largestPrimeFactor(7) should return 7.');"
+ "testString":
+ "assert.strictEqual(largestPrimeFactor(7), 7, 'largestPrimeFactor(7) should return 7.');"
},
{
"text": "largestPrimeFactor(13195) should return 29.",
- "testString": "assert.strictEqual(largestPrimeFactor(13195), 29, 'largestPrimeFactor(13195) should return 29.');"
+ "testString":
+ "assert.strictEqual(largestPrimeFactor(13195), 29, 'largestPrimeFactor(13195) should return 29.');"
},
{
- "text": "largestPrimeFactor(600851475143) should return 6857.",
- "testString": "assert.strictEqual(largestPrimeFactor(600851475143), 6857, 'largestPrimeFactor(600851475143) should return 6857.');"
+ "text":
+ "largestPrimeFactor(600851475143) should return 6857.",
+ "testString":
+ "assert.strictEqual(largestPrimeFactor(600851475143), 6857, 'largestPrimeFactor(600851475143) should return 6857.');"
}
],
"solutions": [
@@ -167,12 +186,16 @@
"title": "Problem 4: Largest palindrome product",
"tests": [
{
- "text": "largestPalindromeProduct(2) should return 9009.",
- "testString": "assert.strictEqual(largestPalindromeProduct(2), 9009, 'largestPalindromeProduct(2) should return 9009.');"
+ "text":
+ "largestPalindromeProduct(2) should return 9009.",
+ "testString":
+ "assert.strictEqual(largestPalindromeProduct(2), 9009, 'largestPalindromeProduct(2) should return 9009.');"
},
{
- "text": "largestPalindromeProduct(3) should return 906609.",
- "testString": "assert.strictEqual(largestPalindromeProduct(3), 906609, 'largestPalindromeProduct(3) should return 906609.');"
+ "text":
+ "largestPalindromeProduct(3) should return 906609.",
+ "testString":
+ "assert.strictEqual(largestPalindromeProduct(3), 906609, 'largestPalindromeProduct(3) should return 906609.');"
}
],
"solutions": [
@@ -208,15 +231,18 @@
"tests": [
{
"text": "smallestMult(5) should return 60.",
- "testString": "assert.strictEqual(smallestMult(5), 60, 'smallestMult(5) should return 60.');"
+ "testString":
+ "assert.strictEqual(smallestMult(5), 60, 'smallestMult(5) should return 60.');"
},
{
"text": "smallestMult(10) should return 2520.",
- "testString": "assert.strictEqual(smallestMult(10), 2520, 'smallestMult(10) should return 2520.');"
+ "testString":
+ "assert.strictEqual(smallestMult(10), 2520, 'smallestMult(10) should return 2520.');"
},
{
"text": "smallestMult(20) should return 232792560.",
- "testString": "assert.strictEqual(smallestMult(20), 232792560, 'smallestMult(20) should return 232792560.');"
+ "testString":
+ "assert.strictEqual(smallestMult(20), 232792560, 'smallestMult(20) should return 232792560.');"
}
],
"solutions": [
@@ -252,15 +278,19 @@
"tests": [
{
"text": "sumSquareDifference(10) should return 2640.",
- "testString": "assert.strictEqual(sumSquareDifference(10), 2640, 'sumSquareDifference(10) should return 2640.');"
+ "testString":
+ "assert.strictEqual(sumSquareDifference(10), 2640, 'sumSquareDifference(10) should return 2640.');"
},
{
"text": "sumSquareDifference(20) should return 41230.",
- "testString": "assert.strictEqual(sumSquareDifference(20), 41230, 'sumSquareDifference(20) should return 41230.');"
+ "testString":
+ "assert.strictEqual(sumSquareDifference(20), 41230, 'sumSquareDifference(20) should return 41230.');"
},
{
- "text": "sumSquareDifference(100) should return 25164150.",
- "testString": "assert.strictEqual(sumSquareDifference(100), 25164150, 'sumSquareDifference(100) should return 25164150.');"
+ "text":
+ "sumSquareDifference(100) should return 25164150.",
+ "testString":
+ "assert.strictEqual(sumSquareDifference(100), 25164150, 'sumSquareDifference(100) should return 25164150.');"
}
],
"solutions": [
@@ -300,23 +330,28 @@
"tests": [
{
"text": "nthPrime(6) should return 13.",
- "testString": "assert.strictEqual(nthPrime(6), 13, 'nthPrime(6) should return 13.');"
+ "testString":
+ "assert.strictEqual(nthPrime(6), 13, 'nthPrime(6) should return 13.');"
},
{
"text": "nthPrime(10) should return 29.",
- "testString": "assert.strictEqual(nthPrime(10), 29, 'nthPrime(10) should return 29.');"
+ "testString":
+ "assert.strictEqual(nthPrime(10), 29, 'nthPrime(10) should return 29.');"
},
{
"text": "nthPrime(100) should return 541.",
- "testString": "assert.strictEqual(nthPrime(100), 541, 'nthPrime(100) should return 541.');"
+ "testString":
+ "assert.strictEqual(nthPrime(100), 541, 'nthPrime(100) should return 541.');"
},
{
"text": "nthPrime(1000) should return 7919.",
- "testString": "assert.strictEqual(nthPrime(1000), 7919, 'nthPrime(1000) should return 7919.');"
+ "testString":
+ "assert.strictEqual(nthPrime(1000), 7919, 'nthPrime(1000) should return 7919.');"
},
{
"text": "nthPrime(10001) should return 104743.",
- "testString": "assert.strictEqual(nthPrime(10001), 104743, 'nthPrime(10001) should return 104743.');"
+ "testString":
+ "assert.strictEqual(nthPrime(10001), 104743, 'nthPrime(10001) should return 104743.');"
}
],
"solutions": [
@@ -352,11 +387,14 @@
"tests": [
{
"text": "largestProductinaSeries(4) should return 5832.",
- "testString": "assert.strictEqual(largestProductinaSeries(4), 5832, 'largestProductinaSeries(4) should return 5832.');"
+ "testString":
+ "assert.strictEqual(largestProductinaSeries(4), 5832, 'largestProductinaSeries(4) should return 5832.');"
},
{
- "text": "largestProductinaSeries(13) should return 23514624000.",
- "testString": "assert.strictEqual(largestProductinaSeries(13), 23514624000, 'largestProductinaSeries(13) should return 23514624000.');"
+ "text":
+ "largestProductinaSeries(13) should return 23514624000.",
+ "testString":
+ "assert.strictEqual(largestProductinaSeries(13), 23514624000, 'largestProductinaSeries(13) should return 23514624000.');"
}
],
"solutions": [
@@ -413,16 +451,22 @@
"title": "Problem 9: Special Pythagorean triplet",
"tests": [
{
- "text": "specialPythagoreanTriplet(1000) should return 31875000.",
- "testString": "assert.strictEqual(specialPythagoreanTriplet(1000), 31875000, 'specialPythagoreanTriplet(1000) should return 31875000.');"
+ "text":
+ "specialPythagoreanTriplet(1000) should return 31875000.",
+ "testString":
+ "assert.strictEqual(specialPythagoreanTriplet(1000), 31875000, 'specialPythagoreanTriplet(1000) should return 31875000.');"
},
{
- "text": "specialPythagoreanTriplet(24) should return 480.",
- "testString": "assert.strictEqual(specialPythagoreanTriplet(24), 480, 'specialPythagoreanTriplet(24) should return 480.');"
+ "text":
+ "specialPythagoreanTriplet(24) should return 480.",
+ "testString":
+ "assert.strictEqual(specialPythagoreanTriplet(24), 480, 'specialPythagoreanTriplet(24) should return 480.');"
},
{
- "text": "specialPythagoreanTriplet(120) should return 49920.",
- "testString": "assert.strictEqual(specialPythagoreanTriplet(120), 49920, 'specialPythagoreanTriplet(120) should return 49920.');"
+ "text":
+ "specialPythagoreanTriplet(120) should return 49920.",
+ "testString":
+ "assert.strictEqual(specialPythagoreanTriplet(120), 49920, 'specialPythagoreanTriplet(120) should return 49920.');"
}
],
"solutions": [
@@ -461,19 +505,25 @@
"tests": [
{
"text": "primeSummation(17) should return 41.",
- "testString": "assert.strictEqual(primeSummation(17), 41, 'primeSummation(17) should return 41.');"
+ "testString":
+ "assert.strictEqual(primeSummation(17), 41, 'primeSummation(17) should return 41.');"
},
{
"text": "primeSummation(2001) should return 277050.",
- "testString": "assert.strictEqual(primeSummation(2001), 277050, 'primeSummation(2001) should return 277050.');"
+ "testString":
+ "assert.strictEqual(primeSummation(2001), 277050, 'primeSummation(2001) should return 277050.');"
},
{
- "text": "primeSummation(140759) should return 873608362.",
- "testString": "assert.strictEqual(primeSummation(140759), 873608362, 'primeSummation(140759) should return 873608362.');"
+ "text":
+ "primeSummation(140759) should return 873608362.",
+ "testString":
+ "assert.strictEqual(primeSummation(140759), 873608362, 'primeSummation(140759) should return 873608362.');"
},
{
- "text": "primeSummation(2000000) should return 142913828922.",
- "testString": "assert.strictEqual(primeSummation(2000000), 142913828922, 'primeSummation(2000000) should return 142913828922.');"
+ "text":
+ "primeSummation(2000000) should return 142913828922.",
+ "testString":
+ "assert.strictEqual(primeSummation(2000000), 142913828922, 'primeSummation(2000000) should return 142913828922.');"
}
],
"solutions": [
@@ -508,12 +558,16 @@
"title": "Problem 11: Largest product in a grid",
"tests": [
{
- "text": "largestGridProduct(grid) should return 70600674.",
- "testString": "assert.strictEqual(largestGridProduct(grid), 70600674, 'largestGridProduct(grid) should return 70600674.');"
+ "text":
+ "largestGridProduct(grid) should return 70600674.",
+ "testString":
+ "assert.strictEqual(largestGridProduct(grid), 70600674, 'largestGridProduct(grid) should return 70600674.');"
},
{
- "text": "largestGridProduct(testGrid) should return 14169081.",
- "testString": "assert.strictEqual(largestGridProduct(testGrid), 14169081, 'largestGridProduct(testGrid) should return 14169081.');"
+ "text":
+ "largestGridProduct(testGrid) should return 14169081.",
+ "testString":
+ "assert.strictEqual(largestGridProduct(testGrid), 14169081, 'largestGridProduct(testGrid) should return 14169081.');"
}
],
"solutions": [
@@ -604,15 +658,19 @@
"tests": [
{
"text": "divisibleTriangleNumber(5) should return 28.",
- "testString": "assert.strictEqual(divisibleTriangleNumber(5), 28, 'divisibleTriangleNumber(5) should return 28.');"
+ "testString":
+ "assert.strictEqual(divisibleTriangleNumber(5), 28, 'divisibleTriangleNumber(5) should return 28.');"
},
{
"text": "divisibleTriangleNumber(23) should return 630.",
- "testString": "assert.strictEqual(divisibleTriangleNumber(23), 630, 'divisibleTriangleNumber(23) should return 630.');"
+ "testString":
+ "assert.strictEqual(divisibleTriangleNumber(23), 630, 'divisibleTriangleNumber(23) should return 630.');"
},
{
- "text": "divisibleTriangleNumber() should return 76576500.",
- "testString": "assert.strictEqual(divisibleTriangleNumber(500), 76576500, 'divisibleTriangleNumber() should return 76576500.');"
+ "text":
+ "divisibleTriangleNumber() should return 76576500.",
+ "testString":
+ "assert.strictEqual(divisibleTriangleNumber(500), 76576500, 'divisibleTriangleNumber() should return 76576500.');"
}
],
"solutions": [
@@ -658,11 +716,14 @@
"tests": [
{
"text": "largeSum(testNums) should return 8348422521.",
- "testString": "assert.strictEqual(largeSum(testNums), 8348422521, 'largeSum(testNums) should return 8348422521.');"
+ "testString":
+ "assert.strictEqual(largeSum(testNums), 8348422521, 'largeSum(testNums) should return 8348422521.');"
},
{
- "text": "largeSum(fiftyDigitNums) should return 5537376230.",
- "testString": "assert.strictEqual(largeSum(fiftyDigitNums), 5537376230, 'largeSum(fiftyDigitNums) should return 5537376230.');"
+ "text":
+ "largeSum(fiftyDigitNums) should return 5537376230.",
+ "testString":
+ "assert.strictEqual(largeSum(fiftyDigitNums), 5537376230, 'largeSum(fiftyDigitNums) should return 5537376230.');"
}
],
"solutions": [
@@ -913,15 +974,20 @@
"tests": [
{
"text": "longestCollatzSequence(14) should return 9.",
- "testString": "assert.strictEqual(longestCollatzSequence(14), 9, 'longestCollatzSequence(14) should return 9.');"
+ "testString":
+ "assert.strictEqual(longestCollatzSequence(14), 9, 'longestCollatzSequence(14) should return 9.');"
},
{
- "text": "longestCollatzSequence(5847) should return 3711.",
- "testString": "assert.strictEqual(longestCollatzSequence(5847), 3711, 'longestCollatzSequence(5847) should return 3711.');"
+ "text":
+ "longestCollatzSequence(5847) should return 3711.",
+ "testString":
+ "assert.strictEqual(longestCollatzSequence(5847), 3711, 'longestCollatzSequence(5847) should return 3711.');"
},
{
- "text": "longestCollatzSequence(1000000) should return 837799.",
- "testString": "assert.strictEqual(longestCollatzSequence(1000000), 837799, 'longestCollatzSequence(1000000) should return 837799.');"
+ "text":
+ "longestCollatzSequence(1000000) should return 837799.",
+ "testString":
+ "assert.strictEqual(longestCollatzSequence(1000000), 837799, 'longestCollatzSequence(1000000) should return 837799.');"
}
],
"solutions": [
@@ -963,15 +1029,18 @@
"tests": [
{
"text": "latticePaths(4) should return 70.",
- "testString": "assert.strictEqual(latticePaths(4), 70, 'latticePaths(4) should return 70.');"
+ "testString":
+ "assert.strictEqual(latticePaths(4), 70, 'latticePaths(4) should return 70.');"
},
{
"text": "latticePaths(9) should return 48620.",
- "testString": "assert.strictEqual(latticePaths(9), 48620, 'latticePaths(9) should return 48620.');"
+ "testString":
+ "assert.strictEqual(latticePaths(9), 48620, 'latticePaths(9) should return 48620.');"
},
{
"text": "latticePaths(20) should return 137846528820.",
- "testString": "assert.strictEqual(latticePaths(20), 137846528820, 'latticePaths(20) should return 137846528820.');"
+ "testString":
+ "assert.strictEqual(latticePaths(20), 137846528820, 'latticePaths(20) should return 137846528820.');"
}
],
"solutions": [
@@ -1010,15 +1079,18 @@
"tests": [
{
"text": "powerDigitSum(15) should return 26.",
- "testString": "assert.strictEqual(powerDigitSum(15), 26, 'powerDigitSum(15) should return 26.');"
+ "testString":
+ "assert.strictEqual(powerDigitSum(15), 26, 'powerDigitSum(15) should return 26.');"
},
{
"text": "powerDigitSum(128) should return 166.",
- "testString": "assert.strictEqual(powerDigitSum(128), 166, 'powerDigitSum(128) should return 166.');"
+ "testString":
+ "assert.strictEqual(powerDigitSum(128), 166, 'powerDigitSum(128) should return 166.');"
},
{
"text": "powerDigitSum(1000) should return 1366.",
- "testString": "assert.strictEqual(powerDigitSum(1000), 1366, 'powerDigitSum(1000) should return 1366.');"
+ "testString":
+ "assert.strictEqual(powerDigitSum(1000), 1366, 'powerDigitSum(1000) should return 1366.');"
}
],
"solutions": [
@@ -1054,15 +1126,18 @@
"tests": [
{
"text": "numberLetterCounts(5) should return 19.",
- "testString": "assert.strictEqual(numberLetterCounts(5), 19, 'numberLetterCounts(5) should return 19.');"
+ "testString":
+ "assert.strictEqual(numberLetterCounts(5), 19, 'numberLetterCounts(5) should return 19.');"
},
{
"text": "numberLetterCounts(150) should return 1903.",
- "testString": "assert.strictEqual(numberLetterCounts(150), 1903, 'numberLetterCounts(150) should return 1903.');"
+ "testString":
+ "assert.strictEqual(numberLetterCounts(150), 1903, 'numberLetterCounts(150) should return 1903.');"
},
{
"text": "numberLetterCounts(1000) should return 21124.",
- "testString": "assert.strictEqual(numberLetterCounts(1000), 21124, 'numberLetterCounts(1000) should return 21124.');"
+ "testString":
+ "assert.strictEqual(numberLetterCounts(1000), 21124, 'numberLetterCounts(1000) should return 21124.');"
}
],
"solutions": [
@@ -1098,12 +1173,16 @@
"title": "Problem 18: Maximum path sum I",
"tests": [
{
- "text": "maximumPathSumI(testTriangle) should return 23.",
- "testString": "assert.strictEqual(maximumPathSumI(testTriangle), 23, 'maximumPathSumI(testTriangle) should return 23.');"
+ "text":
+ "maximumPathSumI(testTriangle) should return 23.",
+ "testString":
+ "assert.strictEqual(maximumPathSumI(testTriangle), 23, 'maximumPathSumI(testTriangle) should return 23.');"
},
{
- "text": "maximumPathSumI(numTriangle) should return 1074.",
- "testString": "assert.strictEqual(maximumPathSumI(numTriangle), 1074, 'maximumPathSumI(numTriangle) should return 1074.');"
+ "text":
+ "maximumPathSumI(numTriangle) should return 1074.",
+ "testString":
+ "assert.strictEqual(maximumPathSumI(numTriangle), 1074, 'maximumPathSumI(numTriangle) should return 1074.');"
}
],
"solutions": [
@@ -1150,15 +1229,18 @@
"tests": [
{
"text": "countingSundays(1943, 1946) should return 6.",
- "testString": "assert.strictEqual(countingSundays(1943, 1946), 6, 'countingSundays(1943, 1946) should return 6.');"
+ "testString":
+ "assert.strictEqual(countingSundays(1943, 1946), 6, 'countingSundays(1943, 1946) should return 6.');"
},
{
"text": "countingSundays(1995, 2000) should return 9.",
- "testString": "assert.strictEqual(countingSundays(1995, 2000), 9, 'countingSundays(1995, 2000) should return 9.');"
+ "testString":
+ "assert.strictEqual(countingSundays(1995, 2000), 9, 'countingSundays(1995, 2000) should return 9.');"
},
{
"text": "countingSundays(1901, 2000) should return 171.",
- "testString": "assert.strictEqual(countingSundays(1901, 2000), 171, 'countingSundays(1901, 2000) should return 171.');"
+ "testString":
+ "assert.strictEqual(countingSundays(1901, 2000), 171, 'countingSundays(1901, 2000) should return 171.');"
}
],
"solutions": [
@@ -1195,23 +1277,28 @@
"tests": [
{
"text": "sumFactorialDigits(10) should return 27.",
- "testString": "assert.strictEqual(sumFactorialDigits(10), 27, 'sumFactorialDigits(10) should return 27.');"
+ "testString":
+ "assert.strictEqual(sumFactorialDigits(10), 27, 'sumFactorialDigits(10) should return 27.');"
},
{
"text": "sumFactorialDigits(25) should return 72.",
- "testString": "assert.strictEqual(sumFactorialDigits(25), 72, 'sumFactorialDigits(25) should return 72.');"
+ "testString":
+ "assert.strictEqual(sumFactorialDigits(25), 72, 'sumFactorialDigits(25) should return 72.');"
},
{
"text": "sumFactorialDigits(50) should return 216.",
- "testString": "assert.strictEqual(sumFactorialDigits(50), 216, 'sumFactorialDigits(50) should return 216.');"
+ "testString":
+ "assert.strictEqual(sumFactorialDigits(50), 216, 'sumFactorialDigits(50) should return 216.');"
},
{
"text": "sumFactorialDigits(75) should return 432.",
- "testString": "assert.strictEqual(sumFactorialDigits(75), 432, 'sumFactorialDigits(75) should return 432.');"
+ "testString":
+ "assert.strictEqual(sumFactorialDigits(75), 432, 'sumFactorialDigits(75) should return 432.');"
},
{
"text": "sumFactorialDigits(100) should return 648.",
- "testString": "assert.strictEqual(sumFactorialDigits(100), 648, 'sumFactorialDigits(100) should return 648.');"
+ "testString":
+ "assert.strictEqual(sumFactorialDigits(100), 648, 'sumFactorialDigits(100) should return 648.');"
}
],
"solutions": [],
@@ -1246,19 +1333,23 @@
"tests": [
{
"text": "sumAmicableNum(1000) should return 504.",
- "testString": "assert.strictEqual(sumAmicableNum(1000), 504, 'sumAmicableNum(1000) should return 504.');"
+ "testString":
+ "assert.strictEqual(sumAmicableNum(1000), 504, 'sumAmicableNum(1000) should return 504.');"
},
{
"text": "sumAmicableNum(2000) should return 2898.",
- "testString": "assert.strictEqual(sumAmicableNum(2000), 2898, 'sumAmicableNum(2000) should return 2898.');"
+ "testString":
+ "assert.strictEqual(sumAmicableNum(2000), 2898, 'sumAmicableNum(2000) should return 2898.');"
},
{
"text": "sumAmicableNum(5000) should return 8442.",
- "testString": "assert.strictEqual(sumAmicableNum(5000), 8442, 'sumAmicableNum(5000) should return 8442.');"
+ "testString":
+ "assert.strictEqual(sumAmicableNum(5000), 8442, 'sumAmicableNum(5000) should return 8442.');"
},
{
"text": "sumAmicableNum(10000) should return 31626.",
- "testString": "assert.strictEqual(sumAmicableNum(10000), 31626, 'sumAmicableNum(10000) should return 31626.');"
+ "testString":
+ "assert.strictEqual(sumAmicableNum(10000), 31626, 'sumAmicableNum(10000) should return 31626.');"
}
],
"solutions": [],
@@ -1294,15 +1385,18 @@
"tests": [
{
"text": "namesScores(test1) should return 791.",
- "testString": "assert.strictEqual(namesScores(test1), 791, 'namesScores(test1) should return 791.');"
+ "testString":
+ "assert.strictEqual(namesScores(test1), 791, 'namesScores(test1) should return 791.');"
},
{
"text": "namesScores(test2) should return 1468.",
- "testString": "assert.strictEqual(namesScores(test2), 1468, 'namesScores(test2) should return 1468.');"
+ "testString":
+ "assert.strictEqual(namesScores(test2), 1468, 'namesScores(test2) should return 1468.');"
},
{
"text": "namesScores(names) should return 871198282.",
- "testString": "assert.strictEqual(namesScores(names), 871198282, 'namesScores(names) should return 871198282.');"
+ "testString":
+ "assert.strictEqual(namesScores(names), 871198282, 'namesScores(names) should return 871198282.');"
}
],
"solutions": [],
@@ -1342,20 +1436,28 @@
"title": "Problem 23: Non-abundant sums",
"tests": [
{
- "text": "sumOfNonAbundantNumbers(10000) should return 3731004.",
- "testString": "assert(sumOfNonAbundantNumbers(10000) === 3731004, 'sumOfNonAbundantNumbers(10000) should return 3731004.');"
+ "text":
+ "sumOfNonAbundantNumbers(10000) should return 3731004.",
+ "testString":
+ "assert(sumOfNonAbundantNumbers(10000) === 3731004, 'sumOfNonAbundantNumbers(10000) should return 3731004.');"
},
{
- "text": "sumOfNonAbundantNumbers(15000) should return 4039939.",
- "testString": "assert(sumOfNonAbundantNumbers(15000) === 4039939, 'sumOfNonAbundantNumbers(15000) should return 4039939.');"
+ "text":
+ "sumOfNonAbundantNumbers(15000) should return 4039939.",
+ "testString":
+ "assert(sumOfNonAbundantNumbers(15000) === 4039939, 'sumOfNonAbundantNumbers(15000) should return 4039939.');"
},
{
- "text": "sumOfNonAbundantNumbers(20000) should return 4159710.",
- "testString": "assert(sumOfNonAbundantNumbers(20000) === 4159710, 'sumOfNonAbundantNumbers(20000) should return 4159710.');"
+ "text":
+ "sumOfNonAbundantNumbers(20000) should return 4159710.",
+ "testString":
+ "assert(sumOfNonAbundantNumbers(20000) === 4159710, 'sumOfNonAbundantNumbers(20000) should return 4159710.');"
},
{
- "text": "sumOfNonAbundantNumbers(28123) should return 4179871.",
- "testString": "assert(sumOfNonAbundantNumbers(28123) === 4179871, 'sumOfNonAbundantNumbers(28123) should return 4179871.');"
+ "text":
+ "sumOfNonAbundantNumbers(28123) should return 4179871.",
+ "testString":
+ "assert(sumOfNonAbundantNumbers(28123) === 4179871, 'sumOfNonAbundantNumbers(28123) should return 4179871.');"
}
],
"solutions": [],
@@ -1390,20 +1492,28 @@
"title": "Problem 24: Lexicographic permutations",
"tests": [
{
- "text": "lexicographicPermutations(699999) should return 1938246570.",
- "testString": "assert(lexicographicPermutations(699999) == 1938246570, 'lexicographicPermutations(699999) should return 1938246570.');"
+ "text":
+ "lexicographicPermutations(699999) should return 1938246570.",
+ "testString":
+ "assert(lexicographicPermutations(699999) == 1938246570, 'lexicographicPermutations(699999) should return 1938246570.');"
},
{
- "text": "lexicographicPermutations(899999) should return 2536987410.",
- "testString": "assert(lexicographicPermutations(899999) == 2536987410, 'lexicographicPermutations(899999) should return 2536987410.');"
+ "text":
+ "lexicographicPermutations(899999) should return 2536987410.",
+ "testString":
+ "assert(lexicographicPermutations(899999) == 2536987410, 'lexicographicPermutations(899999) should return 2536987410.');"
},
{
- "text": "lexicographicPermutations(900000) should return 2537014689.",
- "testString": "assert(lexicographicPermutations(900000) == 2537014689, 'lexicographicPermutations(900000) should return 2537014689.');"
+ "text":
+ "lexicographicPermutations(900000) should return 2537014689.",
+ "testString":
+ "assert(lexicographicPermutations(900000) == 2537014689, 'lexicographicPermutations(900000) should return 2537014689.');"
},
{
- "text": "lexicographicPermutations(999999) should return 2783915460.",
- "testString": "assert(lexicographicPermutations(999999) == 2783915460, 'lexicographicPermutations(999999) should return 2783915460.');"
+ "text":
+ "lexicographicPermutations(999999) should return 2783915460.",
+ "testString":
+ "assert(lexicographicPermutations(999999) == 2783915460, 'lexicographicPermutations(999999) should return 2783915460.');"
}
],
"solutions": [],
@@ -1438,19 +1548,23 @@
"tests": [
{
"text": "digitFibonacci(5) should return 20.",
- "testString": "assert(digitFibonacci(5) == 20, 'digitFibonacci(5) should return 20.');"
+ "testString":
+ "assert(digitFibonacci(5) == 20, 'digitFibonacci(5) should return 20.');"
},
{
"text": "digitFibonacci(10) should return 44.",
- "testString": "assert(digitFibonacci(10) == 44, 'digitFibonacci(10) should return 44.');"
+ "testString":
+ "assert(digitFibonacci(10) == 44, 'digitFibonacci(10) should return 44.');"
},
{
"text": "digitFibonacci(15) should return 68.",
- "testString": "assert(digitFibonacci(15) == 68, 'digitFibonacci(15) should return 68.');"
+ "testString":
+ "assert(digitFibonacci(15) == 68, 'digitFibonacci(15) should return 68.');"
},
{
"text": "digitFibonacci(20) should return 92.",
- "testString": "assert(digitFibonacci(20) == 92, 'digitFibonacci(20) should return 92.');"
+ "testString":
+ "assert(digitFibonacci(20) == 92, 'digitFibonacci(20) should return 92.');"
}
],
"solutions": [],
@@ -1488,19 +1602,23 @@
"tests": [
{
"text": "reciprocalCycles(700) should return 659.",
- "testString": "assert(reciprocalCycles(700) == 659, 'reciprocalCycles(700) should return 659.');"
+ "testString":
+ "assert(reciprocalCycles(700) == 659, 'reciprocalCycles(700) should return 659.');"
},
{
"text": "reciprocalCycles(800) should return 743.",
- "testString": "assert(reciprocalCycles(800) == 743, 'reciprocalCycles(800) should return 743.');"
+ "testString":
+ "assert(reciprocalCycles(800) == 743, 'reciprocalCycles(800) should return 743.');"
},
{
"text": "reciprocalCycles(900) should return 887.",
- "testString": "assert(reciprocalCycles(900) == 887, 'reciprocalCycles(900) should return 887.');"
+ "testString":
+ "assert(reciprocalCycles(900) == 887, 'reciprocalCycles(900) should return 887.');"
},
{
"text": "reciprocalCycles(1000) should return 983.",
- "testString": "assert(reciprocalCycles(1000) == 983, 'reciprocalCycles(1000) should return 983.');"
+ "testString":
+ "assert(reciprocalCycles(1000) == 983, 'reciprocalCycles(1000) should return 983.');"
}
],
"solutions": [],
@@ -1536,19 +1654,23 @@
"tests": [
{
"text": "quadraticPrimes(200) should return -4925.",
- "testString": "assert(quadraticPrimes(200) == -4925, 'quadraticPrimes(200) should return -4925.');"
+ "testString":
+ "assert(quadraticPrimes(200) == -4925, 'quadraticPrimes(200) should return -4925.');"
},
{
"text": "quadraticPrimes(500) should return -18901.",
- "testString": "assert(quadraticPrimes(500) == -18901, 'quadraticPrimes(500) should return -18901.');"
+ "testString":
+ "assert(quadraticPrimes(500) == -18901, 'quadraticPrimes(500) should return -18901.');"
},
{
"text": "quadraticPrimes(800) should return -43835.",
- "testString": "assert(quadraticPrimes(800) == -43835, 'quadraticPrimes(800) should return -43835.');"
+ "testString":
+ "assert(quadraticPrimes(800) == -43835, 'quadraticPrimes(800) should return -43835.');"
},
{
"text": "quadraticPrimes(1000) should return -59231.",
- "testString": "assert(quadraticPrimes(1000) == -59231, 'quadraticPrimes(1000) should return -59231.');"
+ "testString":
+ "assert(quadraticPrimes(1000) == -59231, 'quadraticPrimes(1000) should return -59231.');"
}
],
"solutions": [],
@@ -1589,19 +1711,23 @@
"tests": [
{
"text": "spiralDiagonals(101) should return 692101.",
- "testString": "assert(spiralDiagonals(101) == 692101, 'spiralDiagonals(101) should return 692101.');"
+ "testString":
+ "assert(spiralDiagonals(101) == 692101, 'spiralDiagonals(101) should return 692101.');"
},
{
"text": "spiralDiagonals(303) should return 18591725.",
- "testString": "assert(spiralDiagonals(303) == 18591725, 'spiralDiagonals(303) should return 18591725.');"
+ "testString":
+ "assert(spiralDiagonals(303) == 18591725, 'spiralDiagonals(303) should return 18591725.');"
},
{
"text": "spiralDiagonals(505) should return 85986601.",
- "testString": "assert(spiralDiagonals(505) == 85986601, 'spiralDiagonals(505) should return 85986601.');"
+ "testString":
+ "assert(spiralDiagonals(505) == 85986601, 'spiralDiagonals(505) should return 85986601.');"
},
{
"text": "spiralDiagonals(1001) should return 669171001.",
- "testString": "assert(spiralDiagonals(1001) == 669171001, 'spiralDiagonals(1001) should return 669171001.');"
+ "testString":
+ "assert(spiralDiagonals(1001) == 669171001, 'spiralDiagonals(1001) should return 669171001.');"
}
],
"solutions": [],
@@ -1641,19 +1767,23 @@
"tests": [
{
"text": "distinctPowers(15) should return 177.",
- "testString": "assert.strictEqual(distinctPowers(15), 177, 'distinctPowers(15) should return 177.');"
+ "testString":
+ "assert.strictEqual(distinctPowers(15), 177, 'distinctPowers(15) should return 177.');"
},
{
"text": "distinctPowers(20) should return 324.",
- "testString": "assert.strictEqual(distinctPowers(20), 324, 'distinctPowers(20) should return 324.');"
+ "testString":
+ "assert.strictEqual(distinctPowers(20), 324, 'distinctPowers(20) should return 324.');"
},
{
"text": "distinctPowers(25) should return 519.",
- "testString": "assert.strictEqual(distinctPowers(25), 519, 'distinctPowers(25) should return 519.');"
+ "testString":
+ "assert.strictEqual(distinctPowers(25), 519, 'distinctPowers(25) should return 519.');"
},
{
"text": "distinctPowers(30) should return 755.",
- "testString": "assert.strictEqual(distinctPowers(30), 755, 'distinctPowers(30) should return 755.');"
+ "testString":
+ "assert.strictEqual(distinctPowers(30), 755, 'distinctPowers(30) should return 755.');"
}
],
"solutions": [],
@@ -1693,19 +1823,23 @@
"tests": [
{
"text": "digitnPowers(2) should return 0.",
- "testString": "assert(digitnPowers(2) == 0, 'digitnPowers(2) should return 0.');"
+ "testString":
+ "assert(digitnPowers(2) == 0, 'digitnPowers(2) should return 0.');"
},
{
"text": "digitnPowers(3) should return 1301.",
- "testString": "assert(digitnPowers(3) == 1301, 'digitnPowers(3) should return 1301.');"
+ "testString":
+ "assert(digitnPowers(3) == 1301, 'digitnPowers(3) should return 1301.');"
},
{
"text": "digitnPowers(4) should return 19316.",
- "testString": "assert(digitnPowers(4) == 19316, 'digitnPowers(4) should return 19316.');"
+ "testString":
+ "assert(digitnPowers(4) == 19316, 'digitnPowers(4) should return 19316.');"
},
{
"text": "digitnPowers(5) should return 443839.",
- "testString": "assert(digitnPowers(5) == 443839, 'digitnPowers(5) should return 443839.');"
+ "testString":
+ "assert(digitnPowers(5) == 443839, 'digitnPowers(5) should return 443839.');"
}
],
"solutions": [],
@@ -1744,19 +1878,23 @@
"tests": [
{
"text": "coinSums(50) should return 451.",
- "testString": "assert(coinSums(50) == 451, 'coinSums(50) should return 451.');"
+ "testString":
+ "assert(coinSums(50) == 451, 'coinSums(50) should return 451.');"
},
{
"text": "coinSums(100) should return 4563.",
- "testString": "assert(coinSums(100) == 4563, 'coinSums(100) should return 4563.');"
+ "testString":
+ "assert(coinSums(100) == 4563, 'coinSums(100) should return 4563.');"
},
{
"text": "coinSums(150) should return 21873.",
- "testString": "assert(coinSums(150) == 21873, 'coinSums(150) should return 21873.');"
+ "testString":
+ "assert(coinSums(150) == 21873, 'coinSums(150) should return 21873.');"
},
{
"text": "coinSums(200) should return 73682.",
- "testString": "assert(coinSums(200) == 73682, 'coinSums(200) should return 73682.');"
+ "testString":
+ "assert(coinSums(200) == 73682, 'coinSums(200) should return 73682.');"
}
],
"solutions": [],
@@ -1793,11 +1931,13 @@
"tests": [
{
"text": "pandigitalProducts() is a function.",
- "testString": "assert(typeof pandigitalProducts === 'function', 'pandigitalProducts() is a function.');"
+ "testString":
+ "assert(typeof pandigitalProducts === 'function', 'pandigitalProducts() is a function.');"
},
{
"text": "pandigitalProducts() should return 45228.",
- "testString": "assert.strictEqual(pandigitalProducts(), 45228, 'pandigitalProducts() should return 45228.');"
+ "testString":
+ "assert.strictEqual(pandigitalProducts(), 45228, 'pandigitalProducts() should return 45228.');"
}
],
"solutions": [
@@ -1838,7 +1978,8 @@
"tests": [
{
"text": "digitCancellingFractions() should return 100.",
- "testString": "assert.strictEqual(digitCancellingFractions(), 100, 'digitCancellingFractions() should return 100.');"
+ "testString":
+ "assert.strictEqual(digitCancellingFractions(), 100, 'digitCancellingFractions() should return 100.');"
}
],
"solutions": [
@@ -1875,8 +2016,10 @@
"title": "Problem 34: Digit factorials",
"tests": [
{
- "text": "digitFactorial() should return { sum: 40730, numbers: [145, 40585] }.",
- "testString": "assert.deepEqual(digitFactorial(), { sum: 40730, numbers: [145, 40585] }, 'digitFactorial() should return { sum: 40730, numbers: [145, 40585] }.');"
+ "text":
+ "digitFactorial() should return { sum: 40730, numbers: [145, 40585] }.",
+ "testString":
+ "assert.deepEqual(digitFactorial(), { sum: 40730, numbers: [145, 40585] }, 'digitFactorial() should return { sum: 40730, numbers: [145, 40585] }.');"
}
],
"solutions": [],
@@ -1913,27 +2056,33 @@
"tests": [
{
"text": "circularPrimes(100) should return 13.",
- "testString": "assert(circularPrimes(100) == 13, 'circularPrimes(100) should return 13.');"
+ "testString":
+ "assert(circularPrimes(100) == 13, 'circularPrimes(100) should return 13.');"
},
{
"text": "circularPrimes(100000) should return 43.",
- "testString": "assert(circularPrimes(100000) == 43, 'circularPrimes(100000) should return 43.');"
+ "testString":
+ "assert(circularPrimes(100000) == 43, 'circularPrimes(100000) should return 43.');"
},
{
"text": "circularPrimes(250000) should return 45.",
- "testString": "assert(circularPrimes(250000) == 45, 'circularPrimes(250000) should return 45.');"
+ "testString":
+ "assert(circularPrimes(250000) == 45, 'circularPrimes(250000) should return 45.');"
},
{
"text": "circularPrimes(500000) should return 49.",
- "testString": "assert(circularPrimes(500000) == 49, 'circularPrimes(500000) should return 49.');"
+ "testString":
+ "assert(circularPrimes(500000) == 49, 'circularPrimes(500000) should return 49.');"
},
{
"text": "circularPrimes(750000) should return 49.",
- "testString": "assert(circularPrimes(750000) == 49, 'circularPrimes(750000) should return 49.');"
+ "testString":
+ "assert(circularPrimes(750000) == 49, 'circularPrimes(750000) should return 49.');"
},
{
"text": "circularPrimes(1000000) should return 55.",
- "testString": "assert(circularPrimes(1000000) == 55, 'circularPrimes(1000000) should return 55.');"
+ "testString":
+ "assert(circularPrimes(1000000) == 55, 'circularPrimes(1000000) should return 55.');"
}
],
"solutions": [],
@@ -1967,20 +2116,28 @@
"title": "Problem 36: Double-base palindromes",
"tests": [
{
- "text": "doubleBasePalindromes(1000) should return 1772.",
- "testString": "assert(doubleBasePalindromes(1000) == 1772, 'doubleBasePalindromes(1000) should return 1772.');"
+ "text":
+ "doubleBasePalindromes(1000) should return 1772.",
+ "testString":
+ "assert(doubleBasePalindromes(1000) == 1772, 'doubleBasePalindromes(1000) should return 1772.');"
},
{
- "text": "doubleBasePalindromes(50000) should return 105795.",
- "testString": "assert(doubleBasePalindromes(50000) == 105795, 'doubleBasePalindromes(50000) should return 105795.');"
+ "text":
+ "doubleBasePalindromes(50000) should return 105795.",
+ "testString":
+ "assert(doubleBasePalindromes(50000) == 105795, 'doubleBasePalindromes(50000) should return 105795.');"
},
{
- "text": "doubleBasePalindromes(500000) should return 286602.",
- "testString": "assert(doubleBasePalindromes(500000) == 286602, 'doubleBasePalindromes(500000) should return 286602.');"
+ "text":
+ "doubleBasePalindromes(500000) should return 286602.",
+ "testString":
+ "assert(doubleBasePalindromes(500000) == 286602, 'doubleBasePalindromes(500000) should return 286602.');"
},
{
- "text": "doubleBasePalindromes(1000000) should return 872187.",
- "testString": "assert(doubleBasePalindromes(1000000) == 872187, 'doubleBasePalindromes(1000000) should return 872187.');"
+ "text":
+ "doubleBasePalindromes(1000000) should return 872187.",
+ "testString":
+ "assert(doubleBasePalindromes(1000000) == 872187, 'doubleBasePalindromes(1000000) should return 872187.');"
}
],
"solutions": [],
@@ -2015,19 +2172,23 @@
"tests": [
{
"text": "truncatablePrimes(8) should return 1986.",
- "testString": "assert(truncatablePrimes(8) == 1986, 'truncatablePrimes(8) should return 1986.');"
+ "testString":
+ "assert(truncatablePrimes(8) == 1986, 'truncatablePrimes(8) should return 1986.');"
},
{
"text": "truncatablePrimes(9) should return 5123.",
- "testString": "assert(truncatablePrimes(9) == 5123, 'truncatablePrimes(9) should return 5123.');"
+ "testString":
+ "assert(truncatablePrimes(9) == 5123, 'truncatablePrimes(9) should return 5123.');"
},
{
"text": "truncatablePrimes(10) should return 8920.",
- "testString": "assert(truncatablePrimes(10) == 8920, 'truncatablePrimes(10) should return 8920.');"
+ "testString":
+ "assert(truncatablePrimes(10) == 8920, 'truncatablePrimes(10) should return 8920.');"
},
{
"text": "truncatablePrimes(11) should return 748317.",
- "testString": "assert(truncatablePrimes(11) == 748317, 'truncatablePrimes(11) should return 748317.');"
+ "testString":
+ "assert(truncatablePrimes(11) == 748317, 'truncatablePrimes(11) should return 748317.');"
}
],
"solutions": [],
@@ -2062,7 +2223,8 @@
"tests": [
{
"text": "pandigitalMultiples() should return 932718654.",
- "testString": "assert.strictEqual(pandigitalMultiples(), 932718654, 'pandigitalMultiples() should return 932718654.');"
+ "testString":
+ "assert.strictEqual(pandigitalMultiples(), 932718654, 'pandigitalMultiples() should return 932718654.');"
}
],
"solutions": [
@@ -2103,19 +2265,23 @@
"tests": [
{
"text": "intRightTriangles(500) should return 420.",
- "testString": "assert(intRightTriangles(500) == 420, 'intRightTriangles(500) should return 420.');"
+ "testString":
+ "assert(intRightTriangles(500) == 420, 'intRightTriangles(500) should return 420.');"
},
{
"text": "intRightTriangles(800) should return 420.",
- "testString": "assert(intRightTriangles(800) == 420, 'intRightTriangles(800) should return 420.');"
+ "testString":
+ "assert(intRightTriangles(800) == 420, 'intRightTriangles(800) should return 420.');"
},
{
"text": "intRightTriangles(900) should return 840.",
- "testString": "assert(intRightTriangles(900) == 840, 'intRightTriangles(900) should return 840.');"
+ "testString":
+ "assert(intRightTriangles(900) == 840, 'intRightTriangles(900) should return 840.');"
},
{
"text": "intRightTriangles(1000) should return 840.",
- "testString": "assert(intRightTriangles(1000) == 840, 'intRightTriangles(1000) should return 840.');"
+ "testString":
+ "assert(intRightTriangles(1000) == 840, 'intRightTriangles(1000) should return 840.');"
}
],
"solutions": [],
@@ -2150,15 +2316,19 @@
"tests": [
{
"text": "champernownesConstant(100) should return 5.",
- "testString": "assert.strictEqual(champernownesConstant(100), 5, 'champernownesConstant(100) should return 5.');"
+ "testString":
+ "assert.strictEqual(champernownesConstant(100), 5, 'champernownesConstant(100) should return 5.');"
},
{
"text": "champernownesConstant(1000) should return 15.",
- "testString": "assert.strictEqual(champernownesConstant(1000), 15, 'champernownesConstant(1000) should return 15.');"
+ "testString":
+ "assert.strictEqual(champernownesConstant(1000), 15, 'champernownesConstant(1000) should return 15.');"
},
{
- "text": "champernownesConstant(1000000) should return 210.",
- "testString": "assert.strictEqual(champernownesConstant(1000000), 210, 'champernownesConstant(1000000) should return 210.');"
+ "text":
+ "champernownesConstant(1000000) should return 210.",
+ "testString":
+ "assert.strictEqual(champernownesConstant(1000000), 210, 'champernownesConstant(1000000) should return 210.');"
}
],
"solutions": [
@@ -2197,11 +2367,13 @@
"tests": [
{
"text": "pandigitalPrime(4) should return 4231.",
- "testString": "assert(pandigitalPrime(4) == 4231, 'pandigitalPrime(4) should return 4231.');"
+ "testString":
+ "assert(pandigitalPrime(4) == 4231, 'pandigitalPrime(4) should return 4231.');"
},
{
"text": "pandigitalPrime(7) should return 7652413.",
- "testString": "assert(pandigitalPrime(7) == 7652413, 'pandigitalPrime(7) should return 7652413.');"
+ "testString":
+ "assert(pandigitalPrime(7) == 7652413, 'pandigitalPrime(7) should return 7652413.');"
}
],
"solutions": [
@@ -2237,19 +2409,23 @@
"tests": [
{
"text": "codedTriangleNumbers(1400) should return 129.",
- "testString": "assert(codedTriangleNumbers(1400) == 129, 'codedTriangleNumbers(1400) should return 129.');"
+ "testString":
+ "assert(codedTriangleNumbers(1400) == 129, 'codedTriangleNumbers(1400) should return 129.');"
},
{
"text": "codedTriangleNumbers(1500) should return 137.",
- "testString": "assert(codedTriangleNumbers(1500) == 137, 'codedTriangleNumbers(1500) should return 137.');"
+ "testString":
+ "assert(codedTriangleNumbers(1500) == 137, 'codedTriangleNumbers(1500) should return 137.');"
},
{
"text": "codedTriangleNumbers(1600) should return 141.",
- "testString": "assert(codedTriangleNumbers(1600) == 141, 'codedTriangleNumbers(1600) should return 141.');"
+ "testString":
+ "assert(codedTriangleNumbers(1600) == 141, 'codedTriangleNumbers(1600) should return 141.');"
},
{
"text": "codedTriangleNumbers(1786) should return 162.",
- "testString": "assert(codedTriangleNumbers(1786) == 162, 'codedTriangleNumbers(1786) should return 162.');"
+ "testString":
+ "assert(codedTriangleNumbers(1786) == 162, 'codedTriangleNumbers(1786) should return 162.');"
}
],
"solutions": [],
@@ -2287,8 +2463,10 @@
"title": "Problem 43: Sub-string divisibility",
"tests": [
{
- "text": "substringDivisibility() should return [ 1430952867, 1460357289, 1406357289, 4130952867, 4160357289, 4106357289 ].",
- "testString": "assert.deepEqual(substringDivisibility(), [ 1430952867, 1460357289, 1406357289, 4130952867, 4160357289, 4106357289 ], 'substringDivisibility() should return [ 1430952867, 1460357289, 1406357289, 4130952867, 4160357289, 4106357289 ].');"
+ "text":
+ "substringDivisibility() should return [ 1430952867, 1460357289, 1406357289, 4130952867, 4160357289, 4106357289 ].",
+ "testString":
+ "assert.deepEqual(substringDivisibility(), [ 1430952867, 1460357289, 1406357289, 4130952867, 4160357289, 4106357289 ], 'substringDivisibility() should return [ 1430952867, 1460357289, 1406357289, 4130952867, 4160357289, 4106357289 ].');"
}
],
"solutions": [],
@@ -2330,7 +2508,8 @@
"tests": [
{
"text": "pentagonNumbers() should return 5482660.",
- "testString": "assert.strictEqual(pentagonNumbers(), 5482660, 'pentagonNumbers() should return 5482660.');"
+ "testString":
+ "assert.strictEqual(pentagonNumbers(), 5482660, 'pentagonNumbers() should return 5482660.');"
}
],
"solutions": [
@@ -2368,7 +2547,8 @@
"tests": [
{
"text": "triPentaHexa(40756) should return 1533776805.",
- "testString": "assert.strictEqual(triPentaHexa(40756), 1533776805, 'triPentaHexa(40756) should return 1533776805.');"
+ "testString":
+ "assert.strictEqual(triPentaHexa(40756), 1533776805, 'triPentaHexa(40756) should return 1533776805.');"
}
],
"solutions": [
@@ -2408,7 +2588,8 @@
"tests": [
{
"text": "goldbachsOtherConjecture() should return 5777.",
- "testString": "assert.strictEqual(goldbachsOtherConjecture(), 5777, 'goldbachsOtherConjecture() should return 5777.');"
+ "testString":
+ "assert.strictEqual(goldbachsOtherConjecture(), 5777, 'goldbachsOtherConjecture() should return 5777.');"
}
],
"solutions": [
@@ -2451,15 +2632,19 @@
"tests": [
{
"text": "distinctPrimeFactors(2, 2) should return 14.",
- "testString": "assert.strictEqual(distinctPrimeFactors(2, 2), 14, 'distinctPrimeFactors(2, 2) should return 14.');"
+ "testString":
+ "assert.strictEqual(distinctPrimeFactors(2, 2), 14, 'distinctPrimeFactors(2, 2) should return 14.');"
},
{
"text": "distinctPrimeFactors(3, 3) should return 644.",
- "testString": "assert.strictEqual(distinctPrimeFactors(3, 3), 644, 'distinctPrimeFactors(3, 3) should return 644.');"
+ "testString":
+ "assert.strictEqual(distinctPrimeFactors(3, 3), 644, 'distinctPrimeFactors(3, 3) should return 644.');"
},
{
- "text": "distinctPrimeFactors(4, 4) should return 134043.",
- "testString": "assert.strictEqual(distinctPrimeFactors(4, 4), 134043, 'distinctPrimeFactors(4, 4) should return 134043.');"
+ "text":
+ "distinctPrimeFactors(4, 4) should return 134043.",
+ "testString":
+ "assert.strictEqual(distinctPrimeFactors(4, 4), 134043, 'distinctPrimeFactors(4, 4) should return 134043.');"
}
],
"solutions": [
@@ -2501,19 +2686,23 @@
"tests": [
{
"text": "selfPowers(10, 3) should return 317.",
- "testString": "assert.strictEqual(selfPowers(10, 3), 317, 'selfPowers(10, 3) should return 317.');"
+ "testString":
+ "assert.strictEqual(selfPowers(10, 3), 317, 'selfPowers(10, 3) should return 317.');"
},
{
"text": "selfPowers(150, 6) should return 29045.",
- "testString": "assert.strictEqual(selfPowers(150, 6), 29045, 'selfPowers(150, 6) should return 29045.');"
+ "testString":
+ "assert.strictEqual(selfPowers(150, 6), 29045, 'selfPowers(150, 6) should return 29045.');"
},
{
"text": "selfPowers(673, 7) should return 2473989.",
- "testString": "assert.strictEqual(selfPowers(673, 7), 2473989, 'selfPowers(673, 7) should return 2473989.');"
+ "testString":
+ "assert.strictEqual(selfPowers(673, 7), 2473989, 'selfPowers(673, 7) should return 2473989.');"
},
{
"text": "selfPowers(1000, 10) should return 9110846700.",
- "testString": "assert.strictEqual(selfPowers(1000, 10), 9110846700, 'selfPowers(1000, 10) should return 9110846700.');"
+ "testString":
+ "assert.strictEqual(selfPowers(1000, 10), 9110846700, 'selfPowers(1000, 10) should return 9110846700.');"
}
],
"solutions": [
@@ -2548,8 +2737,10 @@
"title": "Problem 49: Prime permutations",
"tests": [
{
- "text": "primePermutations() should return 296962999629.",
- "testString": "assert.strictEqual(primePermutations(), 296962999629, 'primePermutations() should return 296962999629.');"
+ "text":
+ "primePermutations() should return 296962999629.",
+ "testString":
+ "assert.strictEqual(primePermutations(), 296962999629, 'primePermutations() should return 296962999629.');"
}
],
"solutions": [
@@ -2586,11 +2777,14 @@
"tests": [
{
"text": "consecutivePrimeSum(1000) should return 953.",
- "testString": "assert.strictEqual(consecutivePrimeSum(1000), 953, 'consecutivePrimeSum(1000) should return 953.');"
+ "testString":
+ "assert.strictEqual(consecutivePrimeSum(1000), 953, 'consecutivePrimeSum(1000) should return 953.');"
},
{
- "text": "consecutivePrimeSum(1000000) should return 997651.",
- "testString": "assert.strictEqual(consecutivePrimeSum(1000000), 997651, 'consecutivePrimeSum(1000000) should return 997651.');"
+ "text":
+ "consecutivePrimeSum(1000000) should return 997651.",
+ "testString":
+ "assert.strictEqual(consecutivePrimeSum(1000000), 997651, 'consecutivePrimeSum(1000000) should return 997651.');"
}
],
"solutions": [
@@ -2629,7 +2823,8 @@
"tests": [
{
"text": "euler51() should return 121313.",
- "testString": "assert.strictEqual(euler51(), 121313, 'euler51() should return 121313.');"
+ "testString":
+ "assert.strictEqual(euler51(), 121313, 'euler51() should return 121313.');"
}
],
"solutions": [],
@@ -2663,11 +2858,14 @@
"title": "Problem 52: Permuted multiples",
"tests": [
{
- "text": "euler52() should return 142857.",
- "testString": "assert.strictEqual(euler52(), 142857, 'euler52() should return 142857.');"
+ "text": "permutedMultiples() should return 142857.",
+ "testString":
+ "assert.strictEqual(permutedMultiples(), 142857, 'permutedMultiples() should return 142857.');"
}
],
- "solutions": [],
+ "solutions": [
+ "function permutedMultiples() {\n const isPermutation = (a, b) => \n a.length !== b.length \n ? false\n : a.split('').sort().join() === b.split('').sort().join();\n \n\n let start = 1;\n let found = false;\n let result = 0;\n\n while (!found) {\n start *= 10;\n for (let i = start; i < start * 10 / 6; i++) {\n found = true;\n for (let j = 2; j <= 6; j++) {\n if (!isPermutation(i + '', j * i + '')) {\n found = false;\n break;\n }\n }\n if (found) {\n result = i;\n break;\n }\n }\n }\n\n return result;\n}"
+ ],
"translations": {},
"description": [
"It can be seen that the number, 125874, and its double, 251748, contain exactly the same digits, but in a different order.",
@@ -2679,12 +2877,12 @@
"ext": "js",
"name": "index",
"contents": [
- "function euler52() {",
+ "function permutedMultiples() {",
" // Good luck!",
" return true;",
"}",
"",
- "euler52();"
+ "permutedMultiples();"
],
"head": [],
"tail": []
@@ -2698,7 +2896,8 @@
"tests": [
{
"text": "euler53() should return 4075.",
- "testString": "assert.strictEqual(euler53(), 4075, 'euler53() should return 4075.');"
+ "testString":
+ "assert.strictEqual(euler53(), 4075, 'euler53() should return 4075.');"
}
],
"solutions": [],
@@ -2741,7 +2940,8 @@
"tests": [
{
"text": "euler54() should return 376.",
- "testString": "assert.strictEqual(euler54(), 376, 'euler54() should return 376.');"
+ "testString":
+ "assert.strictEqual(euler54(), 376, 'euler54() should return 376.');"
}
],
"solutions": [],
@@ -2797,7 +2997,8 @@
"tests": [
{
"text": "euler55() should return 249.",
- "testString": "assert.strictEqual(euler55(), 249, 'euler55() should return 249.');"
+ "testString":
+ "assert.strictEqual(euler55(), 249, 'euler55() should return 249.');"
}
],
"solutions": [],
@@ -2839,7 +3040,8 @@
"tests": [
{
"text": "euler56() should return 972.",
- "testString": "assert.strictEqual(euler56(), 972, 'euler56() should return 972.');"
+ "testString":
+ "assert.strictEqual(euler56(), 972, 'euler56() should return 972.');"
}
],
"solutions": [],
@@ -2873,7 +3075,8 @@
"tests": [
{
"text": "euler57() should return 153.",
- "testString": "assert.strictEqual(euler57(), 153, 'euler57() should return 153.');"
+ "testString":
+ "assert.strictEqual(euler57(), 153, 'euler57() should return 153.');"
}
],
"solutions": [],
@@ -2914,7 +3117,8 @@
"tests": [
{
"text": "euler58() should return 26241.",
- "testString": "assert.strictEqual(euler58(), 26241, 'euler58() should return 26241.');"
+ "testString":
+ "assert.strictEqual(euler58(), 26241, 'euler58() should return 26241.');"
}
],
"solutions": [],
@@ -2955,7 +3159,8 @@
"tests": [
{
"text": "euler59() should return 107359.",
- "testString": "assert.strictEqual(euler59(), 107359, 'euler59() should return 107359.');"
+ "testString":
+ "assert.strictEqual(euler59(), 107359, 'euler59() should return 107359.');"
}
],
"solutions": [],
@@ -2992,7 +3197,8 @@
"tests": [
{
"text": "euler60() should return 26033.",
- "testString": "assert.strictEqual(euler60(), 26033, 'euler60() should return 26033.');"
+ "testString":
+ "assert.strictEqual(euler60(), 26033, 'euler60() should return 26033.');"
}
],
"solutions": [],
@@ -3026,7 +3232,8 @@
"tests": [
{
"text": "euler61() should return 28684.",
- "testString": "assert.strictEqual(euler61(), 28684, 'euler61() should return 28684.');"
+ "testString":
+ "assert.strictEqual(euler61(), 28684, 'euler61() should return 28684.');"
}
],
"solutions": [],
@@ -3094,7 +3301,8 @@
"tests": [
{
"text": "euler62() should return 127035954683.",
- "testString": "assert.strictEqual(euler62(), 127035954683, 'euler62() should return 127035954683.');"
+ "testString":
+ "assert.strictEqual(euler62(), 127035954683, 'euler62() should return 127035954683.');"
}
],
"solutions": [],
@@ -3128,7 +3336,8 @@
"tests": [
{
"text": "euler63() should return 49.",
- "testString": "assert.strictEqual(euler63(), 49, 'euler63() should return 49.');"
+ "testString":
+ "assert.strictEqual(euler63(), 49, 'euler63() should return 49.');"
}
],
"solutions": [],
@@ -3162,7 +3371,8 @@
"tests": [
{
"text": "euler64() should return 1322.",
- "testString": "assert.strictEqual(euler64(), 1322, 'euler64() should return 1322.');"
+ "testString":
+ "assert.strictEqual(euler64(), 1322, 'euler64() should return 1322.');"
}
],
"solutions": [],
@@ -3318,7 +3528,8 @@
"tests": [
{
"text": "euler65() should return 272.",
- "testString": "assert.strictEqual(euler65(), 272, 'euler65() should return 272.');"
+ "testString":
+ "assert.strictEqual(euler65(), 272, 'euler65() should return 272.');"
}
],
"solutions": [],
@@ -3440,7 +3651,8 @@
"tests": [
{
"text": "euler66() should return 661.",
- "testString": "assert.strictEqual(euler66(), 661, 'euler66() should return 661.');"
+ "testString":
+ "assert.strictEqual(euler66(), 661, 'euler66() should return 661.');"
}
],
"solutions": [],
@@ -3483,7 +3695,8 @@
"tests": [
{
"text": "euler67() should return 7273.",
- "testString": "assert.strictEqual(euler67(), 7273, 'euler67() should return 7273.');"
+ "testString":
+ "assert.strictEqual(euler67(), 7273, 'euler67() should return 7273.');"
}
],
"solutions": [],
@@ -3522,7 +3735,8 @@
"tests": [
{
"text": "euler68() should return 6531031914842725.",
- "testString": "assert.strictEqual(euler68(), 6531031914842725, 'euler68() should return 6531031914842725.');"
+ "testString":
+ "assert.strictEqual(euler68(), 6531031914842725, 'euler68() should return 6531031914842725.');"
}
],
"solutions": [],
@@ -3572,7 +3786,8 @@
"tests": [
{
"text": "euler69() should return 510510.",
- "testString": "assert.strictEqual(euler69(), 510510, 'euler69() should return 510510.');"
+ "testString":
+ "assert.strictEqual(euler69(), 510510, 'euler69() should return 510510.');"
}
],
"solutions": [],
@@ -3649,7 +3864,8 @@
"tests": [
{
"text": "euler70() should return 8319823.",
- "testString": "assert.strictEqual(euler70(), 8319823, 'euler70() should return 8319823.');"
+ "testString":
+ "assert.strictEqual(euler70(), 8319823, 'euler70() should return 8319823.');"
}
],
"solutions": [],
@@ -3684,7 +3900,8 @@
"tests": [
{
"text": "euler71() should return 428570.",
- "testString": "assert.strictEqual(euler71(), 428570, 'euler71() should return 428570.');"
+ "testString":
+ "assert.strictEqual(euler71(), 428570, 'euler71() should return 428570.');"
}
],
"solutions": [],
@@ -3721,7 +3938,8 @@
"tests": [
{
"text": "euler72() should return 303963552391.",
- "testString": "assert.strictEqual(euler72(), 303963552391, 'euler72() should return 303963552391.');"
+ "testString":
+ "assert.strictEqual(euler72(), 303963552391, 'euler72() should return 303963552391.');"
}
],
"solutions": [],
@@ -3758,7 +3976,8 @@
"tests": [
{
"text": "euler73() should return 7295372.",
- "testString": "assert.strictEqual(euler73(), 7295372, 'euler73() should return 7295372.');"
+ "testString":
+ "assert.strictEqual(euler73(), 7295372, 'euler73() should return 7295372.');"
}
],
"solutions": [],
@@ -3795,7 +4014,8 @@
"tests": [
{
"text": "euler74() should return 402.",
- "testString": "assert.strictEqual(euler74(), 402, 'euler74() should return 402.');"
+ "testString":
+ "assert.strictEqual(euler74(), 402, 'euler74() should return 402.');"
}
],
"solutions": [],
@@ -3839,7 +4059,8 @@
"tests": [
{
"text": "euler75() should return 161667.",
- "testString": "assert.strictEqual(euler75(), 161667, 'euler75() should return 161667.');"
+ "testString":
+ "assert.strictEqual(euler75(), 161667, 'euler75() should return 161667.');"
}
],
"solutions": [],
@@ -3876,7 +4097,8 @@
"tests": [
{
"text": "euler76() should return 190569291.",
- "testString": "assert.strictEqual(euler76(), 190569291, 'euler76() should return 190569291.');"
+ "testString":
+ "assert.strictEqual(euler76(), 190569291, 'euler76() should return 190569291.');"
}
],
"solutions": [],
@@ -3916,7 +4138,8 @@
"tests": [
{
"text": "euler77() should return 71.",
- "testString": "assert.strictEqual(euler77(), 71, 'euler77() should return 71.');"
+ "testString":
+ "assert.strictEqual(euler77(), 71, 'euler77() should return 71.');"
}
],
"solutions": [],
@@ -3955,7 +4178,8 @@
"tests": [
{
"text": "euler78() should return 55374.",
- "testString": "assert.strictEqual(euler78(), 55374, 'euler78() should return 55374.');"
+ "testString":
+ "assert.strictEqual(euler78(), 55374, 'euler78() should return 55374.');"
}
],
"solutions": [],
@@ -3998,7 +4222,8 @@
"tests": [
{
"text": "euler79() should return 73162890.",
- "testString": "assert.strictEqual(euler79(), 73162890, 'euler79() should return 73162890.');"
+ "testString":
+ "assert.strictEqual(euler79(), 73162890, 'euler79() should return 73162890.');"
}
],
"solutions": [],
@@ -4033,7 +4258,8 @@
"tests": [
{
"text": "euler80() should return 40886.",
- "testString": "assert.strictEqual(euler80(), 40886, 'euler80() should return 40886.');"
+ "testString":
+ "assert.strictEqual(euler80(), 40886, 'euler80() should return 40886.');"
}
],
"solutions": [],
@@ -4068,7 +4294,8 @@
"tests": [
{
"text": "euler81() should return 427337.",
- "testString": "assert.strictEqual(euler81(), 427337, 'euler81() should return 427337.');"
+ "testString":
+ "assert.strictEqual(euler81(), 427337, 'euler81() should return 427337.');"
}
],
"solutions": [],
@@ -4113,7 +4340,8 @@
"tests": [
{
"text": "euler82() should return 260324.",
- "testString": "assert.strictEqual(euler82(), 260324, 'euler82() should return 260324.');"
+ "testString":
+ "assert.strictEqual(euler82(), 260324, 'euler82() should return 260324.');"
}
],
"solutions": [],
@@ -4159,7 +4387,8 @@
"tests": [
{
"text": "euler83() should return 425185.",
- "testString": "assert.strictEqual(euler83(), 425185, 'euler83() should return 425185.');"
+ "testString":
+ "assert.strictEqual(euler83(), 425185, 'euler83() should return 425185.');"
}
],
"solutions": [],
@@ -4206,7 +4435,8 @@
"tests": [
{
"text": "euler84() should return 101524.",
- "testString": "assert.strictEqual(euler84(), 101524, 'euler84() should return 101524.');"
+ "testString":
+ "assert.strictEqual(euler84(), 101524, 'euler84() should return 101524.');"
}
],
"solutions": [],
@@ -4313,7 +4543,8 @@
"tests": [
{
"text": "euler85() should return 2772.",
- "testString": "assert.strictEqual(euler85(), 2772, 'euler85() should return 2772.');"
+ "testString":
+ "assert.strictEqual(euler85(), 2772, 'euler85() should return 2772.');"
}
],
"solutions": [],
@@ -4349,7 +4580,8 @@
"tests": [
{
"text": "euler86() should return 1818.",
- "testString": "assert.strictEqual(euler86(), 1818, 'euler86() should return 1818.');"
+ "testString":
+ "assert.strictEqual(euler86(), 1818, 'euler86() should return 1818.');"
}
],
"solutions": [],
@@ -4387,7 +4619,8 @@
"tests": [
{
"text": "euler87() should return 1097343.",
- "testString": "assert.strictEqual(euler87(), 1097343, 'euler87() should return 1097343.');"
+ "testString":
+ "assert.strictEqual(euler87(), 1097343, 'euler87() should return 1097343.');"
}
],
"solutions": [],
@@ -4425,7 +4658,8 @@
"tests": [
{
"text": "euler88() should return 7587457.",
- "testString": "assert.strictEqual(euler88(), 7587457, 'euler88() should return 7587457.');"
+ "testString":
+ "assert.strictEqual(euler88(), 7587457, 'euler88() should return 7587457.');"
}
],
"solutions": [],
@@ -4464,7 +4698,8 @@
"tests": [
{
"text": "euler89() should return 743.",
- "testString": "assert.strictEqual(euler89(), 743, 'euler89() should return 743.');"
+ "testString":
+ "assert.strictEqual(euler89(), 743, 'euler89() should return 743.');"
}
],
"solutions": [],
@@ -4508,7 +4743,8 @@
"tests": [
{
"text": "euler90() should return 1217.",
- "testString": "assert.strictEqual(euler90(), 1217, 'euler90() should return 1217.');"
+ "testString":
+ "assert.strictEqual(euler90(), 1217, 'euler90() should return 1217.');"
}
],
"solutions": [],
@@ -4561,7 +4797,8 @@
"tests": [
{
"text": "euler91() should return 14234.",
- "testString": "assert.strictEqual(euler91(), 14234, 'euler91() should return 14234.');"
+ "testString":
+ "assert.strictEqual(euler91(), 14234, 'euler91() should return 14234.');"
}
],
"solutions": [],
@@ -4604,7 +4841,8 @@
"tests": [
{
"text": "euler92() should return 8581146.",
- "testString": "assert.strictEqual(euler92(), 8581146, 'euler92() should return 8581146.');"
+ "testString":
+ "assert.strictEqual(euler92(), 8581146, 'euler92() should return 8581146.');"
}
],
"solutions": [],
@@ -4642,7 +4880,8 @@
"tests": [
{
"text": "euler93() should return 1258.",
- "testString": "assert.strictEqual(euler93(), 1258, 'euler93() should return 1258.');"
+ "testString":
+ "assert.strictEqual(euler93(), 1258, 'euler93() should return 1258.');"
}
],
"solutions": [],
@@ -4683,7 +4922,8 @@
"tests": [
{
"text": "euler94() should return 518408346.",
- "testString": "assert.strictEqual(euler94(), 518408346, 'euler94() should return 518408346.');"
+ "testString":
+ "assert.strictEqual(euler94(), 518408346, 'euler94() should return 518408346.');"
}
],
"solutions": [],
@@ -4718,7 +4958,8 @@
"tests": [
{
"text": "euler95() should return 14316.",
- "testString": "assert.strictEqual(euler95(), 14316, 'euler95() should return 14316.');"
+ "testString":
+ "assert.strictEqual(euler95(), 14316, 'euler95() should return 14316.');"
}
],
"solutions": [],
@@ -4756,7 +4997,8 @@
"tests": [
{
"text": "euler96() should return 24702.",
- "testString": "assert.strictEqual(euler96(), 24702, 'euler96() should return 24702.');"
+ "testString":
+ "assert.strictEqual(euler96(), 24702, 'euler96() should return 24702.');"
}
],
"solutions": [],
@@ -4817,7 +5059,8 @@
"tests": [
{
"text": "euler97() should return 8739992577.",
- "testString": "assert.strictEqual(euler97(), 8739992577, 'euler97() should return 8739992577.');"
+ "testString":
+ "assert.strictEqual(euler97(), 8739992577, 'euler97() should return 8739992577.');"
}
],
"solutions": [],
@@ -4852,7 +5095,8 @@
"tests": [
{
"text": "euler98() should return 18769.",
- "testString": "assert.strictEqual(euler98(), 18769, 'euler98() should return 18769.');"
+ "testString":
+ "assert.strictEqual(euler98(), 18769, 'euler98() should return 18769.');"
}
],
"solutions": [],
@@ -4888,7 +5132,8 @@
"tests": [
{
"text": "euler99() should return 709.",
- "testString": "assert.strictEqual(euler99(), 709, 'euler99() should return 709.');"
+ "testString":
+ "assert.strictEqual(euler99(), 709, 'euler99() should return 709.');"
}
],
"solutions": [],
@@ -4924,7 +5169,8 @@
"tests": [
{
"text": "euler100() should return 756872327473.",
- "testString": "assert.strictEqual(euler100(), 756872327473, 'euler100() should return 756872327473.');"
+ "testString":
+ "assert.strictEqual(euler100(), 756872327473, 'euler100() should return 756872327473.');"
}
],
"solutions": [],
@@ -4959,7 +5205,8 @@
"tests": [
{
"text": "euler101() should return 37076114526.",
- "testString": "assert.strictEqual(euler101(), 37076114526, 'euler101() should return 37076114526.');"
+ "testString":
+ "assert.strictEqual(euler101(), 37076114526, 'euler101() should return 37076114526.');"
}
],
"solutions": [],
@@ -5012,7 +5259,8 @@
"tests": [
{
"text": "euler102() should return 228.",
- "testString": "assert.strictEqual(euler102(), 228, 'euler102() should return 228.');"
+ "testString":
+ "assert.strictEqual(euler102(), 228, 'euler102() should return 228.');"
}
],
"solutions": [],
@@ -5051,7 +5299,8 @@
"tests": [
{
"text": "euler103() should return 20313839404245.",
- "testString": "assert.strictEqual(euler103(), 20313839404245, 'euler103() should return 20313839404245.');"
+ "testString":
+ "assert.strictEqual(euler103(), 20313839404245, 'euler103() should return 20313839404245.');"
}
],
"solutions": [],
@@ -5092,7 +5341,8 @@
"tests": [
{
"text": "euler104() should return 329468.",
- "testString": "assert.strictEqual(euler104(), 329468, 'euler104() should return 329468.');"
+ "testString":
+ "assert.strictEqual(euler104(), 329468, 'euler104() should return 329468.');"
}
],
"solutions": [],
@@ -5128,7 +5378,8 @@
"tests": [
{
"text": "euler105() should return 73702.",
- "testString": "assert.strictEqual(euler105(), 73702, 'euler105() should return 73702.');"
+ "testString":
+ "assert.strictEqual(euler105(), 73702, 'euler105() should return 73702.');"
}
],
"solutions": [],
@@ -5166,7 +5417,8 @@
"tests": [
{
"text": "euler106() should return 21384.",
- "testString": "assert.strictEqual(euler106(), 21384, 'euler106() should return 21384.');"
+ "testString":
+ "assert.strictEqual(euler106(), 21384, 'euler106() should return 21384.');"
}
],
"solutions": [],
@@ -5205,7 +5457,8 @@
"tests": [
{
"text": "euler107() should return 259679.",
- "testString": "assert.strictEqual(euler107(), 259679, 'euler107() should return 259679.');"
+ "testString":
+ "assert.strictEqual(euler107(), 259679, 'euler107() should return 259679.');"
}
],
"solutions": [],
@@ -5253,7 +5506,8 @@
"tests": [
{
"text": "diophantineOne() should return 180180.",
- "testString": "assert.strictEqual(diophantineOne(), 180180, 'diophantineOne() should return 180180.');"
+ "testString":
+ "assert.strictEqual(diophantineOne(), 180180, 'diophantineOne() should return 180180.');"
}
],
"solutions": [],
@@ -5290,7 +5544,8 @@
"tests": [
{
"text": "euler109() should return 38182.",
- "testString": "assert.strictEqual(euler109(), 38182, 'euler109() should return 38182.');"
+ "testString":
+ "assert.strictEqual(euler109(), 38182, 'euler109() should return 38182.');"
}
],
"solutions": [],
@@ -5369,7 +5624,8 @@
"tests": [
{
"text": "diophantineTwo should return 9350130049860600.",
- "testString": "assert.strictEqual(diophantineTwo(), 9350130049860600, 'diophantineTwo() should return 9350130049860600.');"
+ "testString":
+ "assert.strictEqual(diophantineTwo(), 9350130049860600, 'diophantineTwo() should return 9350130049860600.');"
}
],
"solutions": [],
@@ -5405,7 +5661,8 @@
"tests": [
{
"text": "euler111() should return 612407567715.",
- "testString": "assert.strictEqual(euler111(), 612407567715, 'euler111() should return 612407567715.');"
+ "testString":
+ "assert.strictEqual(euler111(), 612407567715, 'euler111() should return 612407567715.');"
}
],
"solutions": [],
@@ -5490,7 +5747,8 @@
"tests": [
{
"text": "euler112() should return 1587000.",
- "testString": "assert.strictEqual(euler112(), 1587000, 'euler112() should return 1587000.');"
+ "testString":
+ "assert.strictEqual(euler112(), 1587000, 'euler112() should return 1587000.');"
}
],
"solutions": [],
@@ -5528,7 +5786,8 @@
"tests": [
{
"text": "euler113() should return 51161058134250.",
- "testString": "assert.strictEqual(euler113(), 51161058134250, 'euler113() should return 51161058134250.');"
+ "testString":
+ "assert.strictEqual(euler113(), 51161058134250, 'euler113() should return 51161058134250.');"
}
],
"solutions": [],
@@ -5565,7 +5824,8 @@
"tests": [
{
"text": "euler114() should return 16475640049.",
- "testString": "assert.strictEqual(euler114(), 16475640049, 'euler114() should return 16475640049.');"
+ "testString":
+ "assert.strictEqual(euler114(), 16475640049, 'euler114() should return 16475640049.');"
}
],
"solutions": [],
@@ -5701,7 +5961,8 @@
"tests": [
{
"text": "euler115() should return 168.",
- "testString": "assert.strictEqual(euler115(), 168, 'euler115() should return 168.');"
+ "testString":
+ "assert.strictEqual(euler115(), 168, 'euler115() should return 168.');"
}
],
"solutions": [],
@@ -5740,7 +6001,8 @@
"tests": [
{
"text": "euler116() should return 20492570929.",
- "testString": "assert.strictEqual(euler116(), 20492570929, 'euler116() should return 20492570929.');"
+ "testString":
+ "assert.strictEqual(euler116(), 20492570929, 'euler116() should return 20492570929.');"
}
],
"solutions": [],
@@ -5846,7 +6108,8 @@
"tests": [
{
"text": "euler117() should return 100808458960497.",
- "testString": "assert.strictEqual(euler117(), 100808458960497, 'euler117() should return 100808458960497.');"
+ "testString":
+ "assert.strictEqual(euler117(), 100808458960497, 'euler117() should return 100808458960497.');"
}
],
"solutions": [],
@@ -5960,7 +6223,8 @@
"tests": [
{
"text": "euler118() should return 44680.",
- "testString": "assert.strictEqual(euler118(), 44680, 'euler118() should return 44680.');"
+ "testString":
+ "assert.strictEqual(euler118(), 44680, 'euler118() should return 44680.');"
}
],
"solutions": [],
@@ -5994,7 +6258,8 @@
"tests": [
{
"text": "euler119() should return 248155780267521.",
- "testString": "assert.strictEqual(euler119(), 248155780267521, 'euler119() should return 248155780267521.');"
+ "testString":
+ "assert.strictEqual(euler119(), 248155780267521, 'euler119() should return 248155780267521.');"
}
],
"solutions": [],
@@ -6030,7 +6295,8 @@
"tests": [
{
"text": "euler120() should return 333082500.",
- "testString": "assert.strictEqual(euler120(), 333082500, 'euler120() should return 333082500.');"
+ "testString":
+ "assert.strictEqual(euler120(), 333082500, 'euler120() should return 333082500.');"
}
],
"solutions": [],
@@ -6065,7 +6331,8 @@
"tests": [
{
"text": "euler121() should return 2269.",
- "testString": "assert.strictEqual(euler121(), 2269, 'euler121() should return 2269.');"
+ "testString":
+ "assert.strictEqual(euler121(), 2269, 'euler121() should return 2269.');"
}
],
"solutions": [],
@@ -6101,7 +6368,8 @@
"tests": [
{
"text": "euler122() should return 1582.",
- "testString": "assert.strictEqual(euler122(), 1582, 'euler122() should return 1582.');"
+ "testString":
+ "assert.strictEqual(euler122(), 1582, 'euler122() should return 1582.');"
}
],
"solutions": [],
@@ -6141,7 +6409,8 @@
"tests": [
{
"text": "euler123() should return 21035.",
- "testString": "assert.strictEqual(euler123(), 21035, 'euler123() should return 21035.');"
+ "testString":
+ "assert.strictEqual(euler123(), 21035, 'euler123() should return 21035.');"
}
],
"solutions": [],
@@ -6177,7 +6446,8 @@
"tests": [
{
"text": "euler124() should return 21417.",
- "testString": "assert.strictEqual(euler124(), 21417, 'euler124() should return 21417.');"
+ "testString":
+ "assert.strictEqual(euler124(), 21417, 'euler124() should return 21417.');"
}
],
"solutions": [],
@@ -6252,7 +6522,8 @@
"tests": [
{
"text": "euler125() should return 2906969179.",
- "testString": "assert.strictEqual(euler125(), 2906969179, 'euler125() should return 2906969179.');"
+ "testString":
+ "assert.strictEqual(euler125(), 2906969179, 'euler125() should return 2906969179.');"
}
],
"solutions": [],
@@ -6287,7 +6558,8 @@
"tests": [
{
"text": "euler126() should return 18522.",
- "testString": "assert.strictEqual(euler126(), 18522, 'euler126() should return 18522.');"
+ "testString":
+ "assert.strictEqual(euler126(), 18522, 'euler126() should return 18522.');"
}
],
"solutions": [],
@@ -6327,7 +6599,8 @@
"tests": [
{
"text": "euler127() should return 18407904.",
- "testString": "assert.strictEqual(euler127(), 18407904, 'euler127() should return 18407904.');"
+ "testString":
+ "assert.strictEqual(euler127(), 18407904, 'euler127() should return 18407904.');"
}
],
"solutions": [],
@@ -6372,7 +6645,8 @@
"tests": [
{
"text": "euler128() should return 14516824220.",
- "testString": "assert.strictEqual(euler128(), 14516824220, 'euler128() should return 14516824220.');"
+ "testString":
+ "assert.strictEqual(euler128(), 14516824220, 'euler128() should return 14516824220.');"
}
],
"solutions": [],
@@ -6414,7 +6688,8 @@
"tests": [
{
"text": "euler129() should return 1000023.",
- "testString": "assert.strictEqual(euler129(), 1000023, 'euler129() should return 1000023.');"
+ "testString":
+ "assert.strictEqual(euler129(), 1000023, 'euler129() should return 1000023.');"
}
],
"solutions": [],
@@ -6450,7 +6725,8 @@
"tests": [
{
"text": "euler130() should return 149253.",
- "testString": "assert.strictEqual(euler130(), 149253, 'euler130() should return 149253.');"
+ "testString":
+ "assert.strictEqual(euler130(), 149253, 'euler130() should return 149253.');"
}
],
"solutions": [],
@@ -6487,7 +6763,8 @@
"tests": [
{
"text": "euler131() should return 173.",
- "testString": "assert.strictEqual(euler131(), 173, 'euler131() should return 173.');"
+ "testString":
+ "assert.strictEqual(euler131(), 173, 'euler131() should return 173.');"
}
],
"solutions": [],
@@ -6523,7 +6800,8 @@
"tests": [
{
"text": "euler132() should return 843296.",
- "testString": "assert.strictEqual(euler132(), 843296, 'euler132() should return 843296.');"
+ "testString":
+ "assert.strictEqual(euler132(), 843296, 'euler132() should return 843296.');"
}
],
"solutions": [],
@@ -6558,7 +6836,8 @@
"tests": [
{
"text": "euler133() should return 453647705.",
- "testString": "assert.strictEqual(euler133(), 453647705, 'euler133() should return 453647705.');"
+ "testString":
+ "assert.strictEqual(euler133(), 453647705, 'euler133() should return 453647705.');"
}
],
"solutions": [],
@@ -6594,7 +6873,8 @@
"tests": [
{
"text": "euler134() should return 18613426663617120.",
- "testString": "assert.strictEqual(euler134(), 18613426663617120, 'euler134() should return 18613426663617120.');"
+ "testString":
+ "assert.strictEqual(euler134(), 18613426663617120, 'euler134() should return 18613426663617120.');"
}
],
"solutions": [],
@@ -6629,7 +6909,8 @@
"tests": [
{
"text": "euler135() should return 4989.",
- "testString": "assert.strictEqual(euler135(), 4989, 'euler135() should return 4989.');"
+ "testString":
+ "assert.strictEqual(euler135(), 4989, 'euler135() should return 4989.');"
}
],
"solutions": [],
@@ -6665,7 +6946,8 @@
"tests": [
{
"text": "euler136() should return 2544559.",
- "testString": "assert.strictEqual(euler136(), 2544559, 'euler136() should return 2544559.');"
+ "testString":
+ "assert.strictEqual(euler136(), 2544559, 'euler136() should return 2544559.');"
}
],
"solutions": [],
@@ -6701,7 +6983,8 @@
"tests": [
{
"text": "euler137() should return 1120149658760.",
- "testString": "assert.strictEqual(euler137(), 1120149658760, 'euler137() should return 1120149658760.');"
+ "testString":
+ "assert.strictEqual(euler137(), 1120149658760, 'euler137() should return 1120149658760.');"
}
],
"solutions": [],
@@ -6755,7 +7038,8 @@
"tests": [
{
"text": "euler138() should return 1118049290473932.",
- "testString": "assert.strictEqual(euler138(), 1118049290473932, 'euler138() should return 1118049290473932.');"
+ "testString":
+ "assert.strictEqual(euler138(), 1118049290473932, 'euler138() should return 1118049290473932.');"
}
],
"solutions": [],
@@ -6793,7 +7077,8 @@
"tests": [
{
"text": "euler139() should return 10057761.",
- "testString": "assert.strictEqual(euler139(), 10057761, 'euler139() should return 10057761.');"
+ "testString":
+ "assert.strictEqual(euler139(), 10057761, 'euler139() should return 10057761.');"
}
],
"solutions": [],
@@ -6831,7 +7116,8 @@
"tests": [
{
"text": "euler140() should return 5673835352990.",
- "testString": "assert.strictEqual(euler140(), 5673835352990, 'euler140() should return 5673835352990.');"
+ "testString":
+ "assert.strictEqual(euler140(), 5673835352990, 'euler140() should return 5673835352990.');"
}
],
"solutions": [],
@@ -6872,11 +7158,13 @@
{
"id": "5900f3f91000cf542c50ff0b",
"challengeType": 5,
- "title": "Problem 141: Investigating progressive numbers, n, which are also square",
+ "title":
+ "Problem 141: Investigating progressive numbers, n, which are also square",
"tests": [
{
"text": "euler141() should return 878454337159.",
- "testString": "assert.strictEqual(euler141(), 878454337159, 'euler141() should return 878454337159.');"
+ "testString":
+ "assert.strictEqual(euler141(), 878454337159, 'euler141() should return 878454337159.');"
}
],
"solutions": [],
@@ -6913,7 +7201,8 @@
"tests": [
{
"text": "euler142() should return 1006193.",
- "testString": "assert.strictEqual(euler142(), 1006193, 'euler142() should return 1006193.');"
+ "testString":
+ "assert.strictEqual(euler142(), 1006193, 'euler142() should return 1006193.');"
}
],
"solutions": [],
@@ -6946,7 +7235,8 @@
"tests": [
{
"text": "euler143() should return 30758397.",
- "testString": "assert.strictEqual(euler143(), 30758397, 'euler143() should return 30758397.');"
+ "testString":
+ "assert.strictEqual(euler143(), 30758397, 'euler143() should return 30758397.');"
}
],
"solutions": [],
@@ -6980,11 +7270,13 @@
{
"id": "5900f3fc1000cf542c50ff0f",
"challengeType": 5,
- "title": "Problem 144: Investigating multiple reflections of a laser beam",
+ "title":
+ "Problem 144: Investigating multiple reflections of a laser beam",
"tests": [
{
"text": "euler144() should return 354.",
- "testString": "assert.strictEqual(euler144(), 354, 'euler144() should return 354.');"
+ "testString":
+ "assert.strictEqual(euler144(), 354, 'euler144() should return 354.');"
}
],
"solutions": [],
@@ -7022,11 +7314,13 @@
{
"id": "5900f3fd1000cf542c50ff10",
"challengeType": 5,
- "title": "Problem 145: How many reversible numbers are there below one-billion?",
+ "title":
+ "Problem 145: How many reversible numbers are there below one-billion?",
"tests": [
{
"text": "euler145() should return 608720.",
- "testString": "assert.strictEqual(euler145(), 608720, 'euler145() should return 608720.');"
+ "testString":
+ "assert.strictEqual(euler145(), 608720, 'euler145() should return 608720.');"
}
],
"solutions": [],
@@ -7063,7 +7357,8 @@
"tests": [
{
"text": "euler146() should return 676333270.",
- "testString": "assert.strictEqual(euler146(), 676333270, 'euler146() should return 676333270.');"
+ "testString":
+ "assert.strictEqual(euler146(), 676333270, 'euler146() should return 676333270.');"
}
],
"solutions": [],
@@ -7098,7 +7393,8 @@
"tests": [
{
"text": "euler147() should return 846910284.",
- "testString": "assert.strictEqual(euler147(), 846910284, 'euler147() should return 846910284.');"
+ "testString":
+ "assert.strictEqual(euler147(), 846910284, 'euler147() should return 846910284.');"
}
],
"solutions": [],
@@ -7142,7 +7438,8 @@
"tests": [
{
"text": "euler148() should return 2129970655314432.",
- "testString": "assert.strictEqual(euler148(), 2129970655314432, 'euler148() should return 2129970655314432.');"
+ "testString":
+ "assert.strictEqual(euler148(), 2129970655314432, 'euler148() should return 2129970655314432.');"
}
],
"solutions": [],
@@ -7248,7 +7545,8 @@
"tests": [
{
"text": "euler149() should return 52852124.",
- "testString": "assert.strictEqual(euler149(), 52852124, 'euler149() should return 52852124.');"
+ "testString":
+ "assert.strictEqual(euler149(), 52852124, 'euler149() should return 52852124.');"
}
],
"solutions": [],
@@ -7293,11 +7591,13 @@
{
"id": "5900f4031000cf542c50ff15",
"challengeType": 5,
- "title": "Problem 150: Searching a triangular array for a sub-triangle having minimum-sum",
+ "title":
+ "Problem 150: Searching a triangular array for a sub-triangle having minimum-sum",
"tests": [
{
"text": "euler150() should return -271248680.",
- "testString": "assert.strictEqual(euler150(), -271248680, 'euler150() should return -271248680.');"
+ "testString":
+ "assert.strictEqual(euler150(), -271248680, 'euler150() should return -271248680.');"
}
],
"solutions": [],
@@ -7351,11 +7651,13 @@
{
"id": "5900f4031000cf542c50ff16",
"challengeType": 5,
- "title": "Problem 151: Paper sheets of standard sizes: an expected-value problem",
+ "title":
+ "Problem 151: Paper sheets of standard sizes: an expected-value problem",
"tests": [
{
"text": "euler151() should return 0.464399.",
- "testString": "assert.strictEqual(euler151(), 0.464399, 'euler151() should return 0.464399.');"
+ "testString":
+ "assert.strictEqual(euler151(), 0.464399, 'euler151() should return 0.464399.');"
}
],
"solutions": [],
@@ -7395,7 +7697,8 @@
"tests": [
{
"text": "euler152() should return 301.",
- "testString": "assert.strictEqual(euler152(), 301, 'euler152() should return 301.');"
+ "testString":
+ "assert.strictEqual(euler152(), 301, 'euler152() should return 301.');"
}
],
"solutions": [],
@@ -7432,7 +7735,8 @@
"tests": [
{
"text": "euler153() should return 17971254122360636.",
- "testString": "assert.strictEqual(euler153(), 17971254122360636, 'euler153() should return 17971254122360636.');"
+ "testString":
+ "assert.strictEqual(euler153(), 17971254122360636, 'euler153() should return 17971254122360636.');"
}
],
"solutions": [],
@@ -7509,7 +7813,8 @@
"tests": [
{
"text": "euler154() should return 479742450.",
- "testString": "assert.strictEqual(euler154(), 479742450, 'euler154() should return 479742450.');"
+ "testString":
+ "assert.strictEqual(euler154(), 479742450, 'euler154() should return 479742450.');"
}
],
"solutions": [],
@@ -7549,7 +7854,8 @@
"tests": [
{
"text": "euler155() should return 3857447.",
- "testString": "assert.strictEqual(euler155(), 3857447, 'euler155() should return 3857447.');"
+ "testString":
+ "assert.strictEqual(euler155(), 3857447, 'euler155() should return 3857447.');"
}
],
"solutions": [],
@@ -7591,7 +7897,8 @@
"tests": [
{
"text": "euler156() should return 21295121502550.",
- "testString": "assert.strictEqual(euler156(), 21295121502550, 'euler156() should return 21295121502550.');"
+ "testString":
+ "assert.strictEqual(euler156(), 21295121502550, 'euler156() should return 21295121502550.');"
}
],
"solutions": [],
@@ -7656,7 +7963,8 @@
"tests": [
{
"text": "euler157() should return 53490.",
- "testString": "assert.strictEqual(euler157(), 53490, 'euler157() should return 53490.');"
+ "testString":
+ "assert.strictEqual(euler157(), 53490, 'euler157() should return 53490.');"
}
],
"solutions": [],
@@ -7707,11 +8015,13 @@
{
"id": "5900f40a1000cf542c50ff1d",
"challengeType": 5,
- "title": "Problem 158: Exploring strings for which only one character comes lexicographically after its neighbour to the left",
+ "title":
+ "Problem 158: Exploring strings for which only one character comes lexicographically after its neighbour to the left",
"tests": [
{
"text": "euler158() should return 409511334375.",
- "testString": "assert.strictEqual(euler158(), 409511334375, 'euler158() should return 409511334375.');"
+ "testString":
+ "assert.strictEqual(euler158(), 409511334375, 'euler158() should return 409511334375.');"
}
],
"solutions": [],
@@ -7751,7 +8061,8 @@
"tests": [
{
"text": "euler159() should return 14489159.",
- "testString": "assert.strictEqual(euler159(), 14489159, 'euler159() should return 14489159.');"
+ "testString":
+ "assert.strictEqual(euler159(), 14489159, 'euler159() should return 14489159.');"
}
],
"solutions": [],
@@ -7809,7 +8120,8 @@
"tests": [
{
"text": "euler160() should return 16576.",
- "testString": "assert.strictEqual(euler160(), 16576, 'euler160() should return 16576.');"
+ "testString":
+ "assert.strictEqual(euler160(), 16576, 'euler160() should return 16576.');"
}
],
"solutions": [],
@@ -7847,7 +8159,8 @@
"tests": [
{
"text": "euler161() should return 20574308184277972.",
- "testString": "assert.strictEqual(euler161(), 20574308184277972, 'euler161() should return 20574308184277972.');"
+ "testString":
+ "assert.strictEqual(euler161(), 20574308184277972, 'euler161() should return 20574308184277972.');"
}
],
"solutions": [],
@@ -7894,7 +8207,8 @@
"tests": [
{
"text": "euler162() should return 3D58725572C62302.",
- "testString": "assert.strictEqual(euler162(), 3D58725572C62302, 'euler162() should return 3D58725572C62302.');"
+ "testString":
+ "assert.strictEqual(euler162(), 3D58725572C62302, 'euler162() should return 3D58725572C62302.');"
}
],
"solutions": [],
@@ -7934,7 +8248,8 @@
"tests": [
{
"text": "euler163() should return 343047.",
- "testString": "assert.strictEqual(euler163(), 343047, 'euler163() should return 343047.');"
+ "testString":
+ "assert.strictEqual(euler163(), 343047, 'euler163() should return 343047.');"
}
],
"solutions": [],
@@ -7970,11 +8285,13 @@
{
"id": "5900f4111000cf542c50ff23",
"challengeType": 5,
- "title": "Problem 164: Numbers for which no three consecutive digits have a sum greater than a given value",
+ "title":
+ "Problem 164: Numbers for which no three consecutive digits have a sum greater than a given value",
"tests": [
{
"text": "euler164() should return 378158756814587.",
- "testString": "assert.strictEqual(euler164(), 378158756814587, 'euler164() should return 378158756814587.');"
+ "testString":
+ "assert.strictEqual(euler164(), 378158756814587, 'euler164() should return 378158756814587.');"
}
],
"solutions": [],
@@ -8007,7 +8324,8 @@
"tests": [
{
"text": "euler165() should return 2868868.",
- "testString": "assert.strictEqual(euler165(), 2868868, 'euler165() should return 2868868.');"
+ "testString":
+ "assert.strictEqual(euler165(), 2868868, 'euler165() should return 2868868.');"
}
],
"solutions": [],
@@ -8057,7 +8375,8 @@
"tests": [
{
"text": "euler166() should return 7130034.",
- "testString": "assert.strictEqual(euler166(), 7130034, 'euler166() should return 7130034.');"
+ "testString":
+ "assert.strictEqual(euler166(), 7130034, 'euler166() should return 7130034.');"
}
],
"solutions": [],
@@ -8102,7 +8421,8 @@
"tests": [
{
"text": "euler167() should return 3916160068885.",
- "testString": "assert.strictEqual(euler167(), 3916160068885, 'euler167() should return 3916160068885.');"
+ "testString":
+ "assert.strictEqual(euler167(), 3916160068885, 'euler167() should return 3916160068885.');"
}
],
"solutions": [],
@@ -8140,7 +8460,8 @@
"tests": [
{
"text": "euler168() should return 59206.",
- "testString": "assert.strictEqual(euler168(), 59206, 'euler168() should return 59206.');"
+ "testString":
+ "assert.strictEqual(euler168(), 59206, 'euler168() should return 59206.');"
}
],
"solutions": [],
@@ -8172,11 +8493,13 @@
{
"id": "5900f4151000cf542c50ff28",
"challengeType": 5,
- "title": "Problem 169: Exploring the number of different ways a number can be expressed as a sum of powers of 2",
+ "title":
+ "Problem 169: Exploring the number of different ways a number can be expressed as a sum of powers of 2",
"tests": [
{
"text": "euler169() should return 178653872807.",
- "testString": "assert.strictEqual(euler169(), 178653872807, 'euler169() should return 178653872807.');"
+ "testString":
+ "assert.strictEqual(euler169(), 178653872807, 'euler169() should return 178653872807.');"
}
],
"solutions": [],
@@ -8211,11 +8534,13 @@
{
"id": "5900f4161000cf542c50ff29",
"challengeType": 5,
- "title": "Problem 170: Find the largest 0 to 9 pandigital that can be formed by concatenating products",
+ "title":
+ "Problem 170: Find the largest 0 to 9 pandigital that can be formed by concatenating products",
"tests": [
{
"text": "euler170() should return 9857164023.",
- "testString": "assert.strictEqual(euler170(), 9857164023, 'euler170() should return 9857164023.');"
+ "testString":
+ "assert.strictEqual(euler170(), 9857164023, 'euler170() should return 9857164023.');"
}
],
"solutions": [],
@@ -8253,11 +8578,13 @@
{
"id": "5900f4181000cf542c50ff2a",
"challengeType": 5,
- "title": "Problem 171: Finding numbers for which the sum of the squares of the digits is a square",
+ "title":
+ "Problem 171: Finding numbers for which the sum of the squares of the digits is a square",
"tests": [
{
"text": "euler171() should return 142989277.",
- "testString": "assert.strictEqual(euler171(), 142989277, 'euler171() should return 142989277.');"
+ "testString":
+ "assert.strictEqual(euler171(), 142989277, 'euler171() should return 142989277.');"
}
],
"solutions": [],
@@ -8294,7 +8621,8 @@
"tests": [
{
"text": "euler172() should return 227485267000992000.",
- "testString": "assert.strictEqual(euler172(), 227485267000992000, 'euler172() should return 227485267000992000.');"
+ "testString":
+ "assert.strictEqual(euler172(), 227485267000992000, 'euler172() should return 227485267000992000.');"
}
],
"solutions": [],
@@ -8323,11 +8651,13 @@
{
"id": "5900f41a1000cf542c50ff2c",
"challengeType": 5,
- "title": "Problem 173: Using up to one million tiles how many different \"hollow\" square laminae can be formed?",
+ "title":
+ "Problem 173: Using up to one million tiles how many different \"hollow\" square laminae can be formed?",
"tests": [
{
"text": "euler173() should return 1572729.",
- "testString": "assert.strictEqual(euler173(), 1572729, 'euler173() should return 1572729.');"
+ "testString":
+ "assert.strictEqual(euler173(), 1572729, 'euler173() should return 1572729.');"
}
],
"solutions": [],
@@ -8360,11 +8690,13 @@
{
"id": "5900f41a1000cf542c50ff2d",
"challengeType": 5,
- "title": "Problem 174: Counting the number of \"hollow\" square laminae that can form one, two, three, ... distinct arrangements",
+ "title":
+ "Problem 174: Counting the number of \"hollow\" square laminae that can form one, two, three, ... distinct arrangements",
"tests": [
{
"text": "euler174() should return 209566.",
- "testString": "assert.strictEqual(euler174(), 209566, 'euler174() should return 209566.');"
+ "testString":
+ "assert.strictEqual(euler174(), 209566, 'euler174() should return 209566.');"
}
],
"solutions": [],
@@ -8399,11 +8731,13 @@
{
"id": "5900f41c1000cf542c50ff2e",
"challengeType": 5,
- "title": "Problem 175: Fractions involving the number of different ways a number can be expressed as a sum of powers of 2",
+ "title":
+ "Problem 175: Fractions involving the number of different ways a number can be expressed as a sum of powers of 2",
"tests": [
{
"text": "euler175() should return 1, 13717420, 8.",
- "testString": "assert.strictEqual(euler175(), 1, 13717420, 8, 'euler175() should return 1, 13717420, 8.');"
+ "testString":
+ "assert.strictEqual(euler175(), 1, 13717420, 8, 'euler175() should return 1, 13717420, 8.');"
}
],
"solutions": [],
@@ -8445,7 +8779,8 @@
"tests": [
{
"text": "euler176() should return 96818198400000.",
- "testString": "assert.strictEqual(euler176(), 96818198400000, 'euler176() should return 96818198400000.');"
+ "testString":
+ "assert.strictEqual(euler176(), 96818198400000, 'euler176() should return 96818198400000.');"
}
],
"solutions": [],
@@ -8479,7 +8814,8 @@
"tests": [
{
"text": "euler177() should return 129325.",
- "testString": "assert.strictEqual(euler177(), 129325, 'euler177() should return 129325.');"
+ "testString":
+ "assert.strictEqual(euler177(), 129325, 'euler177() should return 129325.');"
}
],
"solutions": [],
@@ -8517,7 +8853,8 @@
"tests": [
{
"text": "euler178() should return 126461847755.",
- "testString": "assert.strictEqual(euler178(), 126461847755, 'euler178() should return 126461847755.');"
+ "testString":
+ "assert.strictEqual(euler178(), 126461847755, 'euler178() should return 126461847755.');"
}
],
"solutions": [],
@@ -8555,7 +8892,8 @@
"tests": [
{
"text": "euler179() should return 986262.",
- "testString": "assert.strictEqual(euler179(), 986262, 'euler179() should return 986262.');"
+ "testString":
+ "assert.strictEqual(euler179(), 986262, 'euler179() should return 986262.');"
}
],
"solutions": [],
@@ -8588,7 +8926,8 @@
"tests": [
{
"text": "euler180() should return 285196020571078980.",
- "testString": "assert.strictEqual(euler180(), 285196020571078980, 'euler180() should return 285196020571078980.');"
+ "testString":
+ "assert.strictEqual(euler180(), 285196020571078980, 'euler180() should return 285196020571078980.');"
}
],
"solutions": [],
@@ -8625,11 +8964,13 @@
{
"id": "5900f4231000cf542c50ff34",
"challengeType": 5,
- "title": "Problem 181: Investigating in how many ways objects of two different colours can be grouped",
+ "title":
+ "Problem 181: Investigating in how many ways objects of two different colours can be grouped",
"tests": [
{
"text": "euler181() should return 83735848679360670.",
- "testString": "assert.strictEqual(euler181(), 83735848679360670, 'euler181() should return 83735848679360670.');"
+ "testString":
+ "assert.strictEqual(euler181(), 83735848679360670, 'euler181() should return 83735848679360670.');"
}
],
"solutions": [],
@@ -8665,7 +9006,8 @@
"tests": [
{
"text": "euler182() should return 399788195976.",
- "testString": "assert.strictEqual(euler182(), 399788195976, 'euler182() should return 399788195976.');"
+ "testString":
+ "assert.strictEqual(euler182(), 399788195976, 'euler182() should return 399788195976.');"
}
],
"solutions": [],
@@ -8712,7 +9054,8 @@
"tests": [
{
"text": "euler183() should return 48861552.",
- "testString": "assert.strictEqual(euler183(), 48861552, 'euler183() should return 48861552.');"
+ "testString":
+ "assert.strictEqual(euler183(), 48861552, 'euler183() should return 48861552.');"
}
],
"solutions": [],
@@ -8760,7 +9103,8 @@
"tests": [
{
"text": "euler184() should return 1725323624056.",
- "testString": "assert.strictEqual(euler184(), 1725323624056, 'euler184() should return 1725323624056.');"
+ "testString":
+ "assert.strictEqual(euler184(), 1725323624056, 'euler184() should return 1725323624056.');"
}
],
"solutions": [],
@@ -8799,7 +9143,8 @@
"tests": [
{
"text": "euler185() should return 4640261571849533.",
- "testString": "assert.strictEqual(euler185(), 4640261571849533, 'euler185() should return 4640261571849533.');"
+ "testString":
+ "assert.strictEqual(euler185(), 4640261571849533, 'euler185() should return 4640261571849533.');"
}
],
"solutions": [],
@@ -8869,7 +9214,8 @@
"tests": [
{
"text": "euler186() should return 2325629.",
- "testString": "assert.strictEqual(euler186(), 2325629, 'euler186() should return 2325629.');"
+ "testString":
+ "assert.strictEqual(euler186(), 2325629, 'euler186() should return 2325629.');"
}
],
"solutions": [],
@@ -8914,7 +9260,8 @@
"tests": [
{
"text": "euler187() should return 17427258.",
- "testString": "assert.strictEqual(euler187(), 17427258, 'euler187() should return 17427258.');"
+ "testString":
+ "assert.strictEqual(euler187(), 17427258, 'euler187() should return 17427258.');"
}
],
"solutions": [],
@@ -8952,7 +9299,8 @@
"tests": [
{
"text": "euler188() should return 95962097.",
- "testString": "assert.strictEqual(euler188(), 95962097, 'euler188() should return 95962097.');"
+ "testString":
+ "assert.strictEqual(euler188(), 95962097, 'euler188() should return 95962097.');"
}
],
"solutions": [],
@@ -8990,7 +9338,8 @@
"tests": [
{
"text": "euler189() should return 10834893628237824.",
- "testString": "assert.strictEqual(euler189(), 10834893628237824, 'euler189() should return 10834893628237824.');"
+ "testString":
+ "assert.strictEqual(euler189(), 10834893628237824, 'euler189() should return 10834893628237824.');"
}
],
"solutions": [],
@@ -9035,7 +9384,8 @@
"tests": [
{
"text": "euler190() should return 371048281.",
- "testString": "assert.strictEqual(euler190(), 371048281, 'euler190() should return 371048281.');"
+ "testString":
+ "assert.strictEqual(euler190(), 371048281, 'euler190() should return 371048281.');"
}
],
"solutions": [],
@@ -9072,7 +9422,8 @@
"tests": [
{
"text": "euler191() should return 1918080160.",
- "testString": "assert.strictEqual(euler191(), 1918080160, 'euler191() should return 1918080160.');"
+ "testString":
+ "assert.strictEqual(euler191(), 1918080160, 'euler191() should return 1918080160.');"
}
],
"solutions": [],
@@ -9117,7 +9468,8 @@
"tests": [
{
"text": "euler192() should return 57060635927998344.",
- "testString": "assert.strictEqual(euler192(), 57060635927998344, 'euler192() should return 57060635927998344.');"
+ "testString":
+ "assert.strictEqual(euler192(), 57060635927998344, 'euler192() should return 57060635927998344.');"
}
],
"solutions": [],
@@ -9157,7 +9509,8 @@
"tests": [
{
"text": "euler193() should return 684465067343069.",
- "testString": "assert.strictEqual(euler193(), 684465067343069, 'euler193() should return 684465067343069.');"
+ "testString":
+ "assert.strictEqual(euler193(), 684465067343069, 'euler193() should return 684465067343069.');"
}
],
"solutions": [],
@@ -9192,7 +9545,8 @@
"tests": [
{
"text": "euler194() should return 61190912.",
- "testString": "assert.strictEqual(euler194(), 61190912, 'euler194() should return 61190912.');"
+ "testString":
+ "assert.strictEqual(euler194(), 61190912, 'euler194() should return 61190912.');"
}
],
"solutions": [],
@@ -9231,11 +9585,13 @@
{
"id": "5900f4311000cf542c50ff43",
"challengeType": 5,
- "title": "Problem 195: Inscribed circles of triangles with one angle of 60 degrees",
+ "title":
+ "Problem 195: Inscribed circles of triangles with one angle of 60 degrees",
"tests": [
{
"text": "euler195() should return 75085391.",
- "testString": "assert.strictEqual(euler195(), 75085391, 'euler195() should return 75085391.');"
+ "testString":
+ "assert.strictEqual(euler195(), 75085391, 'euler195() should return 75085391.');"
}
],
"solutions": [],
@@ -9274,7 +9630,8 @@
"tests": [
{
"text": "euler196() should return 322303240771079940.",
- "testString": "assert.strictEqual(euler196(), 322303240771079940, 'euler196() should return 322303240771079940.');"
+ "testString":
+ "assert.strictEqual(euler196(), 322303240771079940, 'euler196() should return 322303240771079940.');"
}
],
"solutions": [],
@@ -9329,11 +9686,13 @@
{
"id": "5900f4311000cf542c50ff44",
"challengeType": 5,
- "title": "Problem 197: Investigating the behaviour of a recursively defined sequence",
+ "title":
+ "Problem 197: Investigating the behaviour of a recursively defined sequence",
"tests": [
{
"text": "euler197() should return 1.710637717.",
- "testString": "assert.strictEqual(euler197(), 1.710637717, 'euler197() should return 1.710637717.');"
+ "testString":
+ "assert.strictEqual(euler197(), 1.710637717, 'euler197() should return 1.710637717.');"
}
],
"solutions": [],
@@ -9370,7 +9729,8 @@
"tests": [
{
"text": "euler198() should return 52374425.",
- "testString": "assert.strictEqual(euler198(), 52374425, 'euler198() should return 52374425.');"
+ "testString":
+ "assert.strictEqual(euler198(), 52374425, 'euler198() should return 52374425.');"
}
],
"solutions": [],
@@ -9409,7 +9769,8 @@
"tests": [
{
"text": "euler199() should return 0.00396087.",
- "testString": "assert.strictEqual(euler199(), 0.00396087, 'euler199() should return 0.00396087.');"
+ "testString":
+ "assert.strictEqual(euler199(), 0.00396087, 'euler199() should return 0.00396087.');"
}
],
"solutions": [],
@@ -9446,11 +9807,13 @@
{
"id": "5900f4351000cf542c50ff47",
"challengeType": 5,
- "title": "Problem 200: Find the 200th prime-proof sqube containing the contiguous sub-string \"200\"",
+ "title":
+ "Problem 200: Find the 200th prime-proof sqube containing the contiguous sub-string \"200\"",
"tests": [
{
"text": "euler200() should return 229161792008.",
- "testString": "assert.strictEqual(euler200(), 229161792008, 'euler200() should return 229161792008.');"
+ "testString":
+ "assert.strictEqual(euler200(), 229161792008, 'euler200() should return 229161792008.');"
}
],
"solutions": [],
@@ -9490,7 +9853,8 @@
"tests": [
{
"text": "euler201() should return 115039000.",
- "testString": "assert.strictEqual(euler201(), 115039000, 'euler201() should return 115039000.');"
+ "testString":
+ "assert.strictEqual(euler201(), 115039000, 'euler201() should return 115039000.');"
}
],
"solutions": [],
@@ -9554,7 +9918,8 @@
"tests": [
{
"text": "euler202() should return 1209002624.",
- "testString": "assert.strictEqual(euler202(), 1209002624, 'euler202() should return 1209002624.');"
+ "testString":
+ "assert.strictEqual(euler202(), 1209002624, 'euler202() should return 1209002624.');"
}
],
"solutions": [],
@@ -9596,7 +9961,8 @@
"tests": [
{
"text": "euler203() should return 34029210557338.",
- "testString": "assert.strictEqual(euler203(), 34029210557338, 'euler203() should return 34029210557338.');"
+ "testString":
+ "assert.strictEqual(euler203(), 34029210557338, 'euler203() should return 34029210557338.');"
}
],
"solutions": [],
@@ -9642,7 +10008,8 @@
"tests": [
{
"text": "euler204() should return 2944730.",
- "testString": "assert.strictEqual(euler204(), 2944730, 'euler204() should return 2944730.');"
+ "testString":
+ "assert.strictEqual(euler204(), 2944730, 'euler204() should return 2944730.');"
}
],
"solutions": [],
@@ -9682,7 +10049,8 @@
"tests": [
{
"text": "euler205() should return 0.5731441.",
- "testString": "assert.strictEqual(euler205(), 0.5731441, 'euler205() should return 0.5731441.');"
+ "testString":
+ "assert.strictEqual(euler205(), 0.5731441, 'euler205() should return 0.5731441.');"
}
],
"solutions": [],
@@ -9720,7 +10088,8 @@
"tests": [
{
"text": "euler206() should return 1389019170.",
- "testString": "assert.strictEqual(euler206(), 1389019170, 'euler206() should return 1389019170.');"
+ "testString":
+ "assert.strictEqual(euler206(), 1389019170, 'euler206() should return 1389019170.');"
}
],
"solutions": [],
@@ -9753,7 +10122,8 @@
"tests": [
{
"text": "euler207() should return 44043947822.",
- "testString": "assert.strictEqual(euler207(), 44043947822, 'euler207() should return 44043947822.');"
+ "testString":
+ "assert.strictEqual(euler207(), 44043947822, 'euler207() should return 44043947822.');"
}
],
"solutions": [],
@@ -9807,7 +10177,8 @@
"tests": [
{
"text": "euler208() should return 331951449665644800.",
- "testString": "assert.strictEqual(euler208(), 331951449665644800, 'euler208() should return 331951449665644800.');"
+ "testString":
+ "assert.strictEqual(euler208(), 331951449665644800, 'euler208() should return 331951449665644800.');"
}
],
"solutions": [],
@@ -9847,7 +10218,8 @@
"tests": [
{
"text": "euler209() should return 15964587728784.",
- "testString": "assert.strictEqual(euler209(), 15964587728784, 'euler209() should return 15964587728784.');"
+ "testString":
+ "assert.strictEqual(euler209(), 15964587728784, 'euler209() should return 15964587728784.');"
}
],
"solutions": [],
@@ -9890,7 +10262,8 @@
"tests": [
{
"text": "euler210() should return 1598174770174689500.",
- "testString": "assert.strictEqual(euler210(), 1598174770174689500, 'euler210() should return 1598174770174689500.');"
+ "testString":
+ "assert.strictEqual(euler210(), 1598174770174689500, 'euler210() should return 1598174770174689500.');"
}
],
"solutions": [],
@@ -9928,7 +10301,8 @@
"tests": [
{
"text": "euler211() should return 1922364685.",
- "testString": "assert.strictEqual(euler211(), 1922364685, 'euler211() should return 1922364685.');"
+ "testString":
+ "assert.strictEqual(euler211(), 1922364685, 'euler211() should return 1922364685.');"
}
],
"solutions": [],
@@ -9963,7 +10337,8 @@
"tests": [
{
"text": "euler212() should return 328968937309.",
- "testString": "assert.strictEqual(euler212(), 328968937309, 'euler212() should return 328968937309.');"
+ "testString":
+ "assert.strictEqual(euler212(), 328968937309, 'euler212() should return 328968937309.');"
}
],
"solutions": [],
@@ -10010,7 +10385,8 @@
"tests": [
{
"text": "euler213() should return 330.721154.",
- "testString": "assert.strictEqual(euler213(), 330.721154, 'euler213() should return 330.721154.');"
+ "testString":
+ "assert.strictEqual(euler213(), 330.721154, 'euler213() should return 330.721154.');"
}
],
"solutions": [],
@@ -10046,7 +10422,8 @@
"tests": [
{
"text": "euler214() should return 1677366278943.",
- "testString": "assert.strictEqual(euler214(), 1677366278943, 'euler214() should return 1677366278943.');"
+ "testString":
+ "assert.strictEqual(euler214(), 1677366278943, 'euler214() should return 1677366278943.');"
}
],
"solutions": [],
@@ -10098,7 +10475,8 @@
"tests": [
{
"text": "euler215() should return 806844323190414.",
- "testString": "assert.strictEqual(euler215(), 806844323190414, 'euler215() should return 806844323190414.');"
+ "testString":
+ "assert.strictEqual(euler215(), 806844323190414, 'euler215() should return 806844323190414.');"
}
],
"solutions": [],
@@ -10136,11 +10514,13 @@
{
"id": "5900f4451000cf542c50ff57",
"challengeType": 5,
- "title": "Problem 216: Investigating the primality of numbers of the form 2n2-1",
+ "title":
+ "Problem 216: Investigating the primality of numbers of the form 2n2-1",
"tests": [
{
"text": "euler216() should return 5437849.",
- "testString": "assert.strictEqual(euler216(), 5437849, 'euler216() should return 5437849.');"
+ "testString":
+ "assert.strictEqual(euler216(), 5437849, 'euler216() should return 5437849.');"
}
],
"solutions": [],
@@ -10178,7 +10558,8 @@
"tests": [
{
"text": "euler217() should return 6273134.",
- "testString": "assert.strictEqual(euler217(), 6273134, 'euler217() should return 6273134.');"
+ "testString":
+ "assert.strictEqual(euler217(), 6273134, 'euler217() should return 6273134.');"
}
],
"solutions": [],
@@ -10215,7 +10596,8 @@
"tests": [
{
"text": "euler218() should return 0.",
- "testString": "assert.strictEqual(euler218(), 0, 'euler218() should return 0.');"
+ "testString":
+ "assert.strictEqual(euler218(), 0, 'euler218() should return 0.');"
}
],
"solutions": [],
@@ -10262,7 +10644,8 @@
"tests": [
{
"text": "euler219() should return 64564225042.",
- "testString": "assert.strictEqual(euler219(), 64564225042, 'euler219() should return 64564225042.');"
+ "testString":
+ "assert.strictEqual(euler219(), 64564225042, 'euler219() should return 64564225042.');"
}
],
"solutions": [],
@@ -10307,7 +10690,8 @@
"tests": [
{
"text": "euler220() should return 139776, 963904.",
- "testString": "assert.strictEqual(euler220(), 139776, 963904, 'euler220() should return 139776, 963904.');"
+ "testString":
+ "assert.strictEqual(euler220(), 139776, 963904, 'euler220() should return 139776, 963904.');"
}
],
"solutions": [],
@@ -10355,7 +10739,8 @@
"tests": [
{
"text": "euler221() should return 1884161251122450.",
- "testString": "assert.strictEqual(euler221(), 1884161251122450, 'euler221() should return 1884161251122450.');"
+ "testString":
+ "assert.strictEqual(euler221(), 1884161251122450, 'euler221() should return 1884161251122450.');"
}
],
"solutions": [],
@@ -10407,7 +10792,8 @@
"tests": [
{
"text": "euler222() should return 1590933.",
- "testString": "assert.strictEqual(euler222(), 1590933, 'euler222() should return 1590933.');"
+ "testString":
+ "assert.strictEqual(euler222(), 1590933, 'euler222() should return 1590933.');"
}
],
"solutions": [],
@@ -10442,7 +10828,8 @@
"tests": [
{
"text": "euler223() should return 61614848.",
- "testString": "assert.strictEqual(euler223(), 61614848, 'euler223() should return 61614848.');"
+ "testString":
+ "assert.strictEqual(euler223(), 61614848, 'euler223() should return 61614848.');"
}
],
"solutions": [],
@@ -10477,7 +10864,8 @@
"tests": [
{
"text": "euler224() should return 4137330.",
- "testString": "assert.strictEqual(euler224(), 4137330, 'euler224() should return 4137330.');"
+ "testString":
+ "assert.strictEqual(euler224(), 4137330, 'euler224() should return 4137330.');"
}
],
"solutions": [],
@@ -10512,7 +10900,8 @@
"tests": [
{
"text": "euler225() should return 2009.",
- "testString": "assert.strictEqual(euler225(), 2009, 'euler225() should return 2009.');"
+ "testString":
+ "assert.strictEqual(euler225(), 2009, 'euler225() should return 2009.');"
}
],
"solutions": [],
@@ -10551,7 +10940,8 @@
"tests": [
{
"text": "euler226() should return 0.11316017.",
- "testString": "assert.strictEqual(euler226(), 0.11316017, 'euler226() should return 0.11316017.');"
+ "testString":
+ "assert.strictEqual(euler226(), 0.11316017, 'euler226() should return 0.11316017.');"
}
],
"solutions": [],
@@ -10593,7 +10983,8 @@
"tests": [
{
"text": "euler227() should return 3780.618622.",
- "testString": "assert.strictEqual(euler227(), 3780.618622, 'euler227() should return 3780.618622.');"
+ "testString":
+ "assert.strictEqual(euler227(), 3780.618622, 'euler227() should return 3780.618622.');"
}
],
"solutions": [],
@@ -10633,7 +11024,8 @@
"tests": [
{
"text": "euler228() should return 86226.",
- "testString": "assert.strictEqual(euler228(), 86226, 'euler228() should return 86226.');"
+ "testString":
+ "assert.strictEqual(euler228(), 86226, 'euler228() should return 86226.');"
}
],
"solutions": [],
@@ -10688,7 +11080,8 @@
"tests": [
{
"text": "euler229() should return 11325263.",
- "testString": "assert.strictEqual(euler229(), 11325263, 'euler229() should return 11325263.');"
+ "testString":
+ "assert.strictEqual(euler229(), 11325263, 'euler229() should return 11325263.');"
}
],
"solutions": [],
@@ -10739,7 +11132,8 @@
"tests": [
{
"text": "euler230() should return 850481152593119200.",
- "testString": "assert.strictEqual(euler230(), 850481152593119200, 'euler230() should return 850481152593119200.');"
+ "testString":
+ "assert.strictEqual(euler230(), 850481152593119200, 'euler230() should return 850481152593119200.');"
}
],
"solutions": [],
@@ -10798,7 +11192,8 @@
"tests": [
{
"text": "euler231() should return 7526965179680.",
- "testString": "assert.strictEqual(euler231(), 7526965179680, 'euler231() should return 7526965179680.');"
+ "testString":
+ "assert.strictEqual(euler231(), 7526965179680, 'euler231() should return 7526965179680.');"
}
],
"solutions": [],
@@ -10835,7 +11230,8 @@
"tests": [
{
"text": "euler232() should return 0.83648556.",
- "testString": "assert.strictEqual(euler232(), 0.83648556, 'euler232() should return 0.83648556.');"
+ "testString":
+ "assert.strictEqual(euler232(), 0.83648556, 'euler232() should return 0.83648556.');"
}
],
"solutions": [],
@@ -10874,7 +11270,8 @@
"tests": [
{
"text": "euler233() should return 271204031455541300.",
- "testString": "assert.strictEqual(euler233(), 271204031455541300, 'euler233() should return 271204031455541300.');"
+ "testString":
+ "assert.strictEqual(euler233(), 271204031455541300, 'euler233() should return 271204031455541300.');"
}
],
"solutions": [],
@@ -10910,7 +11307,8 @@
"tests": [
{
"text": "euler234() should return 1259187438574927000.",
- "testString": "assert.strictEqual(euler234(), 1259187438574927000, 'euler234() should return 1259187438574927000.');"
+ "testString":
+ "assert.strictEqual(euler234(), 1259187438574927000, 'euler234() should return 1259187438574927000.');"
}
],
"solutions": [],
@@ -10950,7 +11348,8 @@
"tests": [
{
"text": "euler235() should return 1.002322108633.",
- "testString": "assert.strictEqual(euler235(), 1.002322108633, 'euler235() should return 1.002322108633.');"
+ "testString":
+ "assert.strictEqual(euler235(), 1.002322108633, 'euler235() should return 1.002322108633.');"
}
],
"solutions": [],
@@ -10990,7 +11389,8 @@
"tests": [
{
"text": "euler236() should return 123 / 59.",
- "testString": "assert.strictEqual(euler236(), 123 / 59, 'euler236() should return 123 / 59.');"
+ "testString":
+ "assert.strictEqual(euler236(), 123 / 59, 'euler236() should return 123 / 59.');"
}
],
"solutions": [],
@@ -11035,7 +11435,8 @@
"tests": [
{
"text": "euler237() should return 15836928.",
- "testString": "assert.strictEqual(euler237(), 15836928, 'euler237() should return 15836928.');"
+ "testString":
+ "assert.strictEqual(euler237(), 15836928, 'euler237() should return 15836928.');"
}
],
"solutions": [],
@@ -11078,7 +11479,8 @@
"tests": [
{
"text": "euler238() should return 9922545104535660.",
- "testString": "assert.strictEqual(euler238(), 9922545104535660, 'euler238() should return 9922545104535660.');"
+ "testString":
+ "assert.strictEqual(euler238(), 9922545104535660, 'euler238() should return 9922545104535660.');"
}
],
"solutions": [],
@@ -11144,7 +11546,8 @@
"tests": [
{
"text": "euler239() should return 0.001887854841.",
- "testString": "assert.strictEqual(euler239(), 0.001887854841, 'euler239() should return 0.001887854841.');"
+ "testString":
+ "assert.strictEqual(euler239(), 0.001887854841, 'euler239() should return 0.001887854841.');"
}
],
"solutions": [],
@@ -11182,7 +11585,8 @@
"tests": [
{
"text": "euler240() should return 7448717393364182000.",
- "testString": "assert.strictEqual(euler240(), 7448717393364182000, 'euler240() should return 7448717393364182000.');"
+ "testString":
+ "assert.strictEqual(euler240(), 7448717393364182000, 'euler240() should return 7448717393364182000.');"
}
],
"solutions": [],
@@ -11226,7 +11630,8 @@
"tests": [
{
"text": "euler241() should return 482316491800641150.",
- "testString": "assert.strictEqual(euler241(), 482316491800641150, 'euler241() should return 482316491800641150.');"
+ "testString":
+ "assert.strictEqual(euler241(), 482316491800641150, 'euler241() should return 482316491800641150.');"
}
],
"solutions": [],
@@ -11267,7 +11672,8 @@
"tests": [
{
"text": "euler242() should return 997104142249036700.",
- "testString": "assert.strictEqual(euler242(), 997104142249036700, 'euler242() should return 997104142249036700.');"
+ "testString":
+ "assert.strictEqual(euler242(), 997104142249036700, 'euler242() should return 997104142249036700.');"
}
],
"solutions": [],
@@ -11308,7 +11714,8 @@
"tests": [
{
"text": "euler243() should return 892371480.",
- "testString": "assert.strictEqual(euler243(), 892371480, 'euler243() should return 892371480.');"
+ "testString":
+ "assert.strictEqual(euler243(), 892371480, 'euler243() should return 892371480.');"
}
],
"solutions": [],
@@ -11349,7 +11756,8 @@
"tests": [
{
"text": "euler244() should return 96356848.",
- "testString": "assert.strictEqual(euler244(), 96356848, 'euler244() should return 96356848.');"
+ "testString":
+ "assert.strictEqual(euler244(), 96356848, 'euler244() should return 96356848.');"
}
],
"solutions": [],
@@ -11407,7 +11815,8 @@
"tests": [
{
"text": "euler245() should return 288084712410001.",
- "testString": "assert.strictEqual(euler245(), 288084712410001, 'euler245() should return 288084712410001.');"
+ "testString":
+ "assert.strictEqual(euler245(), 288084712410001, 'euler245() should return 288084712410001.');"
}
],
"solutions": [],
@@ -11450,7 +11859,8 @@
"tests": [
{
"text": "euler246() should return 810834388.",
- "testString": "assert.strictEqual(euler246(), 810834388, 'euler246() should return 810834388.');"
+ "testString":
+ "assert.strictEqual(euler246(), 810834388, 'euler246() should return 810834388.');"
}
],
"solutions": [],
@@ -11501,7 +11911,8 @@
"tests": [
{
"text": "euler247() should return 782252.",
- "testString": "assert.strictEqual(euler247(), 782252, 'euler247() should return 782252.');"
+ "testString":
+ "assert.strictEqual(euler247(), 782252, 'euler247() should return 782252.');"
}
],
"solutions": [],
@@ -11545,11 +11956,13 @@
{
"id": "5900f4651000cf542c50ff77",
"challengeType": 5,
- "title": "Problem 248: Numbers for which Euler’s totient function equals 13!",
+ "title":
+ "Problem 248: Numbers for which Euler’s totient function equals 13!",
"tests": [
{
"text": "euler248() should return 23507044290.",
- "testString": "assert.strictEqual(euler248(), 23507044290, 'euler248() should return 23507044290.');"
+ "testString":
+ "assert.strictEqual(euler248(), 23507044290, 'euler248() should return 23507044290.');"
}
],
"solutions": [],
@@ -11583,7 +11996,8 @@
"tests": [
{
"text": "euler249() should return 9275262564250418.",
- "testString": "assert.strictEqual(euler249(), 9275262564250418, 'euler249() should return 9275262564250418.');"
+ "testString":
+ "assert.strictEqual(euler249(), 9275262564250418, 'euler249() should return 9275262564250418.');"
}
],
"solutions": [],
@@ -11618,7 +12032,8 @@
"tests": [
{
"text": "euler250() should return 1425480602091519.",
- "testString": "assert.strictEqual(euler250(), 1425480602091519, 'euler250() should return 1425480602091519.');"
+ "testString":
+ "assert.strictEqual(euler250(), 1425480602091519, 'euler250() should return 1425480602091519.');"
}
],
"solutions": [],
@@ -11651,7 +12066,8 @@
"tests": [
{
"text": "euler251() should return 18946051.",
- "testString": "assert.strictEqual(euler251(), 18946051, 'euler251() should return 18946051.');"
+ "testString":
+ "assert.strictEqual(euler251(), 18946051, 'euler251() should return 18946051.');"
}
],
"solutions": [],
@@ -11694,7 +12110,8 @@
"tests": [
{
"text": "euler252() should return 104924.",
- "testString": "assert.strictEqual(euler252(), 104924, 'euler252() should return 104924.');"
+ "testString":
+ "assert.strictEqual(euler252(), 104924, 'euler252() should return 104924.');"
}
],
"solutions": [],
@@ -11753,7 +12170,8 @@
"tests": [
{
"text": "euler253() should return 11.492847.",
- "testString": "assert.strictEqual(euler253(), 11.492847, 'euler253() should return 11.492847.');"
+ "testString":
+ "assert.strictEqual(euler253(), 11.492847, 'euler253() should return 11.492847.');"
}
],
"solutions": [],
@@ -11804,7 +12222,8 @@
"tests": [
{
"text": "euler254() should return 8184523820510.",
- "testString": "assert.strictEqual(euler254(), 8184523820510, 'euler254() should return 8184523820510.');"
+ "testString":
+ "assert.strictEqual(euler254(), 8184523820510, 'euler254() should return 8184523820510.');"
}
],
"solutions": [],
@@ -11847,7 +12266,8 @@
"tests": [
{
"text": "euler255() should return 4.447401118.",
- "testString": "assert.strictEqual(euler255(), 4.447401118, 'euler255() should return 4.447401118.');"
+ "testString":
+ "assert.strictEqual(euler255(), 4.447401118, 'euler255() should return 4.447401118.');"
}
],
"solutions": [],
@@ -11903,7 +12323,8 @@
"tests": [
{
"text": "euler256() should return 85765680.",
- "testString": "assert.strictEqual(euler256(), 85765680, 'euler256() should return 85765680.');"
+ "testString":
+ "assert.strictEqual(euler256(), 85765680, 'euler256() should return 85765680.');"
}
],
"solutions": [],
@@ -11961,7 +12382,8 @@
"tests": [
{
"text": "euler257() should return 139012411.",
- "testString": "assert.strictEqual(euler257(), 139012411, 'euler257() should return 139012411.');"
+ "testString":
+ "assert.strictEqual(euler257(), 139012411, 'euler257() should return 139012411.');"
}
],
"solutions": [],
@@ -12006,7 +12428,8 @@
"tests": [
{
"text": "euler258() should return 12747994.",
- "testString": "assert.strictEqual(euler258(), 12747994, 'euler258() should return 12747994.');"
+ "testString":
+ "assert.strictEqual(euler258(), 12747994, 'euler258() should return 12747994.');"
}
],
"solutions": [],
@@ -12043,7 +12466,8 @@
"tests": [
{
"text": "euler259() should return 20101196798.",
- "testString": "assert.strictEqual(euler259(), 20101196798, 'euler259() should return 20101196798.');"
+ "testString":
+ "assert.strictEqual(euler259(), 20101196798, 'euler259() should return 20101196798.');"
}
],
"solutions": [],
@@ -12086,7 +12510,8 @@
"tests": [
{
"text": "euler260() should return 167542057.",
- "testString": "assert.strictEqual(euler260(), 167542057, 'euler260() should return 167542057.');"
+ "testString":
+ "assert.strictEqual(euler260(), 167542057, 'euler260() should return 167542057.');"
}
],
"solutions": [],
@@ -12138,7 +12563,8 @@
"tests": [
{
"text": "euler261() should return 238890850232021.",
- "testString": "assert.strictEqual(euler261(), 238890850232021, 'euler261() should return 238890850232021.');"
+ "testString":
+ "assert.strictEqual(euler261(), 238890850232021, 'euler261() should return 238890850232021.');"
}
],
"solutions": [],
@@ -12180,7 +12606,8 @@
"tests": [
{
"text": "euler262() should return 2531.205.",
- "testString": "assert.strictEqual(euler262(), 2531.205, 'euler262() should return 2531.205.');"
+ "testString":
+ "assert.strictEqual(euler262(), 2531.205, 'euler262() should return 2531.205.');"
}
],
"solutions": [],
@@ -12228,7 +12655,8 @@
"tests": [
{
"text": "euler263() should return 2039506520.",
- "testString": "assert.strictEqual(euler263(), 2039506520, 'euler263() should return 2039506520.');"
+ "testString":
+ "assert.strictEqual(euler263(), 2039506520, 'euler263() should return 2039506520.');"
}
],
"solutions": [],
@@ -12280,7 +12708,8 @@
"tests": [
{
"text": "euler264() should return 2816417.1055.",
- "testString": "assert.strictEqual(euler264(), 2816417.1055, 'euler264() should return 2816417.1055.');"
+ "testString":
+ "assert.strictEqual(euler264(), 2816417.1055, 'euler264() should return 2816417.1055.');"
}
],
"solutions": [],
@@ -12333,7 +12762,8 @@
"tests": [
{
"text": "euler265() should return 209110240768.",
- "testString": "assert.strictEqual(euler265(), 209110240768, 'euler265() should return 209110240768.');"
+ "testString":
+ "assert.strictEqual(euler265(), 209110240768, 'euler265() should return 209110240768.');"
}
],
"solutions": [],
@@ -12379,7 +12809,8 @@
"tests": [
{
"text": "euler266() should return 1096883702440585.",
- "testString": "assert.strictEqual(euler266(), 1096883702440585, 'euler266() should return 1096883702440585.');"
+ "testString":
+ "assert.strictEqual(euler266(), 1096883702440585, 'euler266() should return 1096883702440585.');"
}
],
"solutions": [],
@@ -12419,7 +12850,8 @@
"tests": [
{
"text": "euler267() should return 0.999992836187.",
- "testString": "assert.strictEqual(euler267(), 0.999992836187, 'euler267() should return 0.999992836187.');"
+ "testString":
+ "assert.strictEqual(euler267(), 0.999992836187, 'euler267() should return 0.999992836187.');"
}
],
"solutions": [],
@@ -12453,11 +12885,13 @@
{
"id": "5900f4791000cf542c50ff8b",
"challengeType": 5,
- "title": "Problem 268: Counting numbers with at least four distinct prime factors less than 100",
+ "title":
+ "Problem 268: Counting numbers with at least four distinct prime factors less than 100",
"tests": [
{
"text": "euler268() should return 785478606870985.",
- "testString": "assert.strictEqual(euler268(), 785478606870985, 'euler268() should return 785478606870985.');"
+ "testString":
+ "assert.strictEqual(euler268(), 785478606870985, 'euler268() should return 785478606870985.');"
}
],
"solutions": [],
@@ -12492,7 +12926,8 @@
"tests": [
{
"text": "euler269() should return 1311109198529286.",
- "testString": "assert.strictEqual(euler269(), 1311109198529286, 'euler269() should return 1311109198529286.');"
+ "testString":
+ "assert.strictEqual(euler269(), 1311109198529286, 'euler269() should return 1311109198529286.');"
}
],
"solutions": [],
@@ -12535,7 +12970,8 @@
"tests": [
{
"text": "euler270() should return 82282080.",
- "testString": "assert.strictEqual(euler270(), 82282080, 'euler270() should return 82282080.');"
+ "testString":
+ "assert.strictEqual(euler270(), 82282080, 'euler270() should return 82282080.');"
}
],
"solutions": [],
@@ -12575,7 +13011,8 @@
"tests": [
{
"text": "euler271() should return 4617456485273130000.",
- "testString": "assert.strictEqual(euler271(), 4617456485273130000, 'euler271() should return 4617456485273130000.');"
+ "testString":
+ "assert.strictEqual(euler271(), 4617456485273130000, 'euler271() should return 4617456485273130000.');"
}
],
"solutions": [],
@@ -12614,7 +13051,8 @@
"tests": [
{
"text": "euler272() should return 8495585919506151000.",
- "testString": "assert.strictEqual(euler272(), 8495585919506151000, 'euler272() should return 8495585919506151000.');"
+ "testString":
+ "assert.strictEqual(euler272(), 8495585919506151000, 'euler272() should return 8495585919506151000.');"
}
],
"solutions": [],
@@ -12653,7 +13091,8 @@
"tests": [
{
"text": "euler273() should return 2032447591196869000.",
- "testString": "assert.strictEqual(euler273(), 2032447591196869000, 'euler273() should return 2032447591196869000.');"
+ "testString":
+ "assert.strictEqual(euler273(), 2032447591196869000, 'euler273() should return 2032447591196869000.');"
}
],
"solutions": [],
@@ -12692,7 +13131,8 @@
"tests": [
{
"text": "euler274() should return 1601912348822.",
- "testString": "assert.strictEqual(euler274(), 1601912348822, 'euler274() should return 1601912348822.');"
+ "testString":
+ "assert.strictEqual(euler274(), 1601912348822, 'euler274() should return 1601912348822.');"
}
],
"solutions": [],
@@ -12737,7 +13177,8 @@
"tests": [
{
"text": "euler275() should return 15030564.",
- "testString": "assert.strictEqual(euler275(), 15030564, 'euler275() should return 15030564.');"
+ "testString":
+ "assert.strictEqual(euler275(), 15030564, 'euler275() should return 15030564.');"
}
],
"solutions": [],
@@ -12778,7 +13219,8 @@
"tests": [
{
"text": "euler276() should return 5777137137739633000.",
- "testString": "assert.strictEqual(euler276(), 5777137137739633000, 'euler276() should return 5777137137739633000.');"
+ "testString":
+ "assert.strictEqual(euler276(), 5777137137739633000, 'euler276() should return 5777137137739633000.');"
}
],
"solutions": [],
@@ -12813,7 +13255,8 @@
"tests": [
{
"text": "euler277() should return 1125977393124310.",
- "testString": "assert.strictEqual(euler277(), 1125977393124310, 'euler277() should return 1125977393124310.');"
+ "testString":
+ "assert.strictEqual(euler277(), 1125977393124310, 'euler277() should return 1125977393124310.');"
}
],
"solutions": [],
@@ -12870,7 +13313,8 @@
"tests": [
{
"text": "euler278() should return 1228215747273908500.",
- "testString": "assert.strictEqual(euler278(), 1228215747273908500, 'euler278() should return 1228215747273908500.');"
+ "testString":
+ "assert.strictEqual(euler278(), 1228215747273908500, 'euler278() should return 1228215747273908500.');"
}
],
"solutions": [],
@@ -12909,11 +13353,13 @@
{
"id": "5900f4841000cf542c50ff96",
"challengeType": 5,
- "title": "Problem 279: Triangles with integral sides and an integral angle",
+ "title":
+ "Problem 279: Triangles with integral sides and an integral angle",
"tests": [
{
"text": "euler279() should return 416577688.",
- "testString": "assert.strictEqual(euler279(), 416577688, 'euler279() should return 416577688.');"
+ "testString":
+ "assert.strictEqual(euler279(), 416577688, 'euler279() should return 416577688.');"
}
],
"solutions": [],
@@ -12946,7 +13392,8 @@
"tests": [
{
"text": "euler280() should return 430.088247.",
- "testString": "assert.strictEqual(euler280(), 430.088247, 'euler280() should return 430.088247.');"
+ "testString":
+ "assert.strictEqual(euler280(), 430.088247, 'euler280() should return 430.088247.');"
}
],
"solutions": [],
@@ -12984,7 +13431,8 @@
"tests": [
{
"text": "euler281() should return 1485776387445623.",
- "testString": "assert.strictEqual(euler281(), 1485776387445623, 'euler281() should return 1485776387445623.');"
+ "testString":
+ "assert.strictEqual(euler281(), 1485776387445623, 'euler281() should return 1485776387445623.');"
}
],
"solutions": [],
@@ -13025,7 +13473,8 @@
"tests": [
{
"text": "euler282() should return 1098988351.",
- "testString": "assert.strictEqual(euler282(), 1098988351, 'euler282() should return 1098988351.');"
+ "testString":
+ "assert.strictEqual(euler282(), 1098988351, 'euler282() should return 1098988351.');"
}
],
"solutions": [],
@@ -13061,11 +13510,13 @@
{
"id": "5900f4881000cf542c50ff9a",
"challengeType": 5,
- "title": "Problem 283: Integer sided triangles for which the area/perimeter ratio is integral",
+ "title":
+ "Problem 283: Integer sided triangles for which the area/perimeter ratio is integral",
"tests": [
{
"text": "euler283() should return 28038042525570324.",
- "testString": "assert.strictEqual(euler283(), 28038042525570324, 'euler283() should return 28038042525570324.');"
+ "testString":
+ "assert.strictEqual(euler283(), 28038042525570324, 'euler283() should return 28038042525570324.');"
}
],
"solutions": [],
@@ -13104,7 +13555,8 @@
"tests": [
{
"text": "euler284() should return 5a411d7b.",
- "testString": "assert.strictEqual(euler284(), 5a411d7b, 'euler284() should return 5a411d7b.');"
+ "testString":
+ "assert.strictEqual(euler284(), 5a411d7b, 'euler284() should return 5a411d7b.');"
}
],
"solutions": [],
@@ -13144,7 +13596,8 @@
"tests": [
{
"text": "euler285() should return 157055.80999.",
- "testString": "assert.strictEqual(euler285(), 157055.80999, 'euler285() should return 157055.80999.');"
+ "testString":
+ "assert.strictEqual(euler285(), 157055.80999, 'euler285() should return 157055.80999.');"
}
],
"solutions": [],
@@ -13186,7 +13639,8 @@
"tests": [
{
"text": "euler286() should return 52.6494571953.",
- "testString": "assert.strictEqual(euler286(), 52.6494571953, 'euler286() should return 52.6494571953.');"
+ "testString":
+ "assert.strictEqual(euler286(), 52.6494571953, 'euler286() should return 52.6494571953.');"
}
],
"solutions": [],
@@ -13219,11 +13673,13 @@
{
"id": "5900f48b1000cf542c50ff9e",
"challengeType": 5,
- "title": "Problem 287: Quadtree encoding (a simple compression algorithm)",
+ "title":
+ "Problem 287: Quadtree encoding (a simple compression algorithm)",
"tests": [
{
"text": "euler287() should return 313135496.",
- "testString": "assert.strictEqual(euler287(), 313135496, 'euler287() should return 313135496.');"
+ "testString":
+ "assert.strictEqual(euler287(), 313135496, 'euler287() should return 313135496.');"
}
],
"solutions": [],
@@ -13271,7 +13727,8 @@
"tests": [
{
"text": "euler288() should return 605857431263982000.",
- "testString": "assert.strictEqual(euler288(), 605857431263982000, 'euler288() should return 605857431263982000.');"
+ "testString":
+ "assert.strictEqual(euler288(), 605857431263982000, 'euler288() should return 605857431263982000.');"
}
],
"solutions": [],
@@ -13319,7 +13776,8 @@
"tests": [
{
"text": "euler289() should return 6567944538.",
- "testString": "assert.strictEqual(euler289(), 6567944538, 'euler289() should return 6567944538.');"
+ "testString":
+ "assert.strictEqual(euler289(), 6567944538, 'euler289() should return 6567944538.');"
}
],
"solutions": [],
@@ -13366,7 +13824,8 @@
"tests": [
{
"text": "euler290() should return 20444710234716470.",
- "testString": "assert.strictEqual(euler290(), 20444710234716470, 'euler290() should return 20444710234716470.');"
+ "testString":
+ "assert.strictEqual(euler290(), 20444710234716470, 'euler290() should return 20444710234716470.');"
}
],
"solutions": [],
@@ -13399,7 +13858,8 @@
"tests": [
{
"text": "euler291() should return 4037526.",
- "testString": "assert.strictEqual(euler291(), 4037526, 'euler291() should return 4037526.');"
+ "testString":
+ "assert.strictEqual(euler291(), 4037526, 'euler291() should return 4037526.');"
}
],
"solutions": [],
@@ -13435,7 +13895,8 @@
"tests": [
{
"text": "euler292() should return 3600060866.",
- "testString": "assert.strictEqual(euler292(), 3600060866, 'euler292() should return 3600060866.');"
+ "testString":
+ "assert.strictEqual(euler292(), 3600060866, 'euler292() should return 3600060866.');"
}
],
"solutions": [],
@@ -13475,7 +13936,8 @@
"tests": [
{
"text": "euler293() should return 2209.",
- "testString": "assert.strictEqual(euler293(), 2209, 'euler293() should return 2209.');"
+ "testString":
+ "assert.strictEqual(euler293(), 2209, 'euler293() should return 2209.');"
}
],
"solutions": [],
@@ -13520,7 +13982,8 @@
"tests": [
{
"text": "euler294() should return 789184709.",
- "testString": "assert.strictEqual(euler294(), 789184709, 'euler294() should return 789184709.');"
+ "testString":
+ "assert.strictEqual(euler294(), 789184709, 'euler294() should return 789184709.');"
}
],
"solutions": [],
@@ -13564,7 +14027,8 @@
"tests": [
{
"text": "euler295() should return 4884650818.",
- "testString": "assert.strictEqual(euler295(), 4884650818, 'euler295() should return 4884650818.');"
+ "testString":
+ "assert.strictEqual(euler295(), 4884650818, 'euler295() should return 4884650818.');"
}
],
"solutions": [],
@@ -13619,7 +14083,8 @@
"tests": [
{
"text": "euler296() should return 1137208419.",
- "testString": "assert.strictEqual(euler296(), 1137208419, 'euler296() should return 1137208419.');"
+ "testString":
+ "assert.strictEqual(euler296(), 1137208419, 'euler296() should return 1137208419.');"
}
],
"solutions": [],
@@ -13657,7 +14122,8 @@
"tests": [
{
"text": "euler297() should return 2252639041804718000.",
- "testString": "assert.strictEqual(euler297(), 2252639041804718000, 'euler297() should return 2252639041804718000.');"
+ "testString":
+ "assert.strictEqual(euler297(), 2252639041804718000, 'euler297() should return 2252639041804718000.');"
}
],
"solutions": [],
@@ -13700,7 +14166,8 @@
"tests": [
{
"text": "euler298() should return 1.76882294.",
- "testString": "assert.strictEqual(euler298(), 1.76882294, 'euler298() should return 1.76882294.');"
+ "testString":
+ "assert.strictEqual(euler298(), 1.76882294, 'euler298() should return 1.76882294.');"
}
],
"solutions": [],
@@ -13807,7 +14274,8 @@
"tests": [
{
"text": "euler299() should return 549936643.",
- "testString": "assert.strictEqual(euler299(), 549936643, 'euler299() should return 549936643.');"
+ "testString":
+ "assert.strictEqual(euler299(), 549936643, 'euler299() should return 549936643.');"
}
],
"solutions": [],
@@ -13853,7 +14321,8 @@
"tests": [
{
"text": "euler300() should return 8.0540771484375.",
- "testString": "assert.strictEqual(euler300(), 8.0540771484375, 'euler300() should return 8.0540771484375.');"
+ "testString":
+ "assert.strictEqual(euler300(), 8.0540771484375, 'euler300() should return 8.0540771484375.');"
}
],
"solutions": [],
@@ -13903,7 +14372,8 @@
"tests": [
{
"text": "euler301() should return 2178309.",
- "testString": "assert.strictEqual(euler301(), 2178309, 'euler301() should return 2178309.');"
+ "testString":
+ "assert.strictEqual(euler301(), 2178309, 'euler301() should return 2178309.');"
}
],
"solutions": [],
@@ -13951,7 +14421,8 @@
"tests": [
{
"text": "euler302() should return 1170060.",
- "testString": "assert.strictEqual(euler302(), 1170060, 'euler302() should return 1170060.');"
+ "testString":
+ "assert.strictEqual(euler302(), 1170060, 'euler302() should return 1170060.');"
}
],
"solutions": [],
@@ -14002,7 +14473,8 @@
"tests": [
{
"text": "euler303() should return 1111981904675169.",
- "testString": "assert.strictEqual(euler303(), 1111981904675169, 'euler303() should return 1111981904675169.');"
+ "testString":
+ "assert.strictEqual(euler303(), 1111981904675169, 'euler303() should return 1111981904675169.');"
}
],
"solutions": [],
@@ -14039,7 +14511,8 @@
"tests": [
{
"text": "euler304() should return 283988410192.",
- "testString": "assert.strictEqual(euler304(), 283988410192, 'euler304() should return 283988410192.');"
+ "testString":
+ "assert.strictEqual(euler304(), 283988410192, 'euler304() should return 283988410192.');"
}
],
"solutions": [],
@@ -14087,7 +14560,8 @@
"tests": [
{
"text": "euler305() should return 18174995535140.",
- "testString": "assert.strictEqual(euler305(), 18174995535140, 'euler305() should return 18174995535140.');"
+ "testString":
+ "assert.strictEqual(euler305(), 18174995535140, 'euler305() should return 18174995535140.');"
}
],
"solutions": [],
@@ -14131,7 +14605,8 @@
"tests": [
{
"text": "euler306() should return 852938.",
- "testString": "assert.strictEqual(euler306(), 852938, 'euler306() should return 852938.');"
+ "testString":
+ "assert.strictEqual(euler306(), 852938, 'euler306() should return 852938.');"
}
],
"solutions": [],
@@ -14181,7 +14656,8 @@
"tests": [
{
"text": "euler307() should return 0.7311720251.",
- "testString": "assert.strictEqual(euler307(), 0.7311720251, 'euler307() should return 0.7311720251.');"
+ "testString":
+ "assert.strictEqual(euler307(), 0.7311720251, 'euler307() should return 0.7311720251.');"
}
],
"solutions": [],
@@ -14221,7 +14697,8 @@
"tests": [
{
"text": "euler308() should return 1539669807660924.",
- "testString": "assert.strictEqual(euler308(), 1539669807660924, 'euler308() should return 1539669807660924.');"
+ "testString":
+ "assert.strictEqual(euler308(), 1539669807660924, 'euler308() should return 1539669807660924.');"
}
],
"solutions": [],
@@ -14292,7 +14769,8 @@
"tests": [
{
"text": "euler309() should return 210139.",
- "testString": "assert.strictEqual(euler309(), 210139, 'euler309() should return 210139.');"
+ "testString":
+ "assert.strictEqual(euler309(), 210139, 'euler309() should return 210139.');"
}
],
"solutions": [],
@@ -14335,7 +14813,8 @@
"tests": [
{
"text": "euler310() should return 2586528661783.",
- "testString": "assert.strictEqual(euler310(), 2586528661783, 'euler310() should return 2586528661783.');"
+ "testString":
+ "assert.strictEqual(euler310(), 2586528661783, 'euler310() should return 2586528661783.');"
}
],
"solutions": [],
@@ -14374,7 +14853,8 @@
"tests": [
{
"text": "euler311() should return 2466018557.",
- "testString": "assert.strictEqual(euler311(), 2466018557, 'euler311() should return 2466018557.');"
+ "testString":
+ "assert.strictEqual(euler311(), 2466018557, 'euler311() should return 2466018557.');"
}
],
"solutions": [],
@@ -14421,7 +14901,8 @@
"tests": [
{
"text": "euler312() should return 324681947.",
- "testString": "assert.strictEqual(euler312(), 324681947, 'euler312() should return 324681947.');"
+ "testString":
+ "assert.strictEqual(euler312(), 324681947, 'euler312() should return 324681947.');"
}
],
"solutions": [],
@@ -14472,7 +14953,8 @@
"tests": [
{
"text": "euler313() should return 2057774861813004.",
- "testString": "assert.strictEqual(euler313(), 2057774861813004, 'euler313() should return 2057774861813004.');"
+ "testString":
+ "assert.strictEqual(euler313(), 2057774861813004, 'euler313() should return 2057774861813004.');"
}
],
"solutions": [],
@@ -14515,7 +14997,8 @@
"tests": [
{
"text": "euler314() should return 132.52756426.",
- "testString": "assert.strictEqual(euler314(), 132.52756426, 'euler314() should return 132.52756426.');"
+ "testString":
+ "assert.strictEqual(euler314(), 132.52756426, 'euler314() should return 132.52756426.');"
}
],
"solutions": [],
@@ -14565,7 +15048,8 @@
"tests": [
{
"text": "euler315() should return 13625242.",
- "testString": "assert.strictEqual(euler315(), 13625242, 'euler315() should return 13625242.');"
+ "testString":
+ "assert.strictEqual(euler315(), 13625242, 'euler315() should return 13625242.');"
}
],
"solutions": [],
@@ -14644,7 +15128,8 @@
"tests": [
{
"text": "euler316() should return 542934735751917760.",
- "testString": "assert.strictEqual(euler316(), 542934735751917760, 'euler316() should return 542934735751917760.');"
+ "testString":
+ "assert.strictEqual(euler316(), 542934735751917760, 'euler316() should return 542934735751917760.');"
}
],
"solutions": [],
@@ -14691,7 +15176,8 @@
"tests": [
{
"text": "euler317() should return 1856532.8455.",
- "testString": "assert.strictEqual(euler317(), 1856532.8455, 'euler317() should return 1856532.8455.');"
+ "testString":
+ "assert.strictEqual(euler317(), 1856532.8455, 'euler317() should return 1856532.8455.');"
}
],
"solutions": [],
@@ -14731,7 +15217,8 @@
"tests": [
{
"text": "euler318() should return 709313889.",
- "testString": "assert.strictEqual(euler318(), 709313889, 'euler318() should return 709313889.');"
+ "testString":
+ "assert.strictEqual(euler318(), 709313889, 'euler318() should return 709313889.');"
}
],
"solutions": [],
@@ -14790,7 +15277,8 @@
"tests": [
{
"text": "euler319() should return 268457129.",
- "testString": "assert.strictEqual(euler319(), 268457129, 'euler319() should return 268457129.');"
+ "testString":
+ "assert.strictEqual(euler319(), 268457129, 'euler319() should return 268457129.');"
}
],
"solutions": [],
@@ -14838,7 +15326,8 @@
"tests": [
{
"text": "euler320() should return 278157919195482660.",
- "testString": "assert.strictEqual(euler320(), 278157919195482660, 'euler320() should return 278157919195482660.');"
+ "testString":
+ "assert.strictEqual(euler320(), 278157919195482660, 'euler320() should return 278157919195482660.');"
}
],
"solutions": [],
@@ -14879,7 +15368,8 @@
"tests": [
{
"text": "euler321() should return 2470433131948040.",
- "testString": "assert.strictEqual(euler321(), 2470433131948040, 'euler321() should return 2470433131948040.');"
+ "testString":
+ "assert.strictEqual(euler321(), 2470433131948040, 'euler321() should return 2470433131948040.');"
}
],
"solutions": [],
@@ -14926,7 +15416,8 @@
"tests": [
{
"text": "euler322() should return 999998760323314000.",
- "testString": "assert.strictEqual(euler322(), 999998760323314000, 'euler322() should return 999998760323314000.');"
+ "testString":
+ "assert.strictEqual(euler322(), 999998760323314000, 'euler322() should return 999998760323314000.');"
}
],
"solutions": [],
@@ -14963,7 +15454,8 @@
"tests": [
{
"text": "euler323() should return 6.3551758451.",
- "testString": "assert.strictEqual(euler323(), 6.3551758451, 'euler323() should return 6.3551758451.');"
+ "testString":
+ "assert.strictEqual(euler323(), 6.3551758451, 'euler323() should return 6.3551758451.');"
}
],
"solutions": [],
@@ -15003,7 +15495,8 @@
"tests": [
{
"text": "euler324() should return 96972774.",
- "testString": "assert.strictEqual(euler324(), 96972774, 'euler324() should return 96972774.');"
+ "testString":
+ "assert.strictEqual(euler324(), 96972774, 'euler324() should return 96972774.');"
}
],
"solutions": [],
@@ -15039,7 +15532,8 @@
"tests": [
{
"text": "euler325() should return 54672965.",
- "testString": "assert.strictEqual(euler325(), 54672965, 'euler325() should return 54672965.');"
+ "testString":
+ "assert.strictEqual(euler325(), 54672965, 'euler325() should return 54672965.');"
}
],
"solutions": [],
@@ -15096,7 +15590,8 @@
"tests": [
{
"text": "euler326() should return 1966666166408794400.",
- "testString": "assert.strictEqual(euler326(), 1966666166408794400, 'euler326() should return 1966666166408794400.');"
+ "testString":
+ "assert.strictEqual(euler326(), 1966666166408794400, 'euler326() should return 1966666166408794400.');"
}
],
"solutions": [],
@@ -15142,7 +15637,8 @@
"tests": [
{
"text": "euler327() should return 34315549139516.",
- "testString": "assert.strictEqual(euler327(), 34315549139516, 'euler327() should return 34315549139516.');"
+ "testString":
+ "assert.strictEqual(euler327(), 34315549139516, 'euler327() should return 34315549139516.');"
}
],
"solutions": [],
@@ -15196,7 +15692,8 @@
"tests": [
{
"text": "euler328() should return 260511850222.",
- "testString": "assert.strictEqual(euler328(), 260511850222, 'euler328() should return 260511850222.');"
+ "testString":
+ "assert.strictEqual(euler328(), 260511850222, 'euler328() should return 260511850222.');"
}
],
"solutions": [],
@@ -15250,8 +15747,10 @@
"title": "Problem 329: Prime Frog",
"tests": [
{
- "text": "euler329() should return 199740353 / 29386561536000.",
- "testString": "assert.strictEqual(euler329(), 199740353 / 29386561536000, 'euler329() should return 199740353 / 29386561536000.');"
+ "text":
+ "euler329() should return 199740353 / 29386561536000.",
+ "testString":
+ "assert.strictEqual(euler329(), 199740353 / 29386561536000, 'euler329() should return 199740353 / 29386561536000.');"
}
],
"solutions": [],
@@ -15295,7 +15794,8 @@
"tests": [
{
"text": "euler330() should return 15955822.",
- "testString": "assert.strictEqual(euler330(), 15955822, 'euler330() should return 15955822.');"
+ "testString":
+ "assert.strictEqual(euler330(), 15955822, 'euler330() should return 15955822.');"
}
],
"solutions": [],
@@ -15368,7 +15868,8 @@
"tests": [
{
"text": "euler331() should return 467178235146843500.",
- "testString": "assert.strictEqual(euler331(), 467178235146843500, 'euler331() should return 467178235146843500.');"
+ "testString":
+ "assert.strictEqual(euler331(), 467178235146843500, 'euler331() should return 467178235146843500.');"
}
],
"solutions": [],
@@ -15418,7 +15919,8 @@
"tests": [
{
"text": "euler332() should return 2717.751525.",
- "testString": "assert.strictEqual(euler332(), 2717.751525, 'euler332() should return 2717.751525.');"
+ "testString":
+ "assert.strictEqual(euler332(), 2717.751525, 'euler332() should return 2717.751525.');"
}
],
"solutions": [],
@@ -15464,7 +15966,8 @@
"tests": [
{
"text": "euler333() should return 3053105.",
- "testString": "assert.strictEqual(euler333(), 3053105, 'euler333() should return 3053105.');"
+ "testString":
+ "assert.strictEqual(euler333(), 3053105, 'euler333() should return 3053105.');"
}
],
"solutions": [],
@@ -15512,7 +16015,8 @@
"tests": [
{
"text": "euler334() should return 150320021261690850.",
- "testString": "assert.strictEqual(euler334(), 150320021261690850, 'euler334() should return 150320021261690850.');"
+ "testString":
+ "assert.strictEqual(euler334(), 150320021261690850, 'euler334() should return 150320021261690850.');"
}
],
"solutions": [],
@@ -15599,7 +16103,8 @@
"tests": [
{
"text": "euler335() should return 5032316.",
- "testString": "assert.strictEqual(euler335(), 5032316, 'euler335() should return 5032316.');"
+ "testString":
+ "assert.strictEqual(euler335(), 5032316, 'euler335() should return 5032316.');"
}
],
"solutions": [],
@@ -15640,7 +16145,8 @@
"tests": [
{
"text": "euler336() should return CAGBIHEFJDK.",
- "testString": "assert.strictEqual(euler336(), CAGBIHEFJDK, 'euler336() should return CAGBIHEFJDK.');"
+ "testString":
+ "assert.strictEqual(euler336(), CAGBIHEFJDK, 'euler336() should return CAGBIHEFJDK.');"
}
],
"solutions": [],
@@ -15686,7 +16192,8 @@
"tests": [
{
"text": "euler337() should return 85068035.",
- "testString": "assert.strictEqual(euler337(), 85068035, 'euler337() should return 85068035.');"
+ "testString":
+ "assert.strictEqual(euler337(), 85068035, 'euler337() should return 85068035.');"
}
],
"solutions": [],
@@ -15728,7 +16235,8 @@
"tests": [
{
"text": "euler338() should return 15614292.",
- "testString": "assert.strictEqual(euler338(), 15614292, 'euler338() should return 15614292.');"
+ "testString":
+ "assert.strictEqual(euler338(), 15614292, 'euler338() should return 15614292.');"
}
],
"solutions": [],
@@ -15778,7 +16286,8 @@
"tests": [
{
"text": "euler339() should return 19823.542204.",
- "testString": "assert.strictEqual(euler339(), 19823.542204, 'euler339() should return 19823.542204.');"
+ "testString":
+ "assert.strictEqual(euler339(), 19823.542204, 'euler339() should return 19823.542204.');"
}
],
"solutions": [],
@@ -15820,7 +16329,8 @@
"tests": [
{
"text": "euler340() should return 291504964.",
- "testString": "assert.strictEqual(euler340(), 291504964, 'euler340() should return 291504964.');"
+ "testString":
+ "assert.strictEqual(euler340(), 291504964, 'euler340() should return 291504964.');"
}
],
"solutions": [],
@@ -15865,7 +16375,8 @@
"tests": [
{
"text": "euler341() should return 56098610614277016.",
- "testString": "assert.strictEqual(euler341(), 56098610614277016, 'euler341() should return 56098610614277016.');"
+ "testString":
+ "assert.strictEqual(euler341(), 56098610614277016, 'euler341() should return 56098610614277016.');"
}
],
"solutions": [],
@@ -15906,7 +16417,8 @@
"tests": [
{
"text": "euler342() should return 5943040885644.",
- "testString": "assert.strictEqual(euler342(), 5943040885644, 'euler342() should return 5943040885644.');"
+ "testString":
+ "assert.strictEqual(euler342(), 5943040885644, 'euler342() should return 5943040885644.');"
}
],
"solutions": [],
@@ -15947,7 +16459,8 @@
"tests": [
{
"text": "euler343() should return 269533451410884200.",
- "testString": "assert.strictEqual(euler343(), 269533451410884200, 'euler343() should return 269533451410884200.');"
+ "testString":
+ "assert.strictEqual(euler343(), 269533451410884200, 'euler343() should return 269533451410884200.');"
}
],
"solutions": [],
@@ -16001,7 +16514,8 @@
"tests": [
{
"text": "euler344() should return 65579304332.",
- "testString": "assert.strictEqual(euler344(), 65579304332, 'euler344() should return 65579304332.');"
+ "testString":
+ "assert.strictEqual(euler344(), 65579304332, 'euler344() should return 65579304332.');"
}
],
"solutions": [],
@@ -16054,7 +16568,8 @@
"tests": [
{
"text": "euler345() should return 13938.",
- "testString": "assert.strictEqual(euler345(), 13938, 'euler345() should return 13938.');"
+ "testString":
+ "assert.strictEqual(euler345(), 13938, 'euler345() should return 13938.');"
}
],
"solutions": [],
@@ -16112,7 +16627,8 @@
"tests": [
{
"text": "euler346() should return 336108797689259260.",
- "testString": "assert.strictEqual(euler346(), 336108797689259260, 'euler346() should return 336108797689259260.');"
+ "testString":
+ "assert.strictEqual(euler346(), 336108797689259260, 'euler346() should return 336108797689259260.');"
}
],
"solutions": [],
@@ -16150,7 +16666,8 @@
"tests": [
{
"text": "euler347() should return 11109800204052.",
- "testString": "assert.strictEqual(euler347(), 11109800204052, 'euler347() should return 11109800204052.');"
+ "testString":
+ "assert.strictEqual(euler347(), 11109800204052, 'euler347() should return 11109800204052.');"
}
],
"solutions": [],
@@ -16197,7 +16714,8 @@
"tests": [
{
"text": "euler348() should return 1004195061.",
- "testString": "assert.strictEqual(euler348(), 1004195061, 'euler348() should return 1004195061.');"
+ "testString":
+ "assert.strictEqual(euler348(), 1004195061, 'euler348() should return 1004195061.');"
}
],
"solutions": [],
@@ -16239,7 +16757,8 @@
"tests": [
{
"text": "euler349() should return 115384615384614940.",
- "testString": "assert.strictEqual(euler349(), 115384615384614940, 'euler349() should return 115384615384614940.');"
+ "testString":
+ "assert.strictEqual(euler349(), 115384615384614940, 'euler349() should return 115384615384614940.');"
}
],
"solutions": [],
@@ -16273,11 +16792,13 @@
{
"id": "5900f4cb1000cf542c50ffdd",
"challengeType": 5,
- "title": "Problem 350: Constraining the least greatest and the greatest least",
+ "title":
+ "Problem 350: Constraining the least greatest and the greatest least",
"tests": [
{
"text": "euler350() should return 84664213.",
- "testString": "assert.strictEqual(euler350(), 84664213, 'euler350() should return 84664213.');"
+ "testString":
+ "assert.strictEqual(euler350(), 84664213, 'euler350() should return 84664213.');"
}
],
"solutions": [],
@@ -16323,7 +16844,8 @@
"tests": [
{
"text": "euler351() should return 11762187201804552.",
- "testString": "assert.strictEqual(euler351(), 11762187201804552, 'euler351() should return 11762187201804552.');"
+ "testString":
+ "assert.strictEqual(euler351(), 11762187201804552, 'euler351() should return 11762187201804552.');"
}
],
"solutions": [],
@@ -16375,7 +16897,8 @@
"tests": [
{
"text": "euler352() should return 378563.260589.",
- "testString": "assert.strictEqual(euler352(), 378563.260589, 'euler352() should return 378563.260589.');"
+ "testString":
+ "assert.strictEqual(euler352(), 378563.260589, 'euler352() should return 378563.260589.');"
}
],
"solutions": [],
@@ -16445,7 +16968,8 @@
"tests": [
{
"text": "euler353() should return 1.2759860331.",
- "testString": "assert.strictEqual(euler353(), 1.2759860331, 'euler353() should return 1.2759860331.');"
+ "testString":
+ "assert.strictEqual(euler353(), 1.2759860331, 'euler353() should return 1.2759860331.');"
}
],
"solutions": [],
@@ -16506,7 +17030,8 @@
"tests": [
{
"text": "euler354() should return 58065134.",
- "testString": "assert.strictEqual(euler354(), 58065134, 'euler354() should return 58065134.');"
+ "testString":
+ "assert.strictEqual(euler354(), 58065134, 'euler354() should return 58065134.');"
}
],
"solutions": [],
@@ -16550,7 +17075,8 @@
"tests": [
{
"text": "euler355() should return 1726545007.",
- "testString": "assert.strictEqual(euler355(), 1726545007, 'euler355() should return 1726545007.');"
+ "testString":
+ "assert.strictEqual(euler355(), 1726545007, 'euler355() should return 1726545007.');"
}
],
"solutions": [],
@@ -16590,7 +17116,8 @@
"tests": [
{
"text": "euler356() should return 28010159.",
- "testString": "assert.strictEqual(euler356(), 28010159, 'euler356() should return 28010159.');"
+ "testString":
+ "assert.strictEqual(euler356(), 28010159, 'euler356() should return 28010159.');"
}
],
"solutions": [],
@@ -16630,7 +17157,8 @@
"tests": [
{
"text": "euler357() should return 1739023853137.",
- "testString": "assert.strictEqual(euler357(), 1739023853137, 'euler357() should return 1739023853137.');"
+ "testString":
+ "assert.strictEqual(euler357(), 1739023853137, 'euler357() should return 1739023853137.');"
}
],
"solutions": [],
@@ -16668,7 +17196,8 @@
"tests": [
{
"text": "euler358() should return 3284144505.",
- "testString": "assert.strictEqual(euler358(), 3284144505, 'euler358() should return 3284144505.');"
+ "testString":
+ "assert.strictEqual(euler358(), 3284144505, 'euler358() should return 3284144505.');"
}
],
"solutions": [],
@@ -16729,7 +17258,8 @@
"tests": [
{
"text": "euler359() should return 40632119.",
- "testString": "assert.strictEqual(euler359(), 40632119, 'euler359() should return 40632119.');"
+ "testString":
+ "assert.strictEqual(euler359(), 40632119, 'euler359() should return 40632119.');"
}
],
"solutions": [],
@@ -16791,7 +17321,8 @@
"tests": [
{
"text": "euler360() should return 878825614395267100.",
- "testString": "assert.strictEqual(euler360(), 878825614395267100, 'euler360() should return 878825614395267100.');"
+ "testString":
+ "assert.strictEqual(euler360(), 878825614395267100, 'euler360() should return 878825614395267100.');"
}
],
"solutions": [],
@@ -16835,7 +17366,8 @@
"tests": [
{
"text": "euler361() should return 178476944.",
- "testString": "assert.strictEqual(euler361(), 178476944, 'euler361() should return 178476944.');"
+ "testString":
+ "assert.strictEqual(euler361(), 178476944, 'euler361() should return 178476944.');"
}
],
"solutions": [],
@@ -16893,7 +17425,8 @@
"tests": [
{
"text": "euler362() should return 457895958010.",
- "testString": "assert.strictEqual(euler362(), 457895958010, 'euler362() should return 457895958010.');"
+ "testString":
+ "assert.strictEqual(euler362(), 457895958010, 'euler362() should return 457895958010.');"
}
],
"solutions": [],
@@ -16942,7 +17475,8 @@
"tests": [
{
"text": "euler363() should return 0.0000372091.",
- "testString": "assert.strictEqual(euler363(), 0.0000372091, 'euler363() should return 0.0000372091.');"
+ "testString":
+ "assert.strictEqual(euler363(), 0.0000372091, 'euler363() should return 0.0000372091.');"
}
],
"solutions": [],
@@ -16996,7 +17530,8 @@
"tests": [
{
"text": "euler364() should return 44855254.",
- "testString": "assert.strictEqual(euler364(), 44855254, 'euler364() should return 44855254.');"
+ "testString":
+ "assert.strictEqual(euler364(), 44855254, 'euler364() should return 44855254.');"
}
],
"solutions": [],
@@ -17041,7 +17576,8 @@
"tests": [
{
"text": "euler365() should return 162619462356610300.",
- "testString": "assert.strictEqual(euler365(), 162619462356610300, 'euler365() should return 162619462356610300.');"
+ "testString":
+ "assert.strictEqual(euler365(), 162619462356610300, 'euler365() should return 162619462356610300.');"
}
],
"solutions": [],
@@ -17080,7 +17616,8 @@
"tests": [
{
"text": "euler366() should return 88351299.",
- "testString": "assert.strictEqual(euler366(), 88351299, 'euler366() should return 88351299.');"
+ "testString":
+ "assert.strictEqual(euler366(), 88351299, 'euler366() should return 88351299.');"
}
],
"solutions": [],
@@ -17136,7 +17673,8 @@
"tests": [
{
"text": "euler367() should return 48271207.",
- "testString": "assert.strictEqual(euler367(), 48271207, 'euler367() should return 48271207.');"
+ "testString":
+ "assert.strictEqual(euler367(), 48271207, 'euler367() should return 48271207.');"
}
],
"solutions": [],
@@ -17185,7 +17723,8 @@
"tests": [
{
"text": "euler368() should return 253.6135092068.",
- "testString": "assert.strictEqual(euler368(), 253.6135092068, 'euler368() should return 253.6135092068.');"
+ "testString":
+ "assert.strictEqual(euler368(), 253.6135092068, 'euler368() should return 253.6135092068.');"
}
],
"solutions": [],
@@ -17231,7 +17770,8 @@
"tests": [
{
"text": "euler369() should return 862400558448.",
- "testString": "assert.strictEqual(euler369(), 862400558448, 'euler369() should return 862400558448.');"
+ "testString":
+ "assert.strictEqual(euler369(), 862400558448, 'euler369() should return 862400558448.');"
}
],
"solutions": [],
@@ -17268,7 +17808,8 @@
"tests": [
{
"text": "euler370() should return 41791929448408.",
- "testString": "assert.strictEqual(euler370(), 41791929448408, 'euler370() should return 41791929448408.');"
+ "testString":
+ "assert.strictEqual(euler370(), 41791929448408, 'euler370() should return 41791929448408.');"
}
],
"solutions": [],
@@ -17307,7 +17848,8 @@
"tests": [
{
"text": "euler371() should return 40.66368097.",
- "testString": "assert.strictEqual(euler371(), 40.66368097, 'euler371() should return 40.66368097.');"
+ "testString":
+ "assert.strictEqual(euler371(), 40.66368097, 'euler371() should return 40.66368097.');"
}
],
"solutions": [],
@@ -17352,7 +17894,8 @@
"tests": [
{
"text": "euler372() should return 301450082318807040.",
- "testString": "assert.strictEqual(euler372(), 301450082318807040, 'euler372() should return 301450082318807040.');"
+ "testString":
+ "assert.strictEqual(euler372(), 301450082318807040, 'euler372() should return 301450082318807040.');"
}
],
"solutions": [],
@@ -17391,7 +17934,8 @@
"tests": [
{
"text": "euler373() should return 727227472448913.",
- "testString": "assert.strictEqual(euler373(), 727227472448913, 'euler373() should return 727227472448913.');"
+ "testString":
+ "assert.strictEqual(euler373(), 727227472448913, 'euler373() should return 727227472448913.');"
}
],
"solutions": [],
@@ -17433,7 +17977,8 @@
"tests": [
{
"text": "euler374() should return 334420941.",
- "testString": "assert.strictEqual(euler374(), 334420941, 'euler374() should return 334420941.');"
+ "testString":
+ "assert.strictEqual(euler374(), 334420941, 'euler374() should return 334420941.');"
}
],
"solutions": [],
@@ -17485,7 +18030,8 @@
"tests": [
{
"text": "euler375() should return 7435327983715286000.",
- "testString": "assert.strictEqual(euler375(), 7435327983715286000, 'euler375() should return 7435327983715286000.');"
+ "testString":
+ "assert.strictEqual(euler375(), 7435327983715286000, 'euler375() should return 7435327983715286000.');"
}
],
"solutions": [],
@@ -17533,7 +18079,8 @@
"tests": [
{
"text": "euler376() should return 973059630185670.",
- "testString": "assert.strictEqual(euler376(), 973059630185670, 'euler376() should return 973059630185670.');"
+ "testString":
+ "assert.strictEqual(euler376(), 973059630185670, 'euler376() should return 973059630185670.');"
}
],
"solutions": [],
@@ -17602,7 +18149,8 @@
"tests": [
{
"text": "euler377() should return 732385277.",
- "testString": "assert.strictEqual(euler377(), 732385277, 'euler377() should return 732385277.');"
+ "testString":
+ "assert.strictEqual(euler377(), 732385277, 'euler377() should return 732385277.');"
}
],
"solutions": [],
@@ -17644,7 +18192,8 @@
"tests": [
{
"text": "euler378() should return 147534623725724700.",
- "testString": "assert.strictEqual(euler378(), 147534623725724700, 'euler378() should return 147534623725724700.');"
+ "testString":
+ "assert.strictEqual(euler378(), 147534623725724700, 'euler378() should return 147534623725724700.');"
}
],
"solutions": [],
@@ -17695,7 +18244,8 @@
"tests": [
{
"text": "euler379() should return 132314136838185.",
- "testString": "assert.strictEqual(euler379(), 132314136838185, 'euler379() should return 132314136838185.');"
+ "testString":
+ "assert.strictEqual(euler379(), 132314136838185, 'euler379() should return 132314136838185.');"
}
],
"solutions": [],
@@ -17738,7 +18288,8 @@
"tests": [
{
"text": "euler380() should return Infinity.",
- "testString": "assert.strictEqual(euler380(), Infinity, 'euler380() should return Infinity.');"
+ "testString":
+ "assert.strictEqual(euler380(), Infinity, 'euler380() should return Infinity.');"
}
],
"solutions": [],
@@ -17784,7 +18335,8 @@
"tests": [
{
"text": "euler381() should return 139602943319822.",
- "testString": "assert.strictEqual(euler381(), 139602943319822, 'euler381() should return 139602943319822.');"
+ "testString":
+ "assert.strictEqual(euler381(), 139602943319822, 'euler381() should return 139602943319822.');"
}
],
"solutions": [],
@@ -17828,7 +18380,8 @@
"tests": [
{
"text": "euler382() should return 697003956.",
- "testString": "assert.strictEqual(euler382(), 697003956, 'euler382() should return 697003956.');"
+ "testString":
+ "assert.strictEqual(euler382(), 697003956, 'euler382() should return 697003956.');"
}
],
"solutions": [],
@@ -17884,7 +18437,8 @@
"tests": [
{
"text": "euler383() should return 22173624649806.",
- "testString": "assert.strictEqual(euler383(), 22173624649806, 'euler383() should return 22173624649806.');"
+ "testString":
+ "assert.strictEqual(euler383(), 22173624649806, 'euler383() should return 22173624649806.');"
}
],
"solutions": [],
@@ -17927,7 +18481,8 @@
"tests": [
{
"text": "euler384() should return 3354706415856333000.",
- "testString": "assert.strictEqual(euler384(), 3354706415856333000, 'euler384() should return 3354706415856333000.');"
+ "testString":
+ "assert.strictEqual(euler384(), 3354706415856333000, 'euler384() should return 3354706415856333000.');"
}
],
"solutions": [],
@@ -17984,7 +18539,8 @@
"tests": [
{
"text": "euler385() should return 3776957309612154000.",
- "testString": "assert.strictEqual(euler385(), 3776957309612154000, 'euler385() should return 3776957309612154000.');"
+ "testString":
+ "assert.strictEqual(euler385(), 3776957309612154000, 'euler385() should return 3776957309612154000.');"
}
],
"solutions": [],
@@ -18037,7 +18593,8 @@
"tests": [
{
"text": "euler386() should return 528755790.",
- "testString": "assert.strictEqual(euler386(), 528755790, 'euler386() should return 528755790.');"
+ "testString":
+ "assert.strictEqual(euler386(), 528755790, 'euler386() should return 528755790.');"
}
],
"solutions": [],
@@ -18080,7 +18637,8 @@
"tests": [
{
"text": "euler387() should return 696067597313468.",
- "testString": "assert.strictEqual(euler387(), 696067597313468, 'euler387() should return 696067597313468.');"
+ "testString":
+ "assert.strictEqual(euler387(), 696067597313468, 'euler387() should return 696067597313468.');"
}
],
"solutions": [],
@@ -18129,7 +18687,8 @@
"tests": [
{
"text": "euler388() should return 831907372805130000.",
- "testString": "assert.strictEqual(euler388(), 831907372805130000, 'euler388() should return 831907372805130000.');"
+ "testString":
+ "assert.strictEqual(euler388(), 831907372805130000, 'euler388() should return 831907372805130000.');"
}
],
"solutions": [],
@@ -18171,7 +18730,8 @@
"tests": [
{
"text": "euler389() should return 2406376.3623.",
- "testString": "assert.strictEqual(euler389(), 2406376.3623, 'euler389() should return 2406376.3623.');"
+ "testString":
+ "assert.strictEqual(euler389(), 2406376.3623, 'euler389() should return 2406376.3623.');"
}
],
"solutions": [],
@@ -18201,11 +18761,13 @@
{
"id": "5900f4f21000cf542c510005",
"challengeType": 5,
- "title": "Problem 390: Triangles with non rational sides and integral area",
+ "title":
+ "Problem 390: Triangles with non rational sides and integral area",
"tests": [
{
"text": "euler390() should return 2919133642971.",
- "testString": "assert.strictEqual(euler390(), 2919133642971, 'euler390() should return 2919133642971.');"
+ "testString":
+ "assert.strictEqual(euler390(), 2919133642971, 'euler390() should return 2919133642971.');"
}
],
"solutions": [],
@@ -18247,7 +18809,8 @@
"tests": [
{
"text": "euler391() should return 61029882288.",
- "testString": "assert.strictEqual(euler391(), 61029882288, 'euler391() should return 61029882288.');"
+ "testString":
+ "assert.strictEqual(euler391(), 61029882288, 'euler391() should return 61029882288.');"
}
],
"solutions": [],
@@ -18307,7 +18870,8 @@
"tests": [
{
"text": "euler392() should return 3.1486734435.",
- "testString": "assert.strictEqual(euler392(), 3.1486734435, 'euler392() should return 3.1486734435.');"
+ "testString":
+ "assert.strictEqual(euler392(), 3.1486734435, 'euler392() should return 3.1486734435.');"
}
],
"solutions": [],
@@ -18356,7 +18920,8 @@
"tests": [
{
"text": "euler393() should return 112398351350823100.",
- "testString": "assert.strictEqual(euler393(), 112398351350823100, 'euler393() should return 112398351350823100.');"
+ "testString":
+ "assert.strictEqual(euler393(), 112398351350823100, 'euler393() should return 112398351350823100.');"
}
],
"solutions": [],
@@ -18395,7 +18960,8 @@
"tests": [
{
"text": "euler394() should return 3.2370342194.",
- "testString": "assert.strictEqual(euler394(), 3.2370342194, 'euler394() should return 3.2370342194.');"
+ "testString":
+ "assert.strictEqual(euler394(), 3.2370342194, 'euler394() should return 3.2370342194.');"
}
],
"solutions": [],
@@ -18444,7 +19010,8 @@
"tests": [
{
"text": "euler395() should return 28.2453753155.",
- "testString": "assert.strictEqual(euler395(), 28.2453753155, 'euler395() should return 28.2453753155.');"
+ "testString":
+ "assert.strictEqual(euler395(), 28.2453753155, 'euler395() should return 28.2453753155.');"
}
],
"solutions": [],
@@ -18495,7 +19062,8 @@
"tests": [
{
"text": "euler396() should return 173214653.",
- "testString": "assert.strictEqual(euler396(), 173214653, 'euler396() should return 173214653.');"
+ "testString":
+ "assert.strictEqual(euler396(), 173214653, 'euler396() should return 173214653.');"
}
],
"solutions": [],
@@ -18552,7 +19120,8 @@
"tests": [
{
"text": "euler397() should return 141630459461893730.",
- "testString": "assert.strictEqual(euler397(), 141630459461893730, 'euler397() should return 141630459461893730.');"
+ "testString":
+ "assert.strictEqual(euler397(), 141630459461893730, 'euler397() should return 141630459461893730.');"
}
],
"solutions": [],
@@ -18592,7 +19161,8 @@
"tests": [
{
"text": "euler398() should return 2010.59096.",
- "testString": "assert.strictEqual(euler398(), 2010.59096, 'euler398() should return 2010.59096.');"
+ "testString":
+ "assert.strictEqual(euler398(), 2010.59096, 'euler398() should return 2010.59096.');"
}
],
"solutions": [],
@@ -18633,8 +19203,10 @@
"title": "Problem 399: Squarefree Fibonacci Numbers",
"tests": [
{
- "text": "euler399() should return 1508395636674243, 6.5e27330467.",
- "testString": "assert.strictEqual(euler399(), 1508395636674243, 6.5e27330467, 'euler399() should return 1508395636674243, 6.5e27330467.');"
+ "text":
+ "euler399() should return 1508395636674243, 6.5e27330467.",
+ "testString":
+ "assert.strictEqual(euler399(), 1508395636674243, 6.5e27330467, 'euler399() should return 1508395636674243, 6.5e27330467.');"
}
],
"solutions": [],
@@ -18688,7 +19260,8 @@
"tests": [
{
"text": "euler400() should return 438505383468410600.",
- "testString": "assert.strictEqual(euler400(), 438505383468410600, 'euler400() should return 438505383468410600.');"
+ "testString":
+ "assert.strictEqual(euler400(), 438505383468410600, 'euler400() should return 438505383468410600.');"
}
],
"solutions": [],
@@ -18742,7 +19315,8 @@
"tests": [
{
"text": "euler401() should return 281632621.",
- "testString": "assert.strictEqual(euler401(), 281632621, 'euler401() should return 281632621.');"
+ "testString":
+ "assert.strictEqual(euler401(), 281632621, 'euler401() should return 281632621.');"
}
],
"solutions": [],
@@ -18786,7 +19360,8 @@
"tests": [
{
"text": "euler402() should return 356019862.",
- "testString": "assert.strictEqual(euler402(), 356019862, 'euler402() should return 356019862.');"
+ "testString":
+ "assert.strictEqual(euler402(), 356019862, 'euler402() should return 356019862.');"
}
],
"solutions": [],
@@ -18836,7 +19411,8 @@
"tests": [
{
"text": "euler403() should return 18224771.",
- "testString": "assert.strictEqual(euler403(), 18224771, 'euler403() should return 18224771.');"
+ "testString":
+ "assert.strictEqual(euler403(), 18224771, 'euler403() should return 18224771.');"
}
],
"solutions": [],
@@ -18880,7 +19456,8 @@
"tests": [
{
"text": "euler404() should return 1199215615081353.",
- "testString": "assert.strictEqual(euler404(), 1199215615081353, 'euler404() should return 1199215615081353.');"
+ "testString":
+ "assert.strictEqual(euler404(), 1199215615081353, 'euler404() should return 1199215615081353.');"
}
],
"solutions": [],
@@ -18932,7 +19509,8 @@
"tests": [
{
"text": "euler405() should return 237696125.",
- "testString": "assert.strictEqual(euler405(), 237696125, 'euler405() should return 237696125.');"
+ "testString":
+ "assert.strictEqual(euler405(), 237696125, 'euler405() should return 237696125.');"
}
],
"solutions": [],
@@ -18986,7 +19564,8 @@
"tests": [
{
"text": "euler406() should return 36813.12757207.",
- "testString": "assert.strictEqual(euler406(), 36813.12757207, 'euler406() should return 36813.12757207.');"
+ "testString":
+ "assert.strictEqual(euler406(), 36813.12757207, 'euler406() should return 36813.12757207.');"
}
],
"solutions": [],
@@ -19042,7 +19621,8 @@
"tests": [
{
"text": "euler407() should return 39782849136421.",
- "testString": "assert.strictEqual(euler407(), 39782849136421, 'euler407() should return 39782849136421.');"
+ "testString":
+ "assert.strictEqual(euler407(), 39782849136421, 'euler407() should return 39782849136421.');"
}
],
"solutions": [],
@@ -19083,7 +19663,8 @@
"tests": [
{
"text": "euler408() should return 299742733.",
- "testString": "assert.strictEqual(euler408(), 299742733, 'euler408() should return 299742733.');"
+ "testString":
+ "assert.strictEqual(euler408(), 299742733, 'euler408() should return 299742733.');"
}
],
"solutions": [],
@@ -19125,7 +19706,8 @@
"tests": [
{
"text": "euler409() should return 253223948.",
- "testString": "assert.strictEqual(euler409(), 253223948, 'euler409() should return 253223948.');"
+ "testString":
+ "assert.strictEqual(euler409(), 253223948, 'euler409() should return 253223948.');"
}
],
"solutions": [],
@@ -19164,7 +19746,8 @@
"tests": [
{
"text": "euler410() should return 799999783589946600.",
- "testString": "assert.strictEqual(euler410(), 799999783589946600, 'euler410() should return 799999783589946600.');"
+ "testString":
+ "assert.strictEqual(euler410(), 799999783589946600, 'euler410() should return 799999783589946600.');"
}
],
"solutions": [],
@@ -19204,7 +19787,8 @@
"tests": [
{
"text": "euler411() should return 9936352.",
- "testString": "assert.strictEqual(euler411(), 9936352, 'euler411() should return 9936352.');"
+ "testString":
+ "assert.strictEqual(euler411(), 9936352, 'euler411() should return 9936352.');"
}
],
"solutions": [],
@@ -19249,7 +19833,8 @@
"tests": [
{
"text": "euler412() should return 38788800.",
- "testString": "assert.strictEqual(euler412(), 38788800, 'euler412() should return 38788800.');"
+ "testString":
+ "assert.strictEqual(euler412(), 38788800, 'euler412() should return 38788800.');"
}
],
"solutions": [],
@@ -19296,7 +19881,8 @@
"tests": [
{
"text": "euler413() should return 3079418648040719.",
- "testString": "assert.strictEqual(euler413(), 3079418648040719, 'euler413() should return 3079418648040719.');"
+ "testString":
+ "assert.strictEqual(euler413(), 3079418648040719, 'euler413() should return 3079418648040719.');"
}
],
"solutions": [],
@@ -19338,7 +19924,8 @@
"tests": [
{
"text": "euler414() should return 552506775824935500.",
- "testString": "assert.strictEqual(euler414(), 552506775824935500, 'euler414() should return 552506775824935500.');"
+ "testString":
+ "assert.strictEqual(euler414(), 552506775824935500, 'euler414() should return 552506775824935500.');"
}
],
"solutions": [],
@@ -19402,7 +19989,8 @@
"tests": [
{
"text": "euler415() should return 55859742.",
- "testString": "assert.strictEqual(euler415(), 55859742, 'euler415() should return 55859742.');"
+ "testString":
+ "assert.strictEqual(euler415(), 55859742, 'euler415() should return 55859742.');"
}
],
"solutions": [],
@@ -19444,7 +20032,8 @@
"tests": [
{
"text": "euler416() should return 898082747.",
- "testString": "assert.strictEqual(euler416(), 898082747, 'euler416() should return 898082747.');"
+ "testString":
+ "assert.strictEqual(euler416(), 898082747, 'euler416() should return 898082747.');"
}
],
"solutions": [],
@@ -19482,7 +20071,8 @@
"tests": [
{
"text": "euler417() should return 446572970925740.",
- "testString": "assert.strictEqual(euler417(), 446572970925740, 'euler417() should return 446572970925740.');"
+ "testString":
+ "assert.strictEqual(euler417(), 446572970925740, 'euler417() should return 446572970925740.');"
}
],
"solutions": [],
@@ -19537,7 +20127,8 @@
"tests": [
{
"text": "euler418() should return 1177163565297340400.",
- "testString": "assert.strictEqual(euler418(), 1177163565297340400, 'euler418() should return 1177163565297340400.');"
+ "testString":
+ "assert.strictEqual(euler418(), 1177163565297340400, 'euler418() should return 1177163565297340400.');"
}
],
"solutions": [],
@@ -19578,8 +20169,10 @@
"title": "Problem 419: Look and say sequence",
"tests": [
{
- "text": "euler419() should return 998567458, 1046245404, 43363922.",
- "testString": "assert.strictEqual(euler419(), 998567458, 1046245404, 43363922, 'euler419() should return 998567458, 1046245404, 43363922.');"
+ "text":
+ "euler419() should return 998567458, 1046245404, 43363922.",
+ "testString":
+ "assert.strictEqual(euler419(), 998567458, 1046245404, 43363922, 'euler419() should return 998567458, 1046245404, 43363922.');"
}
],
"solutions": [],
@@ -19629,7 +20222,8 @@
"tests": [
{
"text": "euler420() should return 145159332.",
- "testString": "assert.strictEqual(euler420(), 145159332, 'euler420() should return 145159332.');"
+ "testString":
+ "assert.strictEqual(euler420(), 145159332, 'euler420() should return 145159332.');"
}
],
"solutions": [],
@@ -19674,7 +20268,8 @@
"tests": [
{
"text": "euler421() should return 2304215802083466200.",
- "testString": "assert.strictEqual(euler421(), 2304215802083466200, 'euler421() should return 2304215802083466200.');"
+ "testString":
+ "assert.strictEqual(euler421(), 2304215802083466200, 'euler421() should return 2304215802083466200.');"
}
],
"solutions": [],
@@ -19715,7 +20310,8 @@
"tests": [
{
"text": "euler422() should return 92060460.",
- "testString": "assert.strictEqual(euler422(), 92060460, 'euler422() should return 92060460.');"
+ "testString":
+ "assert.strictEqual(euler422(), 92060460, 'euler422() should return 92060460.');"
}
],
"solutions": [],
@@ -19760,7 +20356,8 @@
"tests": [
{
"text": "euler423() should return 653972374.",
- "testString": "assert.strictEqual(euler423(), 653972374, 'euler423() should return 653972374.');"
+ "testString":
+ "assert.strictEqual(euler423(), 653972374, 'euler423() should return 653972374.');"
}
],
"solutions": [],
@@ -19810,7 +20407,8 @@
"tests": [
{
"text": "euler424() should return 1059760019628.",
- "testString": "assert.strictEqual(euler424(), 1059760019628, 'euler424() should return 1059760019628.');"
+ "testString":
+ "assert.strictEqual(euler424(), 1059760019628, 'euler424() should return 1059760019628.');"
}
],
"solutions": [],
@@ -19863,7 +20461,8 @@
"tests": [
{
"text": "euler425() should return 46479497324.",
- "testString": "assert.strictEqual(euler425(), 46479497324, 'euler425() should return 46479497324.');"
+ "testString":
+ "assert.strictEqual(euler425(), 46479497324, 'euler425() should return 46479497324.');"
}
],
"solutions": [],
@@ -19913,7 +20512,8 @@
"tests": [
{
"text": "euler426() should return 31591886008.",
- "testString": "assert.strictEqual(euler426(), 31591886008, 'euler426() should return 31591886008.');"
+ "testString":
+ "assert.strictEqual(euler426(), 31591886008, 'euler426() should return 31591886008.');"
}
],
"solutions": [],
@@ -19975,7 +20575,8 @@
"tests": [
{
"text": "euler427() should return 97138867.",
- "testString": "assert.strictEqual(euler427(), 97138867, 'euler427() should return 97138867.');"
+ "testString":
+ "assert.strictEqual(euler427(), 97138867, 'euler427() should return 97138867.');"
}
],
"solutions": [],
@@ -20017,8 +20618,10 @@
"title": "Problem 428: Necklace of Circles",
"tests": [
{
- "text": "necklace(1000000000) should return 747215561862.",
- "testString": "assert.strictEqual(necklace(1000000000), 747215561862, 'necklace(1000000000) should return 747215561862.');"
+ "text":
+ "necklace(1000000000) should return 747215561862.",
+ "testString":
+ "assert.strictEqual(necklace(1000000000), 747215561862, 'necklace(1000000000) should return 747215561862.');"
}
],
"solutions": [],
@@ -20064,7 +20667,8 @@
"tests": [
{
"text": "euler429() should return 98792821.",
- "testString": "assert.strictEqual(euler429(), 98792821, 'euler429() should return 98792821.');"
+ "testString":
+ "assert.strictEqual(euler429(), 98792821, 'euler429() should return 98792821.');"
}
],
"solutions": [],
@@ -20105,7 +20709,8 @@
"tests": [
{
"text": "euler430() should return 5000624921.38.",
- "testString": "assert.strictEqual(euler430(), 5000624921.38, 'euler430() should return 5000624921.38.');"
+ "testString":
+ "assert.strictEqual(euler430(), 5000624921.38, 'euler430() should return 5000624921.38.');"
}
],
"solutions": [],
@@ -20152,7 +20757,8 @@
"tests": [
{
"text": "euler431() should return 23.386029052.",
- "testString": "assert.strictEqual(euler431(), 23.386029052, 'euler431() should return 23.386029052.');"
+ "testString":
+ "assert.strictEqual(euler431(), 23.386029052, 'euler431() should return 23.386029052.');"
}
],
"solutions": [],
@@ -20196,7 +20802,8 @@
"tests": [
{
"text": "euler432() should return 754862080.",
- "testString": "assert.strictEqual(euler432(), 754862080, 'euler432() should return 754862080.');"
+ "testString":
+ "assert.strictEqual(euler432(), 754862080, 'euler432() should return 754862080.');"
}
],
"solutions": [],
@@ -20234,7 +20841,8 @@
"tests": [
{
"text": "euler433() should return 326624372659664.",
- "testString": "assert.strictEqual(euler433(), 326624372659664, 'euler433() should return 326624372659664.');"
+ "testString":
+ "assert.strictEqual(euler433(), 326624372659664, 'euler433() should return 326624372659664.');"
}
],
"solutions": [],
@@ -20278,7 +20886,8 @@
"tests": [
{
"text": "euler434() should return 863253606.",
- "testString": "assert.strictEqual(euler434(), 863253606, 'euler434() should return 863253606.');"
+ "testString":
+ "assert.strictEqual(euler434(), 863253606, 'euler434() should return 863253606.');"
}
],
"solutions": [],
@@ -20326,7 +20935,8 @@
"tests": [
{
"text": "euler435() should return 252541322550.",
- "testString": "assert.strictEqual(euler435(), 252541322550, 'euler435() should return 252541322550.');"
+ "testString":
+ "assert.strictEqual(euler435(), 252541322550, 'euler435() should return 252541322550.');"
}
],
"solutions": [],
@@ -20362,7 +20972,8 @@
"tests": [
{
"text": "euler436() should return 0.5276662759.",
- "testString": "assert.strictEqual(euler436(), 0.5276662759, 'euler436() should return 0.5276662759.');"
+ "testString":
+ "assert.strictEqual(euler436(), 0.5276662759, 'euler436() should return 0.5276662759.');"
}
],
"solutions": [],
@@ -20409,7 +21020,8 @@
"tests": [
{
"text": "euler437() should return 74204709657207.",
- "testString": "assert.strictEqual(euler437(), 74204709657207, 'euler437() should return 74204709657207.');"
+ "testString":
+ "assert.strictEqual(euler437(), 74204709657207, 'euler437() should return 74204709657207.');"
}
],
"solutions": [],
@@ -20460,7 +21072,8 @@
"tests": [
{
"text": "euler438() should return 2046409616809.",
- "testString": "assert.strictEqual(euler438(), 2046409616809, 'euler438() should return 2046409616809.');"
+ "testString":
+ "assert.strictEqual(euler438(), 2046409616809, 'euler438() should return 2046409616809.');"
}
],
"solutions": [],
@@ -20505,7 +21118,8 @@
"tests": [
{
"text": "euler439() should return 968697378.",
- "testString": "assert.strictEqual(euler439(), 968697378, 'euler439() should return 968697378.');"
+ "testString":
+ "assert.strictEqual(euler439(), 968697378, 'euler439() should return 968697378.');"
}
],
"solutions": [],
@@ -20543,7 +21157,8 @@
"tests": [
{
"text": "euler440() should return 970746056.",
- "testString": "assert.strictEqual(euler440(), 970746056, 'euler440() should return 970746056.');"
+ "testString":
+ "assert.strictEqual(euler440(), 970746056, 'euler440() should return 970746056.');"
}
],
"solutions": [],
@@ -20590,7 +21205,8 @@
"tests": [
{
"text": "euler441() should return 5000088.8395.",
- "testString": "assert.strictEqual(euler441(), 5000088.8395, 'euler441() should return 5000088.8395.');"
+ "testString":
+ "assert.strictEqual(euler441(), 5000088.8395, 'euler441() should return 5000088.8395.');"
}
],
"solutions": [],
@@ -20633,7 +21249,8 @@
"tests": [
{
"text": "euler442() should return 1295552661530920200.",
- "testString": "assert.strictEqual(euler442(), 1295552661530920200, 'euler442() should return 1295552661530920200.');"
+ "testString":
+ "assert.strictEqual(euler442(), 1295552661530920200, 'euler442() should return 1295552661530920200.');"
}
],
"solutions": [],
@@ -20672,7 +21289,8 @@
"tests": [
{
"text": "euler443() should return 2744233049300770.",
- "testString": "assert.strictEqual(euler443(), 2744233049300770, 'euler443() should return 2744233049300770.');"
+ "testString":
+ "assert.strictEqual(euler443(), 2744233049300770, 'euler443() should return 2744233049300770.');"
}
],
"solutions": [],
@@ -20717,7 +21335,8 @@
"tests": [
{
"text": "euler444() should return 1.200856722e+263.",
- "testString": "assert.strictEqual(euler444(), 1.200856722e+263, 'euler444() should return 1.200856722e+263.');"
+ "testString":
+ "assert.strictEqual(euler444(), 1.200856722e+263, 'euler444() should return 1.200856722e+263.');"
}
],
"solutions": [],
@@ -20766,7 +21385,8 @@
"tests": [
{
"text": "euler445() should return 659104042.",
- "testString": "assert.strictEqual(euler445(), 659104042, 'euler445() should return 659104042.');"
+ "testString":
+ "assert.strictEqual(euler445(), 659104042, 'euler445() should return 659104042.');"
}
],
"solutions": [],
@@ -20810,7 +21430,8 @@
"tests": [
{
"text": "euler446() should return 907803852.",
- "testString": "assert.strictEqual(euler446(), 907803852, 'euler446() should return 907803852.');"
+ "testString":
+ "assert.strictEqual(euler446(), 907803852, 'euler446() should return 907803852.');"
}
],
"solutions": [],
@@ -20852,7 +21473,8 @@
"tests": [
{
"text": "euler447() should return 530553372.",
- "testString": "assert.strictEqual(euler447(), 530553372, 'euler447() should return 530553372.');"
+ "testString":
+ "assert.strictEqual(euler447(), 530553372, 'euler447() should return 530553372.');"
}
],
"solutions": [],
@@ -20895,7 +21517,8 @@
"tests": [
{
"text": "euler448() should return 106467648.",
- "testString": "assert.strictEqual(euler448(), 106467648, 'euler448() should return 106467648.');"
+ "testString":
+ "assert.strictEqual(euler448(), 106467648, 'euler448() should return 106467648.');"
}
],
"solutions": [],
@@ -20936,7 +21559,8 @@
"tests": [
{
"text": "euler449() should return 103.37870096.",
- "testString": "assert.strictEqual(euler449(), 103.37870096, 'euler449() should return 103.37870096.');"
+ "testString":
+ "assert.strictEqual(euler449(), 103.37870096, 'euler449() should return 103.37870096.');"
}
],
"solutions": [],
@@ -20981,7 +21605,8 @@
"tests": [
{
"text": "euler450() should return 583333163984220900.",
- "testString": "assert.strictEqual(euler450(), 583333163984220900, 'euler450() should return 583333163984220900.');"
+ "testString":
+ "assert.strictEqual(euler450(), 583333163984220900, 'euler450() should return 583333163984220900.');"
}
],
"solutions": [],
@@ -21042,7 +21667,8 @@
"tests": [
{
"text": "euler451() should return 153651073760956.",
- "testString": "assert.strictEqual(euler451(), 153651073760956, 'euler451() should return 153651073760956.');"
+ "testString":
+ "assert.strictEqual(euler451(), 153651073760956, 'euler451() should return 153651073760956.');"
}
],
"solutions": [],
@@ -21090,7 +21716,8 @@
"tests": [
{
"text": "euler452() should return 345558983.",
- "testString": "assert.strictEqual(euler452(), 345558983, 'euler452() should return 345558983.');"
+ "testString":
+ "assert.strictEqual(euler452(), 345558983, 'euler452() should return 345558983.');"
}
],
"solutions": [],
@@ -21126,7 +21753,8 @@
"tests": [
{
"text": "euler453() should return 104354107.",
- "testString": "assert.strictEqual(euler453(), 104354107, 'euler453() should return 104354107.');"
+ "testString":
+ "assert.strictEqual(euler453(), 104354107, 'euler453() should return 104354107.');"
}
],
"solutions": [],
@@ -21167,7 +21795,8 @@
"tests": [
{
"text": "euler454() should return 5435004633092.",
- "testString": "assert.strictEqual(euler454(), 5435004633092, 'euler454() should return 5435004633092.');"
+ "testString":
+ "assert.strictEqual(euler454(), 5435004633092, 'euler454() should return 5435004633092.');"
}
],
"solutions": [],
@@ -21211,7 +21840,8 @@
"tests": [
{
"text": "euler455() should return 450186511399999.",
- "testString": "assert.strictEqual(euler455(), 450186511399999, 'euler455() should return 450186511399999.');"
+ "testString":
+ "assert.strictEqual(euler455(), 450186511399999, 'euler455() should return 450186511399999.');"
}
],
"solutions": [],
@@ -21252,7 +21882,8 @@
"tests": [
{
"text": "euler456() should return 333333208685971500.",
- "testString": "assert.strictEqual(euler456(), 333333208685971500, 'euler456() should return 333333208685971500.');"
+ "testString":
+ "assert.strictEqual(euler456(), 333333208685971500, 'euler456() should return 333333208685971500.');"
}
],
"solutions": [],
@@ -21300,7 +21931,8 @@
"tests": [
{
"text": "euler457() should return 2647787126797397000.",
- "testString": "assert.strictEqual(euler457(), 2647787126797397000, 'euler457() should return 2647787126797397000.');"
+ "testString":
+ "assert.strictEqual(euler457(), 2647787126797397000, 'euler457() should return 2647787126797397000.');"
}
],
"solutions": [],
@@ -21341,7 +21973,8 @@
"tests": [
{
"text": "euler458() should return 423341841.",
- "testString": "assert.strictEqual(euler458(), 423341841, 'euler458() should return 423341841.');"
+ "testString":
+ "assert.strictEqual(euler458(), 423341841, 'euler458() should return 423341841.');"
}
],
"solutions": [],
@@ -21380,7 +22013,8 @@
"tests": [
{
"text": "euler459() should return 3996390106631.",
- "testString": "assert.strictEqual(euler459(), 3996390106631, 'euler459() should return 3996390106631.');"
+ "testString":
+ "assert.strictEqual(euler459(), 3996390106631, 'euler459() should return 3996390106631.');"
}
],
"solutions": [],
@@ -21433,7 +22067,8 @@
"tests": [
{
"text": "euler460() should return 18.420738199.",
- "testString": "assert.strictEqual(euler460(), 18.420738199, 'euler460() should return 18.420738199.');"
+ "testString":
+ "assert.strictEqual(euler460(), 18.420738199, 'euler460() should return 18.420738199.');"
}
],
"solutions": [],
@@ -21486,7 +22121,8 @@
"tests": [
{
"text": "euler461() should return 159820276.",
- "testString": "assert.strictEqual(euler461(), 159820276, 'euler461() should return 159820276.');"
+ "testString":
+ "assert.strictEqual(euler461(), 159820276, 'euler461() should return 159820276.');"
}
],
"solutions": [],
@@ -21525,7 +22161,8 @@
"tests": [
{
"text": "euler462() should return Infinity.",
- "testString": "assert.strictEqual(euler462(), Infinity, 'euler462() should return Infinity.');"
+ "testString":
+ "assert.strictEqual(euler462(), Infinity, 'euler462() should return Infinity.');"
}
],
"solutions": [],
@@ -21572,7 +22209,8 @@
"tests": [
{
"text": "euler463() should return 808981553.",
- "testString": "assert.strictEqual(euler463(), 808981553, 'euler463() should return 808981553.');"
+ "testString":
+ "assert.strictEqual(euler463(), 808981553, 'euler463() should return 808981553.');"
}
],
"solutions": [],
@@ -21614,7 +22252,8 @@
"tests": [
{
"text": "euler464() should return 198775297232878.",
- "testString": "assert.strictEqual(euler464(), 198775297232878, 'euler464() should return 198775297232878.');"
+ "testString":
+ "assert.strictEqual(euler464(), 198775297232878, 'euler464() should return 198775297232878.');"
}
],
"solutions": [],
@@ -21666,7 +22305,8 @@
"tests": [
{
"text": "euler465() should return 585965659.",
- "testString": "assert.strictEqual(euler465(), 585965659, 'euler465() should return 585965659.');"
+ "testString":
+ "assert.strictEqual(euler465(), 585965659, 'euler465() should return 585965659.');"
}
],
"solutions": [],
@@ -21715,7 +22355,8 @@
"tests": [
{
"text": "euler466() should return 258381958195474750.",
- "testString": "assert.strictEqual(euler466(), 258381958195474750, 'euler466() should return 258381958195474750.');"
+ "testString":
+ "assert.strictEqual(euler466(), 258381958195474750, 'euler466() should return 258381958195474750.');"
}
],
"solutions": [],
@@ -21763,7 +22404,8 @@
"tests": [
{
"text": "euler467() should return 775181359.",
- "testString": "assert.strictEqual(euler467(), 775181359, 'euler467() should return 775181359.');"
+ "testString":
+ "assert.strictEqual(euler467(), 775181359, 'euler467() should return 775181359.');"
}
],
"solutions": [],
@@ -21814,7 +22456,8 @@
"tests": [
{
"text": "euler468() should return 852950321.",
- "testString": "assert.strictEqual(euler468(), 852950321, 'euler468() should return 852950321.');"
+ "testString":
+ "assert.strictEqual(euler468(), 852950321, 'euler468() should return 852950321.');"
}
],
"solutions": [],
@@ -21861,7 +22504,8 @@
"tests": [
{
"text": "euler469() should return 0.56766764161831.",
- "testString": "assert.strictEqual(euler469(), 0.56766764161831, 'euler469() should return 0.56766764161831.');"
+ "testString":
+ "assert.strictEqual(euler469(), 0.56766764161831, 'euler469() should return 0.56766764161831.');"
}
],
"solutions": [],
@@ -21904,7 +22548,8 @@
"tests": [
{
"text": "euler470() should return 147668794.",
- "testString": "assert.strictEqual(euler470(), 147668794, 'euler470() should return 147668794.');"
+ "testString":
+ "assert.strictEqual(euler470(), 147668794, 'euler470() should return 147668794.');"
}
],
"solutions": [],
@@ -21949,7 +22594,8 @@
"tests": [
{
"text": "euler471() should return 1.895093981e+31.",
- "testString": "assert.strictEqual(euler471(), 1.895093981e+31, 'euler471() should return 1.895093981e+31.');"
+ "testString":
+ "assert.strictEqual(euler471(), 1.895093981e+31, 'euler471() should return 1.895093981e+31.');"
}
],
"solutions": [],
@@ -21991,7 +22637,8 @@
"tests": [
{
"text": "euler472() should return 73811586.",
- "testString": "assert.strictEqual(euler472(), 73811586, 'euler472() should return 73811586.');"
+ "testString":
+ "assert.strictEqual(euler472(), 73811586, 'euler472() should return 73811586.');"
}
],
"solutions": [],
@@ -22041,7 +22688,8 @@
"tests": [
{
"text": "euler473() should return 35856681704365.",
- "testString": "assert.strictEqual(euler473(), 35856681704365, 'euler473() should return 35856681704365.');"
+ "testString":
+ "assert.strictEqual(euler473(), 35856681704365, 'euler473() should return 35856681704365.');"
}
],
"solutions": [],
@@ -22091,7 +22739,8 @@
"tests": [
{
"text": "euler474() should return 9690646731515010.",
- "testString": "assert.strictEqual(euler474(), 9690646731515010, 'euler474() should return 9690646731515010.');"
+ "testString":
+ "assert.strictEqual(euler474(), 9690646731515010, 'euler474() should return 9690646731515010.');"
}
],
"solutions": [],
@@ -22131,7 +22780,8 @@
"tests": [
{
"text": "euler475() should return 75780067.",
- "testString": "assert.strictEqual(euler475(), 75780067, 'euler475() should return 75780067.');"
+ "testString":
+ "assert.strictEqual(euler475(), 75780067, 'euler475() should return 75780067.');"
}
],
"solutions": [],
@@ -22171,7 +22821,8 @@
"tests": [
{
"text": "euler476() should return 110242.87794.",
- "testString": "assert.strictEqual(euler476(), 110242.87794, 'euler476() should return 110242.87794.');"
+ "testString":
+ "assert.strictEqual(euler476(), 110242.87794, 'euler476() should return 110242.87794.');"
}
],
"solutions": [],
@@ -22207,7 +22858,8 @@
"tests": [
{
"text": "euler477() should return 25044905874565164.",
- "testString": "assert.strictEqual(euler477(), 25044905874565164, 'euler477() should return 25044905874565164.');"
+ "testString":
+ "assert.strictEqual(euler477(), 25044905874565164, 'euler477() should return 25044905874565164.');"
}
],
"solutions": [],
@@ -22254,7 +22906,8 @@
"tests": [
{
"text": "euler478() should return 59510340.",
- "testString": "assert.strictEqual(euler478(), 59510340, 'euler478() should return 59510340.');"
+ "testString":
+ "assert.strictEqual(euler478(), 59510340, 'euler478() should return 59510340.');"
}
],
"solutions": [],
@@ -22307,7 +22960,8 @@
"tests": [
{
"text": "euler479() should return 191541795.",
- "testString": "assert.strictEqual(euler479(), 191541795, 'euler479() should return 191541795.');"
+ "testString":
+ "assert.strictEqual(euler479(), 191541795, 'euler479() should return 191541795.');"
}
],
"solutions": [],
@@ -22348,7 +23002,8 @@
"tests": [
{
"text": "euler480() should return turnthestarson.",
- "testString": "assert.strictEqual(euler480(), turnthestarson, 'euler480() should return turnthestarson.');"
+ "testString":
+ "assert.strictEqual(euler480(), turnthestarson, 'euler480() should return turnthestarson.');"
}
],
"solutions": [],
@@ -22413,4 +23068,4 @@
}
}
]
-}
\ No newline at end of file
+}