Merge pull request algorithm-archivists#118 from Gustorn/js

Add/improve JS implementations

Author: zsparal

chapters/computational_geometry/gift_wrapping/graham_scan/code/javascript/graham-scan.js

@@ -0,0 +1,52 @@
+function grahamScan(points) {
+ // First, sort the points so the one with the lowest y-coordinate comes first (the pivot)
+ points = [...points].sort((a, b) => (a.y - b.y));
+ const pivot = points[0];
+
+ // Then sort all remaining points based on the angle between the pivot and itself
+ const hull = points.slice(1).sort((a, b) => polarAngle(a, pivot) - polarAngle(b, pivot));
+
+ // The pivot is always on the hull
+ hull.unshift(pivot);
+
+ let n = hull.length;
+ let m = 1;
+ for (let i = 2; i < n; i++) {
+ while (ccw(hull[m - 1], hull[m], hull[i]) <= 0) {
+ if (m > 1) {
+ m -= 1;
+ } else if (m === i) {
+ break;
+ } else {
+ i += 1;
+ }
+ }
+
+ m += 1;
+ [hull[i], hull[m]] = [hull[m], hull[i]];
+ }
+
+ return hull.slice(0, m + 1);
+}
+
+function polarAngle(a, b) {
+ return Math.atan2(a.y - b.y, a.x - b.x);
+}
+
+function ccw(a, b, c) {
+ return (b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y);
+}
+
+const points = [
+ { x: 1, y: 3 },
+ { x: 2, y: 4 },
+ { x: 4, y: 0 },
+ { x: 1, y: 0 },
+ { x: 0, y: 2 },
+ { x: 2, y: 2 },
+ { x: 3, y: 4 },
+ { x: 3, y: 1 },
+];
+
+const convexHull = grahamScan(points);
+convexHull.forEach(p => console.log(`(${p.x}, ${p.y})`));

chapters/computational_geometry/gift_wrapping/graham_scan/graham_scan.md

@@ -18,6 +18,8 @@ We can find whether a rotation is counter-clockwise with trigonometric functions
 [import:6-7, lang:"haskell"](code/haskell/grahamScan.hs)
 {% sample lang="c" %}
 [import:24-26, lang:"c_cpp"](code/c/graham.c)
+{% sample lang="js" %}
+[import:36-38, lang:"javascript"](code/javascript/graham-scan.js)
 {% endmethod %}
 
 If the output of this function is 0, the points are collinear.
@@ -38,6 +40,8 @@ In the end, the code should look something like this:
 [import:9-18, lang:"haskell"](code/haskell/grahamScan.hs)
 {% sample lang="c" %}
 [import:65-95, lang:"c_cpp"](code/c/graham.c)
+{% sample lang="js" %}
+[import:1-30, lang:"javascript"](code/javascript/graham-scan.js)
 {% endmethod %}
 
 ### Bibliography
@@ -56,6 +60,8 @@ In the end, the code should look something like this:
 {% sample lang="c" %}
 ### C
 [import, lang:"c_cpp"](code/c/graham.c)
+{% sample lang="js" %}
+[import, lang:"javascript"](code/javascript/graham-scan.js)
 {% endmethod %}
 
 <script>

chapters/computational_geometry/gift_wrapping/jarvis_march/code/javascript/jarvis-march.js

@@ -0,0 +1,39 @@
+function jarvisMarch(points) {
+ const hull = [];
+
+ let pointOnHull = points.reduce((leftmost, current) => leftmost.x < current.x ? leftmost : current);
+ do {
+ hull.push(pointOnHull);
+ pointOnHull = points.reduce(chooseNextPointOnHull(pointOnHull));
+ } while (pointOnHull !== hull[0]);
+
+ return hull;
+}
+
+function chooseNextPointOnHull(currentPoint) {
+ return function (nextPoint, candidate) {
+ if (nextPoint === currentPoint || isLeftOf({ a: currentPoint, b: nextPoint }, candidate)) {
+ return candidate;
+ }
+ return nextPoint;
+ }
+}
+
+function isLeftOf({ a, b }, p) {
+ return (b.x - a.x) * (p.y - a.y) > (p.x - a.x) * (b.y - a.y);
+}
+
+const points = [
+ { x: 1, y: 3 },
+ { x: 2, y: 4 },
+ { x: 4, y: 0 },
+ { x: 1, y: 0 },
+ { x: 0, y: 2 },
+ { x: 2, y: 2 },
+ { x: 3, y: 4 },
+ { x: 3, y: 1 },
+];
+
+const convexHull = jarvisMarch(points);
+convexHull.forEach(p => console.log(`(${p.x}, ${p.y})`));
+

chapters/computational_geometry/gift_wrapping/jarvis_march/jarvis_march.md

@@ -38,6 +38,9 @@ Program.cs
 {% sample lang="c" %}
 ### C
 [import, lang:"c_cpp"](code/c/jarvis_march.c)
+{% sample lang="js" %}
+### JavaScript
+[import, lang:"javascript"](code/javascript/jarvis-march.js)
 {% endmethod %}
 
 <script>

chapters/data_compression/huffman/code/javascript/huffman.js

