JavaScript Loops : A Detailed Guide

for (initialization; condition; increment) {
  // code to be executed
}

for (let i = 0; i < 5; i++) {
  console.log(i);
}

while (condition) {
  // code to be executed
}

let i = 0;
while (i < 5) {
  console.log(i);
  i++;
}

do {
  // code to be executed
} while (condition);

let i = 0;
do {
  console.log(i);
  i++;
} while (i < 5);

for (key in object) {
  // code to be executed
}

const person = {
  name: 'Alice',
  age: 30,
  city: 'Wonderland'
};

for (let key in person) {
  console.log(key + ': ' + person[key]);
}

for (let value of iterable) {
  // code to be executed
}

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

for (let number of numbers) {
  console.log(number);
}

for (let i = 0; i < outerLimit; i++) {
  for (let j = 0; j < innerLimit; j++) {
    // code to be executed
  }
}

for (let i = 0; i < 3; i++) {
  for (let j = 0; j < 3; j++) {
    console.log(`i: ${i}, j: ${j}`);
  }
}

// Arrays are used to store multiple values in a single variable.
// They are indexed collections, which means each element is accessed via an index.

const numbers = [1, 2, 3, 4, 5]; // An array of numbers

console.log("Initial array:", numbers);

// Accessing Elements
console.log("First element:", numbers[0]); // Output: 1
console.log("Second element:", numbers[1]); // Output: 2

// Adding Elements
// Push adds an element to the end of the array
numbers.push(6);
console.log("After push:", numbers); // Output: [1, 2, 3, 4, 5, 6]

// Unshift adds an element to the beginning of the array
numbers.unshift(0);
console.log("After unshift:", numbers); // Output: [0, 1, 2, 3, 4, 5, 6]

// Removing Elements
// Pop removes the last element of the array
numbers.pop();
console.log("After pop:", numbers); // Output: [0, 1, 2, 3, 4, 5]

// Shift removes the first element of the array
numbers.shift();
console.log("After shift:", numbers); // Output: [1, 2, 3, 4, 5]

// Iterating Over Arrays
// Using a for loop
for (let i = 0; i < numbers.length; i++) {
  console.log("Element at index", i, ":", numbers[i]);
}

// Using for...of loop
for (let num of numbers) {
  console.log("Value:", num);
}

// Using forEach() method
numbers.forEach((num, index) => {
  console.log("Element at index", index, ":", num);
});

// Common Array Methods
// slice creates a shallow copy of a portion of an array
const slicedArray = numbers.slice(1, 4);
console.log("Sliced array:", slicedArray); // Output: [2, 3, 4]

// splice changes the contents of an array by removing or replacing elements
numbers.splice(2, 1, 10); // Removes 1 element at index 2 and adds 10
console.log("After splice:", numbers); // Output: [1, 2, 10, 4, 5]

// concat merges two or more arrays
const moreNumbers = [7, 8, 9];
const combinedArray = numbers.concat(moreNumbers);
console.log("Combined array:", combinedArray); // Output: [1, 2, 10, 4, 5, 7, 8, 9]

// map creates a new array with the results of calling a provided function on every element
const doubledNumbers = numbers.map(num => num * 2);
console.log("Doubled numbers:", doubledNumbers); // Output: [2, 4, 20, 8, 10]

// filter creates a new array with all elements that pass the test implemented by the provided function
const evenNumbers = numbers.filter(num => num % 2 === 0);
console.log("Even numbers:", evenNumbers); // Output: [2, 10, 4]

// reduce applies a function against an accumulator and each element to reduce it to a single value
const sum = numbers.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
console.log("Sum of numbers:", sum); // Output: 22

// find returns the first element that satisfies the provided testing function
const firstGreaterThanFive = numbers.find(num => num > 5);
console.log("First number greater than 5:", firstGreaterThanFive); // Output: 10

// sort sorts the elements of an array in place
const sortedNumbers = numbers.slice().sort((a, b) => a - b); // Sorts in ascending order
console.log("Sorted numbers:", sortedNumbers); // Output: [1, 2, 4, 5, 10]

