♻️ Update

Author: UltiRequiem

deps.ts

@@ -1,6 +1,7 @@
 export {
   assert,
   assertEquals,
+  assertFalse,
   assertNotEquals,
   assertThrows,
-} from "https://deno.land/std@0.137.0/testing/asserts.ts";
+} from "https://deno.land/std@0.139.0/testing/asserts.ts";

src/language/average.bench.ts

@@ -1,13 +1,11 @@
-// Benchmarking Lover
+import { average, averageIterative } from "./average.ts";
 
-import { average, averageFor } from "./average.ts";
+const BENCH_DATA = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 
-const BENCH_DATA = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] as const;
-
-Deno.bench("[average] Reduce", { group: "average" }, () => {
+Deno.bench("Reduce", { group: "average" }, () => {
   average(BENCH_DATA);
 });
 
-Deno.bench("[average] For", { group: "average" }, () => {
-  averageFor(BENCH_DATA);
+Deno.bench("Iterative", { group: "average" }, () => {
+  averageIterative(BENCH_DATA);
 });

src/language/average.ts

@@ -2,11 +2,11 @@ export function average(array: readonly number[]) {
   return array.reduce((a, b) => a + b) / array.length;
 }
 
-export function averageFor(array: readonly number[]) {
+export function averageIterative(array: readonly number[]) {
   let count = 0;
 
-  for (const value of array) {
-    count += value;
+  for (let index = 0; index < count; index++) {
+    count += array[index];
   }
 
   return count / array.length;

src/language/chessboard.ts

@@ -1,5 +1,6 @@
 export function chessboard(length = 8) {
   let result = "";
+
   const newLines = length - 1;
 
   for (let line = 0; line < length; line++) {

src/language/deep_equal.test.ts

@@ -1,20 +1,26 @@
 import { deepEqual } from "./deep_equal.ts";
-import { assert } from "../../deps.ts";
+import { assert, assertFalse } from "../../deps.ts";
 
-Deno.test("[deepEqual]", () => {
+Deno.test("deepEqual", () => {
   const obj = { here: { is: "an" }, object: 2 };
 
   assert(deepEqual(obj, obj));
 
+  assert(deepEqual([1, 2, 3], [1, 2, 3]));
+
+  assertFalse(deepEqual([1, 2, 3], [1, 3]));
+
+  assertFalse(deepEqual([2, 1], [1, 2]));
+
   assert(deepEqual("a", "a"));
 
-  assert(!deepEqual(23, 34));
+  assertFalse(deepEqual(23, 34));
 
-  assert(!deepEqual(obj, { here: 1, object: 2 }));
+  assertFalse(deepEqual(obj, { here: 1, object: 2 }));
 
   assert(deepEqual(obj, { here: { is: "an" }, object: 2 }));
 
-  assert(!deepEqual({ a: "b" }, { c: "d" }));
+  assertFalse(deepEqual({ a: "b" }, { c: "d" }));
 
-  assert(!deepEqual({ hey: "rosa", chales: "diah" }, { me: "eliaz" }));
+  assertFalse(deepEqual({ hey: "rosa", chales: "diah" }, { me: "eliaz" }));
 });

src/language/deep_equal.ts

@@ -17,7 +17,7 @@ export function deepEqual(first: any, second: any) {
     return first === second;
   }
 
-  const [firstKeys, secondKeys] = [Object.keys(first), Object.keys(second)];
+  const [firstKeys, secondKeys] = [first, second].map(Object.keys);
 
   if (firstKeys.length !== secondKeys.length) {
     return false;
@@ -28,7 +28,7 @@ export function deepEqual(first: any, second: any) {
       return false;
     }
 
-    if (!deepEqual(first[key] as unknown, second[key])) {
+    if (!deepEqual(first[key], second[key])) {
       return false;
     }
   }

src/language/fizzbuzz.test.ts

@@ -1,20 +1,18 @@
-import { fizzBuzz, isDivisbleBy } from "./fizzbuzz.ts";
-import { assert, assertEquals } from "../../deps.ts";
+import { divisibleBy, fizzBuzz } from "./fizzbuzz.ts";
+import { assert, assertEquals, assertFalse } from "../../deps.ts";
 
 Deno.test("[fizzBuzz]", () => {
-  const result = fizzBuzz(15);
-
   const F = "Fizz";
   const B = "Buzz";
-  const FB = `${F}${B}` as const;
+  const FB = "FizzBuzz";
 
   const expected = [1, 2, F, 4, B, F, 7, 8, F, B, 11, F, 13, 14, F, FB];
 
-  assertEquals(result, expected);
+  assertEquals(fizzBuzz(15), expected);
 });
 
 Deno.test("[isDivisbleBy]", () => {
-  assert(isDivisbleBy(15, 3));
-  assert(isDivisbleBy(15, 5));
-  assert(!isDivisbleBy(15, 7));
+  assert(divisibleBy(15, 3));
+  assert(divisibleBy(15, 5));
+  assertFalse(divisibleBy(15, 7));
 });

src/language/fizzbuzz.ts

@@ -1,13 +1,11 @@
-export const isDivisbleBy = (n: number, divisor: number) => n % divisor === 0;
+export const divisibleBy = (n: number, divisor: number) => n % divisor === 0;
 
 export function fizzBuzz(max = 100) {
   const result = [];
 
   for (let number = 1; number <= max; number++) {
-    const fizz = isDivisbleBy(number, 3);
-    const buzz = isDivisbleBy(number, 5);
-
-    const fizzBuzz = fizz && buzz;
+    const fizz = divisibleBy(number, 3);
+    const buzz = divisibleBy(number, 5);
 
     if (fizz) {
       result.push("Fizz");
@@ -17,7 +15,7 @@ export function fizzBuzz(max = 100) {
       result.push(number);
     }
 
-    if (fizzBuzz) {
+    if (fizz && buzz) {
       result.push("FizzBuzz");
     }
   }

src/language/high_order.test.ts

@@ -1,14 +1,14 @@
 import { isEven } from "./is_even.ts";
-import { assert, assertThrows } from "../../deps.ts";
+import { assert, assertFalse, assertThrows } from "../../deps.ts";
 
 Deno.test("[isEven]", () => {
   assert(isEven(2));
-  assert(!isEven(11));
+  assertFalse(isEven(11));
   assert(isEven(24));
   assert(isEven(24));
   assert(isEven(50));
-  assert(!isEven(75));
-  assert(!isEven(75));
+  assertFalse(isEven(75));
+  assertFalse(isEven(75));
 
   assertThrows(() => isEven(-3));