add all code template and solutions

Author: Vkube

Makefile

@@ -0,0 +1,6 @@
+install:
+	npm install
+lint:
+	npx eslint .
+prettier:
+	npx prettier --write .

book/Хавербеке_М_Выразительный_JavaScript.pdf

@@ -2,10 +2,10 @@
 // используя для разделения строк символы новой строки. В каждой позиции
 // сетки стоит либо пробел, либо символ"#".
 // Эти символы должны располагаться в шахматном порядке.
-var size = 8;
-var symbol = "";
-for (var y = 0; y < size; y++) {
-  for (var x = 0; x < size; x++) {
+const size = 8;
+let symbol = "";
+for (let y = 0; y < size; y++) {
+  for (let x = 0; x < size; x++) {
     if ((x + y) % 2 == 0) {
       symbol += " ";
     } else {
@@ -15,4 +15,3 @@ for (var y = 0; y < size; y++) {
   symbol += "\n";
 }
 console.log(symbol);
-

build/Chapter02/Chessboard.js

@@ -1,5 +1,5 @@
-for (var i = 1; i <= 100; i++) {
-  var result = "";
+for (let i = 1; i <= 100; i++) {
+  let result = "";
   if (i % 3 == 0) result += "Fizz";
   else if (i % 5 == 0) result += "Buzz";
   console.log(result || i);

build/Chapter02/FizzBuzz.js

@@ -1,4 +1,4 @@
-var char = "#";
-for (var i = char; char.length < 8; char += "#") {
+let char = "#";
+for (let i = char; char.length < 8; char += "#") {
   console.log(char);
 }

build/Chapter02/Looping a triangle.js

@@ -4,7 +4,7 @@
 function min(num1, num2) {
   return num1 < num2 ? num1 : num2;
 }
-let result = min(0, 10);
+const result = min(0, 10);
 console.log(result);
 
-module.exports=min;
+module.exports = min;

build/Chapter03/Minimum.js

@@ -2,17 +2,13 @@
 // санию. Функция должна принимать один параметр (положительное целое
 // число) и возвращать логическое значение.
 function isEven(num1) {
-    if (num1 == 0)
-        return true;
-    else if (num1 == 1)
-        return false;
-    else if (num1 < 0)
-        return isEven(-num1);
-    else
-        return isEven(num1 - 2);
+  if (num1 == 0) return true;
+  if (num1 == 1) return false;
+  if (num1 < 0) return isEven(-num1);
+  return isEven(num1 - 2);
 }
-var result = isEven(50);
-var resultForNum = isEven(75);
+const result = isEven(50);
+const resultForNum = isEven(75);
 console.log(result, resultForNum);
 
-module.exports=isEven;
+module.exports = isEven;

build/Chapter03/Recursion.js

@@ -1,16 +1,16 @@
 function countChar(word, letter) {
-    var count = 0;
-    for (var i = 0; i < word.length; i++) {
-        if (word.charAt(i) == letter) {
-            count++;
-        }
+  let count = 0;
+  for (let i = 0; i < word.length; i++) {
+    if (word.charAt(i) == letter) {
+      count++;
     }
-    return count;
+  }
+  return count;
 }
 function countBs(string) {
-    return countChar(string, "B");
+  return countChar(string, "B");
 }
-var result = countBs('Bdcd');
+const result = countBs("Bdcd");
 console.log(result);
-module.exports=countBs();
-module.exports=countChar();
+module.exports = countBs();
+module.exports = countChar();

build/Chapter03/bean_counting.js

@@ -1,20 +1,20 @@
-//Сумма диапазона
-//Напишите функцию range, котрая принимает два аргумента start и end
+// Сумма диапазона
+// Напишите функцию range, котрая принимает два аргумента start и end
 // возвращает массив содержащий все числа от start до end
-var range = function (start, end) {
-    var arr = [];
-    for (var i = start; i <= end; i++) {
-        arr.push(i);
-    }
-    return arr;
+const range = function (start, end) {
+  const arr = [];
+  for (let i = start; i <= end; i++) {
+    arr.push(i);
+  }
+  return arr;
 };
 function sum(array) {
-    var total = 0;
-    for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
-        var value = array_1[_i];
-        total += value;
-    }
-    return total;
+  let total = 0;
+  for (let _i = 0, array_1 = array; _i < array_1.length; _i++) {
+    const value = array_1[_i];
+    total += value;
+  }
+  return total;
 }
 console.log(sum(range(1, 10)));
-//console.log()
+// console.log()

build/Chapter04/range.js

@@ -1,11 +1,11 @@
-//Напишите две функции reverseArray и reverseArrayInPlace
+// Напишите две функции reverseArray и reverseArrayInPlace
 // Первая функция reverseArray принимает массив в качестве аргумента и создает новый массив, содержащий те же элементы в обратном порядке.
-//Вторая reverseArrayInPlace делает то же самое что и метод reverse.
-var reverseArray = function (array) {
-    const newArr = [];
-    for (let i = array.length - 1; i < 0; i--) {
-        newArr.push(i);
-    }
-    return newArr;
+// Вторая reverseArrayInPlace делает то же самое что и метод reverse.
+const reverseArray = function (array) {
+  const newArr = [];
+  for (let i = array.length - 1; i < 0; i--) {
+    newArr.push(i);
+  }
+  return newArr;
 };
 console.log(reverseArray([1002, 2232, 22323, 34]));

build/Chapter04/reversing_array.js

@@ -0,0 +1,9 @@
+function min(a, b) {
+  if (a < b) return a;
+  else return b;
+}
+
+console.log(min(0, 10));
+// → 0
+console.log(min(0, -10));
+// → -10

solution/Chapter03/solution3.1.js

@@ -0,0 +1,13 @@
+function isEven(n) {
+  if (n == 0) return true;
+  else if (n == 1) return false;
+  else if (n < 0) return isEven(-n);
+  else return isEven(n - 2);
+}
+
+console.log(isEven(50));
+// → true
+console.log(isEven(75));
+// → false
+console.log(isEven(-1));
+// → false

solution/Chapter03/solution3.2.js

@@ -0,0 +1,18 @@
+function countChar(string, ch) {
+  let counted = 0;
+  for (let i = 0; i < string.length; i++) {
+    if (string[i] == ch) {
+      counted += 1;
+    }
+  }
+  return counted;
+}
+
+function countBs(string) {
+  return countChar(string, "B");
+}
+
+console.log(countBs("BBC"));
+// → 2
+console.log(countChar("kakkerlak", "k"));
+// → 4

solution/Chapter03/solution3.3.js

@@ -0,0 +1,25 @@
+function range(start, end, step = start < end ? 1 : -1) {
+  let array = [];
+
+  if (step > 0) {
+    for (let i = start; i <= end; i += step) array.push(i);
+  } else {
+    for (let i = start; i >= end; i += step) array.push(i);
+  }
+  return array;
+}
+
+function sum(array) {
+  let total = 0;
+  for (let value of array) {
+    total += value;
+  }
+  return total;
+}
+
+console.log(range(1, 10));
+// → [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+console.log(range(5, 2, -1));
+// → [5, 4, 3, 2]
+console.log(sum(range(1, 10)));
+// → 55

solution/Chapter04/solution4.1.js

@@ -0,0 +1,23 @@
+function reverseArray(array) {
+  let output = [];
+  for (let i = array.length - 1; i >= 0; i--) {
+    output.push(array[i]);
+  }
+  return output;
+}
+
+function reverseArrayInPlace(array) {
+  for (let i = 0; i < Math.floor(array.length / 2); i++) {
+    let old = array[i];
+    array[i] = array[array.length - 1 - i];
+    array[array.length - 1 - i] = old;
+  }
+  return array;
+}
+
+console.log(reverseArray(["A", "B", "C"]));
+// → ["C", "B", "A"];
+let arrayValue = [1, 2, 3, 4, 5];
+reverseArrayInPlace(arrayValue);
+console.log(arrayValue);
+// → [5, 4, 3, 2, 1]

solution/Chapter04/solution4.2.js

@@ -0,0 +1,34 @@
+function arrayToList(array) {
+  let list = null;
+  for (let i = array.length - 1; i >= 0; i--) {
+    list = { value: array[i], rest: list };
+  }
+  return list;
+}
+
+function listToArray(list) {
+  let array = [];
+  for (let node = list; node; node = node.rest) {
+    array.push(node.value);
+  }
+  return array;
+}
+
+function prepend(value, list) {
+  return { value, rest: list };
+}
+
+function nth(list, n) {
+  if (!list) return undefined;
+  else if (n == 0) return list.value;
+  else return nth(list.rest, n - 1);
+}
+
+console.log(arrayToList([10, 20]));
+// → {value: 10, rest: {value: 20, rest: null}}
+console.log(listToArray(arrayToList([10, 20, 30])));
+// → [10, 20, 30]
+console.log(prepend(10, prepend(20, null)));
+// → {value: 10, rest: {value: 20, rest: null}}
+console.log(nth(arrayToList([10, 20, 30]), 1));
+// → 20

solution/Chapter04/solution4.3.js

@@ -0,0 +1,25 @@
+function deepEqual(a, b) {
+  if (a === b) return true;
+
+  if (a == null || typeof a != "object" || b == null || typeof b != "object")
+    return false;
+
+  let keysA = Object.keys(a),
+    keysB = Object.keys(b);
+
+  if (keysA.length != keysB.length) return false;
+
+  for (let key of keysA) {
+    if (!keysB.includes(key) || !deepEqual(a[key], b[key])) return false;
+  }
+
+  return true;
+}
+
+let obj = { here: { is: "an" }, object: 2 };
+console.log(deepEqual(obj, obj));
+// → true
+console.log(deepEqual(obj, { here: 1, object: 2 }));
+// → false
+console.log(deepEqual(obj, { here: { is: "an" }, object: 2 }));
+// → true

solution/Chapter04/solution4.4.js

@@ -0,0 +1,4 @@
+let arrays = [[1, 2, 3], [4, 5], [6]];
+
+console.log(arrays.reduce((flat, current) => flat.concat(current), []));
+// → [1, 2, 3, 4, 5, 6]

solution/Chapter05/solution5.1.js

@@ -0,0 +1,15 @@
+function loop(start, test, update, body) {
+  for (let value = start; test(value); value = update(value)) {
+    body(value);
+  }
+}
+
+loop(
+  3,
+  (n) => n > 0,
+  (n) => n - 1,
+  console.log
+);
+// → 3
+// → 2
+// → 1

solution/Chapter05/solution5.2.js

@@ -0,0 +1,17 @@
+function every(array, predicate) {
+  for (let element of array) {
+    if (!predicate(element)) return false;
+  }
+  return true;
+}
+
+function every2(array, predicate) {
+  return !array.some((element) => !predicate(element));
+}
+
+console.log(every([1, 3, 5], (n) => n < 10));
+// → true
+console.log(every([2, 4, 16], (n) => n < 10));
+// → false
+console.log(every([], (n) => n < 10));
+// → true

solution/Chapter05/solution5.3.js

@@ -0,0 +1,15 @@
+function dominantDirection(text) {
+  let counted = countBy(text, (char) => {
+    let script = characterScript(char.codePointAt(0));
+    return script ? script.direction : "none";
+  }).filter(({ name }) => name != "none");
+
+  if (counted.length == 0) return "ltr";
+
+  return counted.reduce((a, b) => (a.count > b.count ? a : b)).name;
+}
+
+console.log(dominantDirection("Hello!"));
+// → ltr
+console.log(dominantDirection("Hey, مساء الخير"));
+// → rtl

solution/Chapter05/solution5.4.js

@@ -0,0 +1,25 @@
+class Vec {
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+
+  plus(other) {
+    return new Vec(this.x + other.x, this.y + other.y);
+  }
+
+  minus(other) {
+    return new Vec(this.x - other.x, this.y - other.y);
+  }
+
+  get length() {
+    return Math.sqrt(this.x * this.x + this.y * this.y);
+  }
+}
+
+console.log(new Vec(1, 2).plus(new Vec(2, 3)));
+// → Vec{x: 3, y: 5}
+console.log(new Vec(1, 2).minus(new Vec(2, 3)));
+// → Vec{x: -1, y: -1}
+console.log(new Vec(3, 4).length);
+// → 5