const numbers = [1, 2, 3, 4, 5];

const result = numbers.filter(num => num % 2 === 0)
                     .map(num => num ** 2)
                     .reduce((acc, val) => acc + val, 0);

console.log(result);

const numbers = [1, 2, 3, 4, 5];function recursiveMaxSubarraySum(nums, startIndex = 0, currentSum = 0, maxSum = -Infinity) {
  if (startIndex === nums.length) {
    return maxSum;
  }

  currentSum = Math.max(nums[startIndex], currentSum + nums[startIndex]);
  maxSum = Math.max(currentSum, maxSum);

  return recursiveMaxSubarraySum(nums, startIndex + 1, currentSum, maxSum);
}

const result = recursiveMaxSubarraySum([-2, 1, -3, 4, -1, 2, 1, -5, 4]);

console.log(result);

const numbers = [1, 2, 3, 4, 5];

const sum = numbers.reduce((acc, curr) => {
  setTimeout(() => {
    acc += curr;
  }, 0);
  return acc;
}, 0);

console.log(sum);

function* generatorQuiz() {
  yield 1;
}

const generator = generatorQuiz();

setTimeout(() => console.log(generator.next().value), 0);

for (const value of generator) {
  console.log(value);
}

const obj = {
  0: 'a',
  1: 'b',
  length: 2
};

const result = Array.from(obj);

console.log(result);

function recursiveReverseString(str) {
  return str === "" ? str : recursiveReverseString(str.substr(1)) + str[0];
}

const result = recursiveReverseString("hello");

console.log(result);

function recursiveBinarySearch(arr, target, start = 0, end = arr.length - 1) {
  if (start > end) {
    return -1;
  }

  const mid = Math.floor((start + end) / 2);

  if (arr[mid] === target) {
    return mid;
  } else if (arr[mid] < target) {
    return recursiveBinarySearch(arr, target, mid + 1, end);
  } else {
    return recursiveBinarySearch(arr, target, start, mid - 1);
  }
}

const result = recursiveBinarySearch([1, 2, 3, 4, 5, 6, 7, 8, 9], 6);

console.log(result);

function recursivePalindromeCheck(str) {
  if (str.length <= 1) {
    return true;
  }

  return str[0] === str[str.length - 1] && recursivePalindromeCheck(str.slice(1, -1));
}

const result = recursivePalindromeCheck("radar");

console.log(result);

function recursiveFibonacci(n) {
  return n <= 1 ? n : recursiveFibonacci(n - 1) + recursiveFibonacci(n - 2);
}

const result = recursiveFibonacci(6);

console.log(result);

function asyncSum(arr) {
  return arr.reduce(async (acc, num) => (await acc) + num, Promise.resolve(0));
}

async function computeTotal() {
  const result = await asyncSum([1, 2, 3, 4, 5]);
  console.log(result);
}

computeTotal();

var foo = {};
var bar = Object.create(foo);

foo.a = 1;

console.log(bar.a);

function Animal() {}
const dog = new Animal();
console.log(dog.constructor === Animal);

function Shape() {}
function Circle(radius) {}
Circle.prototype = Object.create(Shape.prototype);
const shape = new Shape();
console.log(shape instanceof Circle);

function Animal() {}
function Dog() {}
Dog.prototype = Object.create(Animal.prototype);
const rover = new Dog();
console.log(rover.hasOwnProperty('constructor'));

function Shape() {}

function Circle(radius) {
  this.radius = radius;
}

Circle.prototype = Object.create(Shape.prototype);
Circle.prototype.constructor = Circle;

const shape = new Shape();
const circle = new Circle(5);

console.log(circle instanceof Circle);
console.log(circle instanceof Shape);
console.log(shape instanceof Circle);
console.log(shape instanceof Shape);

var x = 1;
function changeX() { x = 2; }
changeX();
console.log(x);

console.log(typeof null);

const string = "hello world";
const result = string.replace(/l/g, "");
console.log(result);

const obj = { a: 1, b: 2, c: 3 };
let result = "";
for (const [key, value] of Object.entries(obj)) {
  result += key + value;
}
console.log(result);

const array = [
  { name: 'John', score: 80 },
  { name: 'Jane', score: 95 },
  { name: 'Doe', score: 88 },
];

const result = array.every(obj => obj.score >= 80);

console.log(result);

const a = [1, 2, 3];
const b = a.slice(0, 2).push(4);
console.log(b);