Initial data commit

Task/100-doors/JavaScript/100-doors-1.js

@@ -0,0 +1,8 @@
+var doors=[];
+for (var i=0;i<100;i++)
+    doors[i]=false;
+for (var i=1;i<=100;i++)
+    for (var i2=i-1;i2<100;i2+=i)
+        doors[i2]=!doors[i2];
+for (var i=1;i<=100;i++)
+    console.log("Door %d is %s",i,doors[i-1]?"open":"closed")

Task/100-doors/JavaScript/100-doors-10.js

@@ -0,0 +1 @@
+[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Task/100-doors/JavaScript/100-doors-11.js

@@ -0,0 +1,40 @@
+"use strict";
+
+// Doors can be open or closed.
+const open = "O";
+const closed = "C";
+
+// There are 100 doors in a row that are all initially closed.
+const doorsCount = 100;
+const doors = [];
+for (let i = 0; i < doorsCount; doors[i] = closed, i++);
+
+// You make 100 passes by the doors, visiting every door and toggle the door (if
+// the door is closed, open it; if it is open, close it), according to the rules
+// of the task.
+for (let pass = 1; pass <= doorsCount; pass++)
+    for (let i = pass - 1; i < doorsCount; i += pass)
+        doors[i] = doors[i] == open ? closed : open;
+
+// Answer the question: what state are the doors in after the last pass?
+doors.forEach((v, i) =>
+    console.log(`Doors ${i + 1} are ${v == open ? 'opened' : 'closed'}.`));
+
+// Which are open, which are closed?
+let openKeyList = [];
+let closedKeyList = [];
+for (let door of doors.entries())
+    if (door[1] == open)
+        openKeyList.push(door[0] + 1);
+    else
+        closedKeyList.push(door[0] + 1);
+console.log("These are open doors: " + openKeyList.join(", ") + ".");
+console.log("These are closed doors: " + closedKeyList.join(", ") + ".");
+
+// Assert:
+const expected = [];
+for (let i = 1; i * i <= doorsCount; expected.push(i * i), i++);
+if (openKeyList.every((v, i) => v === expected[i]))
+    console.log("The task is solved.")
+else
+    throw "These aren't the doors you're looking for.";

Task/100-doors/JavaScript/100-doors-2.js

@@ -0,0 +1,58 @@
+(function (n) {
+    "use strict";
+    function finalDoors(n) {
+        var lstRange = range(1, n);
+        return lstRange
+            .reduce(function (a, _, k) {
+                var m = k + 1;
+                return a.map(function (x, i) {
+                    var j = i + 1;
+                    return [j, j % m ? x[1] : !x[1]];
+                });
+            }, zip(
+                lstRange,
+                replicate(n, false)
+            ));
+    };
+    function zip(xs, ys) {
+        return xs.length === ys.length ? (
+            xs.map(function (x, i) {
+                return [x, ys[i]];
+            })
+        ) : undefined;
+    }
+    function replicate(n, a) {
+        var v = [a],
+            o = [];
+        if (n < 1) return o;
+        while (n > 1) {
+            if (n & 1) o = o.concat(v);
+            n >>= 1;
+            v = v.concat(v);
+        }
+        return o.concat(v);
+    }
+    function range(m, n, delta) {
+        var d = delta || 1,
+            blnUp = n > m,
+            lng = Math.floor((blnUp ? n - m : m - n) / d) + 1,
+            a = Array(lng),
+            i = lng;
+        if (blnUp)
+            while (i--) a[i] = (d * i) + m;
+        else
+            while (i--) a[i] = m - (d * i);
+        return a;
+    }
+    return finalDoors(n)
+        .filter(function (tuple) {
+            return tuple[1];
+        })
+        .map(function (tuple) {
+            return {
+                door: tuple[0],
+                open: tuple[1]
+            };
+        });
+
+})(100);

Task/100-doors/JavaScript/100-doors-3.js

@@ -0,0 +1,6 @@
+for (var door = 1; door <= 100; door++) {
+  var sqrt = Math.sqrt(door);
+  if (sqrt === (sqrt | 0)) {
+    console.log("Door %d is open", door);
+  }
+}

Task/100-doors/JavaScript/100-doors-4.js

@@ -0,0 +1,3 @@
+for(var door=1;i<10/*Math.sqrt(100)*/;i++){
+ console.log("Door %d is open",i*i);
+}

Task/100-doors/JavaScript/100-doors-5.js

@@ -0,0 +1,33 @@
+(function (n) {
+    "use strict";
+    return range(1, 100)
+        .filter(function (x) {
+            return integerFactors(x)
+                .length % 2;
+        });
+    function integerFactors(n) {
+        var rRoot = Math.sqrt(n),
+            intRoot = Math.floor(rRoot),
+            lows = range(1, intRoot)
+            .filter(function (x) {
+                return (n % x) === 0;
+            });
+        return lows.concat(lows.map(function (x) {
+                return n / x;
+            })
+            .reverse()
+            .slice((rRoot === intRoot) | 0));
+    }
+    function range(m, n, delta) {
+        var d = delta || 1,
+            blnUp = n > m,
+            lng = Math.floor((blnUp ? n - m : m - n) / d) + 1,
+            a = Array(lng),
+            i = lng;
+        if (blnUp)
+            while (i--) a[i] = (d * i) + m;
+        else
+            while (i--) a[i] = m - (d * i);
+        return a;
+    }
+})(100);

Task/100-doors/JavaScript/100-doors-6.js

@@ -0,0 +1,22 @@
+(function (n) {
+    "use strict";
+    return perfectSquaresUpTo(100);
+    function perfectSquaresUpTo(n) {
+        return range(1, Math.floor(Math.sqrt(n)))
+            .map(function (x) {
+                return x * x;
+            });
+    }
+    function range(m, n, delta) {
+        var d = delta || 1,
+            blnUp = n > m,
+            lng = Math.floor((blnUp ? n - m : m - n) / d) + 1,
+            a = Array(lng),
+            i = lng;
+        if (blnUp)
+            while (i--) a[i] = (d * i) + m;
+        else
+            while (i--) a[i] = m - (d * i);
+        return a;
+    }
+})(100);

Task/100-doors/JavaScript/100-doors-7.js

@@ -0,0 +1,9 @@
+Array.apply(null, { length: 100 })
+  .map((v, i) => i + 1)
+    .forEach(door => {
+      var sqrt = Math.sqrt(door);
+
+      if (sqrt === (sqrt | 0)) {
+        console.log("Door %d is open", door);
+      }
+    });

Task/100-doors/JavaScript/100-doors-8.js

@@ -0,0 +1,9 @@
+// Array comprehension style
+[ for (i of Array.apply(null, { length: 100 })) i ].forEach((_, i) => {
+  var door = i + 1
+  var sqrt = Math.sqrt(door);
+
+  if (sqrt === (sqrt | 0)) {
+    console.log("Door %d is open", door);
+  }
+});

Task/100-doors/JavaScript/100-doors-9.js

@@ -0,0 +1,29 @@
+(function (n) {
+
+
+    // ONLY PERFECT SQUARES HAVE AN ODD NUMBER OF INTEGER FACTORS
+    // (Leaving the door open at the end of the process)
+
+    return perfectSquaresUpTo(n);
+
+
+    // perfectSquaresUpTo :: Int -> [Int]
+    function perfectSquaresUpTo(n) {
+        return range(1, Math.floor(Math.sqrt(n)))
+            .map(x => x * x);
+    }
+
+
+    // GENERIC
+
+    // range(intFrom, intTo, optional intStep)
+    // Int -> Int -> Maybe Int -> [Int]
+    function range(m, n, step) {
+        let d = (step || 1) * (n >= m ? 1 : -1);
+
+        return Array.from({
+            length: Math.floor((n - m) / d) + 1
+        }, (_, i) => m + (i * d));
+    }
+
+})(100);