@@ -0,0 +1,84 @@
+function encode(str) {
+ const tree = createTree(str);
+ const codebook = createCodebook(tree);
+ return {
+ string: [...str].map(c => codebook[c]).join(""),
+ tree,
+ codebook
+ };
+
+ function createTree(str) {
+ const chars = [...str];
+ const charCounts = chars.reduce((counts, char) => {
+ counts[char] = (counts[char] || 0) + 1;
+ return counts;
+ }, {});
+
+ const nodes = Object.entries(charCounts).map(([key, weight]) => ({ key, weight }));
+ const priorityQueue = makeQueue(nodes);
+ while (priorityQueue.data.length > 1) {
+ const left = priorityQueue.dequeue();
+ const right = priorityQueue.dequeue();
+ priorityQueue.enqueue({ weight: left.weight + right.weight, left, right });
+ }
+ return priorityQueue.dequeue();
+ }
+
+ function createCodebook(tree) {
+ return recurse(tree, "", {});
+
+ function recurse(node, bitstring, dict) {
+ if (!node.left && !node.right) {
+ dict[node.key] = bitstring;
+ } else {
+ if (node.left) {
+ recurse(node.left, bitstring + "0", dict);
+ }
+
+ if (node.right) {
+ recurse(node.right, bitstring + "1", dict);
+ }
+ }
+ return dict;
+ }
+ }
+}
+
+function decode(bitstring, tree) {
+ const result = [];
+ let node = tree;
+
+ for (const bit of [...bitstring]) {
+ node = bit === "0" ? node.left : node.right;
+ if (!node.left && !node.right) {
+ result.push(node.key);
+ node = tree;
+ }
+ }
+
+ return result.join("");
+}
+
+// This queue implementation is horribly inefficient, but a proper, heap-based implementation would
+// be longer that the algorithm itself
+function makeQueue(iterable) {
+ return {
+ data: [...iterable].sort((a, b) => a.weight - b.weight),
+ enqueue(value) {
+ const target = this.data.findIndex(x => x.weight > value.weight);
+ if (target === -1) {
+ this.data.push(value);
+ } else {
+ this.data = [...this.data.slice(0, target), value, ...this.data.slice(target)];
+ }
+ },
+ dequeue() {
+ return this.data.shift();
+ }
+ };
+}
+
+const encoded = encode("bibbity bobbity");
+const decoded = decode(encoded.string, encoded.tree);
+console.log(encoded.string);
+console.log(decoded);

chapters/data_compression/huffman/huffman.md

@@ -81,6 +81,9 @@ Program.cs
 {% sample lang="py" %}
 ### Python
 [import, lang:"python"](code/python/huffman.py)
+{% sample lang="js" %}
+### JavaScript
+[import, lang:"javascript"](code/javascript/huffman.js)
 {% endmethod %}
 
 

chapters/decision_problems/stable_marriage/code/javascript/stable-marriage.js

@@ -0,0 +1,71 @@
+class Person {
+ constructor(name) {
+ this.name = name;
+ }
+
+ get hasFiance() {
+ return !!this.fiance;
+ }
+
+ prefers(other) {
+ return this.preferences.indexOf(other) < this.preferences.indexOf(this.fiance);
+ }
+
+ engageTo(other) {
+ if (other.hasFiance) {
+ other.fiance.fiance = undefined;
+ }
+
+ this.fiance = other;
+ other.fiance = this;
+ }
+}
+
+function stableMarriage(guys, girls) {
+ const bachelors = [...guys];
+ while (bachelors.length > 0) {
+ const guy = bachelors.shift();
+ for (const girl of guy.preferences) {
+ if (!girl.hasFiance) {
+ guy.engageTo(girl);
+ break;
+ } else if (girl.prefers(guy)) {
+ bachelors.push(girl.fiance);
+ guy.engageTo(girl);
+ break;
+ }
+ }
+ }
+}
+
+function shuffle(iterable) {
+ const array = [...iterable];
+ for (let i = array.length - 1; i > 0; i--) {
+ const j = Math.floor(Math.random() * (i + 1));
+ [array[i], array[j]] = [array[j], array[i]];
+ }
+ return array;
+}
+
+const guys = [..."ABCDE"].map(name => new Person(name));
+const girls = [..."FGHIJ"].map(name => new Person(name));
+
+console.log("Guys");
+for (const guy of guys) {
+ guy.preferences = shuffle(girls);
+ console.log(`${guy.name}: ${guy.preferences.map(p => p.name).join()}`)
+}
+
+console.log("\nGirls");
+for (const girl of girls) {
+ girl.preferences = shuffle(guys);
+ console.log(`${girl.name}: ${girl.preferences.map(p => p.name).join()}`)
+}
+
+stableMarriage(guys, girls);
+
+console.log("\nPairings");
+for (const guy of guys) {
+ console.log(`${guy.name}: ${guy.fiance.name}`);
+}
+

chapters/decision_problems/stable_marriage/stable_marriage.md

@@ -34,6 +34,9 @@ I am incredibly interested to see what you guys do and how you implement the alg
 {% sample lang="cpp" %}
 ### C++
 [import, lang:"c_cpp"](code/c++/stable_marriage.cpp)
+{% sample lang="js" %}
+### JavaScript
+[import, lang:"javascript"](code/javascript/stable-marriage.js)
 {% sample lang="cs" %}
 ### C# #
 GaleShapleyAlgorithm.cs