diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/cumulative-standard-deviation.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/cumulative-standard-deviation.english.md index af9a7431a7..aee7abd883 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/cumulative-standard-deviation.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/cumulative-standard-deviation.english.md @@ -6,40 +6,45 @@ forumTopicId: 302240 --- ## Description +
Write a function that takes an array of numbers as parameter and returns the standard deviation of the series. +
## Instructions +
## Tests +
-``` yml +```yml tests: - text: standardDeviation should be a function. - testString: assert(typeof standardDeviation == 'function', 'standardDeviation should be a function.'); + testString: assert(typeof standardDeviation == 'function'); - text: standardDeviation([2, 4, 4, 4, 5, 5, 7, 9]) should return a number. - testString: assert(typeof standardDeviation([2, 4, 4, 4, 5, 5, 7, 9]) == 'number', 'standardDeviation([2, 4, 4, 4, 5, 5, 7, 9]) should return a number.'); + testString: assert(typeof standardDeviation([2, 4, 4, 4, 5, 5, 7, 9]) == 'number'); - text: standardDeviation([2, 4, 4, 4, 5, 5, 7, 9]) should return 2. - testString: assert.equal(standardDeviation([2, 4, 4, 4, 5, 5, 7, 9]), 2, 'standardDeviation([2, 4, 4, 4, 5, 5, 7, 9]) should return 2.'); + testString: assert.equal(standardDeviation([2, 4, 4, 4, 5, 5, 7, 9]), 2); - text: standardDeviation([600, 470, 170, 430, 300]) should return 147.323. - testString: assert.equal(standardDeviation([600, 470, 170, 430, 300]), 147.323, 'standardDeviation([600, 470, 170, 430, 300]) should return 147.323.'); + testString: assert.equal(standardDeviation([600, 470, 170, 430, 300]), 147.323); - text: standardDeviation([75, 83, 96, 100, 121, 125]) should return 18.239. - testString: assert.equal(standardDeviation([75, 83, 96, 100, 121, 125]), 18.239, 'standardDeviation([75, 83, 96, 100, 121, 125]) should return 18.239.'); + testString: assert.equal(standardDeviation([75, 83, 96, 100, 121, 125]), 18.239); - text: standardDeviation([23, 37, 45, 49, 56, 63, 63, 70, 72, 82]) should return 16.87. - testString: assert.equal(standardDeviation([23, 37, 45, 49, 56, 63, 63, 70, 72, 82]), 16.87, 'standardDeviation([23, 37, 45, 49, 56, 63, 63, 70, 72, 82]) should return 16.87.'); + testString: assert.equal(standardDeviation([23, 37, 45, 49, 56, 63, 63, 70, 72, 82]), 16.87); - text: standardDeviation([271, 354, 296, 301, 333, 326, 285, 298, 327, 316, 287, 314]) should return 22.631. - testString: assert.equal(standardDeviation([271, 354, 296, 301, 333, 326, 285, 298, 327, 316, 287, 314]), 22.631, 'standardDeviation([271, 354, 296, 301, 333, 326, 285, 298, 327, 316, 287, 314]) should return 22.631.'); + testString: assert.equal(standardDeviation([271, 354, 296, 301, 333, 326, 285, 298, 327, 316, 287, 314]), 22.631); ```
## Challenge Seed +
@@ -54,6 +59,7 @@ function standardDeviation(arr) {
## Solution +
```js @@ -64,10 +70,10 @@ function standardDeviation(arr) { arr.forEach(function(e) { sum += e; sum_sq += e * e; - }) + }); - var std_dev=Math.sqrt((sum_sq / n) - Math.pow(sum / n, 2)) - return Math.round(std_dev*1000)/1000; + var std_dev = Math.sqrt(sum_sq / n - Math.pow(sum / n, 2)); + return Math.round(std_dev * 1000) / 1000; } ``` diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/cusip.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/cusip.english.md index cf0b711bea..30cb2ea4c5 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/cusip.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/cusip.english.md @@ -6,46 +6,51 @@ forumTopicId: 302241 --- ## Description +
A CUSIP is a nine-character alphanumeric code that identifies a North American financial security for the purposes of facilitating clearing and settlement of trades. The CUSIP was adopted as an American National Standard under Accredited Standards X9.6. +
## Instructions +
Write a function that takes a string as a parameter and checks if the string is valid CUSIP.
## Tests +
-``` yml +```yml tests: - text: isCusip should be a function. - testString: assert(typeof isCusip == 'function', 'isCusip should be a function.'); + testString: assert(typeof isCusip == 'function'); - text: isCusip("037833100") should return a boolean. - testString: assert(typeof isCusip("037833100") == 'boolean', 'isCusip("037833100") should return a boolean.'); + testString: assert(typeof isCusip("037833100") == 'boolean'); - text: isCusip("037833100") should return true. - testString: assert.equal(isCusip("037833100"), true, 'isCusip("037833100") should return true.'); + testString: assert.equal(isCusip("037833100"), true); - text: isCusip("17275R102") should return true. - testString: assert.equal(isCusip("17275R102"), true, 'isCusip("17275R102") should return true.'); + testString: assert.equal(isCusip("17275R102"), true); - text: isCusip("38259P50a") should return false. - testString: assert.equal(isCusip("38259P50a"), false, 'isCusip("38259P50a") should return false.'); + testString: assert.equal(isCusip("38259P50a"), false); - text: isCusip("38259P508") should return true. - testString: assert.equal(isCusip("38259P508"), true, 'isCusip("38259P508") should return true.'); + testString: assert.equal(isCusip("38259P508"), true); - text: isCusip("38259P50#") should return false. - testString: assert.equal(isCusip("38259P50#"), false, 'isCusip("38259P50#") should return false.'); + testString: assert.equal(isCusip("38259P50#"), false); - text: isCusip("68389X105") should return true. - testString: assert.equal(isCusip("68389X105"), true, 'isCusip("68389X105") should return true.'); + testString: assert.equal(isCusip("68389X105"), true); - text: isCusip("68389X106") should return false. - testString: assert.equal(isCusip("68389X106"), false, 'isCusip("68389X106") should return false.'); + testString: assert.equal(isCusip("68389X106"), false); - text: isCusip("5949181") should return false. - testString: assert.equal(isCusip("5949181"), false, 'isCusip("5949181") should return false.'); + testString: assert.equal(isCusip("5949181"), false); ```
## Challenge Seed +
@@ -60,6 +65,7 @@ function isCusip(s) {
## Solution +
```js @@ -85,7 +91,7 @@ function isCusip(s) { return false; } if (i % 2 == 1) v *= 2; // check if odd as using 0-based indexing - sum += Math.floor(v / 10) + v % 10; + sum += Math.floor(v / 10) + (v % 10); } return s.charCodeAt(8) - 48 == (10 - (sum % 10)) % 10; } diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/cut-a-rectangle.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/cut-a-rectangle.english.md index 027788a550..0a5e447c63 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/cut-a-rectangle.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/cut-a-rectangle.english.md @@ -6,9 +6,11 @@ forumTopicId: 302242 --- ## Description +
A given rectangle is made from m × n squares. If m and n are not both odd, then it is possible to cut a path through the rectangle along the square edges such that the rectangle splits into two connected pieces with the same shape (after rotating one of the pieces by 180°). All such paths for 2 × 2 and 4 × 3 rectangles are shown below. +
m × n squares. If m and
## Instructions +
Write a function that calculates the number of different ways to cut an m × n rectangle.
## Tests +
-``` yml +```yml tests: - text: cutRectangle should be a function. - testString: assert(typeof cutRectangle == 'function', 'cutRectangle should be a function.'); + testString: assert(typeof cutRectangle == 'function'); - text: cutRectangle(2, 2) should return a number. - testString: assert(typeof cutRectangle(2, 2) == 'number', 'cutRectangle(2, 2) should return a number.'); + testString: assert(typeof cutRectangle(2, 2) == 'number'); - text: cutRectangle(2, 2) should return 2. - testString: assert.equal(cutRectangle(2, 2), 2, 'cutRectangle(2, 2) should return 2.'); + testString: assert.equal(cutRectangle(2, 2), 2); - text: cutRectangle(4, 3) should return 9. - testString: assert.equal(cutRectangle(4, 3), 9, 'cutRectangle(4, 3) should return 9.'); + testString: assert.equal(cutRectangle(4, 3), 9); - text: cutRectangle(4, 4) should return 22. - testString: assert.equal(cutRectangle(4, 4), 22, 'cutRectangle(4, 4) should return 22.'); + testString: assert.equal(cutRectangle(4, 4), 22); - text: cutRectangle(8, 3) should return 53. - testString: assert.equal(cutRectangle(8, 3), 53, 'cutRectangle(8, 3) should return 53.'); + testString: assert.equal(cutRectangle(8, 3), 53); - text: cutRectangle(7, 4) should return 151. - testString: assert.equal(cutRectangle(7, 4), 151, 'cutRectangle(7, 4) should return 151.'); + testString: assert.equal(cutRectangle(7, 4), 151); ```
## Challenge Seed +
@@ -102,23 +107,23 @@ function cutRectangle(w, h) {
## Solution +
```js function cutRectangle(w, h) { - if (w % 2 == 1 && h % 2 == 1) - return; + if (w % 2 == 1 && h % 2 == 1) return; var dirs = [[0, -1], [-1, 0], [0, 1], [1, 0]]; - var grid = new Array(h); for (var i = 0; i < grid.length; i++) grid[i]=new Array(w); + var grid = new Array(h); + for (var i = 0; i < grid.length; i++) grid[i] = new Array(w); var stack = []; var half = Math.floor((w * h) / 2); var bits = Math.pow(2, half) - 1; - var result=0; + var result = 0; for (; bits > 0; bits -= 2) { - for (var i = 0; i < half; i++) { var r = Math.floor(i / w); var c = i % w; @@ -129,8 +134,7 @@ function cutRectangle(w, h) { stack.push(0); grid[0][0] = 2; var count = 1; - while (stack.length!=0) { - + while (stack.length != 0) { var pos = stack.pop(); var r = Math.floor(pos / w); var c = pos % w; @@ -140,7 +144,6 @@ function cutRectangle(w, h) { var nextC = c + dir[1]; if (nextR >= 0 && nextR < h && nextC >= 0 && nextC < w) { - if (grid[nextR][nextC] == 1) { stack.push(nextR * w + nextC); grid[nextR][nextC] = 2; diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/dot-product.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/dot-product.english.md index 84aac6c4cd..ee5e7ea271 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/dot-product.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/dot-product.english.md @@ -6,40 +6,45 @@ forumTopicId: 302251 --- ## Description +
Create a function, to compute the dot product, also known as the scalar product of two vectors. +
## Instructions +
## Tests +
-``` yml +```yml tests: - text: dotProduct should be a function. - testString: assert(typeof dotProduct == 'function', 'dotProduct should be a function.'); + testString: assert(typeof dotProduct == 'function'); - text: dotProduct([1, 3, -5], [4, -2, -1]) should return a number. - testString: assert(typeof dotProduct([1, 3, -5], [4, -2, -1]) == 'number', 'dotProduct([1, 3, -5], [4, -2, -1]) should return a number.'); + testString: assert(typeof dotProduct([1, 3, -5], [4, -2, -1]) == 'number'); - text: dotProduct([1, 3, -5], [4, -2, -1]) should return 3. - testString: assert.equal(dotProduct([1, 3, -5], [4, -2, -1]), 3, 'dotProduct([1, 3, -5], [4, -2, -1]) should return 3.'); + testString: assert.equal(dotProduct([1, 3, -5], [4, -2, -1]), 3); - text: dotProduct([1, 2, 3, 4, 5], [6, 7, 8, 9, 10]) should return 130. - testString: assert.equal(dotProduct([1, 2, 3, 4, 5], [6, 7, 8, 9, 10]), 130, 'dotProduct([1, 2, 3, 4, 5], [6, 7, 8, 9, 10]) should return 130.'); + testString: assert.equal(dotProduct([1, 2, 3, 4, 5], [6, 7, 8, 9, 10]), 130); - text: dotProduct([5, 4, 3, 2], [7, 8, 9, 6]) should return 106. - testString: assert.equal(dotProduct([5, 4, 3, 2], [7, 8, 9, 6]), 106, 'dotProduct([5, 4, 3, 2], [7, 8, 9, 6]) should return 106.'); + testString: assert.equal(dotProduct([5, 4, 3, 2], [7, 8, 9, 6]), 106); - text: dotProduct([-5, 4, -3, 2], [-7, -8, 9, -6]) should return -36. - testString: assert.equal(dotProduct([-5, 4, -3, 2], [-7, -8, 9, -6]), -36, 'dotProduct([-5, 4, -3, 2], [-7, -8, 9, -6]) should return -36.'); + testString: assert.equal(dotProduct([-5, 4, -3, 2], [-7, -8, 9, -6]), -36); - text: dotProduct([17, 27, 34, 43, 15], [62, 73, 48, 95, 110]) should return 10392. - testString: assert.equal(dotProduct([17, 27, 34, 43, 15], [62, 73, 48, 95, 110]), 10392, 'dotProduct([17, 27, 34, 43, 15], [62, 73, 48, 95, 110]) should return 10392.'); + testString: assert.equal(dotProduct([17, 27, 34, 43, 15], [62, 73, 48, 95, 110]), 10392); ```
## Challenge Seed +
@@ -54,14 +59,14 @@ function dotProduct(ary1, ary2) {
## Solution +
```js function dotProduct(ary1, ary2) { - var dotprod = 0; - for (var i = 0; i < ary1.length; i++) - dotprod += ary1[i] * ary2[i]; - return dotprod; + var dotprod = 0; + for (var i = 0; i < ary1.length; i++) dotprod += ary1[i] * ary2[i]; + return dotprod; } ``` diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/k-d-tree.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/k-d-tree.english.md index aa72e0a537..02aa2646a4 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/k-d-tree.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/k-d-tree.english.md @@ -6,46 +6,52 @@ forumTopicId: 302295 --- ## Description +
A k-d tree (short for k-dimensional tree) is a space-partitioning data structure for organizing points in a k-dimensional space. k-d trees are a useful data structure for several applications, such as searches involving a multidimensional search key (e.g. range searches and nearest neighbor searches). k-d trees are a special case of binary space partitioning trees. k-d trees are not suitable, however, for efficiently finding the nearest neighbor in high dimensional spaces. As a general rule, if the dimensionality is k, the number of points in the data, N, should be N ≫ 2k. Otherwise, when k-d trees are used with high-dimensional data, most of the points in the tree will be evaluated and the efficiency is no better than exhaustive search, and other methods such as approximate nearest-neighbor are used instead. +
## Instructions +
Write a function to perform a nearest neighbour search using k-d tree. The function takes two parameters: an array of k-dimensional points, and a single k-dimensional point whose nearest neighbour should be returned by the function. A k-dimensional point will be given as an array of k elements. +
## Tests +
-``` yml +```yml tests: - text: kdNN should be a function. - testString: assert(typeof kdNN == 'function', 'kdNN should be a function.'); + testString: assert(typeof kdNN == 'function'); - text: kdNN([[[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [9, 2]) should return an array. - testString: assert(Array.isArray(kdNN([[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [9, 2])), 'kdNN([[[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [9, 2]) should return an array.'); + testString: assert(Array.isArray(kdNN([[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [9, 2]))); - text: kdNN([[[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [9, 2]) should return [ 8, 1 ]. - testString: assert.deepEqual(kdNN([[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [9, 2]), [8, 1], 'kdNN([[[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [9, 2]) should return [ 8, 1 ].'); + testString: assert.deepEqual(kdNN([[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [9, 2]), [8, 1]); - text: kdNN([[[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [7, 1]) should return [ 8, 1 ]. - testString: assert.deepEqual(kdNN([[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [7, 1]), [8, 1], 'kdNN([[[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [7, 1]) should return [ 8, 1 ].'); + testString: assert.deepEqual(kdNN([[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [7, 1]), [8, 1]); - text: kdNN([[[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [3, 2]) should return [ 2, 3 ]. - testString: assert.deepEqual(kdNN([[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [3, 2]), [2, 3], 'kdNN([[[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [3, 2]) should return [ 2, 3 ].'); + testString: assert.deepEqual(kdNN([[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]], [3, 2]), [2, 3]); - text: kdNN([[2, 3, 1], [9, 4, 5], [4, 6, 7], [1, 2, 5], [7, 8, 9], [3, 6, 1]], [1, 2, 3]) should return [ 1, 2, 5 ]. - testString: assert.deepEqual(kdNN([[2, 3, 1], [9, 4, 5], [4, 6, 7], [1, 2, 5], [7, 8, 9], [3, 6, 1]], [1, 2, 3]), [1, 2, 5], 'kdNN([[2, 3, 1], [9, 4, 5], [4, 6, 7], [1, 2, 5], [7, 8, 9], [3, 6, 1]], [1, 2, 3]) should return [ 1, 2, 5 ].'); + testString: assert.deepEqual(kdNN([[2, 3, 1], [9, 4, 5], [4, 6, 7], [1, 2, 5], [7, 8, 9], [3, 6, 1]], [1, 2, 3]), [1, 2, 5]); - text: kdNN([[2, 3, 1], [9, 4, 5], [4, 6, 7], [1, 2, 5], [7, 8, 9], [3, 6, 1]], [4, 5, 6]) should return [ 4, 6, 7 ]. - testString: assert.deepEqual(kdNN([[2, 3, 1], [9, 4, 5], [4, 6, 7], [1, 2, 5], [7, 8, 9], [3, 6, 1]], [4, 5, 6]), [4, 6, 7], 'kdNN([[2, 3, 1], [9, 4, 5], [4, 6, 7], [1, 2, 5], [7, 8, 9], [3, 6, 1]], [4, 5, 6]) should return [ 4, 6, 7 ].'); + testString: assert.deepEqual(kdNN([[2, 3, 1], [9, 4, 5], [4, 6, 7], [1, 2, 5], [7, 8, 9], [3, 6, 1]], [4, 5, 6]), [4, 6, 7]); - text: kdNN([[2, 3, 1], [9, 4, 5], [4, 6, 7], [1, 2, 5], [7, 8, 9], [3, 6, 1]], [8, 8, 8]) should return [ 7, 8, 9 ]. - testString: assert.deepEqual(kdNN([[2, 3, 1], [9, 4, 5], [4, 6, 7], [1, 2, 5], [7, 8, 9], [3, 6, 1]], [8, 8, 8]), [7, 8, 9], 'kdNN([[2, 3, 1], [9, 4, 5], [4, 6, 7], [1, 2, 5], [7, 8, 9], [3, 6, 1]], [8, 8, 8]) should return [ 7, 8, 9 ].'); + testString: assert.deepEqual(kdNN([[2, 3, 1], [9, 4, 5], [4, 6, 7], [1, 2, 5], [7, 8, 9], [3, 6, 1]], [8, 8, 8]), [7, 8, 9]); ```
## Challenge Seed +
@@ -60,6 +66,7 @@ function kdNN(fpoints, fpoint) {
## Solution +
```js @@ -73,7 +80,6 @@ function kdNN(fpoints, fpoint) { } function kdTree(points, metric, dimensions) { - var self = this; function buildTree(points, depth, parent) { @@ -88,7 +94,7 @@ function kdNN(fpoints, fpoint) { return new Node(points[0], dim, parent); } - points.sort(function (a, b) { + points.sort(function(a, b) { return a[dimensions[dim]] - b[dimensions[dim]]; }); @@ -102,9 +108,8 @@ function kdNN(fpoints, fpoint) { this.root = buildTree(points, 0, null); - this.insert = function (point) { + this.insert = function(point) { function innerSearch(node, parent) { - if (node === null) { return parent; } @@ -126,7 +131,11 @@ function kdNN(fpoints, fpoint) { return; } - newNode = new Node(point, (insertPosition.dimension + 1) % dimensions.length, insertPosition); + newNode = new Node( + point, + (insertPosition.dimension + 1) % dimensions.length, + insertPosition + ); dimension = dimensions[insertPosition.dimension]; if (point[dimension] < insertPosition.obj[dimension]) { @@ -136,14 +145,12 @@ function kdNN(fpoints, fpoint) { } }; - this.nearest = function (point, maxNodes, maxDistance) { - var i, - result, - bestNodes; + this.nearest = function(point, maxNodes, maxDistance) { + var i, result, bestNodes; - bestNodes = new BinaryHeap( - function (e) { return -e[1]; } - ); + bestNodes = new BinaryHeap(function(e) { + return -e[1]; + }); function nearestSearch(node) { var bestChild, @@ -172,7 +179,10 @@ function kdNN(fpoints, fpoint) { linearDistance = metric(linearPoint, node.obj); if (node.right === null && node.left === null) { - if (bestNodes.size() < maxNodes || ownDistance < bestNodes.peek()[1]) { + if ( + bestNodes.size() < maxNodes || + ownDistance < bestNodes.peek()[1] + ) { saveNode(node, ownDistance); } return; @@ -196,7 +206,10 @@ function kdNN(fpoints, fpoint) { saveNode(node, ownDistance); } - if (bestNodes.size() < maxNodes || Math.abs(linearDistance) < bestNodes.peek()[1]) { + if ( + bestNodes.size() < maxNodes || + Math.abs(linearDistance) < bestNodes.peek()[1] + ) { if (bestChild === node.left) { otherChild = node.right; } else { @@ -214,8 +227,7 @@ function kdNN(fpoints, fpoint) { } } - if (self.root) - nearestSearch(self.root); + if (self.root) nearestSearch(self.root); result = []; @@ -234,14 +246,14 @@ function kdNN(fpoints, fpoint) { } BinaryHeap.prototype = { - push: function (element) { + push: function(element) { // Add the new element to the end of the array. this.content.push(element); // Allow it to bubble up. this.bubbleUp(this.content.length - 1); }, - pop: function () { + pop: function() { // Store the first element so we can return it later. var result = this.content[0]; // Get the element at the end of the array. @@ -255,15 +267,15 @@ function kdNN(fpoints, fpoint) { return result; }, - peek: function () { + peek: function() { return this.content[0]; }, - size: function () { + size: function() { return this.content.length; }, - bubbleUp: function (n) { + bubbleUp: function(n) { // Fetch the element that has to be moved. var element = this.content[n]; // When at 0, an element can not go up any further. @@ -285,7 +297,7 @@ function kdNN(fpoints, fpoint) { } }, - sinkDown: function (n) { + sinkDown: function(n) { // Look up the target element and its score. var length = this.content.length, element = this.content[n], @@ -293,7 +305,8 @@ function kdNN(fpoints, fpoint) { while (true) { // Compute the indices of the child elements. - var child2N = (n + 1) * 2, child1N = child2N - 1; + var child2N = (n + 1) * 2, + child1N = child2N - 1; // This is used to store the new position of the element, // if any. var swap = null; @@ -303,8 +316,7 @@ function kdNN(fpoints, fpoint) { var child1 = this.content[child1N], child1Score = this.scoreFunction(child1); // If the score is less than our element's, we need to swap. - if (child1Score < elemScore) - swap = child1N; + if (child1Score < elemScore) swap = child1N; } // Do the same checks for the other child. if (child2N < length) { @@ -329,26 +341,29 @@ function kdNN(fpoints, fpoint) { } }; - var dims = [] + var dims = []; - for (var i = 0; i < fpoint.length; i++) dims.push(i) + for (var i = 0; i < fpoint.length; i++) dims.push(i); - var tree = new kdTree(fpoints, function (e1, e2) { - var d = 0; - var e3 = e1; - if (!Array.isArray(e1)) { - e3 = [] - for (var key in e1) - e3.push(e1[key]) + var tree = new kdTree( + fpoints, + function(e1, e2) { + var d = 0; + var e3 = e1; + if (!Array.isArray(e1)) { + e3 = []; + for (var key in e1) e3.push(e1[key]); - e1 = e3 - } - e1.forEach(function (e, i) { - var sqd = (e1[i] - e2[i]); - d += sqd * sqd; - }) - return d; - }, dims) + e1 = e3; + } + e1.forEach(function(e, i) { + var sqd = e1[i] - e2[i]; + d += sqd * sqd; + }); + return d; + }, + dims + ); return tree.nearest(fpoint, 1, 1000)[0][0]; } diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/kaprekar-numbers.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/kaprekar-numbers.english.md index 2a8735cbcd..bcd2084616 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/kaprekar-numbers.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/kaprekar-numbers.english.md @@ -6,6 +6,7 @@ forumTopicId: 302296 --- ## Description +
A positive integer is a Kaprekar number if:
    @@ -21,38 +22,41 @@ Kaprekar numbers:
## Instructions +
Write a function that takes a number $n$, a base $bs$, and returns true if the number is a Kaprekar number for the given base. Otherwise, the function returns false.
## Tests +
-``` yml +```yml tests: - text: isKaprekar should be a function. - testString: assert(typeof isKaprekar == 'function', 'isKaprekar should be a function.'); + testString: assert(typeof isKaprekar == 'function'); - text: isKaprekar(1, 10) should return a boolean. - testString: assert(typeof isKaprekar(1, 10) == 'boolean', 'isKaprekar(1, 10) should return a boolean.'); + testString: assert(typeof isKaprekar(1, 10) == 'boolean'); - text: isKaprekar(1, 10) should return true. - testString: assert.equal(isKaprekar(1, 10), true, 'isKaprekar(1, 10) should return true.'); + testString: assert.equal(isKaprekar(1, 10), true); - text: isKaprekar(9, 10) should return true. - testString: assert.equal(isKaprekar(9, 10), true, 'isKaprekar(9, 10) should return true.'); + testString: assert.equal(isKaprekar(9, 10), true); - text: isKaprekar(2223, 10) should return true. - testString: assert.equal(isKaprekar(2223, 10), true, 'isKaprekar(2223, 10) should return true.'); + testString: assert.equal(isKaprekar(2223, 10), true); - text: isKaprekar(22823, 10) should return false. - testString: assert.equal(isKaprekar(22823, 10), false, 'isKaprekar(22823, 10) should return false.'); + testString: assert.equal(isKaprekar(22823, 10), false); - text: isKaprekar(9, 17) should return false. - testString: assert.equal(isKaprekar(9, 17), false, 'isKaprekar(9, 17) should return false.'); + testString: assert.equal(isKaprekar(9, 17), false); - text: isKaprekar(225, 17) should return true. - testString: assert.equal(isKaprekar(225, 17), true, 'isKaprekar(225, 17) should return true.'); + testString: assert.equal(isKaprekar(225, 17), true); - text: isKaprekar(999, 17) should return false. - testString: assert.equal(isKaprekar(999, 17), false, 'isKaprekar(999, 17) should return false.'); + testString: assert.equal(isKaprekar(999, 17), false); ```
## Challenge Seed +
@@ -66,6 +70,7 @@ function isKaprekar(n, bs) {
## Solution +
```js @@ -73,11 +78,12 @@ function isKaprekar(n, bs) { if (n < 1) return false; if (n == 1) return true; for (var a = n * n, b = 0, s = 1; a; s *= bs) { - b += a % bs * s; + b += (a % bs) * s; a = Math.floor(a / bs); if (b && a + b == n) return true; - } return false; -} + } + return false; +} ```
diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/knapsack-problem-0-1.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/knapsack-problem-0-1.english.md index 7969a7ceaa..28ca96649f 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/knapsack-problem-0-1.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/knapsack-problem-0-1.english.md @@ -6,38 +6,42 @@ forumTopicId: 323649 --- ## Description +
The 0-1 knapsack problem is defined as follows: You are given an array of objects representing items to be put in a knapsack. The objects have 3 attributes: name, weight, and value. The items need to be selected so that the total weight does not exceed the maximum weight and the value is maximized.
## Instructions +
Write a function to solve the knapsack problem. The function is given the array of objects and the maximum weight as parameters. It should return the maximum total value possible.
## Tests +
-``` yml +```yml tests: - text: knapsack([{ name:'map', weight:9, value:150 }, { name:'compass', weight:13, value:35 }, { name:'water', weight:153, value:200 }, { name:'sandwich', weight:50, value:160 }, { name:'glucose', weight:15, value:60 }, { name:'tin', weight:68, value:45 }, { name:'banana', weight:27, value:60 }, { name:'apple', weight:39, value:40 }], 100) should return 405. - testString: assert.equal(knapsack([{ name:'map', weight:9, value:150 }, { name:'compass', weight:13, value:35 }, { name:'water', weight:153, value:200 }, { name:'sandwich', weight:50, value:160 }, { name:'glucose', weight:15, value:60 }, { name:'tin', weight:68, value:45 }, { name:'banana', weight:27, value:60 }, { name:'apple', weight:39, value:40 }], 100), 405, "knapsack([{ name:'map', weight:9, value:150 }, { name:'compass', weight:13, value:35 }, { name:'water', weight:153, value:200 }, { name:'sandwich', weight:50, value:160 }, { name:'glucose', weight:15, value:60 }, { name:'tin', weight:68, value:45 }, { name:'banana', weight:27, value:60 }, { name:'apple', weight:39, value:40 }], 100) should return 405."); + testString: assert.equal(knapsack([{ name:'map', weight:9, value:150 }, { name:'compass', weight:13, value:35 }, { name:'water', weight:153, value:200 }, { name:'sandwich', weight:50, value:160 }, { name:'glucose', weight:15, value:60 }, { name:'tin', weight:68, value:45 }, { name:'banana', weight:27, value:60 }, { name:'apple', weight:39, value:40 }], 100), 405); - text: knapsack([{ name:'map', weight:9, value:150 }, { name:'compass', weight:13, value:35 }, { name:'water', weight:153, value:200 }, { name:'sandwich', weight:50, value:160 }, { name:'glucose', weight:15, value:60 }, { name:'tin', weight:68, value:45 }, { name:'banana', weight:27, value:60 }, { name:'apple', weight:39, value:40 }], 200) should return 510. - testString: assert.equal(knapsack([{ name:'map', weight:9, value:150 }, { name:'compass', weight:13, value:35 }, { name:'water', weight:153, value:200 }, { name:'sandwich', weight:50, value:160 }, { name:'glucose', weight:15, value:60 }, { name:'tin', weight:68, value:45 }, { name:'banana', weight:27, value:60 }, { name:'apple', weight:39, value:40 }], 200), 510, "knapsack([{ name:'map', weight:9, value:150 }, { name:'compass', weight:13, value:35 }, { name:'water', weight:153, value:200 }, { name:'sandwich', weight:50, value:160 }, { name:'glucose', weight:15, value:60 }, { name:'tin', weight:68, value:45 }, { name:'banana', weight:27, value:60 }, { name:'apple', weight:39, value:40 }], 200) should return 510."); + testString: assert.equal(knapsack([{ name:'map', weight:9, value:150 }, { name:'compass', weight:13, value:35 }, { name:'water', weight:153, value:200 }, { name:'sandwich', weight:50, value:160 }, { name:'glucose', weight:15, value:60 }, { name:'tin', weight:68, value:45 }, { name:'banana', weight:27, value:60 }, { name:'apple', weight:39, value:40 }], 200), 510); - text: knapsack([{ name:'cheese', weight:23, value:30 }, { name:'beer', weight:52, value:10 }, { name:'suntan cream', weight:11, value:70 }, { name:'camera', weight:32, value:30 }, { name:'T-shirt', weight:24, value:15 }, { name:'trousers', weight:48, value:10 }, { name:'umbrella', weight:73, value:40 }], 100) should return 145. - testString: assert.equal(knapsack([{ name:'cheese', weight:23, value:30 }, { name:'beer', weight:52, value:10 }, { name:'suntan cream', weight:11, value:70 }, { name:'camera', weight:32, value:30 }, { name:'T-shirt', weight:24, value:15 }, { name:'trousers', weight:48, value:10 }, { name:'umbrella', weight:73, value:40 }], 100), 145, "knapsack([{ name:'cheese', weight:23, value:30 }, { name:'beer', weight:52, value:10 }, { name:'suntan cream', weight:11, value:70 }, { name:'camera', weight:32, value:30 }, { name:'T-shirt', weight:24, value:15 }, { name:'trousers', weight:48, value:10 }, { name:'umbrella', weight:73, value:40 }], 100) should return 145."); + testString: assert.equal(knapsack([{ name:'cheese', weight:23, value:30 }, { name:'beer', weight:52, value:10 }, { name:'suntan cream', weight:11, value:70 }, { name:'camera', weight:32, value:30 }, { name:'T-shirt', weight:24, value:15 }, { name:'trousers', weight:48, value:10 }, { name:'umbrella', weight:73, value:40 }], 100), 145); - text: knapsack([{ name:'cheese', weight:23, value:30 }, { name:'beer', weight:52, value:10 }, { name:'suntan cream', weight:11, value:70 }, { name:'camera', weight:32, value:30 }, { name:'T-shirt', weight:24, value:15 }, { name:'trousers', weight:48, value:10 }, { name:'umbrella', weight:73, value:40 }], 200) should return 185. - testString: assert.equal(knapsack([{ name:'cheese', weight:23, value:30 }, { name:'beer', weight:52, value:10 }, { name:'suntan cream', weight:11, value:70 }, { name:'camera', weight:32, value:30 }, { name:'T-shirt', weight:24, value:15 }, { name:'trousers', weight:48, value:10 }, { name:'umbrella', weight:73, value:40 }], 200), 185, "knapsack([{ name:'cheese', weight:23, value:30 }, { name:'beer', weight:52, value:10 }, { name:'suntan cream', weight:11, value:70 }, { name:'camera', weight:32, value:30 }, { name:'T-shirt', weight:24, value:15 }, { name:'trousers', weight:48, value:10 }, { name:'umbrella', weight:73, value:40 }], 200) should return 185."); + testString: assert.equal(knapsack([{ name:'cheese', weight:23, value:30 }, { name:'beer', weight:52, value:10 }, { name:'suntan cream', weight:11, value:70 }, { name:'camera', weight:32, value:30 }, { name:'T-shirt', weight:24, value:15 }, { name:'trousers', weight:48, value:10 }, { name:'umbrella', weight:73, value:40 }], 200), 185); - text: knapsack([{ name:'waterproof trousers', weight:42, value:70 }, { name:'waterproof overclothes', weight:43, value:75 }, { name:'note-case', weight:22, value:80 }, { name:'sunglasses', weight:7, value:20 }, { name:'towel', weight:18, value:12 }, { name:'socks', weight:4, value:50 }, { name:'book', weight:30, value:10 }], 100) should return 237. - testString: assert.equal(knapsack([{ name:'waterproof trousers', weight:42, value:70 }, { name:'waterproof overclothes', weight:43, value:75 }, { name:'note-case', weight:22, value:80 }, { name:'sunglasses', weight:7, value:20 }, { name:'towel', weight:18, value:12 }, { name:'socks', weight:4, value:50 }, { name:'book', weight:30, value:10 }], 100), 237, "knapsack([{ name:'waterproof trousers', weight:42, value:70 }, { name:'waterproof overclothes', weight:43, value:75 }, { name:'note-case', weight:22, value:80 }, { name:'sunglasses', weight:7, value:20 }, { name:'towel', weight:18, value:12 }, { name:'socks', weight:4, value:50 }, { name:'book', weight:30, value:10 }], 100) should return 237."); + testString: assert.equal(knapsack([{ name:'waterproof trousers', weight:42, value:70 }, { name:'waterproof overclothes', weight:43, value:75 }, { name:'note-case', weight:22, value:80 }, { name:'sunglasses', weight:7, value:20 }, { name:'towel', weight:18, value:12 }, { name:'socks', weight:4, value:50 }, { name:'book', weight:30, value:10 }], 100), 237); - text: knapsack([{ name:'waterproof trousers', weight:42, value:70 }, { name:'waterproof overclothes', weight:43, value:75 }, { name:'note-case', weight:22, value:80 }, { name:'sunglasses', weight:7, value:20 }, { name:'towel', weight:18, value:12 }, { name:'socks', weight:4, value:50 }, { name:'book', weight:30, value:10 }], 200) should return 317.' - testString: assert.equal(knapsack([{ name:'waterproof trousers', weight:42, value:70 }, { name:'waterproof overclothes', weight:43, value:75 }, { name:'note-case', weight:22, value:80 }, { name:'sunglasses', weight:7, value:20 }, { name:'towel', weight:18, value:12 }, { name:'socks', weight:4, value:50 }, { name:'book', weight:30, value:10 }], 200), 317, "knapsack([{ name:'waterproof trousers', weight:42, value:70 }, { name:'waterproof overclothes', weight:43, value:75 }, { name:'note-case', weight:22, value:80 }, { name:'sunglasses', weight:7, value:20 }, { name:'towel', weight:18, value:12 }, { name:'socks', weight:4, value:50 }, { name:'book', weight:30, value:10 }], 200) should return 317."); + testString: assert.equal(knapsack([{ name:'waterproof trousers', weight:42, value:70 }, { name:'waterproof overclothes', weight:43, value:75 }, { name:'note-case', weight:22, value:80 }, { name:'sunglasses', weight:7, value:20 }, { name:'towel', weight:18, value:12 }, { name:'socks', weight:4, value:50 }, { name:'book', weight:30, value:10 }], 200), 317); ```
## Challenge Seed +
@@ -51,110 +55,108 @@ function knapsack(items, maxweight) {
## Solution +
```js function knapsack(items, maxweight) { - var _ = { - max: function (e) { - var mx = e[0]; - e.forEach(function (f) { - if (mx < f) - mx = f; - }) - return mx; - }, - map: function (array, func) { - return array.map(func) - }, - isUndefined: function (a) { - if (a) { - return false; - } - return true; - }, - range: function (start, end, step) { - var a = [] - var f = f = (i, end) => i < end - if (start > end) - f = (i, end) => i > end + var _ = { + max: function(e) { + var mx = e[0]; + e.forEach(function(f) { + if (mx < f) mx = f; + }); + return mx; + }, + map: function(array, func) { + return array.map(func); + }, + isUndefined: function(a) { + if (a) { + return false; + } + return true; + }, + range: function(start, end, step) { + var a = []; + var f = (f = (i, end) => i < end); + if (start > end) f = (i, end) => i > end; - for (var i = start; f(i, end); i += step) - a.push(i) - return a - } + for (var i = start; f(i, end); i += step) a.push(i); + return a; + } + }; + + var valuefn = e => e.value; + var weightfn = e => e.weight; + var _epsilon = 0.01; + var _p = _.max(_.map(items, valuefn)); + var _k = (_epsilon * _p) / items.length; + + var _memo = (function() { + var _mem = {}; + var _key = function(i, w) { + return i + '::' + w; + }; + return { + get: function(i, w) { + return _mem[_key(i, w)]; + }, + put: function(i, w, r) { + _mem[_key(i, w)] = r; + return r; + } + }; + })(); + + var _m = function(i, w) { + i = Math.round(i); + w = Math.round(w); + + if (i < 0 || w === 0) { + // empty base case + return { items: [], totalWeight: 0, totalValue: 0 }; } - var valuefn = (e) => e.value - var weightfn = (e) => e.weight - var _epsilon = 0.01; - var _p = _.max(_.map(items, valuefn)); - var _k = _epsilon * _p / items.length; + var mm = _memo.get(i, w); + if (!_.isUndefined(mm)) { + return mm; + } - var _memo = (function () { - var _mem = {}; - var _key = function (i, w) { - return i + '::' + w; - }; - return { - get: function (i, w) { - return _mem[_key(i, w)]; - }, - put: function (i, w, r) { - _mem[_key(i, w)] = r; - return r; - } - }; - })(); + var item = items[i]; + if (weightfn(item) > w) { + //item does not fit, try the next item + return _memo.put(i, w, _m(i - 1, w)); + } + // this item could fit. + // are we better off excluding it? + var excluded = _m(i - 1, w); + // or including it? + var included = _m(i - 1, w - weightfn(item)); + if ( + included.totalValue + Math.floor(valuefn(item) / _k) > + excluded.totalValue + ) { + // better off including it + // make a copy of the list + var i1 = included.items.slice(); + i1.push(item); + return _memo.put(i, w, { + items: i1, + totalWeight: included.totalWeight + weightfn(item), + totalValue: included.totalValue + Math.floor(valuefn(item) / _k) + }); + } + //better off excluding it + return _memo.put(i, w, excluded); + }; + var scaled = _m(items.length - 1, maxweight); - var _m = function (i, w) { - - i = Math.round(i); - w = Math.round(w); - - - if (i < 0 || w === 0) { - // empty base case - return { items: [], totalWeight: 0, totalValue: 0 }; - } - - var mm = _memo.get(i, w); - if (!_.isUndefined(mm)) { - return mm; - } - - var item = items[i]; - if (weightfn(item) > w) { - //item does not fit, try the next item - return _memo.put(i, w, _m(i - 1, w)); - } - // this item could fit. - // are we better off excluding it? - var excluded = _m(i - 1, w); - // or including it? - var included = _m(i - 1, w - weightfn(item)); - if (included.totalValue + Math.floor(valuefn(item) / _k) > excluded.totalValue) { - // better off including it - // make a copy of the list - var i1 = included.items.slice(); - i1.push(item); - return _memo.put(i, w, - { - items: i1, - totalWeight: included.totalWeight + weightfn(item), - totalValue: included.totalValue + Math.floor(valuefn(item) / _k) - }); - } - //better off excluding it - return _memo.put(i, w, excluded); - }; - var scaled = _m(items.length - 1, maxweight); - - var val = 0; - scaled.items.forEach(function (e) { - val += e.value - }) - return val; + var val = 0; + scaled.items.forEach(function(e) { + val += e.value; + }); + return val; } ``` diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/knapsack-problem-bounded.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/knapsack-problem-bounded.english.md index 0784b599e2..24c4897025 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/knapsack-problem-bounded.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/knapsack-problem-bounded.english.md @@ -6,36 +6,40 @@ forumTopicId: 323652 --- ## Description +
The bounded knapsack problem is defined as follows: You are given an array of objects representing items to be put in a knapsack. The objects have 4 attributes: name, pieces (the number of the particular item), weight, and value. The items need to be selected so that the total weight does not exceed the maximum weight and the value is maximized. Keep in mind that each item can appear between 0 and pieces times.
## Instructions +
Write a function to solve the knapsack problem. The function is given the array of objects and the maximum weight as parameters. It should return the maximum total value possible.
## Tests +
-``` yml +```yml tests: - text: findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 300) should return 755. - testString: assert.equal(findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 300), 755, "findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 300) should return 755."); + testString: assert.equal(findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 300), 755); - text: findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 400) should return 875. - testString: assert.equal(findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 400), 875, "findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 400) should return 875."); + testString: assert.equal(findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 400), 875); - text: findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 500) should return 1015. - testString: assert.equal(findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 500), 1015, "findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 500) should return 1015."); + testString: assert.equal(findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 500), 1015); - text: findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 600) should return 1120. - testString: assert.equal(findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 600), 1120, "findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 600) should return 1120."); + testString: assert.equal(findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 600), 1120); - text: findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 700) should return 1225. - testString: assert.equal(findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 700), 1225, "findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 700) should return 1225."); + testString: assert.equal(findBestPack([{ name:'map', weight:9, value:150, pieces:1 }, { name:'compass', weight:13, value:35, pieces:1 }, { name:'water', weight:153, value:200, pieces:2 }, { name:'sandwich', weight:50, value:60, pieces:2 }, { name:'glucose', weight:15, value:60, pieces:2 }, { name:'tin', weight:68, value:45, pieces:3 }, { name:'banana', weight:27, value:60, pieces:3 }, { name:'apple', weight:39, value:40, pieces:3 }, { name:'cheese', weight:23, value:30, pieces:1 }, { name:'beer', weight:52, value:10, pieces:3 }, { name:'suntan, cream', weight:11, value:70, pieces:1 }, { name:'camera', weight:32, value:30, pieces:1 }, { name:'T-shirt', weight:24, value:15, pieces:2 }], 700), 1225); ```
## Challenge Seed +
@@ -49,16 +53,13 @@ function findBestPack(data, maxweight) {
## Solution +
```js function findBestPack(data, maxweight) { - var m = [ - [0] - ]; // maximum pack value found so far - var b = [ - [0] - ]; // best combination found so far + var m = [[0]]; // maximum pack value found so far + var b = [[0]]; // best combination found so far var opts = [0]; // item index for 0 of item 0 var P = [1]; // item encoding for 0 of item 0 var choose = 0; diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/knapsack-problem-continuous.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/knapsack-problem-continuous.english.md index 78cd070a2c..02d3d90448 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/knapsack-problem-continuous.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/knapsack-problem-continuous.english.md @@ -6,41 +6,45 @@ forumTopicId: 323654 --- ## Description +
A thief burgles a butcher's shop, where he can select from some items. The thief knows the weights and prices of each items. Because he has a knapsack with a limit on the maximum weight that it can carry, he wants to select the items such that he would have his profit maximized. He may cut the items; the item has a reduced price after cutting that is proportional to the original price by the ratio of masses. That means: half of an item has half the price of the original.
## Instructions +
Write a function that takes an array of objects representing the items available in the shop. Each object has 3 attributes: name, weight, and value. The function also takes the maximum weight as a parameter. The function should return the maximum value possible, and the total weight of the selected items should not exceed the maximum weight.
## Tests +
-``` yml +```yml tests: - text: knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 10) should return 257.875. - testString: assert.equal(knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 10), 257.875, 'knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 10) should return 257.875.'); + testString: assert.equal(knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 10), 257.875); - text: knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 12) should return 295.05405405405406. - testString: assert.equal(knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 12), 295.05405405405406, 'knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 12) should return 295.05405405405406.'); + testString: assert.equal(knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 12), 295.05405405405406); - text: knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 15) should return 349.3783783783784. - testString: assert.equal(knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 15), 349.3783783783784, 'knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 15) should return 349.3783783783784.'); + testString: assert.equal(knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 15), 349.3783783783784); - text: knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 22) should return 459.5263157894737. - testString: assert.equal(knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 22), 459.5263157894737, 'knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 22) should return 459.5263157894737.'); + testString: assert.equal(knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 22), 459.5263157894737); - text: knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 24) should return 478.4736842105263. - testString: assert.equal(knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 24), 478.4736842105263, 'knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 24) should return 478.4736842105263.'); + testString: assert.equal(knapContinuous([{ "weight":3.8, "value":36, name:"beef" }, { "weight":5.4, "value":43, name:"pork" }, { "weight":3.6, "value":90, name:"ham" }, { "weight":2.4, "value":45, name:"greaves" }, { "weight":4.0, "value":30, name:"flitch" }, { "weight":2.5, "value":56, name:"brawn" }, { "weight":3.7, "value":67, name:"welt" }, { "weight":3.0, "value":95, name:"salami" }, { "weight":5.9, "value":98, name:"sausage" }], 24), 478.4736842105263); ```
## Challenge Seed +
```js -function knapContinuous (items, maxweight) { +function knapContinuous(items, maxweight) { // Good luck! } ``` @@ -49,16 +53,21 @@ function knapContinuous (items, maxweight) {
## Solution +
```js function knapContinuous(items, maxweight) { function item_cmp(a, b) { - const ua = a.unitVal, ub = b.unitVal; + const ua = a.unitVal, + ub = b.unitVal; return ua < ub ? 1 : ua > ub ? -1 : 0; } - items = items.map(({ value, weight }) => ({ unitVal: value / weight, weight })); - items.sort(item_cmp) + items = items.map(({ value, weight }) => ({ + unitVal: value / weight, + weight + })); + items.sort(item_cmp); let val = 0; let wt = 0; diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/knapsack-problem-unbounded.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/knapsack-problem-unbounded.english.md index dcbe180fa9..521d646efc 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/knapsack-problem-unbounded.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/knapsack-problem-unbounded.english.md @@ -6,6 +6,7 @@ forumTopicId: 323655 --- ## Description +
A traveler gets diverted and has to make an unscheduled stop in what turns out to be Shangri-La. Opting to leave, he is allowed to take as much as he likes of the items available there, so long as it will fit in his knapsack, and he can carry it. He knows that he can carry no more than a particular value of maximum weight in total; and that the capacity of his knapsack has a limited volume. @@ -14,30 +15,33 @@ He can only take whole units of any item, but there is much more of any item tha
## Instructions +
Write a function that takes an array of objects, maximum weight, and maximum volume as parameters. Each object has 4 attributes: name, value, weight, and volume. The function should return the maximum value of items the traveller can take with him.
## Tests +
-``` yml +```yml tests: - text: knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 25, 0.25) should return 54500. - testString: assert.equal(knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 25, 0.25), 54500, 'knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 25, 0.25) should return 54500.'); + testString: assert.equal(knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 25, 0.25), 54500); - text: knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 55, 0.25) should return 88400. - testString: assert.equal(knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 55, 0.25), 88400, 'knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 55, 0.25) should return 88400.'); + testString: assert.equal(knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 55, 0.25), 88400); - text: knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 25, 0.15) should return 42500. - testString: assert.equal(knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 25, 0.15), 42500, 'knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 25, 0.15) should return 42500.'); + testString: assert.equal(knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 25, 0.15), 42500); - text: knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 35, 0.35) should return 75300. - testString: assert.equal(knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 35, 0.35), 75300, 'knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 35, 0.35) should return 75300.'); + testString: assert.equal(knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 35, 0.35), 75300); - text: knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 15, 0.25) should return 43200. - testString: assert.equal(knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 15, 0.25), 43200, 'knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 15, 0.25) should return 43200.'); + testString: assert.equal(knapsackUnbounded([{ name:"panacea", value:3000, weight:0.3, volume:0.025 }, { name:"ichor", value:1800, weight:0.2, volume:0.015 }, { name:"gold", value:2500, weight:2, volume:0.002 }], 15, 0.25), 43200); ```
## Challenge Seed +
@@ -51,40 +55,41 @@ function knapsackUnbounded(items, maxweight, maxvolume) {
## Solution +
```js function knapsackUnbounded(items, maxweight, maxvolume) { - var n = items.length; - var best_value = 0; - var count = new Array(n) - var best = new Array(n) - function recurseKnapsack(i, value, weight, volume) { - var j, m1, m2, m; - if (i == n) { - if (value > best_value) { - best_value = value; - for (j = 0; j < n; j++) { - best[j] = count[j]; - } - } - return; - } - m1 = Math.floor(weight / items[i].weight); - m2 = Math.floor(volume / items[i].volume); - m = m1 < m2 ? m1 : m2; - for (count[i] = m; count[i] >= 0; count[i]--) { - recurseKnapsack( - i + 1, - value + count[i] * items[i].value, - weight - count[i] * items[i].weight, - volume - count[i] * items[i].volume - ); + var n = items.length; + var best_value = 0; + var count = new Array(n); + var best = new Array(n); + function recurseKnapsack(i, value, weight, volume) { + var j, m1, m2, m; + if (i == n) { + if (value > best_value) { + best_value = value; + for (j = 0; j < n; j++) { + best[j] = count[j]; } + } + return; } + m1 = Math.floor(weight / items[i].weight); + m2 = Math.floor(volume / items[i].volume); + m = m1 < m2 ? m1 : m2; + for (count[i] = m; count[i] >= 0; count[i]--) { + recurseKnapsack( + i + 1, + value + count[i] * items[i].value, + weight - count[i] * items[i].weight, + volume - count[i] * items[i].volume + ); + } + } - recurseKnapsack(0, 0, maxweight, maxvolume); - return best_value; + recurseKnapsack(0, 0, maxweight, maxvolume); + return best_value; } ``` diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/knights-tour.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/knights-tour.english.md index 12ee7af44a..431432112d 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/knights-tour.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/knights-tour.english.md @@ -6,39 +6,43 @@ forumTopicId: 302297 --- ## Description +
Knight's TourProblem: You have an empty w * h chessboard, but for a single knight on some square. The knight must perform a sequence of legal moves that result in the knight visiting every square on the chessboard exactly once. Note that it is not a requirement that the tour be "closed"; that is, the knight need not end within a single move of its start position.
## Instructions +
Write a function that takes w and h as parameters and returns the number of initial positions from where it is possible to achieve the task stated above.
## Tests +
-``` yml +```yml tests: - text: knightTour should be a function. - testString: assert(typeof knightTour == 'function', 'knightTour should be a function.'); + testString: assert(typeof knightTour == 'function'); - text: knightTour(6, 6) should return a number. - testString: assert(typeof knightTour(6, 6) == 'number', 'knightTour(6, 6) should return a number.'); + testString: assert(typeof knightTour(6, 6) == 'number'); - text: knightTour(6, 6) should return 35. - testString: assert.equal(knightTour(6, 6), 35, 'knightTour(6, 6) should return 35.'); + testString: assert.equal(knightTour(6, 6), 35); - text: knightTour(5, 6) should return 20. - testString: assert.equal(knightTour(5, 6), 20, 'knightTour(5, 6) should return 20.'); + testString: assert.equal(knightTour(5, 6), 20); - text: knightTour(4, 6) should return 10. - testString: assert.equal(knightTour(4, 6), 10, 'knightTour(4, 6) should return 10.'); + testString: assert.equal(knightTour(4, 6), 10); - text: knightTour(7, 3) should return 4. - testString: assert.equal(knightTour(7, 3), 4, 'knightTour(7, 3) should return 4.'); + testString: assert.equal(knightTour(7, 3), 4); - text: knightTour(8, 6) should return 47. - testString: assert.equal(knightTour(8, 6), 47, 'knightTour(8, 6) should return 47.'); + testString: assert.equal(knightTour(8, 6), 47); ```
## Challenge Seed +
@@ -52,85 +56,84 @@ function knightTour(w, h) {
## Solution +
```js -function knightTour (w, h) { - var b, cnt=0; +function knightTour(w, h) { + var b, + cnt = 0; - var dx = [ -2, -2, -1, 1, 2, 2, 1, -1 ]; - var dy = [ -1, 1, 2, 2, 1, -1, -2, -2 ]; + var dx = [-2, -2, -1, 1, 2, 2, 1, -1]; + var dy = [-1, 1, 2, 2, 1, -1, -2, -2]; - function init_board() - { - var i, j, k, x, y; - // * b is board; a is board with 2 rows padded at each side + function init_board() { + var i, j, k, x, y; + // * b is board; a is board with 2 rows padded at each side - for(i=0;i= 0 && x < w && y >= 0 && y < h) b[i][j]++; - } - } - } + for (i = 0; i < h; i++) { + for (j = 0; j < w; j++) { + for (k = 0; k < 8; k++) { + (x = j + dx[k]), (y = i + dy[k]); + if (b[i][j] == 255) b[i][j] = 0; + if (x >= 0 && x < w && y >= 0 && y < h) b[i][j]++; + } + } + } } - function walk_board(x, y) - { - var i, nx, ny, least; - var steps = 0; - // printf(E"H"E"J"E"%d;%dH"E"32m[]"E"m", y + 1, 1 + 2 * x); + function walk_board(x, y) { + var i, nx, ny, least; + var steps = 0; + // printf(E"H"E"J"E"%d;%dH"E"32m[]"E"m", y + 1, 1 + 2 * x); - while (1) { - // * occupy cell - b[y][x] = 255; + while (1) { + // * occupy cell + b[y][x] = 255; - // * reduce all neighbors' neighbor count - for (i = 0; i < 8; i++) - if(y+dy[i] >= 0 && x+dx[i] >= 0 && y+dy[i] < h && x+dx[i] < w) - b[ y + dy[i] ][ x + dx[i] ]--; + // * reduce all neighbors' neighbor count + for (i = 0; i < 8; i++) + if (y + dy[i] >= 0 && x + dx[i] >= 0 && y + dy[i] < h && x + dx[i] < w) + b[y + dy[i]][x + dx[i]]--; - // find neighbor with lowest neighbor count - least = 255; - for (i = 0; i < 8; i++) { - if(y+dy[i] >= 0 && x+dx[i] >= 0 && y+dy[i] < h && x+dx[i] < w) - if (b[ y + dy[i] ][ x + dx[i] ] < least) { - nx = x + dx[i]; - ny = y + dy[i]; - least = b[ny][nx]; - } - } + // find neighbor with lowest neighbor count + least = 255; + for (i = 0; i < 8; i++) { + if (y + dy[i] >= 0 && x + dx[i] >= 0 && y + dy[i] < h && x + dx[i] < w) + if (b[y + dy[i]][x + dx[i]] < least) { + nx = x + dx[i]; + ny = y + dy[i]; + least = b[ny][nx]; + } + } - if (least > 7) { - return steps == w * h - 1; - } + if (least > 7) { + return steps == w * h - 1; + } steps++; - x = nx, y = ny; - } + (x = nx), (y = ny); + } } - function solve (x, y) { - b=new Array(h); - for(var i=0;i Given a set of positive integers, write a function to order the integers in such a way that the concatenation of the numbers forms the largest possible integer and return this integer. +
## Instructions +
## Tests +
-``` yml +```yml tests: - text: maxCombine should be a function. - testString: assert(typeof maxCombine == 'function', 'maxCombine should be a function.'); + testString: assert(typeof maxCombine == 'function'); - text: maxCombine([1, 3, 3, 4, 55]) should return a number. - testString: assert(typeof maxCombine([1, 3, 3, 4, 55]) == 'number', 'maxCombine([1, 3, 3, 4, 55]) should return a number.'); + testString: assert(typeof maxCombine([1, 3, 3, 4, 55]) == 'number'); - text: maxCombine([1, 3, 3, 4, 55]) should return 554331. - testString: assert.equal(maxCombine([1, 3, 3, 4, 55]), 554331, 'maxCombine([1, 3, 3, 4, 55]) should return 554331.'); + testString: assert.equal(maxCombine([1, 3, 3, 4, 55]), 554331); - text: maxCombine([71, 45, 23, 4, 5]) should return 71545423. - testString: assert.equal(maxCombine([71, 45, 23, 4, 5]), 71545423, 'maxCombine([71, 45, 23, 4, 5]) should return 71545423.'); + testString: assert.equal(maxCombine([71, 45, 23, 4, 5]), 71545423); - text: maxCombine([14, 43, 53, 114, 55]) should return 55534314114. - testString: assert.equal(maxCombine([14, 43, 53, 114, 55]), 55534314114, 'maxCombine([14, 43, 53, 114, 55]) should return 55534314114.'); + testString: assert.equal(maxCombine([14, 43, 53, 114, 55]), 55534314114); - text: maxCombine([1, 34, 3, 98, 9, 76, 45, 4]) should return 998764543431. - testString: assert.equal(maxCombine([1, 34, 3, 98, 9, 76, 45, 4]), 998764543431, 'maxCombine([1, 34, 3, 98, 9, 76, 45, 4]) should return 998764543431.'); + testString: assert.equal(maxCombine([1, 34, 3, 98, 9, 76, 45, 4]), 998764543431); - text: maxCombine([54, 546, 548, 60]) should return 6054854654. - testString: assert.equal(maxCombine([54, 546, 548, 60]), 6054854654, 'maxCombine([54, 546, 548, 60]) should return 6054854654.'); + testString: assert.equal(maxCombine([54, 546, 548, 60]), 6054854654); ```
## Challenge Seed +
@@ -54,23 +59,24 @@ function maxCombine(xs) {
## Solution +
```js -function maxCombine (xs) { - return parseInt( - xs.sort( - function (x, y) { - var a = x.toString(), - b = y.toString(), - ab = parseInt(a + b), - ba = parseInt(b + a); +function maxCombine(xs) { + return parseInt( + xs + .sort(function(x, y) { + var a = x.toString(), + b = y.toString(), + ab = parseInt(a + b), + ba = parseInt(b + a); - return ab > ba ? -1 : (ab < ba ? 1 : 0); - } - ) - .join(''), 10 - ); + return ab > ba ? -1 : ab < ba ? 1 : 0; + }) + .join(''), + 10 + ); } ``` diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/last-friday-of-each-month.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/last-friday-of-each-month.english.md index a222a0f3fe..156f1b01ac 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/last-friday-of-each-month.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/last-friday-of-each-month.english.md @@ -6,46 +6,51 @@ forumTopicId: 302299 --- ## Description +
Write a function that returns the date of the last Friday of a given month for a given year. +
## Instructions +
## Tests +
-``` yml +```yml tests: - text: lastFriday should be a function. - testString: assert(typeof lastFriday == 'function', 'lastFriday should be a function.'); + testString: assert(typeof lastFriday == 'function'); - text: lastFriday(2018, 1) should return a number. - testString: assert(typeof lastFriday(2018, 1) == 'number', 'lastFriday(2018, 1) should return a number.'); + testString: assert(typeof lastFriday(2018, 1) == 'number'); - text: lastFriday(2018, 1) should return 26. - testString: assert.equal(lastFriday(2018, 1), 26, 'lastFriday(2018, 1) should return 26.'); + testString: assert.equal(lastFriday(2018, 1), 26); - text: lastFriday(2017, 2) should return 24. - testString: assert.equal(lastFriday(2017, 2), 24, 'lastFriday(2017, 2) should return 24.'); + testString: assert.equal(lastFriday(2017, 2), 24); - text: lastFriday(2012, 3) should return 30. - testString: assert.equal(lastFriday(2012, 3), 30, 'lastFriday(2012, 3) should return 30.'); + testString: assert.equal(lastFriday(2012, 3), 30); - text: lastFriday(1900, 4) should return 27. - testString: assert.equal(lastFriday(1900, 4), 27, 'lastFriday(1900, 4) should return 27.'); + testString: assert.equal(lastFriday(1900, 4), 27); - text: lastFriday(2000, 5) should return 26. - testString: assert.equal(lastFriday(2000, 5), 26, 'lastFriday(2000, 5) should return 26.'); + testString: assert.equal(lastFriday(2000, 5), 26); - text: lastFriday(2006, 6) should return 30. - testString: assert.equal(lastFriday(2006, 6), 30, 'lastFriday(2006, 6) should return 30.'); + testString: assert.equal(lastFriday(2006, 6), 30); - text: lastFriday(2010, 7) should return 30. - testString: assert.equal(lastFriday(2010, 7), 30, 'lastFriday(2010, 7) should return 30.'); + testString: assert.equal(lastFriday(2010, 7), 30); - text: lastFriday(2005, 8) should return 26. - testString: assert.equal(lastFriday(2005, 8), 26, 'lastFriday(2005, 8) should return 26.'); + testString: assert.equal(lastFriday(2005, 8), 26); ```
## Challenge Seed +
@@ -60,10 +65,11 @@ function lastFriday(year, month) {
## Solution +
```js -function lastFriday (year, month) { +function lastFriday(year, month) { var i, last_day; i = 0; while (true) { @@ -73,7 +79,7 @@ function lastFriday (year, month) { } i -= 1; } -}; +} ```
diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/leap-year.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/leap-year.english.md index 800f511715..a743ffebd4 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/leap-year.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/leap-year.english.md @@ -6,42 +6,47 @@ forumTopicId: 302300 --- ## Description +
Determine whether a given year is a leap year in the Gregorian calendar. +
## Instructions +
## Tests +
-``` yml +```yml tests: - text: isLeapYear should be a function. - testString: assert(typeof isLeapYear == 'function', 'isLeapYear should be a function.'); + testString: assert(typeof isLeapYear == 'function'); - text: isLeapYear() should return a boolean. - testString: assert(typeof isLeapYear(2018) == 'boolean', 'isLeapYear() should return a boolean.'); + testString: assert(typeof isLeapYear(2018) == 'boolean'); - text: isLeapYear(2018) should return false. - testString: assert.equal(isLeapYear(2018), false, 'isLeapYear(2018) should return false.'); + testString: assert.equal(isLeapYear(2018), false); - text: isLeapYear(2016) should return true. - testString: assert.equal(isLeapYear(2016), true, 'isLeapYear(2016) should return true.'); + testString: assert.equal(isLeapYear(2016), true); - text: isLeapYear(2000) should return true. - testString: assert.equal(isLeapYear(2000), true, 'isLeapYear(2000) should return true.'); + testString: assert.equal(isLeapYear(2000), true); - text: isLeapYear(1900) should return false. - testString: assert.equal(isLeapYear(1900), false, 'isLeapYear(1900) should return false.'); + testString: assert.equal(isLeapYear(1900), false); - text: isLeapYear(1996) should return true. - testString: assert.equal(isLeapYear(1996), true, 'isLeapYear(1996) should return true.'); + testString: assert.equal(isLeapYear(1996), true); - text: isLeapYear(1800) should return false. - testString: assert.equal(isLeapYear(1800), false, 'isLeapYear(1800) should return false.'); + testString: assert.equal(isLeapYear(1800), false); ```
## Challenge Seed +
@@ -56,12 +61,13 @@ function isLeapYear(year) {
## Solution +
```js -function isLeapYear (year) { - return (year % 100 === 0) ? (year % 400 === 0) : (year % 4 === 0); -}; +function isLeapYear(year) { + return year % 100 === 0 ? year % 400 === 0 : year % 4 === 0; +} ```
diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/least-common-multiple.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/least-common-multiple.english.md index bf24c795af..60dc731695 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/least-common-multiple.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/least-common-multiple.english.md @@ -6,45 +6,51 @@ forumTopicId: 302301 --- ## Description +
-The least common multiple of 12 and 18 is 36, because 12 is a factor (12 × 3 = 36), and 18 is a factor (18 × 2 = 36), and there is no positive integer less than 36 that has both factors. As a special case, if either m or n is zero, then the least common multiple is zero. -One way to calculate the least common multiple is to iterate all the multiples of m, until you find one that is also a multiple of n. -If you already have gcd for greatest common divisor, then this formula calculates lcm. +The least common multiple of 12 and 18 is 36, because 12 is a factor (12 × 3 = 36), and 18 is a factor (18 × 2 = 36), and there is no positive integer less than 36 that has both factors. As a special case, if either m or n is zero, then the least common multiple is zero. +One way to calculate the least common multiple is to iterate all the multiples of m, until you find one that is also a multiple of n. +If you already have gcd for greatest common divisor, then this formula calculates lcm. \( \operatorname{lcm}(m, n) = \frac{|m \times n|}{\operatorname{gcd}(m, n)} \) +
## Instructions +
Compute the least common multiple of an array of integers. -Given m and n, the least common multiple is the smallest positive integer that has both m and n as factors. +Given m and n, the least common multiple is the smallest positive integer that has both m and n as factors. +
## Tests +
-``` yml +```yml tests: - text: LCM should be a function. - testString: assert(typeof LCM == 'function', 'LCM should be a function.'); + testString: assert(typeof LCM == 'function'); - text: LCM([2, 4, 8]) should return a number. - testString: assert(typeof LCM([2, 4, 8]) == 'number', 'LCM([2, 4, 8]) should return a number.'); + testString: assert(typeof LCM([2, 4, 8]) == 'number'); - text: LCM([2, 4, 8]) should return 8. - testString: assert.equal(LCM([2, 4, 8]), 8, 'LCM([2, 4, 8]) should return 8.'); + testString: assert.equal(LCM([2, 4, 8]), 8); - text: LCM([4, 8, 12]) should return 24. - testString: assert.equal(LCM([4, 8, 12]), 24, 'LCM([4, 8, 12]) should return 24.'); + testString: assert.equal(LCM([4, 8, 12]), 24); - text: LCM([3, 4, 5, 12, 40]) should return 120. - testString: assert.equal(LCM([3, 4, 5, 12, 40]), 120, 'LCM([3, 4, 5, 12, 40]) should return 120.'); + testString: assert.equal(LCM([3, 4, 5, 12, 40]), 120); - text: LCM([11, 33, 90]) should return 990. - testString: assert.equal(LCM([11, 33, 90]), 990, 'LCM([11, 33, 90]) should return 990.'); + testString: assert.equal(LCM([11, 33, 90]), 990); - text: LCM([-50, 25, -45, -18, 90, 447]) should return 67050. - testString: assert.equal(LCM([-50, 25, -45, -18, 90, 447]), 67050, 'LCM([-50, 25, -45, -18, 90, 447]) should return 67050.'); + testString: assert.equal(LCM([-50, 25, -45, -18, 90, 447]), 67050); ```
## Challenge Seed +
@@ -59,17 +65,22 @@ function LCM(A) {
## Solution +
```js -function LCM (A) { - var n = A.length, a = Math.abs(A[0]); - for (var i = 1; i < n; i++) - { var b = Math.abs(A[i]), c = a; - while (a && b){ a > b ? a %= b : b %= a; } - a = Math.abs(c*A[i])/(a+b); - } - return a; +function LCM(A) { + var n = A.length, + a = Math.abs(A[0]); + for (var i = 1; i < n; i++) { + var b = Math.abs(A[i]), + c = a; + while (a && b) { + a > b ? (a %= b) : (b %= a); + } + a = Math.abs(c * A[i]) / (a + b); + } + return a; } ``` diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/left-factorials.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/left-factorials.english.md index 84829fdbba..eaa57744ea 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/left-factorials.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/left-factorials.english.md @@ -6,6 +6,7 @@ forumTopicId: 302302 --- ## Description +
Left factorials, $ !n $, may refer to either subfactorials or to factorial sums. The same notation can be confusingly seen used for the two different definitions. Sometimes, subfactorials (also known as derangements) may use any of the notations:
    @@ -19,38 +20,41 @@ where $!0 = 0$
## Instructions +
Write a function to calculate the left factorial of a given number.
## Tests +
-``` yml +```yml tests: - text: leftFactorial should be a function. - testString: assert(typeof leftFactorial == 'function', 'leftFactorial should be a function.'); + testString: assert(typeof leftFactorial == 'function'); - text: leftFactorial(0) should return a number. - testString: assert(typeof leftFactorial(0) == 'number', 'leftFactorial(0) should return a number.'); + testString: assert(typeof leftFactorial(0) == 'number'); - text: leftFactorial(0) should return 0. - testString: assert.equal(leftFactorial(0), 0, 'leftFactorial(0) should return 0.'); + testString: assert.equal(leftFactorial(0), 0); - text: leftFactorial(1) should return 1. - testString: assert.equal(leftFactorial(1), 1, 'leftFactorial(1) should return 1.'); + testString: assert.equal(leftFactorial(1), 1); - text: leftFactorial(2) should return 2. - testString: assert.equal(leftFactorial(2), 2, 'leftFactorial(2) should return 2.'); + testString: assert.equal(leftFactorial(2), 2); - text: leftFactorial(3) should return 4. - testString: assert.equal(leftFactorial(3), 4, 'leftFactorial(3) should return 4.'); + testString: assert.equal(leftFactorial(3), 4); - text: leftFactorial(10) should return 409114. - testString: assert.equal(leftFactorial(10), 409114, 'leftFactorial(10) should return 409114.'); + testString: assert.equal(leftFactorial(10), 409114); - text: leftFactorial(17) should return 22324392524314. - testString: assert.equal(leftFactorial(17), 22324392524314, 'leftFactorial(17) should return 22324392524314.'); + testString: assert.equal(leftFactorial(17), 22324392524314); - text: leftFactorial(19) should return 6780385526348314. - testString: assert.equal(leftFactorial(19), 6780385526348314, 'leftFactorial(19) should return 6780385526348314.'); + testString: assert.equal(leftFactorial(19), 6780385526348314); ```
## Challenge Seed +
@@ -64,26 +68,26 @@ function leftFactorial(n) {
## Solution +
```js function leftFactorial(n) { - if (n == 0) - return 0 - if (n == 1) - return 1; + if (n == 0) return 0; + if (n == 1) return 1; - // Note: for n>=20, the result may not be correct. - // This is because JavaScript uses 53 bit integers and - // for n>=20 result becomes too large. + // Note: for n>=20, the result may not be correct. + // This is because JavaScript uses 53 bit integers and + // for n>=20 result becomes too large. - let res = 2, fact = 2; - for (var i = 2; i < n; i++) { - res += fact; - fact *= (i + 1); - } + let res = 2, + fact = 2; + for (var i = 2; i < n; i++) { + res += fact; + fact *= i + 1; + } - return res; + return res; } ``` diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sort-disjoint-sublist.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sort-disjoint-sublist.english.md index 83a4d315b2..87420d0c29 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sort-disjoint-sublist.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sort-disjoint-sublist.english.md @@ -6,6 +6,7 @@ forumTopicId: 302307 --- ## Description +
Given a list of values and a set of integer indices into that value list, the task is to sort the values at the given indices, but preserving the values at indices outside the set of those to be sorted. Make your function work with the following list of values and set of indices: @@ -16,34 +17,37 @@ Where the correct result would be:
## Instructions +
## Tests +
-``` yml +```yml tests: - text: sortDisjoint should be a function. - testString: assert(typeof sortDisjoint == 'function', 'sortDisjoint should be a function.'); + testString: assert(typeof sortDisjoint == 'function'); - text: sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7]) should return an array. - testString: assert(Array.isArray(sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7])), 'sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7]) should return an array.'); + testString: assert(Array.isArray(sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7]))); - text: sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7]) should return [7, 0, 5, 4, 3, 2, 1, 6]. - testString: assert.deepEqual(sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7]), [7, 0, 5, 4, 3, 2, 1, 6], 'sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7]) should return [7, 0, 5, 4, 3, 2, 1, 6].'); + testString: assert.deepEqual(sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7]), [7, 0, 5, 4, 3, 2, 1, 6]); - text: sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [1, 2, 5, 6]) should return [7, 1, 2, 4, 3, 5, 6, 0]. - testString: assert.deepEqual(sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [1, 2, 5, 6]), [7, 1, 2, 4, 3, 5, 6, 0], 'sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [1, 2, 5, 6]) should return [7, 1, 2, 4, 3, 5, 6, 0].'); + testString: assert.deepEqual(sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [1, 2, 5, 6]), [7, 1, 2, 4, 3, 5, 6, 0]); - text: sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [6, 1, 7]) should return [8, 1, 6, 5, 4, 3, 2, 7]. - testString: assert.deepEqual(sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [6, 1, 7]), [8, 1, 6, 5, 4, 3, 2, 7], 'sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [6, 1, 7]) should return [8, 1, 6, 5, 4, 3, 2, 7].'); + testString: assert.deepEqual(sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [6, 1, 7]), [8, 1, 6, 5, 4, 3, 2, 7]); - text: sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [1, 3, 5, 6]) should return [8, 2, 6, 3, 4, 5, 7, 1]. - testString: assert.deepEqual(sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [1, 3, 5, 6]), [8, 2, 6, 3, 4, 5, 7, 1], 'sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [1, 3, 5, 6]) should return [8, 2, 6, 3, 4, 5, 7, 1].'); + testString: assert.deepEqual(sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [1, 3, 5, 6]), [8, 2, 6, 3, 4, 5, 7, 1]); - text: sortDisjoint([6, 1, 7, 1, 3, 5, 6], [6, 1, 5, 4]) should return [6, 1, 7, 1, 3, 5, 6]. - testString: assert.deepEqual(sortDisjoint([6, 1, 7, 1, 3, 5, 6], [6, 1, 5, 4]), [6, 1, 7, 1, 3, 5, 6],'sortDisjoint([6, 1, 7, 1, 3, 5, 6], [6, 1, 5, 4]) should return [6, 1, 7, 1, 3, 5, 6].'); + testString: assert.deepEqual(sortDisjoint([6, 1, 7, 1, 3, 5, 6], [6, 1, 5, 4]), [6, 1, 7, 1, 3, 5, 6]); ```
## Challenge Seed +
@@ -58,20 +62,25 @@ function sortDisjoint(values, indices) {
## Solution +
```js function sortDisjoint(values, indices) { let sublist = []; - indices.sort(function (a, b) { return a - b; }); - + indices.sort(function(a, b) { + return a - b; + }); + for (let i = 0; i < indices.length; i++) { sublist.push(values[indices[i]]); } - - sublist.sort((a, b) => { return a - b; }); - + + sublist.sort((a, b) => { + return a - b; + }); + for (let i = 0; i < indices.length; i++) { values[indices[i]] = sublist[i]; } diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sort-stability.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sort-stability.english.md index 6bb1b774d9..418401b52b 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sort-stability.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sort-stability.english.md @@ -6,6 +6,7 @@ forumTopicId: 302308 --- ## Description +
When sorting records in a table by a particular column or field, a stable sort will always retain the relative order of records that have the same key. For example, in this table of countries and cities, a stable sort on the second column, the cities, would keep the US Birmingham above the UK Birmingham. (Although an unstable sort might, in this case, place the US Birmingham above the UK Birmingham, a stable sort routine would guarantee it). @@ -19,34 +20,37 @@ Similarly, stable sorting on just the first column would generate "UK London" as
## Instructions +
Write a function that takes a 2D array as a parameter. Each element has 2 elements similar to the above example. The function should sort the array as mentioned previously and return the sorted array.
## Tests +
-``` yml +```yml tests: - text: stableSort should be a function. - testString: assert(typeof stableSort == 'function', 'stableSort should be a function.'); + testString: assert(typeof stableSort == 'function'); - text: stableSort([["UK", "London"], ["US", "New York"], ["US", "Birmingham"], ["UK", "Birmingham"]]) should return an array. - testString: assert(Array.isArray(stableSort([["UK", "London"], ["US", "New York"], ["US", "Birmingham"], ["UK", "Birmingham"]])), 'stableSort([["UK", "London"], ["US", "New York"], ["US", "Birmingham"], ["UK", "Birmingham"]]) should return an array.'); + testString: assert(Array.isArray(stableSort([["UK", "London"], ["US", "New York"], ["US", "Birmingham"], ["UK", "Birmingham"]]))); - text: stableSort([["UK", "London"], ["US", "New York"], ["US", "Birmingham"], ["UK", "Birmingham"]]) should return [["US", "Birmingham"], ["UK", "Birmingham"], ["UK", "London"], ["US", "New York"]]. - testString: assert.deepEqual(stableSort([["UK", "London"], ["US", "New York"], ["US", "Birmingham"], ["UK", "Birmingham"]]), [["US", "Birmingham"], ["UK", "Birmingham"], ["UK", "London"], ["US", "New York"]], 'stableSort([["UK", "London"], ["US", "New York"], ["US", "Birmingham"], ["UK", "Birmingham"]]) should return [["US", "Birmingham"], ["UK", "Birmingham"], ["UK", "London"], ["US", "New York"]].'); + testString: assert.deepEqual(stableSort([["UK", "London"], ["US", "New York"], ["US", "Birmingham"], ["UK", "Birmingham"]]), [["US", "Birmingham"], ["UK", "Birmingham"], ["UK", "London"], ["US", "New York"]]); - text: stableSort([[2, 2], [1, 2], [1, 4], [1, 5]]) should return [[2, 2], [1, 2], [1, 4], [1, 5]]. - testString: assert.deepEqual(stableSort([[2, 2], [1, 2], [1, 4], [1, 5]]), [[2, 2], [1, 2], [1, 4], [1, 5]], 'stableSort([[2, 2], [1, 2], [1, 4], [1, 5]]) should return [[2, 2], [1, 2], [1, 4], [1, 5]].'); + testString: assert.deepEqual(stableSort([[2, 2], [1, 2], [1, 4], [1, 5]]), [[2, 2], [1, 2], [1, 4], [1, 5]]); - text: stableSort([[11, 55], [12, 45], [11, 45], [32, 45]]) should return [[12, 45], [11, 45], [32, 45], [11, 55]]. - testString: assert.deepEqual(stableSort([[11, 55], [12, 45], [11, 45], [32, 45]]), [[12, 45], [11, 45], [32, 45], [11, 55]], 'stableSort([[11, 55], [12, 45], [11, 45], [32, 45]]) should return [[12, 45], [11, 45], [32, 45], [11, 55]].'); + testString: assert.deepEqual(stableSort([[11, 55], [12, 45], [11, 45], [32, 45]]), [[12, 45], [11, 45], [32, 45], [11, 55]]); - text: stableSort([[10, 22], [1, 2], [1, 4], [1, 5], [10, 9]]) should return [[1, 2], [1, 4], [1, 5], [10, 9], [10, 22]]. - testString: assert.deepEqual(stableSort([[10, 22], [1, 2], [1, 4], [1, 5], [10, 9]]), [[1, 2], [1, 4], [1, 5], [10, 9], [10, 22]], 'stableSort([[10, 22], [1, 2], [1, 4], [1, 5], [10, 9]]) should return [[1, 2], [1, 4], [1, 5], [10, 9], [10, 22]].'); + testString: assert.deepEqual(stableSort([[10, 22], [1, 2], [1, 4], [1, 5], [10, 9]]), [[1, 2], [1, 4], [1, 5], [10, 9], [10, 22]]); - text: stableSort([[55, 54], [12, 22], [31, 43], [31, 54], [10, 49]]) should return [[12, 22], [31, 43], [10, 49], [55, 54], [31, 54]]. - testString: assert.deepEqual(stableSort([[55, 54], [12, 22], [31, 43], [31, 54], [10, 49]]), [[12, 22], [31, 43], [10, 49], [55, 54], [31, 54]], 'stableSort([[55, 54], [12, 22], [31, 43], [31, 54], [10, 49]]) should return [[12, 22], [31, 43], [10, 49], [55, 54], [31, 54]].'); + testString: assert.deepEqual(stableSort([[55, 54], [12, 22], [31, 43], [31, 54], [10, 49]]), [[12, 22], [31, 43], [10, 49], [55, 54], [31, 54]]); ```
## Challenge Seed +
@@ -61,12 +65,15 @@ function stableSort(arr) {
## Solution +
```js function stableSort(arr) { - arr.sort(function (a, b) { return (a[1] < b[1] ? -1 : (a[1] > b[1] ? 1 : 0)) }); - return arr; + arr.sort(function(a, b) { + return a[1] < b[1] ? -1 : a[1] > b[1] ? 1 : 0; + }); + return arr; } ``` diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sort-using-a-custom-comparator.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sort-using-a-custom-comparator.english.md index 235148e206..01885155aa 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sort-using-a-custom-comparator.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sort-using-a-custom-comparator.english.md @@ -6,39 +6,43 @@ forumTopicId: 302309 --- ## Description +
Write a function to sort an array (or list) of strings in order of descending length, and in ascending lexicographic order for strings of equal length.
## Instructions +
## Tests +
-``` yml +```yml tests: - text: lengthSorter should be a function. - testString: assert(typeof lengthSorter == 'function', 'lengthSorter should be a function.'); + testString: assert(typeof lengthSorter == 'function'); - text: lengthSorter(["Here", "are", "some", "sample", "strings", "to", "be", "sorted"]) should return an array. - testString: assert(Array.isArray(lengthSorter(["Here", "are", "some", "sample", "strings", "to", "be", "sorted"])), 'lengthSorter(["Here", "are", "some", "sample", "strings", "to", "be", "sorted"]) should return an array.'); + testString: assert(Array.isArray(lengthSorter(["Here", "are", "some", "sample", "strings", "to", "be", "sorted"]))); - text: lengthSorter(["Here", "are", "some", "sample", "strings", "to", "be", "sorted"]) should return ["strings", "sample", "sorted", "Here", "some", "are", "be", "to"]. - testString: assert.deepEqual(lengthSorter(["Here", "are", "some", "sample", "strings", "to", "be", "sorted"]), ["strings", "sample", "sorted", "Here", "some", "are", "be", "to"], 'lengthSorter(["Here", "are", "some", "sample", "strings", "to", "be", "sorted"]) should return ["strings", "sample", "sorted", "Here", "some", "are", "be", "to"].'); + testString: assert.deepEqual(lengthSorter(["Here", "are", "some", "sample", "strings", "to", "be", "sorted"]), ["strings", "sample", "sorted", "Here", "some", "are", "be", "to"]); - text: lengthSorter(["I", "hope", "your", "day", "is", "going", "good", "?"]) should return ["going", "good", "hope", "your", "day", "is", "?","I"]. - testString: assert.deepEqual(lengthSorter(["I", "hope", "your", "day", "is", "going", "good", "?"]), ["going", "good", "hope", "your", "day", "is", "?","I"], 'lengthSorter(["I", "hope", "your", "day", "is", "going", "good", "?"]) should return ["going", "good", "hope", "your", "day", "is", "?","I"].'); + testString: assert.deepEqual(lengthSorter(["I", "hope", "your", "day", "is", "going", "good", "?"]), ["going", "good", "hope", "your", "day", "is", "?","I"]); - text: lengthSorter(["Mine", "is", "going", "great"]) should return ["going", "great", "Mine", "is"]. - testString: assert.deepEqual(lengthSorter(["Mine", "is", "going", "great"]), ["going", "great", "Mine", "is"], 'lengthSorter(["Mine", "is", "going", "great"]) should return ["going", "great", "Mine", "is"].'); + testString: assert.deepEqual(lengthSorter(["Mine", "is", "going", "great"]), ["going", "great", "Mine", "is"]); - text: lengthSorter(["Have", "fun", "sorting", "!!"]) should return ["sorting", "Have", "fun", "!!"]. - testString: assert.deepEqual(lengthSorter(["Have", "fun", "sorting", "!!"]), ["sorting", "Have", "fun", "!!"], 'lengthSorter(["Have", "fun", "sorting", "!!"]) should return ["sorting", "Have", "fun", "!!"].'); + testString: assert.deepEqual(lengthSorter(["Have", "fun", "sorting", "!!"]), ["sorting", "Have", "fun", "!!"]); - text: lengthSorter(["Everything", "is", "good", "!!"]) should return ["Everything", "good", "!!", "is"]. - testString: assert.deepEqual(lengthSorter(["Everything", "is", "good", "!!"]), ["Everything", "good", "!!", "is"], 'lengthSorter(["Everything", "is", "good", "!!"]) should return ["Everything", "good", "!!", "is"].'); + testString: assert.deepEqual(lengthSorter(["Everything", "is", "good", "!!"]), ["Everything", "good", "!!", "is"]); ```
## Challenge Seed +
@@ -52,17 +56,17 @@ function lengthSorter(arr) {
## Solution +
```js function lengthSorter(arr) { - arr.sort(function (a, b) { - var result = b.length - a.length; - if (result == 0) - result = a.localeCompare(b); - return result; - }) - return arr; + arr.sort(function(a, b) { + var result = b.length - a.length; + if (result == 0) result = a.localeCompare(b); + return result; + }); + return arr; } ``` diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-bead-sort.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-bead-sort.english.md index a4f53aa657..00b9114d8c 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-bead-sort.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-bead-sort.english.md @@ -6,6 +6,7 @@ forumTopicId: 302310 --- ## Description +
Sort an array of positive integers using the Bead Sort Algorithm. A bead sort is also known as a gravity sort. @@ -14,34 +15,37 @@ This is the case when bead sort is implemented without a mechanism to assist in
## Instructions +
## Tests +
-``` yml +```yml tests: - text: beadSort should be a function. - testString: assert(typeof beadSort == 'function', 'beadSort should be a function.'); + testString: assert(typeof beadSort == 'function'); - text: beadSort([25, 32, 12, 7, 20]) should return an array. - testString: assert(Array.isArray(beadSort([25, 32, 12, 7, 20])), 'beadSort([25, 32, 12, 7, 20]) should return an array.'); + testString: assert(Array.isArray(beadSort([25, 32, 12, 7, 20]))); - text: beadSort([25, 32, 12, 7, 20]) should return [7, 12, 20, 25, 32]. - testString: assert.deepEqual(beadSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32], 'beadSort([25, 32, 12, 7, 20]) should return [7, 12, 20, 25, 32].'); + testString: assert.deepEqual(beadSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]); - text: beadSort([38, 45, 35, 8, 13]) should return [8, 13, 35, 38, 45]. - testString: assert.deepEqual(beadSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45], 'beadSort([38, 45, 35, 8, 13]) should return [8, 13, 35, 38, 45].'); + testString: assert.deepEqual(beadSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]); - text: beadSort([43, 36, 20, 34, 24]) should return [20, 24, 34, 36, 43]. - testString: assert.deepEqual(beadSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43], 'beadSort([43, 36, 20, 34, 24]) should return [20, 24, 34, 36, 43].'); + testString: assert.deepEqual(beadSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]); - text: beadSort([12, 33, 26, 18, 1, 16, 38]) should return [1, 12, 16, 18, 26, 33, 38]. - testString: assert.deepEqual(beadSort([12, 33, 26, 18, 1, 16, 38]), [1, 12, 16, 18, 26, 33, 38], 'beadSort([12, 33, 26, 18, 1, 16, 38]) should return [1, 12, 16, 18, 26, 33, 38].'); + testString: assert.deepEqual(beadSort([12, 33, 26, 18, 1, 16, 38]), [1, 12, 16, 18, 26, 33, 38]); - text: beadSort([3, 39, 48, 16, 1, 4, 29]) should return [1, 3, 4, 16, 29, 39, 48]. - testString: assert.deepEqual(beadSort([3, 39, 48, 16, 1, 4, 29]), [1, 3, 4, 16, 29, 39, 48], 'beadSort([3, 39, 48, 16, 1, 4, 29]) should return [1, 3, 4, 16, 29, 39, 48].'); + testString: assert.deepEqual(beadSort([3, 39, 48, 16, 1, 4, 29]), [1, 3, 4, 16, 29, 39, 48]); ```
## Challenge Seed +
@@ -55,43 +59,46 @@ function beadSort(arr) {
## Solution +
```js function beadSort(arr) { - var max = 0; - for (var i = 0; i < arr.length; i++) - if (arr[i] > max) - max = arr[i];; - var grid = new Array(arr.length); - for (var i = 0; i < grid.length; i++) { - grid[i] = new Array(max); + var max = 0; + for (var i = 0; i < arr.length; i++) if (arr[i] > max) max = arr[i]; + var grid = new Array(arr.length); + for (var i = 0; i < grid.length; i++) { + grid[i] = new Array(max); + } + var levelcount = new Array(max); + levelcount.fill(0); + for (var i = 0; i < max; i++) { + levelcount[i] = 0; + for (var j = 0; j < arr.length; j++) grid[j][i] = '_'; + } + for (var i = 0; i < arr.length; i++) { + var num = arr[i]; + for (var j = 0; num > 0; j++) { + grid[levelcount[j]++][j] = '*'; + num--; } - var levelcount = new Array(max); - levelcount.fill(0) - for (var i = 0; i < max; i++) { - levelcount[i] = 0; - for (var j = 0; j < arr.length; j++) - grid[j][i] = '_'; - }; - for (var i = 0; i < arr.length; i++) { - var num = arr[i]; - for (var j = 0; num > 0; j++) { - grid[levelcount[j]++][j] = '*'; - num--; - }; - }; - var sorted = new Array(arr.length) - sorted.fill(0) - for (var i = 0; i < arr.length; i++) { - var putt = 0; - for (var j = 0; j < max && (function (c) { - return c.charCodeAt == null ? c : c.charCodeAt(0); - })(grid[arr.length - 1 - i][j]) == '*'.charCodeAt(0); j++) - putt++; - sorted[i] = putt; - }; - return sorted; + } + var sorted = new Array(arr.length); + sorted.fill(0); + for (var i = 0; i < arr.length; i++) { + var putt = 0; + for ( + var j = 0; + j < max && + (function(c) { + return c.charCodeAt == null ? c : c.charCodeAt(0); + })(grid[arr.length - 1 - i][j]) == '*'.charCodeAt(0); + j++ + ) + putt++; + sorted[i] = putt; + } + return sorted; } ``` diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-bogosort.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-bogosort.english.md index 4a12609b23..a73b74a111 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-bogosort.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-bogosort.english.md @@ -6,6 +6,7 @@ forumTopicId: 302311 --- ## Description +
Bogosort a list of numbers. Bogosort simply shuffles a collection randomly until it is sorted. @@ -21,34 +22,37 @@ Pseudocode:
## Instructions +
## Tests +
-``` yml +```yml tests: - text: bogosort should be a function. - testString: assert(typeof bogosort == 'function', 'bogosort should be a function.'); + testString: assert(typeof bogosort == 'function'); - text: bogosort([25, 32, 12, 7, 20]) should return an array. - testString: assert(Array.isArray(bogosort([25, 32, 12, 7, 20])), 'bogosort([25, 32, 12, 7, 20]) should return an array.'); + testString: assert(Array.isArray(bogosort([25, 32, 12, 7, 20]))); - text: bogosort([25, 32, 12, 7, 20]) should return [7, 12, 20, 25, 32]. - testString: assert.deepEqual(bogosort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32], 'bogosort([25, 32, 12, 7, 20]) should return [7, 12, 20, 25, 32].'); + testString: assert.deepEqual(bogosort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]); - text: bogosort([38, 45, 35, 8, 13]) should return [8, 13, 35, 38, 45]. - testString: assert.deepEqual(bogosort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45], 'bogosort([38, 45, 35, 8, 13]) should return [8, 13, 35, 38, 45].'); + testString: assert.deepEqual(bogosort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]); - text: bogosort([43, 36, 20, 34, 24]) should return [20, 24, 34, 36, 43]. - testString: assert.deepEqual(bogosort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43], 'bogosort([43, 36, 20, 34, 24]) should return [20, 24, 34, 36, 43].'); + testString: assert.deepEqual(bogosort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]); - text: bogosort([12, 33, 26, 18, 1, 16, 38]) should return [1, 12, 16, 18, 26, 33, 38]. - testString: assert.deepEqual(bogosort([12, 33, 26, 18, 1, 16, 38]), [1, 12, 16, 18, 26, 33, 38], 'bogosort([12, 33, 26, 18, 1, 16, 38]) should return [1, 12, 16, 18, 26, 33, 38].'); + testString: assert.deepEqual(bogosort([12, 33, 26, 18, 1, 16, 38]), [1, 12, 16, 18, 26, 33, 38]); - text: bogosort([3, 39, 48, 16, 1, 4, 29]) should return [1, 3, 4, 16, 29, 39, 48]. - testString: assert.deepEqual(bogosort([3, 39, 48, 16, 1, 4, 29]), [1, 3, 4, 16, 29, 39, 48], 'bogosort([3, 39, 48, 16, 1, 4, 29]) should return [1, 3, 4, 16, 29, 39, 48].'); + testString: assert.deepEqual(bogosort([3, 39, 48, 16, 1, 4, 29]), [1, 3, 4, 16, 29, 39, 48]); ```
## Challenge Seed +
@@ -62,29 +66,34 @@ function bogosort(v) {
## Solution +
```js function bogosort(v) { - function shuffle(v) { - for (var j, x, i = v.length; i; j = Math.floor(Math.random() * i), x = v[--i], v[i] = v[j], v[j] = x); - return v; - }; - - function isSorted(v) { - for (var i = 1; i < v.length; i++) { - if (v[i - 1] > v[i]) { - return false; - } - } - return true; - } - var sorted = false; - while (sorted == false) { - v = shuffle(v); - sorted = isSorted(v); - } + function shuffle(v) { + for ( + var j, x, i = v.length; + i; + j = Math.floor(Math.random() * i), x = v[--i], v[i] = v[j], v[j] = x + ); return v; + } + + function isSorted(v) { + for (var i = 1; i < v.length; i++) { + if (v[i - 1] > v[i]) { + return false; + } + } + return true; + } + var sorted = false; + while (sorted == false) { + v = shuffle(v); + sorted = isSorted(v); + } + return v; } ``` diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-cocktail-sort.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-cocktail-sort.english.md index afc585e6ec..6ba5c20238 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-cocktail-sort.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-cocktail-sort.english.md @@ -6,6 +6,7 @@ forumTopicId: 302312 --- ## Description +
The cocktail shaker sort is an improvement on the Bubble Sort. The improvement is basically that values "bubble" both directions through the array, because on each iteration the cocktail shaker sort bubble sorts once forwards and once backwards. Pseudocode for the algorithm (from wikipedia):

@@ -33,34 +34,37 @@ The cocktail shaker sort is an improvement on the Bubble Sort.
@@ -49,34 +50,37 @@ Pseudocode:
## Instructions +
Write a function that sorts a given array using Comb sort.
## Tests +
-``` yml +```yml tests: - text: combSort should be a function. - testString: assert(typeof combSort == 'function', 'combSort should be a function.'); + testString: assert(typeof combSort == 'function'); - text: combSort([25, 32, 12, 7, 20]) should return an array. - testString: assert(Array.isArray(combSort([25, 32, 12, 7, 20])), 'combSort([25, 32, 12, 7, 20]) should return an array.'); + testString: assert(Array.isArray(combSort([25, 32, 12, 7, 20]))); - text: combSort([25, 32, 12, 7, 20]) should return [7, 12, 20, 25, 32]. - testString: assert.deepEqual(combSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32], 'combSort([25, 32, 12, 7, 20]) should return [7, 12, 20, 25, 32].'); + testString: assert.deepEqual(combSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]); - text: combSort([38, 45, 35, 8, 13]) should return [8, 13, 35, 38, 45]. - testString: assert.deepEqual(combSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45], 'combSort([38, 45, 35, 8, 13]) should return [8, 13, 35, 38, 45].'); + testString: assert.deepEqual(combSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]); - text: combSort([43, 36, 20, 34, 24]) should return [20, 24, 34, 36, 43]. - testString: assert.deepEqual(combSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43], 'combSort([43, 36, 20, 34, 24]) should return [20, 24, 34, 36, 43].'); + testString: assert.deepEqual(combSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]); - text: combSort([12, 33, 26, 18, 1, 16, 38]) should return [1, 12, 16, 18, 26, 33, 38]. - testString: assert.deepEqual(combSort([12, 33, 26, 18, 1, 16, 38]), [1, 12, 16, 18, 26, 33, 38], 'combSort([12, 33, 26, 18, 1, 16, 38]) should return [1, 12, 16, 18, 26, 33, 38].'); + testString: assert.deepEqual(combSort([12, 33, 26, 18, 1, 16, 38]), [1, 12, 16, 18, 26, 33, 38]); - text: combSort([3, 39, 48, 16, 1, 4, 29]) should return [1, 3, 4, 16, 29, 39, 48]. - testString: assert.deepEqual(combSort([3, 39, 48, 16, 1, 4, 29]), [1, 3, 4, 16, 29, 39, 48], 'combSort([3, 39, 48, 16, 1, 4, 29]) should return [1, 3, 4, 16, 29, 39, 48].'); + testString: assert.deepEqual(combSort([3, 39, 48, 16, 1, 4, 29]), [1, 3, 4, 16, 29, 39, 48]); ```
## Challenge Seed +
@@ -90,6 +94,7 @@ function combSort(arr) {
## Solution +
```js @@ -113,7 +118,7 @@ function combSort(arr) { // If not first gap if (iteration_count > 0) // Calculate gap - gap = (gap == 1) ? gap : Math.floor(gap / decrease_factor); + gap = gap == 1 ? gap : Math.floor(gap / decrease_factor); // Set front and back elements and increment to a gap var front = 0; diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-gnome-sort.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-gnome-sort.english.md index 36406772e7..06e2ed8697 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-gnome-sort.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-gnome-sort.english.md @@ -6,6 +6,7 @@ forumTopicId: 302314 --- ## Description +
Gnome sort is a sorting algorithm which is similar to Insertion sort, except that moving an element to its proper place is accomplished by a series of swaps, as in Bubble Sort. The pseudocode for the algorithm is: @@ -31,34 +32,37 @@ The pseudocode for the algorithm is:
## Instructions +
Write a function to implement the above pseudo code. The function should return the sorted array.
## Tests +
-``` yml +```yml tests: - text: gnomeSort should be a function. - testString: assert(typeof gnomeSort == 'function', 'gnomeSort should be a function.'); + testString: assert(typeof gnomeSort == 'function'); - text: gnomeSort([25, 32, 12, 7, 20]) should return an array. - testString: assert(Array.isArray(gnomeSort([25, 32, 12, 7, 20])), 'gnomeSort([25, 32, 12, 7, 20]) should return an array.'); + testString: assert(Array.isArray(gnomeSort([25, 32, 12, 7, 20]))); - text: gnomeSort([25, 32, 12, 7, 20]) should return [7, 12, 20, 25, 32]. - testString: assert.deepEqual(gnomeSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32], 'gnomeSort([25, 32, 12, 7, 20]) should return [7, 12, 20, 25, 32].'); + testString: assert.deepEqual(gnomeSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]); - text: gnomeSort([38, 45, 35, 8, 13]) should return [8, 13, 35, 38, 45]. - testString: assert.deepEqual(gnomeSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45], 'gnomeSort([38, 45, 35, 8, 13]) should return [8, 13, 35, 38, 45].'); + testString: assert.deepEqual(gnomeSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]); - text: gnomeSort([43, 36, 20, 34, 24]) should return [20, 24, 34, 36, 43]. - testString: assert.deepEqual(gnomeSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43], 'gnomeSort([43, 36, 20, 34, 24]) should return [20, 24, 34, 36, 43].'); + testString: assert.deepEqual(gnomeSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]); - text: gnomeSort([12, 33, 26, 18, 1, 16, 38]) should return [1, 12, 16, 18, 26, 33, 38]. - testString: assert.deepEqual(gnomeSort([12, 33, 26, 18, 1, 16, 38]), [1, 12, 16, 18, 26, 33, 38], 'gnomeSort([12, 33, 26, 18, 1, 16, 38]) should return [1, 12, 16, 18, 26, 33, 38].'); + testString: assert.deepEqual(gnomeSort([12, 33, 26, 18, 1, 16, 38]), [1, 12, 16, 18, 26, 33, 38]); - text: gnomeSort([3, 39, 48, 16, 1, 4, 29]) should return [1, 3, 4, 16, 29, 39, 48]. - testString: assert.deepEqual(gnomeSort([3, 39, 48, 16, 1, 4, 29]), [1, 3, 4, 16, 29, 39, 48], 'gnomeSort([3, 39, 48, 16, 1, 4, 29]) should return [1, 3, 4, 16, 29, 39, 48].'); + testString: assert.deepEqual(gnomeSort([3, 39, 48, 16, 1, 4, 29]), [1, 3, 4, 16, 29, 39, 48]); ```
## Challenge Seed +
@@ -72,6 +76,7 @@ function gnomeSort(a) {
## Solution +
```js diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-pancake-sort.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-pancake-sort.english.md index 7ccb83ea9f..26f16d3916 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-pancake-sort.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-pancake-sort.english.md @@ -6,6 +6,7 @@ forumTopicId: 302315 --- ## Description +
Write a function to sort an array of integers (of any convenient size) into ascending order using Pancake sorting. The function should return the sorted array. In short, instead of individual elements being sorted, the only operation allowed is to "flip" one end of the list, like so: @@ -19,34 +20,37 @@ Only one end of the list can be flipped; this should be the low end, but the hig
## Instructions +
## Tests +
-``` yml +```yml tests: - text: pancakeSort should be a function. - testString: assert(typeof pancakeSort == 'function', 'pancakeSort should be a function.'); + testString: assert(typeof pancakeSort == 'function'); - text: pancakeSort([25, 32, 12, 7, 20]) should return an array. - testString: assert(Array.isArray(pancakeSort([25, 32, 12, 7, 20])), 'pancakeSort([25, 32, 12, 7, 20]) should return an array.'); + testString: assert(Array.isArray(pancakeSort([25, 32, 12, 7, 20]))); - text: pancakeSort([25, 32, 12, 7, 20]) should return [7, 12, 20, 25, 32]. - testString: assert.deepEqual(pancakeSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32], 'pancakeSort([25, 32, 12, 7, 20]) should return [7, 12, 20, 25, 32].'); + testString: assert.deepEqual(pancakeSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]); - text: pancakeSort([38, 45, 35, 8, 13]) should return [8, 13, 35, 38, 45]. - testString: assert.deepEqual(pancakeSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45], 'pancakeSort([38, 45, 35, 8, 13]) should return [8, 13, 35, 38, 45].'); + testString: assert.deepEqual(pancakeSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]); - text: pancakeSort([43, 36, 20, 34, 24]) should return [20, 24, 34, 36, 43]. - testString: assert.deepEqual(pancakeSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43], 'pancakeSort([43, 36, 20, 34, 24]) should return [20, 24, 34, 36, 43].'); + testString: assert.deepEqual(pancakeSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]); - text: pancakeSort([12, 33, 26, 18, 1, 16, 38]) should return [1, 12, 16, 18, 26, 33, 38]. - testString: assert.deepEqual(pancakeSort([12, 33, 26, 18, 1, 16, 38]), [1, 12, 16, 18, 26, 33, 38], 'pancakeSort([12, 33, 26, 18, 1, 16, 38]) should return [1, 12, 16, 18, 26, 33, 38].'); + testString: assert.deepEqual(pancakeSort([12, 33, 26, 18, 1, 16, 38]), [1, 12, 16, 18, 26, 33, 38]); - text: pancakeSort([3, 39, 48, 16, 1, 4, 29]) should return [1, 3, 4, 16, 29, 39, 48]. - testString: assert.deepEqual(pancakeSort([3, 39, 48, 16, 1, 4, 29]), [1, 3, 4, 16, 29, 39, 48], 'pancakeSort([3, 39, 48, 16, 1, 4, 29]) should return [1, 3, 4, 16, 29, 39, 48].'); + testString: assert.deepEqual(pancakeSort([3, 39, 48, 16, 1, 4, 29]), [1, 3, 4, 16, 29, 39, 48]); ```
## Challenge Seed +
@@ -60,39 +64,37 @@ function pancakeSort(arr) {
## Solution +
```js function pancakeSort(arr) { - for (var i = arr.length - 1; i >= 1; i--) { - // find the index of the largest element not yet sorted - var max_idx = 0; - var max = arr[0]; - for (var j = 1; j <= i; j++) { - if (arr[j] > max) { - max = arr[j]; - max_idx = j; - } - } - - if (max_idx == i) - continue; // element already in place - - var new_slice; - - // flip arr max element to index 0 - if (max_idx > 0) { - new_slice = arr.slice(0, max_idx + 1).reverse(); - for (var j = 0; j <= max_idx; j++) - arr[j] = new_slice[j]; - } - - // then flip the max element to its place - new_slice = arr.slice(0, i + 1).reverse(); - for (var j = 0; j <= i; j++) - arr[j] = new_slice[j]; + for (var i = arr.length - 1; i >= 1; i--) { + // find the index of the largest element not yet sorted + var max_idx = 0; + var max = arr[0]; + for (var j = 1; j <= i; j++) { + if (arr[j] > max) { + max = arr[j]; + max_idx = j; + } } - return arr; + + if (max_idx == i) continue; // element already in place + + var new_slice; + + // flip arr max element to index 0 + if (max_idx > 0) { + new_slice = arr.slice(0, max_idx + 1).reverse(); + for (var j = 0; j <= max_idx; j++) arr[j] = new_slice[j]; + } + + // then flip the max element to its place + new_slice = arr.slice(0, i + 1).reverse(); + for (var j = 0; j <= i; j++) arr[j] = new_slice[j]; + } + return arr; } ``` diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-permutation-sort.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-permutation-sort.english.md index b8a9c830c5..3a2b82a733 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-permutation-sort.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-permutation-sort.english.md @@ -6,6 +6,7 @@ forumTopicId: 302316 --- ## Description +
Write a function to implement a permutation sort, which proceeds by generating the possible permutations of the input array until discovering the sorted one. The function should return the sorted array. Pseudocode: @@ -17,34 +18,37 @@ Pseudocode:
## Instructions +
## Tests +
-``` yml +```yml tests: - text: permutationSort should be a function. - testString: assert(typeof permutationSort == 'function', 'permutationSort should be a function.'); + testString: assert(typeof permutationSort == 'function'); - text: permutationSort([25, 32, 12, 7, 20]) should return an array. - testString: assert(Array.isArray(permutationSort([25, 32, 12, 7, 20])), 'permutationSort([25, 32, 12, 7, 20]) should return an array.'); + testString: assert(Array.isArray(permutationSort([25, 32, 12, 7, 20]))); - text: permutationSort([25, 32, 12, 7, 20]) should return [7, 12, 20, 25, 32]. - testString: assert.deepEqual(permutationSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32], 'permutationSort([25, 32, 12, 7, 20]) should return [7, 12, 20, 25, 32].'); + testString: assert.deepEqual(permutationSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]); - text: permutationSort([38, 45, 35, 8, 13]) should return [8, 13, 35, 38, 45]. - testString: assert.deepEqual(permutationSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45], 'permutationSort([38, 45, 35, 8, 13]) should return [8, 13, 35, 38, 45].'); + testString: assert.deepEqual(permutationSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]); - text: permutationSort([43, 36, 20, 34, 24]) should return [20, 24, 34, 36, 43]. - testString: assert.deepEqual(permutationSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43], 'permutationSort([43, 36, 20, 34, 24]) should return [20, 24, 34, 36, 43].'); + testString: assert.deepEqual(permutationSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]); - text: permutationSort([12, 33, 26, 18, 1, 16, 38]) should return [1, 12, 16, 18, 26, 33, 38]. - testString: assert.deepEqual(permutationSort([12, 33, 26, 18, 1, 16, 38]), [1, 12, 16, 18, 26, 33, 38], 'permutationSort([12, 33, 26, 18, 1, 16, 38]) should return [1, 12, 16, 18, 26, 33, 38].'); + testString: assert.deepEqual(permutationSort([12, 33, 26, 18, 1, 16, 38]), [1, 12, 16, 18, 26, 33, 38]); - text: permutationSort([3, 39, 48, 16, 1, 4, 29]) should return [1, 3, 4, 16, 29, 39, 48]. - testString: assert.deepEqual(permutationSort([3, 39, 48, 16, 1, 4, 29]), [1, 3, 4, 16, 29, 39, 48], 'permutationSort([3, 39, 48, 16, 1, 4, 29]) should return [1, 3, 4, 16, 29, 39, 48].'); + testString: assert.deepEqual(permutationSort([3, 39, 48, 16, 1, 4, 29]), [1, 3, 4, 16, 29, 39, 48]); ```
## Challenge Seed +
@@ -58,6 +62,7 @@ function permutationSort(arr) {
## Solution +
```js @@ -67,11 +72,10 @@ function permutationSort(arr) { permute(a, a.length, list); for (var i = 0; i < list.length; i++) { var x = list[i]; - if (isSorted(x)) - return x; + if (isSorted(x)) return x; } return a; - }; + } function permute(a, n, list) { if (n === 1) { @@ -83,21 +87,19 @@ function permutationSort(arr) { swap(a, i, n - 1); permute(a, n - 1, list); swap(a, i, n - 1); - }; - }; + } + } function isSorted(a) { - for (var i = 1; i < a.length; i++) - if (a[i - 1] > a[i]) - return false;; + for (var i = 1; i < a.length; i++) if (a[i - 1] > a[i]) return false; return true; - }; + } function swap(arr, i, j) { var temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; - }; + } return pSort(arr); } ``` diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-shell-sort.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-shell-sort.english.md index 8a91a5082c..f386b26fd0 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-shell-sort.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-shell-sort.english.md @@ -6,6 +6,7 @@ forumTopicId: 302317 --- ## Description +
Write a function to sort an array of elements using the Shell sort algorithm, a diminishing increment sort. The function should return the sorted array. The Shell sort (also known as Shellsort or Shell's method) is named after its inventor, Donald Shell, who published the algorithm in 1959. @@ -16,34 +17,37 @@ Empirical studies have shown a geometric increment sequence with a ratio of abou
## Instructions +
## Tests +
-``` yml +```yml tests: - text: shellSort should be a function. - testString: assert(typeof shellSort == 'function', 'shellSort should be a function.'); + testString: assert(typeof shellSort == 'function'); - text: shellSort([25, 32, 12, 7, 20]) should return an array. - testString: assert(Array.isArray(shellSort([25, 32, 12, 7, 20])), 'shellSort([25, 32, 12, 7, 20]) should return an array.'); + testString: assert(Array.isArray(shellSort([25, 32, 12, 7, 20]))); - text: shellSort([25, 32, 12, 7, 20]) should return [7, 12, 20, 25, 32]. - testString: assert.deepEqual(shellSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32], 'shellSort([25, 32, 12, 7, 20]) should return [7, 12, 20, 25, 32].'); + testString: assert.deepEqual(shellSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]); - text: shellSort([38, 45, 35, 8, 13]) should return [8, 13, 35, 38, 45]. - testString: assert.deepEqual(shellSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45], 'shellSort([38, 45, 35, 8, 13]) should return [8, 13, 35, 38, 45].'); + testString: assert.deepEqual(shellSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]); - text: shellSort([43, 36, 20, 34, 24]) should return [20, 24, 34, 36, 43]. - testString: assert.deepEqual(shellSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43], 'shellSort([43, 36, 20, 34, 24]) should return [20, 24, 34, 36, 43].'); + testString: assert.deepEqual(shellSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]); - text: shellSort([12, 33, 26, 18, 1, 16, 38]) should return [1, 12, 16, 18, 26, 33, 38]. - testString: assert.deepEqual(shellSort([12, 33, 26, 18, 1, 16, 38]), [1, 12, 16, 18, 26, 33, 38], 'shellSort([12, 33, 26, 18, 1, 16, 38]) should return [1, 12, 16, 18, 26, 33, 38].'); + testString: assert.deepEqual(shellSort([12, 33, 26, 18, 1, 16, 38]), [1, 12, 16, 18, 26, 33, 38]); - text: shellSort([3, 39, 48, 16, 1, 4, 29]) should return [1, 3, 4, 16, 29, 39, 48]. - testString: assert.deepEqual(shellSort([3, 39, 48, 16, 1, 4, 29]), [1, 3, 4, 16, 29, 39, 48], 'shellSort([3, 39, 48, 16, 1, 4, 29]) should return [1, 3, 4, 16, 29, 39, 48].'); + testString: assert.deepEqual(shellSort([3, 39, 48, 16, 1, 4, 29]), [1, 3, 4, 16, 29, 39, 48]); ```
## Challenge Seed +
@@ -57,19 +61,19 @@ function shellSort(a) {
## Solution +
```js function shellSort(a) { - for (var h = a.length; h > 0; h = parseInt(h / 2)) { - for (var i = h; i < a.length; i++) { - var k = a[i]; - for (var j = i; j >= h && k < a[j - h]; j -= h) - a[j] = a[j - h]; - a[j] = k; - } + for (var h = a.length; h > 0; h = parseInt(h / 2)) { + for (var i = h; i < a.length; i++) { + var k = a[i]; + for (var j = i; j >= h && k < a[j - h]; j -= h) a[j] = a[j - h]; + a[j] = k; } - return a; + } + return a; } ``` diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-stooge-sort.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-stooge-sort.english.md index 586bd619a5..bbd2c780c6 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-stooge-sort.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-stooge-sort.english.md @@ -6,6 +6,7 @@ forumTopicId: 302318 --- ## Description +
Write a function to perform Stooge Sort on an array of integers. The function should return a sorted array. The Stooge Sort algorithm is as follows: @@ -23,34 +24,37 @@ The Stooge Sort algorithm is as follows:
## Instructions +
## Tests +
-``` yml +```yml tests: - text: stoogeSort should be a function. - testString: assert(typeof stoogeSort == 'function', 'stoogeSort should be a function.'); + testString: assert(typeof stoogeSort == 'function'); - text: stoogeSort([25, 32, 12, 7, 20]) should return an array. - testString: assert(Array.isArray(stoogeSort([25, 32, 12, 7, 20])), 'stoogeSort([25, 32, 12, 7, 20]) should return an array.'); + testString: assert(Array.isArray(stoogeSort([25, 32, 12, 7, 20]))); - text: stoogeSort([25, 32, 12, 7, 20]) should return [7, 12, 20, 25, 32]. - testString: assert.deepEqual(stoogeSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32], 'stoogeSort([25, 32, 12, 7, 20]) should return [7, 12, 20, 25, 32].'); + testString: assert.deepEqual(stoogeSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]); - text: stoogeSort([38, 45, 35, 8, 13]) should return [8, 13, 35, 38, 45]. - testString: assert.deepEqual(stoogeSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45], 'stoogeSort([38, 45, 35, 8, 13]) should return [8, 13, 35, 38, 45].'); + testString: assert.deepEqual(stoogeSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]); - text: stoogeSort([43, 36, 20, 34, 24]) should return [20, 24, 34, 36, 43]. - testString: assert.deepEqual(stoogeSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43], 'stoogeSort([43, 36, 20, 34, 24]) should return [20, 24, 34, 36, 43].'); + testString: assert.deepEqual(stoogeSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]); - text: stoogeSort([12, 33, 26, 18, 1, 16, 38]) should return [1, 12, 16, 18, 26, 33, 38]. - testString: assert.deepEqual(stoogeSort([12, 33, 26, 18, 1, 16, 38]), [1, 12, 16, 18, 26, 33, 38], 'stoogeSort([12, 33, 26, 18, 1, 16, 38]) should return [1, 12, 16, 18, 26, 33, 38].'); + testString: assert.deepEqual(stoogeSort([12, 33, 26, 18, 1, 16, 38]), [1, 12, 16, 18, 26, 33, 38]); - text: stoogeSort([3, 39, 48, 16, 1, 4, 29]) should return [1, 3, 4, 16, 29, 39, 48]. - testString: assert.deepEqual(stoogeSort([3, 39, 48, 16, 1, 4, 29]), [1, 3, 4, 16, 29, 39, 48], 'stoogeSort([3, 39, 48, 16, 1, 4, 29]) should return [1, 3, 4, 16, 29, 39, 48].'); + testString: assert.deepEqual(stoogeSort([3, 39, 48, 16, 1, 4, 29]), [1, 3, 4, 16, 29, 39, 48]); ```
## Challenge Seed +
@@ -64,6 +68,7 @@ function stoogeSort(arr) {
## Solution +
```js diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-strand-sort.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-strand-sort.english.md index 0fa0394f20..789ad7d624 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-strand-sort.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sorting-algorithms-strand-sort.english.md @@ -6,40 +6,44 @@ forumTopicId: 302319 --- ## Description +
Write a function to sort an array using the Strand sort. The function should return the sorted array. This is a way of sorting numbers by extracting shorter sequences of already sorted numbers from an unsorted list.
## Instructions +
## Tests +
-``` yml +```yml tests: - text: strandSort should be a function. - testString: assert(typeof strandSort == 'function', 'strandSort should be a function.'); + testString: assert(typeof strandSort == 'function'); - text: strandSort([25, 32, 12, 7, 20]) should return an array. - testString: assert(Array.isArray(strandSort([25, 32, 12, 7, 20])), 'strandSort([25, 32, 12, 7, 20]) should return an array.'); + testString: assert(Array.isArray(strandSort([25, 32, 12, 7, 20]))); - text: strandSort([25, 32, 12, 7, 20]) should return [7, 12, 20, 25, 32]. - testString: assert.deepEqual(strandSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32], 'strandSort([25, 32, 12, 7, 20]) should return [7, 12, 20, 25, 32].'); + testString: assert.deepEqual(strandSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]); - text: strandSort([38, 45, 35, 8, 13]) should return [8, 13, 35, 38, 45]. - testString: assert.deepEqual(strandSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45], 'strandSort([38, 45, 35, 8, 13]) should return [8, 13, 35, 38, 45].'); + testString: assert.deepEqual(strandSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]); - text: strandSort([43, 36, 20, 34, 24]) should return [20, 24, 34, 36, 43]. - testString: assert.deepEqual(strandSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43], 'strandSort([43, 36, 20, 34, 24]) should return [20, 24, 34, 36, 43].'); + testString: assert.deepEqual(strandSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]); - text: strandSort([12, 33, 26, 18, 1, 16, 38]) should return [1, 12, 16, 18, 26, 33, 38]. - testString: assert.deepEqual(strandSort([12, 33, 26, 18, 1, 16, 38]), [1, 12, 16, 18, 26, 33, 38], 'strandSort([12, 33, 26, 18, 1, 16, 38]) should return [1, 12, 16, 18, 26, 33, 38].'); + testString: assert.deepEqual(strandSort([12, 33, 26, 18, 1, 16, 38]), [1, 12, 16, 18, 26, 33, 38]); - text: strandSort([3, 39, 48, 16, 1, 4, 29]) should return [1, 3, 4, 16, 29, 39, 48]. - testString: assert.deepEqual(strandSort([3, 39, 48, 16, 1, 4, 29]), [1, 3, 4, 16, 29, 39, 48], 'strandSort([3, 39, 48, 16, 1, 4, 29]) should return [1, 3, 4, 16, 29, 39, 48].'); + testString: assert.deepEqual(strandSort([3, 39, 48, 16, 1, 4, 29]), [1, 3, 4, 16, 29, 39, 48]); ```
## Challenge Seed +
@@ -53,18 +57,16 @@ function strandSort(list) {
## Solution +
```js function strandSort(list) { - function merge(left, right) { var result = []; while (left.length != 0 && right.length != 0) { - if (left[0] <= right[0]) - result.push(left.shift()); - else - result.push(right.shift()); + if (left[0] <= right[0]) result.push(left.shift()); + else result.push(right.shift()); } result.push.apply(result, left); result.push.apply(result, right); diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/soundex.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/soundex.english.md index d60b4e871e..82d93b64b8 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/soundex.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/soundex.english.md @@ -6,11 +6,13 @@ forumTopicId: 302320 --- ## Description +
Soundex is an algorithm for creating indices for words based on their pronunciation. The goal is for homophones to be encoded to the same representation so that they can be matched despite minor differences in spelling (from the WP article). There is a major issue in many of the implementations concerning the separation of two consonants that have the same soundex code! According to the official Rules. So check for instance if Ashcraft is coded to A-261. +
  • If a vowel (A, E, I, O, U) separates two consonants that have the same soundex code, the consonant to the right of the vowel is coded. Tymczak is coded as T-522 (T, 5 for the M, 2 for the C, Z ignored (see "Side-by-Side" rule above), 2 for the K). Since the vowel "A" separates the Z and K, the K is coded.
  • If "H" or "W" separate two consonants that have the same soundex code, the consonant to the right of the vowel is not coded. Example: Ashcraft is coded A-261 (A, 2 for the S, C ignored, 6 for the R, 1 for the F). It is not coded A-226.
    • @@ -18,44 +20,47 @@ There is a major issue in many of the implementations concerning the separation
## Instructions +
Write a function that takes a string as a parameter and returns the encoded string.
## Tests +
-``` yml +```yml tests: - text: soundex should be a function. - testString: assert(typeof soundex == 'function', 'soundex should be a function.'); + testString: assert(typeof soundex == 'function'); - text: soundex("Soundex") should return a string. - testString: assert(typeof soundex("Soundex") == 'string', 'soundex("Soundex") should return a string.'); + testString: assert(typeof soundex("Soundex") == 'string'); - text: soundex("Soundex") should return "S532". - testString: assert.equal(soundex("Soundex"), "S532", 'soundex("Soundex") should return "S532".'); + testString: assert.equal(soundex("Soundex"), "S532"); - text: soundex("Example") should return "E251". - testString: assert.equal(soundex("Example"), "E251", 'soundex("Example") should return "E251".'); + testString: assert.equal(soundex("Example"), "E251"); - text: soundex("Sownteks") should return "S532". - testString: assert.equal(soundex("Sownteks"), "S532", 'soundex("Sownteks") should return "S532".'); + testString: assert.equal(soundex("Sownteks"), "S532"); - text: soundex("Ekzampul") should return "E251". - testString: assert.equal(soundex("Ekzampul"), "E251", 'soundex("Ekzampul") should return "E251".'); + testString: assert.equal(soundex("Ekzampul"), "E251"); - text: soundex("Euler") should return "E460". - testString: assert.equal(soundex("Euler"), "E460", 'soundex("Euler") should return "E460".'); + testString: assert.equal(soundex("Euler"), "E460"); - text: soundex("Gauss") should return "G200". - testString: assert.equal(soundex("Gauss"), "G200", 'soundex("Gauss") should return "G200".'); + testString: assert.equal(soundex("Gauss"), "G200"); - text: soundex("Hilbert") should return "H416". - testString: assert.equal(soundex("Hilbert"), "H416", 'soundex("Hilbert") should return "H416".'); + testString: assert.equal(soundex("Hilbert"), "H416"); - text: soundex("Knuth") should return "K530". - testString: assert.equal(soundex("Knuth"), "K530", 'soundex("Knuth") should return "K530".'); + testString: assert.equal(soundex("Knuth"), "K530"); - text: soundex("Lloyd") should return "L300". - testString: assert.equal(soundex("Lloyd"), "L300", 'soundex("Lloyd") should return "L300".'); + testString: assert.equal(soundex("Lloyd"), "L300"); - text: soundex("Lukasiewicz") should return "L222". - testString: assert.equal(soundex("Lukasiewicz"), "L222", 'soundex("Lukasiewicz") should return "L222".'); + testString: assert.equal(soundex("Lukasiewicz"), "L222"); ```
## Challenge Seed +
@@ -70,30 +75,49 @@ function soundex(s) {
## Solution +
```js function soundex(s) { - var a = s.toLowerCase().split('') + var a = s.toLowerCase().split(''); var f = a.shift(), r = '', codes = { - a: '', e: '', i: '', o: '', u: '', - b: 1, f: 1, p: 1, v: 1, - c: 2, g: 2, j: 2, k: 2, q: 2, s: 2, x: 2, z: 2, - d: 3, t: 3, - l: 4, - m: 5, n: 5, - r: 6 + a: '', + e: '', + i: '', + o: '', + u: '', + b: 1, + f: 1, + p: 1, + v: 1, + c: 2, + g: 2, + j: 2, + k: 2, + q: 2, + s: 2, + x: 2, + z: 2, + d: 3, + t: 3, + l: 4, + m: 5, + n: 5, + r: 6 }; - r = f + a - .map(function(v, i, a) { - return codes[v] - }) - .filter(function(v, i, a) { - return ((i === 0) ? v !== codes[f] : v !== a[i - 1]); - }) - .join(''); + r = + f + + a + .map(function(v, i, a) { + return codes[v]; + }) + .filter(function(v, i, a) { + return i === 0 ? v !== codes[f] : v !== a[i - 1]; + }) + .join(''); return (r + '000').slice(0, 4).toUpperCase(); } diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/spiral-matrix.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/spiral-matrix.english.md index ed05cf2518..281a9782f9 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/spiral-matrix.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/spiral-matrix.english.md @@ -6,11 +6,13 @@ forumTopicId: 302321 --- ## Description +
Produce a spiral array. -A spiral array is a square arrangement of the first N2 natural numbers, where the numbers increase sequentially as you go around the edges of the array spiraling inwards. -For example, given 5, produce this array: +A spiral array is a square arrangement of the first N2 natural numbers, where the numbers increase sequentially as you go around the edges of the array spiraling inwards. +For example, given 5, produce this array: + 
 0  1  2  3  4
 15 16 17 18 5
@@ -21,30 +23,33 @@ For example, given 5,  produce this array:
## Instructions +
## Tests +
-``` yml +```yml tests: - text: spiralArray should be a function. - testString: assert(typeof spiralArray=='function','spiralArray should be a function.'); + testString: assert(typeof spiralArray=='function'); - text: spiralArray(3) should return an array. - testString: assert(Array.isArray(spiralArray(3)), 'spiralArray(3) should return an array.'); + testString: assert(Array.isArray(spiralArray(3))); - text: spiralArray(3) should return [[0, 1, 2],[7, 8, 3],[6, 5, 4]]. - testString: assert.deepEqual(spiralArray(3), [[0, 1, 2], [7, 8, 3], [6, 5, 4]], 'spiralArray(3) should return [[0, 1, 2],[7, 8, 3],[6, 5, 4]].'); + testString: assert.deepEqual(spiralArray(3), [[0, 1, 2], [7, 8, 3], [6, 5, 4]]); - text: spiralArray(4) should return [[0, 1, 2, 3],[11, 12, 13, 4],[10, 15, 14, 5],[9, 8, 7, 6]]. - testString: assert.deepEqual(spiralArray(4), [[0, 1, 2, 3], [11, 12, 13, 4], [10, 15, 14, 5], [9, 8, 7, 6]], 'spiralArray(4) should return [[0, 1, 2, 3],[11, 12, 13, 4],[10, 15, 14, 5],[9, 8, 7, 6]].'); + testString: assert.deepEqual(spiralArray(4), [[0, 1, 2, 3], [11, 12, 13, 4], [10, 15, 14, 5], [9, 8, 7, 6]]); - text: spiralArray(5) should return [[0, 1, 2, 3, 4],[15, 16, 17, 18, 5],[14, 23, 24, 19, 6],[13, 22, 21, 20, 7],[12, 11, 10, 9, 8]]. - testString: assert.deepEqual(spiralArray(5), [[0, 1, 2, 3, 4], [15, 16, 17, 18, 5], [14, 23, 24, 19, 6], [13, 22, 21, 20, 7], [12, 11, 10, 9, 8]], 'spiralArray(5) should return [[0, 1, 2, 3, 4],[15, 16, 17, 18, 5],[14, 23, 24, 19, 6],[13, 22, 21, 20, 7],[12, 11, 10, 9, 8]].'); + testString: assert.deepEqual(spiralArray(5), [[0, 1, 2, 3, 4], [15, 16, 17, 18, 5], [14, 23, 24, 19, 6], [13, 22, 21, 20, 7], [12, 11, 10, 9, 8]]); ```
## Challenge Seed +
@@ -59,25 +64,37 @@ function spiralArray(n) {
## Solution +
```js function spiralArray(n) { - var arr = Array(n), - x = 0, y = n, - total = n * n--, - dx = 1, dy = 0, - i = 0, j = 0; - while (y) arr[--y] = []; - while (i < total) { - arr[y][x] = i++; - x += dx; y += dy; - if (++j == n) { - if (dy < 0) {x++; y++; n -= 2} - j = dx; dx = -dy; dy = j; j = 0; - } + var arr = Array(n), + x = 0, + y = n, + total = n * n--, + dx = 1, + dy = 0, + i = 0, + j = 0; + while (y) arr[--y] = []; + while (i < total) { + arr[y][x] = i++; + x += dx; + y += dy; + if (++j == n) { + if (dy < 0) { + x++; + y++; + n -= 2; + } + j = dx; + dx = -dy; + dy = j; + j = 0; } - return arr; + } + return arr; } ``` diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/split-a-character-string-based-on-change-of-character.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/split-a-character-string-based-on-change-of-character.english.md index 6d03ddde2f..6bf952fccc 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/split-a-character-string-based-on-change-of-character.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/split-a-character-string-based-on-change-of-character.english.md @@ -6,49 +6,56 @@ forumTopicId: 302322 --- ## Description +
-Split a (character) string into comma (plus a blank) delimited strings based on a change of character (left to right). -Blanks should be treated as any other character (except they are problematic to display clearly). The same applies to commas. +Split a (character) string into comma (plus a blank) delimited strings based on a change of character (left to right). +Blanks should be treated as any other character (except they are problematic to display clearly). The same applies to commas. For instance, the string: + 
 "gHHH5YY++///\"
+ should be split as: + 
 ["g", "HHH", "5", "YY", "++", "///", "\" ];
## Instructions +
## Tests +
-``` yml +```yml tests: - text: split should be a function. - testString: assert(typeof split == 'function', 'split should be a function.'); + testString: assert(typeof split == 'function'); - text: split("hello") should return an array. - testString: assert(Array.isArray(split("hello")), 'split("hello") should return an array.'); + testString: assert(Array.isArray(split("hello"))); - text: split("hello") should return ["h", "e", "ll", "o"]. - testString: assert.deepEqual(split("hello"), ["h", "e", "ll", "o"], 'split("hello") should return ["h", "e", "ll", "o"].'); + testString: assert.deepEqual(split("hello"), ["h", "e", "ll", "o"]); - text: split("commission") should return ["c", "o", "mm", "i", "ss", "i", "o", "n"]. - testString: assert.deepEqual(split("commission"), ["c", "o", "mm", "i", "ss", "i", "o", "n"], 'split("commission") should return ["c", "o", "mm", "i", "ss", "i", "o", "n"].'); + testString: assert.deepEqual(split("commission"), ["c", "o", "mm", "i", "ss", "i", "o", "n"]); - text: split("ssss----====llloooo") should return ["ssss", "----", "====", "lll", "oooo"]. - testString: assert.deepEqual(split("ssss----====llloooo"), ["ssss", "----", "====", "lll", "oooo"], 'split("ssss----====llloooo") should return ["ssss", "----", "====", "lll", "oooo"].'); + testString: assert.deepEqual(split("ssss----====llloooo"), ["ssss", "----", "====", "lll", "oooo"]); - text: split("sssmmmaaammmaaat") should return ["sss", "mmm", "aaa", "mmm", "aaa", "t"]. - testString: assert.deepEqual(split("sssmmmaaammmaaat"), ["sss", "mmm", "aaa", "mmm", "aaa", "t"], 'split("sssmmmaaammmaaat") should return ["sss", "mmm", "aaa", "mmm", "aaa", "t"].'); + testString: assert.deepEqual(split("sssmmmaaammmaaat"), ["sss", "mmm", "aaa", "mmm", "aaa", "t"]); - text: split("gHHH5YY++///\") should return ["g", "HHH", "5", "YY", "++", "///", "\\"]. - testString: assert.deepEqual(split("gHHH5YY++///\\"), ["g", "HHH", "5", "YY", "++", "///", "\\"], 'split("gHHH5YY++///\") should return ["g", "HHH", "5", "YY", "++", "///", "\\"].'); + testString: assert.deepEqual(split("gHHH5YY++///\\"), ["g", "HHH", "5", "YY", "++", "///", "\\"]); ```
## Challenge Seed +
@@ -63,32 +70,36 @@ function split(str) {
## Solution +
```js function split(str) { const concat = xs => - xs.length > 0 ? (() => { - const unit = typeof xs[0] === 'string' ? '' : []; - return unit.concat.apply(unit, xs); - })() : []; + xs.length > 0 + ? (() => { + const unit = typeof xs[0] === 'string' ? '' : []; + return unit.concat.apply(unit, xs); + })() + : []; const group = xs => groupBy((a, b) => a === b, xs); const groupBy = (f, xs) => { - const dct = xs.slice(1) - .reduce((a, x) => { - const - h = a.active.length > 0 ? a.active[0] : undefined, + const dct = xs.slice(1).reduce( + (a, x) => { + const h = a.active.length > 0 ? a.active[0] : undefined, blnGroup = h !== undefined && f(h, x); return { active: blnGroup ? a.active.concat([x]) : [x], sofar: blnGroup ? a.sofar : a.sofar.concat([a.active]) }; - }, { + }, + { active: xs.length > 0 ? [xs[0]] : [], sofar: [] - }); + } + ); return dct.sofar.concat(dct.active.length > 0 ? [dct.active] : []); }; @@ -96,7 +107,7 @@ function split(str) { const stringChars = s => s.split(''); - return map(concat, group(stringChars(str))) + return map(concat, group(stringChars(str))); } ``` diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/state-name-puzzle.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/state-name-puzzle.english.md index c29b785f88..8bf4e9b67a 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/state-name-puzzle.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/state-name-puzzle.english.md @@ -6,39 +6,45 @@ forumTopicId: 302323 --- ## Description +
This task is inspired by Mark Nelson's DDJ Column "Wordplay" and one of the weekly puzzle challenges from Will Shortz on NPR Weekend Edition [1] and originally attributed to David Edelheit. The challenge was to take the names of two U.S. States, mix them all together, then rearrange the letters to form the names of two different U.S. States (so that all four state names differ from one another). What states are these? -The problem was reissued on the Unicon Discussion Web which includes several solutions with analysis. Several techniques may be helpful and you may wish to refer to Gödel numbering, equivalence relations, and equivalence classes. The basic merits of these were discussed in the Unicon Discussion Web. +The problem was reissued on the Unicon Discussion Web which includes several solutions with analysis. Several techniques may be helpful and you may wish to refer to Gödel numbering, equivalence relations, and equivalence classes. The basic merits of these were discussed in the Unicon Discussion Web. A second challenge in the form of a set of fictitious new states was also presented. +
## Instructions +
Write a function to solve the challenge for the given array of names of states. The function should return an array. Each element should be an object in this form: {"from":[],"to":[]}. The "from" array should contain the original names and the "to" array should contain the resultant names. +
## Tests +
-``` yml +```yml tests: - text: solve should be a function. - testString: assert(typeof solve == 'function', 'solve should be a function.'); + testString: assert(typeof solve == 'function'); - text: solve(["New Mexico", "New York", "North Carolina ", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota"]) should return an array. - testString: assert(Array.isArray(solve(["New Mexico", "New York", "North Carolina ", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota"])), 'solve(["New Mexico", "New York", "North Carolina ", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota"]) should return an array.'); + testString: assert(Array.isArray(solve(["New Mexico", "New York", "North Carolina ", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota"]))); - text: 'solve(["New Mexico", "New York", "North Carolina ", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota"]) should return [{ from: ["North Carolina ", "South Dakota"], to: ["North Dakota", "South Carolina"] }].' - testString: assert.deepEqual(solve(["New Mexico", "New York", "North Carolina ", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota"]), [{ from:["North Carolina ", "South Dakota"], to:["North Dakota", "South Carolina"] }], 'solve(["New Mexico", "New York", "North Carolina ", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota"]) should return [{ from:["North Carolina ", "South Dakota"], to:["North Dakota", "South Carolina"] }].'); + testString: assert.deepEqual(solve(["New Mexico", "New York", "North Carolina ", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota"]), [{ from:["North Carolina ", "South Dakota"], to:["North Dakota", "South Carolina"] }]); - text: 'solve(["New York", "New Kory", "Wen Kory", "York New", "Kory New", "New Kory"]) should return [{ from: ["New Kory", "New York"], to: ["Wen Kory", "York New"] }, { from: ["New Kory", "New York"], to: ["Kory New", "Wen Kory"] }, { from: ["New Kory", "New York"], to: ["Kory New", "York New"] }, { from: ["New York", "Wen Kory"], to: ["New Kory", "York New"] }, { from: ["New York", "Wen Kory"], to: ["Kory New", "New Kory"] }, { from: ["New York", "Wen Kory"], to: ["Kory New", "York New"] }, { from: ["New York", "York New"], to: ["New Kory", "Wen Kory"] }, { from: ["New York", "York New"], to: ["Kory New", "New Kory"] }, { from: ["New York", "York New"], to: ["Kory New", "Wen Kory"] }, { from: ["Kory New", "New York"], to: ["New Kory", "Wen Kory"] }, { from: ["Kory New", "New York"], to: ["New Kory", "York New"] }, { from: ["Kory New", "New York"], to: ["Wen Kory", "York New"] }, { from: ["New Kory", "Wen Kory"], to: ["Kory New", "York New"] }, { from: ["New Kory", "York New"], to: ["Kory New", "Wen Kory"] }, { from: ["Kory New", "New Kory"], to: ["Wen Kory", "York New"] }].' - testString: assert.deepEqual(solve(["New York", "New Kory", "Wen Kory", "York New", "Kory New", "New Kory"]), [{ from:["New Kory", "New York"], to:["Wen Kory", "York New"] }, { from:["New Kory", "New York"], to:["Kory New", "Wen Kory"] }, { from:["New Kory", "New York"], to:["Kory New", "York New"] }, { from:["New York", "Wen Kory"], to:["New Kory", "York New"] }, { from:["New York", "Wen Kory"], to:["Kory New", "New Kory"] }, { from:["New York", "Wen Kory"], to:["Kory New", "York New"] }, { from:["New York", "York New"], to:["New Kory", "Wen Kory"] }, { from:["New York", "York New"], to:["Kory New", "New Kory"] }, { from:["New York", "York New"], to:["Kory New", "Wen Kory"] }, { from:["Kory New", "New York"], to:["New Kory", "Wen Kory"] }, { from:["Kory New", "New York"], to:["New Kory", "York New"] }, { from:["Kory New", "New York"], to:["Wen Kory", "York New"] }, { from:["New Kory", "Wen Kory"], to:["Kory New", "York New"] }, { from:["New Kory", "York New"], to:["Kory New", "Wen Kory"] }, { from:["Kory New", "New Kory"], to:["Wen Kory", "York New"] }], 'solve(["New York", "New Kory", "Wen Kory", "York New", "Kory New", "New Kory"]) should return [{ from:["New Kory", "New York"], to:["Wen Kory", "York New"] }, { from:["New Kory", "New York"], to:["Kory New", "Wen Kory"] }, { from:["New Kory", "New York"], to:["Kory New", "York New"] }, { from:["New York", "Wen Kory"], to:["New Kory", "York New"] }, { from:["New York", "Wen Kory"], to:["Kory New", "New Kory"] }, { from:["New York", "Wen Kory"], to:["Kory New", "York New"] }, { from:["New York", "York New"], to:["New Kory", "Wen Kory"] }, { from:["New York", "York New"], to:["Kory New", "New Kory"] }, { from:["New York", "York New"], to:["Kory New", "Wen Kory"] }, { from:["Kory New", "New York"], to:["New Kory", "Wen Kory"] }, { from:["Kory New", "New York"], to:["New Kory", "York New"] }, { from:["Kory New", "New York"], to:["Wen Kory", "York New"] }, { from:["New Kory", "Wen Kory"], to:["Kory New", "York New"] }, { from:["New Kory", "York New"], to:["Kory New", "Wen Kory"] }, { from:["Kory New", "New Kory"], to:["Wen Kory", "York New"] }].'); + testString: assert.deepEqual(solve(["New York", "New Kory", "Wen Kory", "York New", "Kory New", "New Kory"]), [{ from:["New Kory", "New York"], to:["Wen Kory", "York New"] }, { from:["New Kory", "New York"], to:["Kory New", "Wen Kory"] }, { from:["New Kory", "New York"], to:["Kory New", "York New"] }, { from:["New York", "Wen Kory"], to:["New Kory", "York New"] }, { from:["New York", "Wen Kory"], to:["Kory New", "New Kory"] }, { from:["New York", "Wen Kory"], to:["Kory New", "York New"] }, { from:["New York", "York New"], to:["New Kory", "Wen Kory"] }, { from:["New York", "York New"], to:["Kory New", "New Kory"] }, { from:["New York", "York New"], to:["Kory New", "Wen Kory"] }, { from:["Kory New", "New York"], to:["New Kory", "Wen Kory"] }, { from:["Kory New", "New York"], to:["New Kory", "York New"] }, { from:["Kory New", "New York"], to:["Wen Kory", "York New"] }, { from:["New Kory", "Wen Kory"], to:["Kory New", "York New"] }, { from:["New Kory", "York New"], to:["Kory New", "Wen Kory"] }, { from:["Kory New", "New Kory"], to:["Wen Kory", "York New"] }]); ```
## Challenge Seed +
@@ -53,24 +59,24 @@ function solve(input) {
## Solution +
```js function solve(input) { var orig = {}; input.forEach(function(e) { - orig[e.replace(/\s/g, "").toLowerCase()] = e; - }) + orig[e.replace(/\s/g, '').toLowerCase()] = e; + }); - input = Object.keys(orig) + input = Object.keys(orig); var map = {}; for (var i = 0; i < input.length - 1; i++) { var pair0 = input[i]; for (var j = i + 1; j < input.length; j++) { - var pair = [pair0, input[j]]; var s = pair0 + pair[1]; - var key = s.split("").sort(); + var key = s.split('').sort(); var val = map[key] ? map[key] : []; val.push(pair); @@ -79,21 +85,19 @@ function solve(input) { } var result = []; - Object.keys(map).forEach((key) => { - + Object.keys(map).forEach(key => { for (var i = 0; i < map[key].length - 1; i++) { var a = map[key][i]; for (var j = i + 1; j < map[key].length; j++) { var b = map[key][j]; - if ((new Set([a[0], b[0], a[1], b[1]])).size < 4) - continue; - var from = [orig[a[0]], orig[a[1]]].sort() - var to = [orig[b[0]], orig[b[1]]].sort() + if (new Set([a[0], b[0], a[1], b[1]]).size < 4) continue; + var from = [orig[a[0]], orig[a[1]]].sort(); + var to = [orig[b[0]], orig[b[1]]].sort(); result.push({ from, to - }) + }); } } }); diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/stern-brocot-sequence.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/stern-brocot-sequence.english.md index d837c94a66..a55ec34158 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/stern-brocot-sequence.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/stern-brocot-sequence.english.md @@ -6,6 +6,7 @@ forumTopicId: 302324 --- ## Description +
For this task, the Stern-Brocot sequence is to be generated by an algorithm similar to that employed in generating the Fibonacci sequence.
    @@ -34,34 +35,37 @@ For this task, the Stern-Brocot sequence is to be generated by an algorithm simi
## Instructions +
Create a function that returns the $ n^{th} $ member of the sequence using the method outlined above.
## Tests +
-``` yml +```yml tests: - text: sternBrocot should be a function. - testString: assert(typeof sternBrocot == 'function', 'sternBrocot should be a function.'); + testString: assert(typeof sternBrocot == 'function'); - text: sternBrocot(2) should return a number. - testString: assert(typeof sternBrocot(2) == 'number', 'sternBrocot(2) should return a number.'); + testString: assert(typeof sternBrocot(2) == 'number'); - text: sternBrocot(2) should return 3. - testString: assert.equal(sternBrocot(2), 3, 'sternBrocot(2) should return 3.'); + testString: assert.equal(sternBrocot(2), 3); - text: sternBrocot(3) should return 5. - testString: assert.equal(sternBrocot(3), 5, 'sternBrocot(3) should return 5.'); + testString: assert.equal(sternBrocot(3), 5); - text: sternBrocot(5) should return 11. - testString: assert.equal(sternBrocot(5), 11, 'sternBrocot(5) should return 11.'); + testString: assert.equal(sternBrocot(5), 11); - text: sternBrocot(7) should return 19. - testString: assert.equal(sternBrocot(7), 19, 'sternBrocot(7) should return 19.'); + testString: assert.equal(sternBrocot(7), 19); - text: sternBrocot(10) should return 39. - testString: assert.equal(sternBrocot(10), 39, 'sternBrocot(10) should return 39.'); + testString: assert.equal(sternBrocot(10), 39); ```
## Challenge Seed +
@@ -75,16 +79,21 @@ function sternBrocot(num) {
## Solution +
```js function sternBrocot(num) { function f(n) { - return n < 2 ? n : (n & 1) ? f(Math.floor(n / 2)) + f(Math.floor(n / 2 + 1)) : f(Math.floor(n / 2)); + return n < 2 + ? n + : n & 1 + ? f(Math.floor(n / 2)) + f(Math.floor(n / 2 + 1)) + : f(Math.floor(n / 2)); } function gcd(a, b) { - return a ? a < b ? gcd(b % a, a) : gcd(a % b, b) : b; + return a ? (a < b ? gcd(b % a, a) : gcd(a % b, b)) : b; } var n; for (n = 1; f(n) != num; n++); diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/straddling-checkerboard.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/straddling-checkerboard.english.md index 0ea5110789..bbe007c833 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/straddling-checkerboard.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/straddling-checkerboard.english.md @@ -6,47 +6,52 @@ forumTopicId: 302325 --- ## Description +
Implement functions to encrypt and decrypt a message using the straddling checkerboard method. The functions will take a string and an array as parameters. The array has 3 strings representing the 3 rows of the checkerboard. The output will be a series of decimal digits. Numbers should be encrypted by inserting the escape character before each digit, then including the digit unencrypted. This should be reversed for decryption. +
## Instructions +
## Tests +
-``` yml +```yml tests: - text: straddle should be a function. - testString: assert(typeof straddle == 'function', 'straddle should be a function.'); + testString: assert(typeof straddle == 'function'); - text: straddle("One night-it was on the twentieth of March, 1888-I was returning.",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"]) should return a string. - testString: assert(typeof straddle("One night-it was on the twentieth of March, 1888-I was returning.", ["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"]) == 'string', 'straddle("One night-it was on the twentieth of March, 1888-I was returning.",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"]) should return a string.'); + testString: assert(typeof straddle("One night-it was on the twentieth of March, 1888-I was returning.", ["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"]) == 'string'); - text: straddle("One night-it was on the twentieth of March, 1888-I was returning.",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"]) should return "34045747525284613427502840425027537379697175891898898898584619028294547488". - testString: assert.equal(straddle("One night-it was on the twentieth of March, 1888-I was returning.", ["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"]), "34045747525284613427502840425027537379697175891898898898584619028294547488", 'straddle("One night-it was on the twentieth of March, 1888-I was returning.",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"]) should return "34045747525284613427502840425027537379697175891898898898584619028294547488".'); + testString: assert.equal(straddle("One night-it was on the twentieth of March, 1888-I was returning.", ["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"]), "34045747525284613427502840425027537379697175891898898898584619028294547488"); - text: straddle("One night-it was on the twentieth of March, 1888-I was returning",["HOL MES RT", "ABCDFGIJKN", "PQUVWXYZ./"]) should return "139539363509369743061399059745399365901344308320791798798798367430685972839363935". - testString: assert.equal(straddle("One night-it was on the twentieth of March, 1888-I was returning", ["HOL MES RT", "ABCDFGIJKN", "PQUVWXYZ./"]), "139539363509369743061399059745399365901344308320791798798798367430685972839363935", 'straddle("One night-it was on the twentieth of March, 1888-I was returning",["HOL MES RT", "ABCDFGIJKN", "PQUVWXYZ./"]) should return "139539363509369743061399059745399365901344308320791798798798367430685972839363935".'); + testString: assert.equal(straddle("One night-it was on the twentieth of March, 1888-I was returning", ["HOL MES RT", "ABCDFGIJKN", "PQUVWXYZ./"]), "139539363509369743061399059745399365901344308320791798798798367430685972839363935"); - text: straddle("Thecheckerboardcakerecipespecifies3largeeggsand2.25cupsofflour.",["ET AON RIS", "BCDFGHJKLM", "PQ/UVWXYZ."]) should return "125021250212707204372221327070218600960021823809623283724002424935226226962262521636094232328463769". - testString: assert.equal(straddle("Thecheckerboardcakerecipespecifies3largeeggsand2.25cupsofflour.", ["ET AON RIS", "BCDFGHJKLM", "PQ/UVWXYZ."]), "125021250212707204372221327070218600960021823809623283724002424935226226962262521636094232328463769", 'straddle("Thecheckerboardcakerecipespecifies3largeeggsand2.25cupsofflour.",["ET AON RIS", "BCDFGHJKLM", "PQ/UVWXYZ."]) should return "125021250212707204372221327070218600960021823809623283724002424935226226962262521636094232328463769".'); + testString: assert.equal(straddle("Thecheckerboardcakerecipespecifies3largeeggsand2.25cupsofflour.", ["ET AON RIS", "BCDFGHJKLM", "PQ/UVWXYZ."]), "125021250212707204372221327070218600960021823809623283724002424935226226962262521636094232328463769"); - text: unstraddle should be a function. - testString: assert(typeof unstraddle == 'function', 'unstraddle should be a function.'); + testString: assert(typeof unstraddle == 'function'); - text: unstraddle("34045747525284613427502840425027537379697175891898898898584619028294547488",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"]) should return a string. - testString: assert(typeof unstraddle("34045747525284613427502840425027537379697175891898898898584619028294547488", ["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"]) == 'string', 'unstraddle("34045747525284613427502840425027537379697175891898898898584619028294547488",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"]) should return a string.'); + testString: assert(typeof unstraddle("34045747525284613427502840425027537379697175891898898898584619028294547488", ["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"]) == 'string'); - text: unstraddle("34045747525284613427502840425027537379697175891898898898584619028294547488",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"]) should return "ONENIGHTITWASONTHETWENTIETHOFMARCH1888IWASRETURNING.". - testString: assert.equal(unstraddle("34045747525284613427502840425027537379697175891898898898584619028294547488", ["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"]), "ONENIGHTITWASONTHETWENTIETHOFMARCH1888IWASRETURNING.", 'unstraddle("34045747525284613427502840425027537379697175891898898898584619028294547488",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"]) should return "ONENIGHTITWASONTHETWENTIETHOFMARCH1888IWASRETURNING.".'); + testString: assert.equal(unstraddle("34045747525284613427502840425027537379697175891898898898584619028294547488", ["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"]), "ONENIGHTITWASONTHETWENTIETHOFMARCH1888IWASRETURNING."); - text: unstraddle("139539363509369743061399059745399365901344308320791798798798367430685972839363935",["HOL MES RT", "ABCDFGIJKN", "PQUVWXYZ./"]) should return "ONENIGHTITWASONTHETWENTIETHOFMARCH1888IWASRETURNING". - testString: assert.equal(unstraddle("139539363509369743061399059745399365901344308320791798798798367430685972839363935", ["HOL MES RT", "ABCDFGIJKN", "PQUVWXYZ./"]), "ONENIGHTITWASONTHETWENTIETHOFMARCH1888IWASRETURNING", 'unstraddle("139539363509369743061399059745399365901344308320791798798798367430685972839363935",["HOL MES RT", "ABCDFGIJKN", "PQUVWXYZ./"]) should return "ONENIGHTITWASONTHETWENTIETHOFMARCH1888IWASRETURNING".'); + testString: assert.equal(unstraddle("139539363509369743061399059745399365901344308320791798798798367430685972839363935", ["HOL MES RT", "ABCDFGIJKN", "PQUVWXYZ./"]), "ONENIGHTITWASONTHETWENTIETHOFMARCH1888IWASRETURNING"); - text: unstraddle("125021250212707204372221327070218600960021823809623283724002424935226226962262521636094232328463769",["ET AON RIS", "BCDFGHJKLM", "PQ/UVWXYZ."]) should return "THECHECKERBOARDCAKERECIPESPECIFIES3LARGEEGGSAND2.25CUPSOFFLOUR.". - testString: assert.equal(unstraddle("125021250212707204372221327070218600960021823809623283724002424935226226962262521636094232328463769", ["ET AON RIS", "BCDFGHJKLM", "PQ/UVWXYZ."]), "THECHECKERBOARDCAKERECIPESPECIFIES3LARGEEGGSAND2.25CUPSOFFLOUR.", 'unstraddle("125021250212707204372221327070218600960021823809623283724002424935226226962262521636094232328463769",["ET AON RIS", "BCDFGHJKLM", "PQ/UVWXYZ."]) should return "THECHECKERBOARDCAKERECIPESPECIFIES3LARGEEGGSAND2.25CUPSOFFLOUR.".'); + testString: assert.equal(unstraddle("125021250212707204372221327070218600960021823809623283724002424935226226962262521636094232328463769", ["ET AON RIS", "BCDFGHJKLM", "PQ/UVWXYZ."]), "THECHECKERBOARDCAKERECIPESPECIFIES3LARGEEGGSAND2.25CUPSOFFLOUR."); ```
## Challenge Seed +
@@ -65,46 +70,55 @@ function unstraddle(message, alphabet) {
## Solution +
```js function straddle(message, alphabet) { - var prefixes = new Array("", alphabet[0].indexOf(" "), alphabet[0].lastIndexOf(" ")) + var prefixes = new Array( + '', + alphabet[0].indexOf(' '), + alphabet[0].lastIndexOf(' ') + ); - var out = "" - message = message.toUpperCase() - message = message.replace(/([0-9])/g, "/$1") // dumb way to escape numbers + var out = ''; + message = message.toUpperCase(); + message = message.replace(/([0-9])/g, '/$1'); // dumb way to escape numbers for (var i = 0; i < message.length; i++) { - var chr = message[i] - if (chr == " ") continue + var chr = message[i]; + if (chr == ' ') continue; for (var j = 0; j < 3; j++) { - var k = alphabet[j].indexOf(chr) - if (k < 0) continue - out += prefixes[j].toString() + k + var k = alphabet[j].indexOf(chr); + if (k < 0) continue; + out += prefixes[j].toString() + k; } - if (chr == "/") out += message[++i] + if (chr == '/') out += message[++i]; } - return out + return out; } function unstraddle(message, alphabet) { - var prefixes = new Array("", alphabet[0].indexOf(" "), alphabet[0].lastIndexOf(" ")) - var out = "" - var n, o + var prefixes = new Array( + '', + alphabet[0].indexOf(' '), + alphabet[0].lastIndexOf(' ') + ); + var out = ''; + var n, o; for (var i = 0; i < message.length; i++) { - n = message[i] * 1 + n = message[i] * 1; switch (n) { case prefixes[1]: o = alphabet[1][message[++i]]; - break + break; case prefixes[2]: o = alphabet[2][message[++i]]; - break + break; default: - o = alphabet[0][n] + o = alphabet[0][n]; } - o == "/" ? out += message[++i] : out += o + o == '/' ? (out += message[++i]) : (out += o); } - return out + return out; } ``` diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/stream-merge.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/stream-merge.english.md index 9be9776e1d..6299dc10c9 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/stream-merge.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/stream-merge.english.md @@ -6,40 +6,45 @@ forumTopicId: 302326 --- ## Description +
Write a function that takes multiple sorted arrays of items, and returns one array of sorted items. +
## Instructions +
## Tests +
-``` yml +```yml tests: - text: mergeLists should be a function. - testString: assert(typeof mergeLists == 'function', 'mergeLists should be a function.'); + testString: assert(typeof mergeLists == 'function'); - text: mergeLists([[1, 3, 5, 9, 10], [2, 4, 6, 7, 8]]) should return an array. - testString: assert(Array.isArray(mergeLists([[1, 3, 5, 9, 10], [2, 4, 6, 7, 8]])), 'mergeLists([[1, 3, 5, 9, 10], [2, 4, 6, 7, 8]]) should return an array.'); + testString: assert(Array.isArray(mergeLists([[1, 3, 5, 9, 10], [2, 4, 6, 7, 8]]))); - text: mergeLists([[1, 3, 5, 9, 10], [2, 4, 6, 7, 8]]) should return [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]. - testString: assert.deepEqual(mergeLists([[1, 3, 5, 9, 10], [2, 4, 6, 7, 8]]), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'mergeLists([[1, 3, 5, 9, 10], [2, 4, 6, 7, 8]]) should return [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].'); + testString: assert.deepEqual(mergeLists([[1, 3, 5, 9, 10], [2, 4, 6, 7, 8]]), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); - text: mergeLists([[1, 4, 7, 10], [2, 5, 8, 11], [3, 6, 9, 12]]) should return [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]. - testString: assert.deepEqual(mergeLists([[1, 4, 7, 10], [2, 5, 8, 11], [3, 6, 9, 12]]), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], 'mergeLists([[1, 4, 7, 10], [2, 5, 8, 11], [3, 6, 9, 12]]) should return [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12].'); + testString: assert.deepEqual(mergeLists([[1, 4, 7, 10], [2, 5, 8, 11], [3, 6, 9, 12]]), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]); - text: mergeLists([[1, 3, 9, 14, 15, 17, 28], [7, 8, 14, 14, 23, 26, 28, 29, 30], [9, 23, 25, 29]]) should return [1, 3, 7, 8, 9, 9, 14, 14, 14, 15, 17, 23, 23, 25, 26, 28, 28, 29, 29, 30]. - testString: assert.deepEqual(mergeLists([[1, 3, 9, 14, 15, 17, 28], [7, 8, 14, 14, 23, 26, 28, 29, 30], [9, 23, 25, 29]]), [1, 3, 7, 8, 9, 9, 14, 14, 14, 15, 17, 23, 23, 25, 26, 28, 28, 29, 29, 30], 'mergeLists([[1, 3, 9, 14, 15, 17, 28], [7, 8, 14, 14, 23, 26, 28, 29, 30], [9, 23, 25, 29]]) should return [1, 3, 7, 8, 9, 9, 14, 14, 14, 15, 17, 23, 23, 25, 26, 28, 28, 29, 29, 30].'); + testString: assert.deepEqual(mergeLists([[1, 3, 9, 14, 15, 17, 28], [7, 8, 14, 14, 23, 26, 28, 29, 30], [9, 23, 25, 29]]), [1, 3, 7, 8, 9, 9, 14, 14, 14, 15, 17, 23, 23, 25, 26, 28, 28, 29, 29, 30]); - text: mergeLists([[3, 14, 15], [2, 17, 18], [], [2, 3, 5, 7]]) should return [2, 2, 3, 3, 5, 7, 14, 15, 17, 18]. - testString: assert.deepEqual(mergeLists([[3, 14, 15], [2, 17, 18], [], [2, 3, 5, 7]]), [2, 2, 3, 3, 5, 7, 14, 15, 17, 18], 'mergeLists([[3, 14, 15], [2, 17, 18], [], [2, 3, 5, 7]]) should return [2, 2, 3, 3, 5, 7, 14, 15, 17, 18].'); + testString: assert.deepEqual(mergeLists([[3, 14, 15], [2, 17, 18], [], [2, 3, 5, 7]]), [2, 2, 3, 3, 5, 7, 14, 15, 17, 18]); - text: mergeLists([[1, 19, 1999], [17, 33, 2999, 3000], [8, 500, 3999]]) should return [1, 8, 17, 19, 33, 500, 1999, 2999, 3000, 3999]. - testString: assert.deepEqual(mergeLists([[1, 19, 1999], [17, 33, 2999, 3000], [8, 500, 3999]]), [1, 8, 17, 19, 33, 500, 1999, 2999, 3000, 3999], 'mergeLists([[1, 19, 1999], [17, 33, 2999, 3000], [8, 500, 3999]]) should return [1, 8, 17, 19, 33, 500, 1999, 2999, 3000, 3999].'); + testString: assert.deepEqual(mergeLists([[1, 19, 1999], [17, 33, 2999, 3000], [8, 500, 3999]]), [1, 8, 17, 19, 33, 500, 1999, 2999, 3000, 3999]); ```
## Challenge Seed +
@@ -54,16 +59,19 @@ function mergeLists(lists) {
## Solution +
```js function mergeLists(lists) { - function merge (l1, l2) { - var result = [], i=0, j=0; + function merge(l1, l2) { + var result = [], + i = 0, + j = 0; while (l1.length && l2.length) { - if(l1[i]<=l2[j]){ + if (l1[i] <= l2[j]) { result.push(l1.shift()); - }else{ + } else { result.push(l2.shift()); } } @@ -73,9 +81,9 @@ function mergeLists(lists) { return result; } - var result=lists[0]; + var result = lists[0]; for (var i = 1; i < lists.length; i++) { - result=merge(result, lists[i]); + result = merge(result, lists[i]); } return result; diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/strip-control-codes-and-extended-characters-from-a-string.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/strip-control-codes-and-extended-characters-from-a-string.english.md index 1a5db5ae34..2e6bd1874c 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/strip-control-codes-and-extended-characters-from-a-string.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/strip-control-codes-and-extended-characters-from-a-string.english.md @@ -6,23 +6,27 @@ forumTopicId: 302327 --- ## Description +
The task is to strip control codes and extended characters from a string. The solution should demonstrate how to achieve each of the following results: A string with control codes and extended characters stripped. In ASCII, the control codes have decimal codes 0 through to 31 and 127. On an ASCII based system, if the control codes are stripped, the resultant string would have all of its characters within the range of 32 to 126 decimal on the ASCII table. On a non-ASCII based system, we consider characters that do not have a corresponding glyph on the ASCII table (within the ASCII range of 32 to 126 decimal) to be an extended character for the purpose of this task. +
## Instructions +
## Tests +
-``` yml +```yml tests: - text: strip should be a function. testString: assert(typeof strip == 'function'); @@ -43,6 +47,7 @@ tests:
## Challenge Seed +
@@ -57,15 +62,19 @@ function strip(s) {
## Solution +
```js function strip(s) { - return s.split('').filter(function(x) { - var n = x.charCodeAt(0); + return s + .split('') + .filter(function(x) { + var n = x.charCodeAt(0); - return 31 < n && 127 > n; - }).join(''); + return 31 < n && 127 > n; + }) + .join(''); } ``` diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/subleq.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/subleq.english.md index a46e4c9009..8d33bb167c 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/subleq.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/subleq.english.md @@ -6,6 +6,7 @@ forumTopicId: 302328 --- ## Description +
Subleq is an example of a One-Instruction Set Computer (OISC). It is named after its only instruction, which is SUbtract and Branch if Less than or EQual @@ -49,27 +50,30 @@ message: "Hello, world!\n\0"
## Instructions +
Write a function that takes an array of integers as a parameter. This represents the memory elements. The function should interpret the sequence and return the output string. For this task, assume that there is no standard input.
## Tests +
-``` yml +```yml tests: - text: Subleq should be a function. - testString: assert(typeof Subleq == 'function', 'Subleq should be a function.'); + testString: assert(typeof Subleq == 'function'); - text: Subleq([15, 17, -1, 17, -1, -1, 16, 1, -1, 16, 3, -1, 15, 15, 0, 0, -1, 72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 0]) should return a string. - testString: assert(typeof Subleq([15, 17, -1, 17, -1, -1, 16, 1, -1, 16, 3, -1, 15, 15, 0, 0, -1, 72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 0]) == 'string', 'Subleq([15, 17, -1, 17, -1, -1, 16, 1, -1, 16, 3, -1, 15, 15, 0, 0, -1, 72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 0]) should return a string.'); + testString: assert(typeof Subleq([15, 17, -1, 17, -1, -1, 16, 1, -1, 16, 3, -1, 15, 15, 0, 0, -1, 72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 0]) == 'string'); - text: Subleq([15, 17, -1, 17, -1, -1, 16, 1, -1, 16, 3, -1, 15, 15, 0, 0, -1, 72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 0]) should return "Hello, world!". - testString: assert.equal(Subleq([15, 17, -1, 17, -1, -1, 16, 1, -1, 16, 3, -1, 15, 15, 0, 0, -1, 72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 0]), "Hello, world!", 'Subleq([15, 17, -1, 17, -1, -1, 16, 1, -1, 16, 3, -1, 15, 15, 0, 0, -1, 72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 0]) should return "Hello, world!".'); + testString: assert.equal(Subleq([15, 17, -1, 17, -1, -1, 16, 1, -1, 16, 3, -1, 15, 15, 0, 0, -1, 72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 0]), "Hello, world!"); ```
## Challenge Seed +
@@ -83,16 +87,18 @@ function Subleq(mem) {
## Solution +
```js function Subleq(mem) { - var out = ""; + var out = ''; var instructionPointer = 0; do { var a = mem[instructionPointer]; var b = mem[instructionPointer + 1]; - if (a === -1) {} else if (b === -1) { + if (a === -1) { + } else if (b === -1) { out += String.fromCharCode(mem[a]); } else { mem[b] -= mem[a]; @@ -102,7 +108,7 @@ function Subleq(mem) { } } instructionPointer += 3; - } while ((instructionPointer >= 0)); + } while (instructionPointer >= 0); return out; } diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sudoku.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sudoku.english.md index 66ba73317a..580f16ea44 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sudoku.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sudoku.english.md @@ -6,37 +6,42 @@ forumTopicId: 302329 --- ## Description +
Write a function to solve a partially filled-in normal 9x9 Sudoku grid and return the result. The blank fields are represented by 0s. Algorithmics of Sudoku may help implement this. +
## Instructions +
## Tests +
-``` yml +```yml tests: - text: solveSudoku should be a function. - testString: assert(typeof solveSudoku == 'function', 'solveSudoku should be a function.'); + testString: assert(typeof solveSudoku == 'function'); - text: solveSudoku([[8, 1, 9, -1, -1, 5, -1, -1, -1],[-1, -1, 2, -1, -1, -1, 7, 5, -1],[-1, 3, 7, 1, -1, 4, -1, 6, -1],[4, -1, -1, 5, 9, -1, 1, -1, -1],[7, -1, -1, 3, -1, 8, -1, -1, 2],[-1, -1, 3, -1, 6, 2, -1, -1, 7],[-1, 5, -1, 7, -1, 9, 2, 1, -1],[-1, 6, 4, -1, -1, -1, 9, -1, -1],[-1, -1, -1, 2, -1, -1, 4, 3, 8]]) should return an array. - testString: assert(Array.isArray(solveSudoku([[8, 1, 9, -1, -1, 5, -1, -1, -1], [-1, -1, 2, -1, -1, -1, 7, 5, -1], [-1, 3, 7, 1, -1, 4, -1, 6, -1], [4, -1, -1, 5, 9, -1, 1, -1, -1], [7, -1, -1, 3, -1, 8, -1, -1, 2], [-1, -1, 3, -1, 6, 2, -1, -1, 7], [-1, 5, -1, 7, -1, 9, 2, 1, -1], [-1, 6, 4, -1, -1, -1, 9, -1, -1], [-1, -1, -1, 2, -1, -1, 4, 3, 8]])), 'solveSudoku([[8, 1, 9, -1, -1, 5, -1, -1, -1],[-1, -1, 2, -1, -1, -1, 7, 5, -1],[-1, 3, 7, 1, -1, 4, -1, 6, -1],[4, -1, -1, 5, 9, -1, 1, -1, -1],[7, -1, -1, 3, -1, 8, -1, -1, 2],[-1, -1, 3, -1, 6, 2, -1, -1, 7],[-1, 5, -1, 7, -1, 9, 2, 1, -1],[-1, 6, 4, -1, -1, -1, 9, -1, -1],[-1, -1, -1, 2, -1, -1, 4, 3, 8]]) should return an array.'); + testString: assert(Array.isArray(solveSudoku([[8, 1, 9, -1, -1, 5, -1, -1, -1], [-1, -1, 2, -1, -1, -1, 7, 5, -1], [-1, 3, 7, 1, -1, 4, -1, 6, -1], [4, -1, -1, 5, 9, -1, 1, -1, -1], [7, -1, -1, 3, -1, 8, -1, -1, 2], [-1, -1, 3, -1, 6, 2, -1, -1, 7], [-1, 5, -1, 7, -1, 9, 2, 1, -1], [-1, 6, 4, -1, -1, -1, 9, -1, -1], [-1, -1, -1, 2, -1, -1, 4, 3, 8]]))); - text: solveSudoku([[8, 1, 9, -1, -1, 5, -1, -1, -1],[-1, -1, 2, -1, -1, -1, 7, 5, -1],[-1, 3, 7, 1, -1, 4, -1, 6, -1],[4, -1, -1, 5, 9, -1, 1, -1, -1],[7, -1, -1, 3, -1, 8, -1, -1, 2],[-1, -1, 3, -1, 6, 2, -1, -1, 7],[-1, 5, -1, 7, -1, 9, 2, 1, -1],[-1, 6, 4, -1, -1, -1, 9, -1, -1],[-1, -1, -1, 2, -1, -1, 4, 3, 8]]) should return [[8, 1, 9, 6, 7, 5, 3, 2, 4],[6, 4, 2, 9, 8, 3, 7, 5, 1],[5, 3, 7, 1, 2, 4, 8, 6, 9],[4, 2, 6, 5, 9, 7, 1, 8, 3],[7, 9, 5, 3, 1, 8, 6, 4, 2],[1, 8, 3, 4, 6, 2, 5, 9, 7],[3, 5, 8, 7, 4, 9, 2, 1, 6],[2, 6, 4, 8, 3, 1, 9, 7, 5],[9, 7, 1, 2, 5, 6, 4, 3, 8]]. - testString: assert.deepEqual(solveSudoku([[8, 1, 9, -1, -1, 5, -1, -1, -1], [-1, -1, 2, -1, -1, -1, 7, 5, -1], [-1, 3, 7, 1, -1, 4, -1, 6, -1], [4, -1, -1, 5, 9, -1, 1, -1, -1], [7, -1, -1, 3, -1, 8, -1, -1, 2], [-1, -1, 3, -1, 6, 2, -1, -1, 7], [-1, 5, -1, 7, -1, 9, 2, 1, -1], [-1, 6, 4, -1, -1, -1, 9, -1, -1], [-1, -1, -1, 2, -1, -1, 4, 3, 8]]), [[8, 1, 9, 6, 7, 5, 3, 2, 4], [6, 4, 2, 9, 8, 3, 7, 5, 1], [5, 3, 7, 1, 2, 4, 8, 6, 9], [4, 2, 6, 5, 9, 7, 1, 8, 3], [7, 9, 5, 3, 1, 8, 6, 4, 2], [1, 8, 3, 4, 6, 2, 5, 9, 7], [3, 5, 8, 7, 4, 9, 2, 1, 6], [2, 6, 4, 8, 3, 1, 9, 7, 5], [9, 7, 1, 2, 5, 6, 4, 3, 8]], 'solveSudoku([[8, 1, 9, -1, -1, 5, -1, -1, -1],[-1, -1, 2, -1, -1, -1, 7, 5, -1],[-1, 3, 7, 1, -1, 4, -1, 6, -1],[4, -1, -1, 5, 9, -1, 1, -1, -1],[7, -1, -1, 3, -1, 8, -1, -1, 2],[-1, -1, 3, -1, 6, 2, -1, -1, 7],[-1, 5, -1, 7, -1, 9, 2, 1, -1],[-1, 6, 4, -1, -1, -1, 9, -1, -1],[-1, -1, -1, 2, -1, -1, 4, 3, 8]]) should return [[8, 1, 9, 6, 7, 5, 3, 2, 4],[6, 4, 2, 9, 8, 3, 7, 5, 1],[5, 3, 7, 1, 2, 4, 8, 6, 9],[4, 2, 6, 5, 9, 7, 1, 8, 3],[7, 9, 5, 3, 1, 8, 6, 4, 2],[1, 8, 3, 4, 6, 2, 5, 9, 7],[3, 5, 8, 7, 4, 9, 2, 1, 6],[2, 6, 4, 8, 3, 1, 9, 7, 5],[9, 7, 1, 2, 5, 6, 4, 3, 8]].'); + testString: assert.deepEqual(solveSudoku([[8, 1, 9, -1, -1, 5, -1, -1, -1], [-1, -1, 2, -1, -1, -1, 7, 5, -1], [-1, 3, 7, 1, -1, 4, -1, 6, -1], [4, -1, -1, 5, 9, -1, 1, -1, -1], [7, -1, -1, 3, -1, 8, -1, -1, 2], [-1, -1, 3, -1, 6, 2, -1, -1, 7], [-1, 5, -1, 7, -1, 9, 2, 1, -1], [-1, 6, 4, -1, -1, -1, 9, -1, -1], [-1, -1, -1, 2, -1, -1, 4, 3, 8]]), [[8, 1, 9, 6, 7, 5, 3, 2, 4], [6, 4, 2, 9, 8, 3, 7, 5, 1], [5, 3, 7, 1, 2, 4, 8, 6, 9], [4, 2, 6, 5, 9, 7, 1, 8, 3], [7, 9, 5, 3, 1, 8, 6, 4, 2], [1, 8, 3, 4, 6, 2, 5, 9, 7], [3, 5, 8, 7, 4, 9, 2, 1, 6], [2, 6, 4, 8, 3, 1, 9, 7, 5], [9, 7, 1, 2, 5, 6, 4, 3, 8]]); - text: solveSudoku([[5, 3, -1, -1, 2, 4, 7, -1, -1],[-1, -1, 2, -1, -1, -1, 8, -1, -1],[1, -1, -1, 7, -1, 3, 9, -1, 2],[-1, -1, 8, -1, 7, 2, -1, 4, 9],[-1, 2, -1, 9, 8, -1, -1, 7, -1],[7, 9, -1, -1, -1, -1, -1, 8, -1],[-1, -1, -1, -1, 3, -1, 5, -1, 6],[9, 6, -1, -1, 1, -1, 3, -1, -1],[-1, 5, -1, 6, 9, -1, -1, 1, -1]]) should return [[5, 3, 9, 8, 2, 4, 7, 6, 1],[6, 7, 2, 1, 5, 9, 8, 3, 4],[1, 8, 4, 7, 6, 3, 9, 5, 2],[3, 1, 8, 5, 7, 2, 6, 4, 9],[4, 2, 5, 9, 8, 6, 1, 7, 3],[7, 9, 6, 3, 4, 1, 2, 8, 5],[8, 4, 1, 2, 3, 7, 5, 9, 6],[9, 6, 7, 4, 1, 5, 3, 2, 8],[2, 5, 3, 6, 9, 8, 4, 1, 7]]. - testString: assert.deepEqual(solveSudoku([[5, 3, -1, -1, 2, 4, 7, -1, -1], [-1, -1, 2, -1, -1, -1, 8, -1, -1], [1, -1, -1, 7, -1, 3, 9, -1, 2], [-1, -1, 8, -1, 7, 2, -1, 4, 9], [-1, 2, -1, 9, 8, -1, -1, 7, -1], [7, 9, -1, -1, -1, -1, -1, 8, -1], [-1, -1, -1, -1, 3, -1, 5, -1, 6], [9, 6, -1, -1, 1, -1, 3, -1, -1], [-1, 5, -1, 6, 9, -1, -1, 1, -1]]), [[5, 3, 9, 8, 2, 4, 7, 6, 1], [6, 7, 2, 1, 5, 9, 8, 3, 4], [1, 8, 4, 7, 6, 3, 9, 5, 2], [3, 1, 8, 5, 7, 2, 6, 4, 9], [4, 2, 5, 9, 8, 6, 1, 7, 3], [7, 9, 6, 3, 4, 1, 2, 8, 5], [8, 4, 1, 2, 3, 7, 5, 9, 6], [9, 6, 7, 4, 1, 5, 3, 2, 8], [2, 5, 3, 6, 9, 8, 4, 1, 7]], 'solveSudoku([[5, 3, -1, -1, 2, 4, 7, -1, -1],[-1, -1, 2, -1, -1, -1, 8, -1, -1],[1, -1, -1, 7, -1, 3, 9, -1, 2],[-1, -1, 8, -1, 7, 2, -1, 4, 9],[-1, 2, -1, 9, 8, -1, -1, 7, -1],[7, 9, -1, -1, -1, -1, -1, 8, -1],[-1, -1, -1, -1, 3, -1, 5, -1, 6],[9, 6, -1, -1, 1, -1, 3, -1, -1],[-1, 5, -1, 6, 9, -1, -1, 1, -1]]) should return [[5, 3, 9, 8, 2, 4, 7, 6, 1],[6, 7, 2, 1, 5, 9, 8, 3, 4],[1, 8, 4, 7, 6, 3, 9, 5, 2],[3, 1, 8, 5, 7, 2, 6, 4, 9],[4, 2, 5, 9, 8, 6, 1, 7, 3],[7, 9, 6, 3, 4, 1, 2, 8, 5],[8, 4, 1, 2, 3, 7, 5, 9, 6],[9, 6, 7, 4, 1, 5, 3, 2, 8],[2, 5, 3, 6, 9, 8, 4, 1, 7]].'); + testString: assert.deepEqual(solveSudoku([[5, 3, -1, -1, 2, 4, 7, -1, -1], [-1, -1, 2, -1, -1, -1, 8, -1, -1], [1, -1, -1, 7, -1, 3, 9, -1, 2], [-1, -1, 8, -1, 7, 2, -1, 4, 9], [-1, 2, -1, 9, 8, -1, -1, 7, -1], [7, 9, -1, -1, -1, -1, -1, 8, -1], [-1, -1, -1, -1, 3, -1, 5, -1, 6], [9, 6, -1, -1, 1, -1, 3, -1, -1], [-1, 5, -1, 6, 9, -1, -1, 1, -1]]), [[5, 3, 9, 8, 2, 4, 7, 6, 1], [6, 7, 2, 1, 5, 9, 8, 3, 4], [1, 8, 4, 7, 6, 3, 9, 5, 2], [3, 1, 8, 5, 7, 2, 6, 4, 9], [4, 2, 5, 9, 8, 6, 1, 7, 3], [7, 9, 6, 3, 4, 1, 2, 8, 5], [8, 4, 1, 2, 3, 7, 5, 9, 6], [9, 6, 7, 4, 1, 5, 3, 2, 8], [2, 5, 3, 6, 9, 8, 4, 1, 7]]); - text: solveSudoku([[-1, -1, 3, -1, 2, -1, 6, -1, -1],[9, -1, -1, 3, -1, 5, -1, -1, 1],[-1, -1, 1, 8, -1, 6, 4, -1, -1],[-1, -1, 8, 1, -1, 2, 9, -1, -1],[7, -1, -1, -1, -1, -1, -1, -1, 8],[-1, -1, 6, 7, -1, 8, 2, -1, -1],[-1, -1, 2, 6, -1, 9, 5, -1, -1],[8, -1, -1, 2, -1, 3, -1, -1, 9],[-1, -1, 5, -1, 1, -1, 3, -1, -1]]) should return [[4, 8, 3, 9, 2, 1, 6, 5, 7],[9, 6, 7, 3, 4, 5, 8, 2, 1],[2, 5, 1, 8, 7, 6, 4, 9, 3],[5, 4, 8, 1, 3, 2, 9, 7, 6],[7, 2, 9, 5, 6, 4, 1, 3, 8],[1, 3, 6, 7, 9, 8, 2, 4, 5],[3, 7, 2, 6, 8, 9, 5, 1, 4],[8, 1, 4, 2, 5, 3, 7, 6, 9],[6, 9, 5, 4, 1, 7, 3, 8, 2]]. - testString: assert.deepEqual(solveSudoku([[-1, -1, 3, -1, 2, -1, 6, -1, -1], [9, -1, -1, 3, -1, 5, -1, -1, 1], [-1, -1, 1, 8, -1, 6, 4, -1, -1], [-1, -1, 8, 1, -1, 2, 9, -1, -1], [7, -1, -1, -1, -1, -1, -1, -1, 8], [-1, -1, 6, 7, -1, 8, 2, -1, -1], [-1, -1, 2, 6, -1, 9, 5, -1, -1], [8, -1, -1, 2, -1, 3, -1, -1, 9], [-1, -1, 5, -1, 1, -1, 3, -1, -1]]), [[4, 8, 3, 9, 2, 1, 6, 5, 7], [9, 6, 7, 3, 4, 5, 8, 2, 1], [2, 5, 1, 8, 7, 6, 4, 9, 3], [5, 4, 8, 1, 3, 2, 9, 7, 6], [7, 2, 9, 5, 6, 4, 1, 3, 8], [1, 3, 6, 7, 9, 8, 2, 4, 5], [3, 7, 2, 6, 8, 9, 5, 1, 4], [8, 1, 4, 2, 5, 3, 7, 6, 9], [6, 9, 5, 4, 1, 7, 3, 8, 2]], 'solveSudoku([[-1, -1, 3, -1, 2, -1, 6, -1, -1],[9, -1, -1, 3, -1, 5, -1, -1, 1],[-1, -1, 1, 8, -1, 6, 4, -1, -1],[-1, -1, 8, 1, -1, 2, 9, -1, -1],[7, -1, -1, -1, -1, -1, -1, -1, 8],[-1, -1, 6, 7, -1, 8, 2, -1, -1],[-1, -1, 2, 6, -1, 9, 5, -1, -1],[8, -1, -1, 2, -1, 3, -1, -1, 9],[-1, -1, 5, -1, 1, -1, 3, -1, -1]]) should return [[4, 8, 3, 9, 2, 1, 6, 5, 7],[9, 6, 7, 3, 4, 5, 8, 2, 1],[2, 5, 1, 8, 7, 6, 4, 9, 3],[5, 4, 8, 1, 3, 2, 9, 7, 6],[7, 2, 9, 5, 6, 4, 1, 3, 8],[1, 3, 6, 7, 9, 8, 2, 4, 5],[3, 7, 2, 6, 8, 9, 5, 1, 4],[8, 1, 4, 2, 5, 3, 7, 6, 9],[6, 9, 5, 4, 1, 7, 3, 8, 2]].'); + testString: assert.deepEqual(solveSudoku([[-1, -1, 3, -1, 2, -1, 6, -1, -1], [9, -1, -1, 3, -1, 5, -1, -1, 1], [-1, -1, 1, 8, -1, 6, 4, -1, -1], [-1, -1, 8, 1, -1, 2, 9, -1, -1], [7, -1, -1, -1, -1, -1, -1, -1, 8], [-1, -1, 6, 7, -1, 8, 2, -1, -1], [-1, -1, 2, 6, -1, 9, 5, -1, -1], [8, -1, -1, 2, -1, 3, -1, -1, 9], [-1, -1, 5, -1, 1, -1, 3, -1, -1]]), [[4, 8, 3, 9, 2, 1, 6, 5, 7], [9, 6, 7, 3, 4, 5, 8, 2, 1], [2, 5, 1, 8, 7, 6, 4, 9, 3], [5, 4, 8, 1, 3, 2, 9, 7, 6], [7, 2, 9, 5, 6, 4, 1, 3, 8], [1, 3, 6, 7, 9, 8, 2, 4, 5], [3, 7, 2, 6, 8, 9, 5, 1, 4], [8, 1, 4, 2, 5, 3, 7, 6, 9], [6, 9, 5, 4, 1, 7, 3, 8, 2]]); ```
## Challenge Seed +
@@ -51,6 +56,7 @@ function solveSudoku(puzzle) {
## Solution +
```js @@ -74,14 +80,14 @@ function solveSudoku(puzzle) { n.R = e.R; n.L = e; e.R.L = n; - return e.R = n; + return (e.R = n); }; const addBelow = (e, n) => { n.D = e.D; n.U = e; e.D.U = n; - return e.D = n; + return (e.D = n); }; const search = function(h, s) { @@ -154,8 +160,11 @@ function solveSudoku(puzzle) { const cellCount = g.length; const tokenCount = Math.sqrt(cellCount); const N = Math.sqrt(tokenCount); - const g2D = g.map(e => isNaN(e * 1) ? - new Array(tokenCount).fill(1).map((_, i) => i + 1) : [e * 1]); + const g2D = g.map(e => + isNaN(e * 1) + ? new Array(tokenCount).fill(1).map((_, i) => i + 1) + : [e * 1] + ); return [cellCount, N, tokenCount, g2D]; }; @@ -166,7 +175,6 @@ function solveSudoku(puzzle) { }; const reduceGrid = puzString => { - const [ numCells, // The total number of cells in a grid (81 for a 9x9 grid) N, // the 'n' value of the grid. (3 for a 9x9 grid) @@ -193,9 +201,9 @@ function solveSudoku(puzzle) { // The 4 columns that we will populate. const A = headRow[i]; - const B = headRow[numCells + candIdx + (ri * U)]; - const C = headRow[(numCells * 2) + candIdx + (ci * U)]; - const D = headRow[(numCells * 3) + candIdx + (bi * U)]; + const B = headRow[numCells + candIdx + ri * U]; + const C = headRow[numCells * 2 + candIdx + ci * U]; + const D = headRow[numCells * 3 + candIdx + bi * U]; // The Row-Column Constraint let rcc = addBelow(A.U, new DoX(id, A)); @@ -213,23 +221,21 @@ function solveSudoku(puzzle) { search(H, []); }; - var stringPuzzle = ""; + var stringPuzzle = ''; for (var i = 0; i < puzzle.length; i++) { puzzle[i].forEach(function(e) { - if (e == -1) - stringPuzzle += "."; - else - stringPuzzle += e; - }) + if (e == -1) stringPuzzle += '.'; + else stringPuzzle += e; + }); } - reduceGrid(stringPuzzle) + reduceGrid(stringPuzzle); var result = []; for (var i = 0; i < 9; i++) { - result.push(solution.slice(i * 9, (i + 1) * 9).map(e => parseInt(e))) + result.push(solution.slice(i * 9, (i + 1) * 9).map(e => parseInt(e))); } return result; diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sum-digits-of-an-integer.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sum-digits-of-an-integer.english.md index 5cfb4b5cc7..f95a62e20a 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sum-digits-of-an-integer.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sum-digits-of-an-integer.english.md @@ -6,6 +6,7 @@ forumTopicId: 302331 --- ## Description +
Write a function that takes a string as a parameter. This string represents a number that can be in any base (less than 37) and return the sum of its digits.
    @@ -17,36 +18,39 @@ Write a function that takes a string as a parameter. This string represents a nu
## Instructions +
## Tests +
-``` yml +```yml tests: - text: sumDigits should be a function. - testString: assert(typeof sumDigits == 'function', 'sumDigits should be a function.'); + testString: assert(typeof sumDigits == 'function'); - text: sumDigits("1") should return a number. - testString: assert(typeof sumDigits("1") == 'number', 'sumDigits("1") should return a number.'); + testString: assert(typeof sumDigits("1") == 'number'); - text: sumDigits("1") should return 1. - testString: assert.equal(sumDigits("1"), 1, 'sumDigits("1") should return 1.'); + testString: assert.equal(sumDigits("1"), 1); - text: sumDigits("12345") should return 15. - testString: assert.equal(sumDigits("12345"), 15, 'sumDigits("12345") should return 15.'); + testString: assert.equal(sumDigits("12345"), 15); - text: sumDigits("254") should return 11. - testString: assert.equal(sumDigits("254"), 11, 'sumDigits("254") should return 11.'); + testString: assert.equal(sumDigits("254"), 11); - text: sumDigits("fe") should return 29. - testString: assert.equal(sumDigits("fe"), 29, 'sumDigits("fe") should return 29.'); + testString: assert.equal(sumDigits("fe"), 29); - text: sumDigits("f0e") should return 29. - testString: assert.equal(sumDigits("f0e"), 29, 'sumDigits("f0e") should return 29.'); + testString: assert.equal(sumDigits("f0e"), 29); - text: sumDigits("999ABCXYZ") should return 162. - testString: assert.equal(sumDigits("999ABCXYZ"), 162, 'sumDigits("999ABCXYZ") should return 162.'); + testString: assert.equal(sumDigits("999ABCXYZ"), 162); ```
## Challenge Seed +
@@ -60,13 +64,15 @@ function sumDigits(n) {
## Solution +
```js function sumDigits(n) { - n += '' - for (var s=0, i=0, e=n.length; i The objective is to write a function that finds the sum of all positive multiples of 3 or 5 below n. +
## Instructions +
## Tests +
-``` yml +```yml tests: - text: sumMults should be a function. - testString: assert(typeof sumMults == 'function', 'sumMults should be a function.'); + testString: assert(typeof sumMults == 'function'); - text: sumMults(10) should return a number. - testString: assert(typeof sumMults(10) == 'number', 'sumMults(10) should return a number.'); + testString: assert(typeof sumMults(10) == 'number'); - text: sumMults(10) should return 23. - testString: assert.equal(sumMults(10), 23, 'sumMults(10) should return 23.'); + testString: assert.equal(sumMults(10), 23); - text: sumMults(100) should return 2318. - testString: assert.equal(sumMults(100), 2318, 'sumMults(100) should return 2318.'); + testString: assert.equal(sumMults(100), 2318); - text: sumMults(1000) should return 233168. - testString: assert.equal(sumMults(1000), 233168, 'sumMults(1000) should return 233168.'); + testString: assert.equal(sumMults(1000), 233168); - text: sumMults(10000) should return 23331668. - testString: assert.equal(sumMults(10000), 23331668, 'sumMults(10000) should return 23331668.'); + testString: assert.equal(sumMults(10000), 23331668); - text: sumMults(100000) should return 2333316668. - testString: assert.equal(sumMults(100000), 2333316668, 'sumMults(100000) should return 2333316668.'); + testString: assert.equal(sumMults(100000), 2333316668); ```
## Challenge Seed +
@@ -54,6 +59,7 @@ function sumMults(n) {
## Solution +
```js diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sum-of-a-series.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sum-of-a-series.english.md index c5d10c9af0..f1ffe3c10e 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sum-of-a-series.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sum-of-a-series.english.md @@ -6,48 +6,54 @@ forumTopicId: 302333 --- ## Description +
-Compute the nth term of a series, i.e. the sum of the n first terms of the corresponding sequence. -Informally this value, or its limit when n tends to infinity, is also called the sum of the series, thus the title of this task. +Compute the nth term of a series, i.e. the sum of the n first terms of the corresponding sequence. +Informally this value, or its limit when n tends to infinity, is also called the sum of the series, thus the title of this task. For this task, use: $S_n = \sum_{k=1}^n \frac{1}{k^2}$ -and compute $S_{1000}$ - This approximates the zeta function for S=2, whose exact value +and compute $S_{1000}$ +This approximates the zeta function for S=2, whose exact value $\zeta(2) = {\pi^2\over 6}$ - is the solution of the Basel problem. +is the solution of the Basel problem. +
## Instructions +
Write a function that take $a$ and $b$ as parameters and returns the sum of $a^{th}$ to $b^{th}$ members of the sequence. +
## Tests +
-``` yml +```yml tests: - text: sum should be a function. - testString: assert(typeof sum == 'function', 'sum should be a function.'); + testString: assert(typeof sum == 'function'); - text: sum(1, 100) should return a number. - testString: assert(typeof sum(1, 100) == 'number', 'sum(1, 100) should return a number.'); + testString: assert(typeof sum(1, 100) == 'number'); - text: sum(1, 100) should return 1.6349839001848923. - testString: assert.equal(sum(1, 100), 1.6349839001848923, 'sum(1, 100) should return 1.6349839001848923.'); + testString: assert.equal(sum(1, 100), 1.6349839001848923); - text: sum(33, 46) should return 0.009262256361481223. - testString: assert.equal(sum(33, 46), 0.009262256361481223, 'sum(33, 46) should return 0.009262256361481223.'); + testString: assert.equal(sum(33, 46), 0.009262256361481223); - text: sum(21, 213) should return 0.044086990748706555. - testString: assert.equal(sum(21, 213), 0.044086990748706555, 'sum(21, 213) should return 0.044086990748706555.'); + testString: assert.equal(sum(21, 213), 0.044086990748706555); - text: sum(11, 111) should return 0.08619778593108679. - testString: assert.equal(sum(11, 111), 0.08619778593108679, 'sum(11, 111) should return 0.08619778593108679.'); + testString: assert.equal(sum(11, 111), 0.08619778593108679); - text: sum(1, 10) should return 1.5497677311665408. - testString: assert.equal(sum(1, 10), 1.5497677311665408, 'sum(1, 10) should return 1.5497677311665408.'); + testString: assert.equal(sum(1, 10), 1.5497677311665408); ```
## Challenge Seed +
@@ -62,12 +68,13 @@ function sum(a, b) {
## Solution +
```js function sum(a, b) { function fn(x) { - return 1 / (x * x) + return 1 / (x * x); } var s = 0; for (; a <= b; a++) s += fn(a); diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sum-of-squares.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sum-of-squares.english.md index 4bbbc750e5..8862ce63ce 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sum-of-squares.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sum-of-squares.english.md @@ -6,40 +6,45 @@ forumTopicId: 302334 --- ## Description +
Write a function to find the sum of squares of an array of integers. +
## Instructions +
## Tests +
-``` yml +```yml tests: - text: sumsq should be a function. - testString: assert(typeof sumsq == 'function', 'sumsq should be a function.'); + testString: assert(typeof sumsq == 'function'); - text: sumsq([1, 2, 3, 4, 5]) should return a number. - testString: assert(typeof sumsq([1, 2, 3, 4, 5]) == 'number', 'sumsq([1, 2, 3, 4, 5]) should return a number.'); + testString: assert(typeof sumsq([1, 2, 3, 4, 5]) == 'number'); - text: sumsq([1, 2, 3, 4, 5]) should return 55. - testString: assert.equal(sumsq([1, 2, 3, 4, 5]), 55, 'sumsq([1, 2, 3, 4, 5]) should return 55.'); + testString: assert.equal(sumsq([1, 2, 3, 4, 5]), 55); - text: sumsq([25, 32, 12, 7, 20]) should return 2242. - testString: assert.equal(sumsq([25, 32, 12, 7, 20]), 2242, 'sumsq([25, 32, 12, 7, 20]) should return 2242.'); + testString: assert.equal(sumsq([25, 32, 12, 7, 20]), 2242); - text: sumsq([38, 45, 35, 8, 13]) should return 4927. - testString: assert.equal(sumsq([38, 45, 35, 8, 13]), 4927, 'sumsq([38, 45, 35, 8, 13]) should return 4927.'); + testString: assert.equal(sumsq([38, 45, 35, 8, 13]), 4927); - text: sumsq([43, 36, 20, 34, 24]) should return 5277. - testString: assert.equal(sumsq([43, 36, 20, 34, 24]), 5277, 'sumsq([43, 36, 20, 34, 24]) should return 5277.'); + testString: assert.equal(sumsq([43, 36, 20, 34, 24]), 5277); - text: sumsq([12, 33, 26, 18, 1, 16, 3]) should return 2499. - testString: assert.equal(sumsq([12, 33, 26, 18, 1, 16, 3]), 2499, 'sumsq([12, 33, 26, 18, 1, 16, 3]) should return 2499.'); + testString: assert.equal(sumsq([12, 33, 26, 18, 1, 16, 3]), 2499); ```
## Challenge Seed +
@@ -54,6 +59,7 @@ function sumsq(array) {
## Solution +
```js diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sum-to-100.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sum-to-100.english.md index 610f56d674..8ac5b19064 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sum-to-100.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sum-to-100.english.md @@ -6,6 +6,7 @@ forumTopicId: 302335 --- ## Description +
Find solutions to the sum to one hundred puzzle. Add (insert) the mathematical operators + or ─ (plus or minus) before any of the digits in the decimal numeric string 123456789 such that the resulting mathematical expression adds up to a particular sum (in this iconic case, 100). @@ -14,34 +15,37 @@ Example:
## Instructions +
Write a function that takes a number as parameter. The function should return an array containing all solutions for the given number. The solutions should be strings representing the expressions. For example: "1+23-456+78-9". Sort the array before returning it.
## Tests +
-``` yml +```yml tests: - text: sumTo100 should be a function. - testString: assert(typeof sumTo100 == 'function', 'sumTo100 should be a function.'); + testString: assert(typeof sumTo100 == 'function'); - text: sumTo100(199) should return an array. - testString: assert(Array.isArray(sumTo100(199)), 'sumTo100(199) should return an array.'); + testString: assert(Array.isArray(sumTo100(199))); - text: sumTo100(199) should return ["-1+2-3+45+67+89", "123-4+5+6+78-9", "123-4+56+7+8+9"]. - testString: assert.deepEqual(sumTo100(199), ["-1+2-3+45+67+89", "123-4+5+6+78-9", "123-4+56+7+8+9"], 'sumTo100(199) should return ["-1+2-3+45+67+89", "123-4+5+6+78-9", "123-4+56+7+8+9"].'); + testString: assert.deepEqual(sumTo100(199), ["-1+2-3+45+67+89", "123-4+5+6+78-9", "123-4+56+7+8+9"]); - text: sumTo100(209) should return ["1+234+56+7-89"]. - testString: assert.deepEqual(sumTo100(209), ["1+234+56+7-89"], 'sumTo100(209) should return ["1+234+56+7-89"].'); + testString: assert.deepEqual(sumTo100(209), ["1+234+56+7-89"]); - text: sumTo100(243) should return ["-1-234+567-89", "-12+345+6-7-89", "123+45+6+78-9"]. - testString: assert.deepEqual(sumTo100(243), ["-1-234+567-89", "-12+345+6-7-89", "123+45+6+78-9"], 'sumTo100(243) should return ["-1-234+567-89", "-12+345+6-7-89", "123+45+6+78-9"].'); + testString: assert.deepEqual(sumTo100(243), ["-1-234+567-89", "-12+345+6-7-89", "123+45+6+78-9"]); - text: sumTo100(199) should return ["-1+2-3+45+67+89", "123-4+5+6+78-9", "123-4+56+7+8+9"]. - testString: assert.deepEqual(sumTo100(199), ["-1+2-3+45+67+89", "123-4+5+6+78-9", "123-4+56+7+8+9"], 'sumTo100(199) should return ["-1+2-3+45+67+89", "123-4+5+6+78-9", "123-4+56+7+8+9"].'); + testString: assert.deepEqual(sumTo100(199), ["-1+2-3+45+67+89", "123-4+5+6+78-9", "123-4+56+7+8+9"]); - text: sumTo100(197) should return ["1-2-3+45+67+89", "12+34-5+67+89", "123+4-5+6+78-9"]. - testString: assert.deepEqual(sumTo100(197), ["1-2-3+45+67+89", "12+34-5+67+89", "123+4-5+6+78-9"], 'sumTo100(197) should return ["1-2-3+45+67+89", "12+34-5+67+89", "123+4-5+6+78-9"].'); + testString: assert.deepEqual(sumTo100(197), ["1-2-3+45+67+89", "12+34-5+67+89", "123+4-5+6+78-9"]); ```
## Challenge Seed +
@@ -55,23 +59,29 @@ function sumTo100(n) {
## Solution +
```js function sumTo100(n) { var permutationsWithRepetition = function(n, as) { - return as.length > 0 ? - foldl1(curry(cartesianProduct)(as), replicate(n, as)) : []; + return as.length > 0 + ? foldl1(curry(cartesianProduct)(as), replicate(n, as)) + : []; }; var cartesianProduct = function(xs, ys) { - return [].concat.apply([], xs.map(function(x) { - return [].concat.apply([], ys.map(function(y) { - return [ - [x].concat(y) - ]; - })); - })); + return [].concat.apply( + [], + xs.map(function(x) { + return [].concat.apply( + [], + ys.map(function(y) { + return [[x].concat(y)]; + }) + ); + }) + ); }; var curry = function(f) { @@ -89,8 +99,7 @@ function sumTo100(n) { }; var foldl1 = function(f, xs) { - return xs.length > 0 ? xs.slice(1) - .reduce(f, xs[0]) : []; + return xs.length > 0 ? xs.slice(1).reduce(f, xs[0]) : []; }; var replicate = function(n, a) { @@ -106,32 +115,35 @@ function sumTo100(n) { }; var asSum = function(xs) { - var dct = xs.reduceRight(function(a, sign, i) { - var d = i + 1; // zero-based index to [1-9] positions - if (sign !== 0) { - // Sum increased, digits cleared - return { - digits: [], - n: a.n + sign * parseInt([d].concat(a.digits) - .join(''), 10) - }; - } else return { // Digits extended, sum unchanged - digits: [d].concat(a.digits), - n: a.n - }; - }, { - digits: [], - n: 0 - }); - return dct.n + ( - dct.digits.length > 0 ? parseInt(dct.digits.join(''), 10) : 0 + var dct = xs.reduceRight( + function(a, sign, i) { + var d = i + 1; // zero-based index to [1-9] positions + if (sign !== 0) { + // Sum increased, digits cleared + return { + digits: [], + n: a.n + sign * parseInt([d].concat(a.digits).join(''), 10) + }; + } else + return { + // Digits extended, sum unchanged + digits: [d].concat(a.digits), + n: a.n + }; + }, + { + digits: [], + n: 0 + } + ); + return ( + dct.n + (dct.digits.length > 0 ? parseInt(dct.digits.join(''), 10) : 0) ); }; var asString = function(xs) { var ns = xs.reduce(function(a, sign, i) { - var d = (i + 1) - .toString(); + var d = (i + 1).toString(); return sign === 0 ? a + d : a + (sign > 0 ? '+' : '-') + d; }, ''); @@ -141,8 +153,9 @@ function sumTo100(n) { var universe = permutationsWithRepetition(9, [0, 1, -1]) .filter(function(x) { return x[0] !== 1 && asSum(x) === n; - }).map(asString); - return universe.sort() + }) + .map(asString); + return universe.sort(); } ``` diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sutherland-hodgman-polygon-clipping.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sutherland-hodgman-polygon-clipping.english.md index 31bd351302..44b2db0df8 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sutherland-hodgman-polygon-clipping.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/sutherland-hodgman-polygon-clipping.english.md @@ -6,42 +6,50 @@ forumTopicId: 302336 --- ## Description +
-The Sutherland-Hodgman clipping algorithm finds the polygon that is the intersection between an arbitrary polygon (the "subject polygon") and a convex polygon (the "clip polygon"). +The Sutherland-Hodgman clipping algorithm finds the polygon that is the intersection between an arbitrary polygon (the "subject polygon") and a convex polygon (the "clip polygon"). It is used in computer graphics (especially 2D graphics) to reduce the complexity of a scene being displayed by eliminating parts of a polygon that do not need to be displayed. Take the closed polygon defined by the points: + 
[(50, 150), (200, 50), (350, 150), (350, 300), (250, 300), (200, 250), (150, 350), (100, 250), (100, 200)]
+ and clip it by the rectangle defined by the points: + 
[(100, 100), (300, 100), (300, 300), (100, 300)]
## Instructions +
Write a function that takes 2 arrays as parameters. The first array contains the points of the subject polygon and the second array contains the points of the clipping polygon. The function should return an array containing the points of the clipped polygon. Each number should be rounded to 3 decimal places. +
## Tests +
-``` yml +```yml tests: - text: clip should be a function. - testString: assert(typeof clip == 'function', 'clip should be a function.'); + testString: assert(typeof clip == 'function'); - text: clip([[50, 150], [200, 50], [350, 150], [350, 300], [250, 300], [200, 250], [150, 350], [100, 250], [100, 200]], [[100, 100], [300, 100], [300, 300], [100, 300]]) should return an array. - testString: assert(Array.isArray(clip([[50, 150], [200, 50], [350, 150], [350, 300], [250, 300], [200, 250], [150, 350], [100, 250], [100, 200]], [[100, 100], [300, 100], [300, 300], [100, 300]])), 'clip([[50, 150], [200, 50], [350, 150], [350, 300], [250, 300], [200, 250], [150, 350], [100, 250], [100, 200]], [[100, 100], [300, 100], [300, 300], [100, 300]]) should return an array.'); + testString: assert(Array.isArray(clip([[50, 150], [200, 50], [350, 150], [350, 300], [250, 300], [200, 250], [150, 350], [100, 250], [100, 200]], [[100, 100], [300, 100], [300, 300], [100, 300]]))); - text: clip([[50, 150], [200, 50], [350, 150], [350, 300], [250, 300], [200, 250], [150, 350], [100, 250], [100, 200]], [[100, 100], [300, 100], [300, 300], [100, 300]]) should return [[100, 116.667], [125, 100], [275, 100], [300, 116.667], [300, 300], [250, 300], [200, 250], [175, 300], [125, 300], [100, 250]]. - testString: assert.deepEqual(clip([[50, 150], [200, 50], [350, 150], [350, 300], [250, 300], [200, 250], [150, 350], [100, 250], [100, 200]], [[100, 100], [300, 100], [300, 300], [100, 300]]), [[100, 116.667], [125, 100], [275, 100], [300, 116.667], [300, 300], [250, 300], [200, 250], [175, 300], [125, 300], [100, 250]], 'clip([[50, 150], [200, 50], [350, 150], [350, 300], [250, 300], [200, 250], [150, 350], [100, 250], [100, 200]], [[100, 100], [300, 100], [300, 300], [100, 300]]) should return [[100, 116.667], [125, 100], [275, 100], [300, 116.667], [300, 300], [250, 300], [200, 250], [175, 300], [125, 300], [100, 250]].'); + testString: assert.deepEqual(clip([[50, 150], [200, 50], [350, 150], [350, 300], [250, 300], [200, 250], [150, 350], [100, 250], [100, 200]], [[100, 100], [300, 100], [300, 300], [100, 300]]), [[100, 116.667], [125, 100], [275, 100], [300, 116.667], [300, 300], [250, 300], [200, 250], [175, 300], [125, 300], [100, 250]]); - text: clip([[150, 200], [400, 450], [30, 50]], [[10, 10], [300, 200], [400, 600], [100, 300]]) should return [[150, 200], [350, 400], [348.611, 394.444], [30, 50]]. - testString: assert.deepEqual(clip([[150, 200], [400, 450], [30, 50]], [[10, 10], [300, 200], [400, 600], [100, 300]]), [[150, 200], [350, 400], [348.611, 394.444], [30, 50]], 'clip([[150, 200], [400, 450], [30, 50]], [[10, 10], [300, 200], [400, 600], [100, 300]]) should return [[150, 200], [350, 400], [348.611, 394.444], [30, 50]].'); + testString: assert.deepEqual(clip([[150, 200], [400, 450], [30, 50]], [[10, 10], [300, 200], [400, 600], [100, 300]]), [[150, 200], [350, 400], [348.611, 394.444], [30, 50]]); - text: clip([[250, 200], [100, 450], [130, 250]], [[50, 60], [100, 230], [400, 600], [100, 300]]) should return [[129.167, 329.167], [119.565, 319.565], [121.854, 304.305]]. - testString: assert.deepEqual(clip([[250, 200], [100, 450], [130, 250]], [[50, 60], [100, 230], [400, 600], [100, 300]]), [[129.167, 329.167], [119.565, 319.565], [121.854, 304.305]], 'clip([[250, 200], [100, 450], [130, 250]], [[50, 60], [100, 230], [400, 600], [100, 300]]) should return [[129.167, 329.167], [119.565, 319.565], [121.854, 304.305]].'); + testString: assert.deepEqual(clip([[250, 200], [100, 450], [130, 250]], [[50, 60], [100, 230], [400, 600], [100, 300]]), [[129.167, 329.167], [119.565, 319.565], [121.854, 304.305]]); ```
## Challenge Seed +
@@ -56,13 +64,16 @@ function clip(subjectPolygon, clipPolygon) {
## Solution +
```js function clip(subjectPolygon, clipPolygon) { var cp1, cp2, s, e, i, j; var inside = function(p) { - return (cp2[0] - cp1[0]) * (p[1] - cp1[1]) > (cp2[1] - cp1[1]) * (p[0] - cp1[0]); + return ( + (cp2[0] - cp1[0]) * (p[1] - cp1[1]) > (cp2[1] - cp1[1]) * (p[0] - cp1[0]) + ); }; var intersection = function() { var dc = [cp1[0] - cp2[0], cp1[1] - cp2[1]], diff --git a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/symmetric-difference.english.md b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/symmetric-difference.english.md index 949922e91c..06a199f3ac 100644 --- a/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/symmetric-difference.english.md +++ b/curriculum/challenges/english/08-coding-interview-prep/rosetta-code/symmetric-difference.english.md @@ -6,43 +6,49 @@ forumTopicId: 16086 --- ## Description +
Given two sets A and B, compute $(A \setminus B) \cup (B \setminus A).$ That is, enumerate the items that are in A or B but not both. This set is called the symmetric difference of A and B. In other words: $(A \cup B) \setminus (A \cap B)$ (the set of items that are in at least one of A or B minus the set of items that are in both A and B). +
## Instructions +
Write a function that takes two arrays as parameters and returns the symmetric difference. Sort the resultant array before returning it. +
## Tests +
-``` yml +```yml tests: - text: symmetricDifference should be a function. - testString: assert(typeof symmetricDifference == 'function', 'symmetricDifference should be a function.'); + testString: assert(typeof symmetricDifference == 'function'); - text: symmetricDifference(["John", "Bob", "Mary", "Serena"], ["Jim", "Mary", "John", "Bob"]) should return an array. - testString: assert(Array.isArray(symmetricDifference(["John", "Bob", "Mary", "Serena"], ["Jim", "Mary", "John", "Bob"])), 'symmetricDifference(["John", "Bob", "Mary", "Serena"], ["Jim", "Mary", "John", "Bob"]) should return an array.'); + testString: assert(Array.isArray(symmetricDifference(["John", "Bob", "Mary", "Serena"], ["Jim", "Mary", "John", "Bob"]))); - text: symmetricDifference(["John", "Bob", "Mary", "Serena"], ["Jim", "Mary", "John", "Bob"]) should return ["Jim", "Serena"]. - testString: assert.deepEqual(symmetricDifference(["John", "Bob", "Mary", "Serena"], ["Jim", "Mary", "John", "Bob"]), ["Jim", "Serena"], 'symmetricDifference(["John", "Bob", "Mary", "Serena"], ["Jim", "Mary", "John", "Bob"]) should return ["Jim", "Serena"].'); + testString: assert.deepEqual(symmetricDifference(["John", "Bob", "Mary", "Serena"], ["Jim", "Mary", "John", "Bob"]), ["Jim", "Serena"]); - text: symmetricDifference([1, 2, 3], [3, 4]) should return [1, 2, 4]. - testString: assert.deepEqual(symmetricDifference([1, 2, 3], [3, 4]), [1, 2, 4], 'symmetricDifference([1, 2, 3], [3, 4]) should return [1, 2, 4].'); + testString: assert.deepEqual(symmetricDifference([1, 2, 3], [3, 4]), [1, 2, 4]); - text: symmetricDifference([1, 2, 3, 4, 5], [3, 4, 8, 7]) should return [1, 2, 5, 7, 8]. - testString: assert.deepEqual(symmetricDifference([1, 2, 3, 4, 5], [3, 4, 8, 7]), [1, 2, 5, 7, 8], 'symmetricDifference([1, 2, 3, 4, 5], [3, 4, 8, 7]) should return [1, 2, 5, 7, 8].'); + testString: assert.deepEqual(symmetricDifference([1, 2, 3, 4, 5], [3, 4, 8, 7]), [1, 2, 5, 7, 8]); - text: symmetricDifference([1, 2, 3, 4, 5, 6, 7, 8], [1, 3, 5, 6, 7, 8, 9]) should return [2, 4, 9]. - testString: assert.deepEqual(symmetricDifference([1, 2, 3, 4, 5, 6, 7, 8], [1, 3, 5, 6, 7, 8, 9]), [2, 4, 9], 'symmetricDifference([1, 2, 3, 4, 5, 6, 7, 8], [1, 3, 5, 6, 7, 8, 9]) should return [2, 4, 9].'); + testString: assert.deepEqual(symmetricDifference([1, 2, 3, 4, 5, 6, 7, 8], [1, 3, 5, 6, 7, 8, 9]), [2, 4, 9]); - text: symmetricDifference([1, 2, 4, 7, 9], [2, 3, 7, 8, 9]) should return [1, 3, 4, 8]. - testString: assert.deepEqual(symmetricDifference([1, 2, 4, 7, 9], [2, 3, 7, 8, 9]), [1, 3, 4, 8], 'symmetricDifference([1, 2, 4, 7, 9], [2, 3, 7, 8, 9]) should return [1, 3, 4, 8].'); + testString: assert.deepEqual(symmetricDifference([1, 2, 4, 7, 9], [2, 3, 7, 8, 9]), [1, 3, 4, 8]); ```
## Challenge Seed +
@@ -57,28 +63,29 @@ function symmetricDifference(A, B) {
## Solution +
```js function symmetricDifference(A, B) { function relative_complement(A, B) { return A.filter(function(elem) { - return B.indexOf(elem) == -1 + return B.indexOf(elem) == -1; }); } function unique(ary) { var u = ary.concat().sort(); - for (var i = 1; i < u.length;) { - if (u[i - 1] === u[i]) - u.splice(i, 1); - else - i++; + for (var i = 1; i < u.length; ) { + if (u[i - 1] === u[i]) u.splice(i, 1); + else i++; } return u; } - return unique(relative_complement(A, B).concat(relative_complement(B, A))).sort(); + return unique( + relative_complement(A, B).concat(relative_complement(B, A)) + ).sort(); } ```