// reverse reverses the elements of an array in place
const reversedNumbers = numbers.slice().reverse();
console.log("Reversed numbers:", reversedNumbers); // Output: [5, 4, 10, 2, 1]

// length property gives the number of elements in the array
console.log("Length of array:", numbers.length); // Output: 5

// Checking if a value is in the array
const containsThree = numbers.includes(3);
console.log("Array contains 3:", containsThree); // Output: true

const indexOfThree = numbers.indexOf(3);
console.log("Index of 3:", indexOfThree); // Output: 2

// Joining array elements into a string
const joinedString = numbers.join(", ");
console.log("Joined string:", joinedString); // Output: "1, 2, 10, 4, 5"

function multiplyMatrices(A, B) {
  const rowsA = A.length;
  const colsA = A[0].length;
  const colsB = B[0].length;
  
  let result = Array.from({ length: rowsA }, () => Array(colsB).fill(0));
  
  for (let i = 0; i < rowsA; i++) {
    for (let j = 0; j < colsB; j++) {
      for (let k = 0; k < colsA; k++) {
        result[i][j] += A[i][k] * B[k][j];
      }
    }
  }
  return result;
}

const A = [
  [1, 2, 3],
  [4, 5, 6]
];

const B = [
  [7, 8],
  [9, 10],
  [11, 12]
];

console.log(multiplyMatrices(A, B));

// Output [ [ 58, 64 ], [ 139, 154 ] ]

function spiralOrder(matrix) {
  const result = [];
  const rows = matrix.length;
  const cols = matrix[0].length;
  let top = 0, bottom = rows - 1;
  let left = 0, right = cols - 1;

  while (top <= bottom && left <= right) {
    for (let i = left; i <= right; i++) result.push(matrix[top][i]);
    top++;
    for (let i = top; i <= bottom; i++) result.push(matrix[i][right]);
    right--;
    if (top <= bottom) {
      for (let i = right; i >= left; i--) result.push(matrix[bottom][i]);
      bottom--;
    }
    if (left <= right) {
      for (let i = bottom; i >= top; i--) result.push(matrix[i][left]);
      left++;
    }
  }
  return result;
}

const matrix = [
  [1, 2, 3, 4],
  [5, 6, 7, 8],
  [9, 10, 11, 12]
];

console.log(spiralOrder(matrix));
/*
Output 
[
   1,  2,  3, 4, 8,
  12, 11, 10, 9, 5,
   6,  7
]
*/

function generatePascalTriangle(n) {
  const result = [];
  
  for (let i = 0; i < n; i++) {
    const row = Array(i + 1).fill(1);
    for (let j = 1; j < i; j++) {
      row[j] = result[i - 1][j - 1] + result[i - 1][j];
    }
    result.push(row);
  }
  
  return result;
}

console.log(generatePascalTriangle(5));

// Output - [ [ 1 ], [ 1, 1 ], [ 1, 2, 1 ], [ 1, 3, 3, 1 ], [ 1, 4, 6, 4, 1 ] ]

function sieveOfEratosthenes(limit) {
  const primes = Array(limit + 1).fill(true);
  primes[0] = primes[1] = false;
  
  for (let p = 2; p * p <= limit; p++) {
    if (primes[p]) {
      for (let i = p * p; i <= limit; i += p) {
        primes[i] = false;
      }
    }
  }
  
  return primes.map((isPrime, num) => isPrime ? num : -1).filter(num => num !== -1);
}

console.log(sieveOfEratosthenes(30));

/* 
Output
[
   2,  3,  5,  7, 11,
  13, 17, 19, 23, 29
]
*/

function fibonacci(n) {
  if (n <= 1) return n;
  const dp = Array(n + 1).fill(0);
  dp[1] = 1;
  
  for (let i = 2; i <= n; i++) {
    dp[i] = dp[i - 1] + dp[i - 2];
  }
  
  return dp[n];
}

console.log(fibonacci(10));

// Output - 55