Sfide di live coding

Come si controlla se un oggetto JavaScript è vuoto?

Spiegazione: Un oggetto è vuoto quando non contiene proprietà proprie enumerabili. Object.keys(obj) restituisce i nomi di queste proprietà: se l’array ha lunghezza 0, l’oggetto è vuoto.

function isEmpty(obj) {
  return Object.keys(obj).length === 0;
}

console.log(isEmpty({})); // true
console.log(isEmpty({ a: 1 })); // false

Scrivi una funzione che inverte una stringa.

Spiegazione: Il modo più semplice è trasformare la stringa in un array di caratteri, usare reverse() e poi unire di nuovo i caratteri con join().

function reverseString(str) {
  return str.split('').reverse().join('');
}

console.log(reverseString('hello')); // 'olleh'

Scrivi una funzione che controlla se una stringa è un palindromo.

Spiegazione: Un palindromo è una parola o frase che si legge allo stesso modo da sinistra a destra e da destra a sinistra. Qui facciamo un controllo semplice: invertiamo la stringa e la confrontiamo con l’originale.

function isPalindrome(str) {
  const reversed = str.split('').reverse().join('');
  return str === reversed;
}

console.log(isPalindrome('racecar')); // true
console.log(isPalindrome('hello')); // false

Scrivi una funzione che trova il numero più grande in un array.

Spiegazione: Puoi scorrere l’array tenendo traccia del valore massimo trovato finora. In alternativa, puoi usare Math.max() insieme allo spread operator (...).

function findMaxNumber(arr) {
  if (arr.length === 0) return undefined; // Or throw an error
  return Math.max(...arr);
}

console.log(findMaxNumber([1, 5, 2, 9, 3])); // 9

Scrivi un programma che stampa i numeri da 1 a n. Per i multipli di tre stampa Fizz, per i multipli di cinque stampa Buzz, e per i numeri divisibili sia per tre sia per cinque stampa FizzBuzz.

Spiegazione: Questo esercizio classico verifica loop e condizioni. Bisogna scorrere i numeri da 1 a n e usare l’operatore modulo (%) per controllare la divisibilità per 3 e 5.

function fizzBuzz(n) {
  for (let i = 1; i <= n; i++) {
    if (i % 3 === 0 && i % 5 === 0) {
      console.log('FizzBuzz');
    } else if (i % 3 === 0) {
      console.log('Fizz');
    } else if (i % 5 === 0) {
      console.log('Buzz');
    } else {
      console.log(i);
    }
  }
}

fizzBuzz(15);

Scrivi una funzione che rimuove gli elementi duplicati da un array.

Spiegazione: Un modo moderno e conciso è usare un Set, che conserva solo valori unici. Puoi convertire l’array in un Set e poi di nuovo in un array.

function removeDuplicates(arr) {
  return [...new Set(arr)];
}

console.log(removeDuplicates([1, 2, 2, 3, 4, 4, 5])); // [1, 2, 3, 4, 5]

Scrivi una funzione che controlla se due stringhe sono anagrammi.

Spiegazione: Gli anagrammi sono parole formate riordinando le lettere di un’altra parola. Per verificarli, pulisci le stringhe, ordinale e confrontale. La pulizia rimuove i caratteri non alfanumerici e normalizza maiuscole e minuscole.

function isAnagram(str1, str2) {
  const clean = (str) => str.replace(/[^a-z0-9]/gi, '').toLowerCase();
  const sorted = (str) => clean(str).split('').sort().join('');
  
  return sorted(str1) === sorted(str2);
}

console.log(isAnagram('listen', 'silent')); // true
console.log(isAnagram('hello', 'world')); // false

Scrivi una funzione che calcola il fattoriale di un intero non negativo.

Spiegazione: Il fattoriale (n!) è il prodotto di tutti gli interi positivi minori o uguali a n. Si può calcolare iterativamente moltiplicando i numeri da 1 a n.

function factorial(n) {
  if (n < 0) return undefined; // Factorial is not defined for negative numbers
  if (n === 0) return 1;
  let result = 1;
  for (let i = 1; i <= n; i++) {
    result *= i;
  }
  return result;
}

console.log(factorial(5)); // 120

Scrivi una funzione che restituisce la somma di tutti i numeri in un array.

Spiegazione: Puoi usare reduce, ideale per accumulare un singolo valore a partire da un array. Richiede una callback e un valore iniziale, in questo caso 0.

function sumArray(arr) {
  return arr.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
}

console.log(sumArray([1, 2, 3, 4])); // 10

Scrivi una funzione che appiattisce un array annidato. Per semplicità, considera un solo livello di annidamento.

Spiegazione: Per un solo livello puoi usare Array.prototype.concat() con lo spread operator oppure flat() (ES2019).

function flattenArray(arr) {
  // Using flat() (simpler if ES2019+ is okay)
  // return arr.flat();

  // Using reduce and concat
  return arr.reduce((acc, val) => acc.concat(val), []);
}

console.log(flattenArray([1, [2, 3], 4, [5]])); // [1, 2, 3, 4, 5]

Scrivi una funzione che conta le vocali (a, e, i, o, u) in una stringa.

Spiegazione: Scorri la stringa senza distinguere maiuscole e minuscole, controlla se ogni carattere è una vocale e aggiorna un contatore.

function countVowels(str) {
  const vowels = 'aeiou';
  let count = 0;
  for (let char of str.toLowerCase()) {
    if (vowels.includes(char)) {
      count++;
    }
  }
  return count;
}

console.log(countVowels('Hello World')); // 3

Scrivi una funzione che converte una frase in title case, con la prima lettera di ogni parola maiuscola.

Spiegazione: Dividi la frase in parole, trasforma la prima lettera di ogni parola in maiuscolo, lascia il resto in minuscolo e poi ricomponi la frase.

function titleCase(str) {
  return str.toLowerCase().split(' ').map(word => {
    return word.charAt(0).toUpperCase() + word.slice(1);
  }).join(' ');
}

console.log(titleCase('i am a little tea pot')); // 'I Am A Little Tea Pot'

Dato un array di interi nums e un intero target, restituisci gli indici dei due numeri la cui somma è target.

Spiegazione: Un approccio comune usa una hash map per memorizzare numeri e indici durante lo scorrimento. Per ogni numero, controlla se target - current_number esiste già nella mappa.

function twoSum(nums, target) {
  const map = {};
  for (let i = 0; i < nums.length; i++) {
    const complement = target - nums[i];
    if (map[complement] !== undefined) {
      return [map[complement], i];
    }
    map[nums[i]] = i;
  }
  return []; // Or null, or throw error if no solution
}

console.log(twoSum([2, 7, 11, 15], 9)); // [0, 1]

Crea una funzione che restituisce una funzione contatore. Ogni chiamata alla funzione restituita deve incrementare e restituire il conteggio.

Spiegazione: L’esempio mostra le closure: la funzione interna può accedere alla variabile count dello scope esterno anche dopo la fine dell’esecuzione della funzione esterna.

function createCounter() {
  let count = 0;
  return function() {
    count++;
    return count;
  };
}

const counter1 = createCounter();
console.log(counter1()); // 1
console.log(counter1()); // 2
const counter2 = createCounter();
console.log(counter2()); // 1

Scrivi una funzione che trova il primo carattere non ripetuto in una stringa.

Spiegazione: Usa una hash map per contare le frequenze dei caratteri. Prima costruisci la mappa, poi scorri di nuovo la stringa e restituisci il primo carattere con conteggio pari a 1.

function firstNonRepeatingChar(str) {
  const charCount = {};
  for (const char of str) {
    charCount[char] = (charCount[char] || 0) + 1;
  }
  for (const char of str) {
    if (charCount[char] === 1) {
      return char;
    }
  }
  return null; // Or some indicator if all repeat
}

console.log(firstNonRepeatingChar('aabbcdeeff')); // 'c'
console.log(firstNonRepeatingChar('swiss')); // 'w'

Scrivi una funzione che divide un array in gruppi di una dimensione specificata.

Spiegazione: Scorri l’array prendendo slice della dimensione richiesta e inseriscile in un nuovo array. Gestisci anche il caso in cui l’ultimo blocco sia più piccolo.

function chunkArray(arr, size) {
  const chunked = [];
  let index = 0;
  while (index < arr.length) {
    chunked.push(arr.slice(index, index + size));
    index += size;
  }
  return chunked;
}

console.log(chunkArray([1, 2, 3, 4, 5, 6, 7], 3)); // [[1, 2, 3], [4, 5, 6], [7]]

Scrivi una funzione che determina se un numero è primo.

Spiegazione: Un numero primo è un numero naturale maggiore di 1 divisibile solo per 1 e per sé stesso. Scorri da 2 fino alla radice quadrata del numero e controlla la divisibilità, includendo casi limite come 1 e 2.

function isPrime(num) {
  if (num <= 1) return false;
  if (num <= 3) return true;

  if (num % 2 === 0 || num % 3 === 0) return false;

  for (let i = 5; i * i <= num; i = i + 6) {
    if (num % i === 0 || num % (i + 2) === 0) return false;
  }

  return true;
}

console.log(isPrime(7)); // true
console.log(isPrime(10)); // false

Scrivi una funzione che trova la parola più lunga in una frase.

Spiegazione: Dividi la stringa in parole e scorri l’array tenendo traccia della parola più lunga trovata finora, oppure della sua lunghezza.

function findLongestWord(str) {
  const words = str.split(' ');
  let longestWord = '';
  for (const word of words) {
    // Clean words if needed (e.g., remove punctuation)
    if (word.length > longestWord.length) {
      longestWord = word;
    }
  }
  return longestWord;
}

console.log(findLongestWord('The quick brown fox jumped over the lazy dog')); // 'jumped'

Implementa una tua versione di Array.prototype.map.

Spiegazione: map riceve una callback e crea un nuovo array applicando la callback a ogni elemento dell’array originale. La tua funzione deve scorrere l’array e costruire il nuovo array.

function myMap(arr, callback) {
  const mappedArray = [];
  for (let i = 0; i < arr.length; i++) {
    mappedArray.push(callback(arr[i], i, arr));
  }
  return mappedArray;
}

const numbers = [1, 4, 9];
const roots = myMap(numbers, Math.sqrt);
console.log(roots); // [1, 2, 3]

Implementa una tua versione di Array.prototype.filter.

Spiegazione: filter riceve una callback e crea un nuovo array con tutti gli elementi che superano il test definito dalla callback.

function myFilter(arr, callback) {
  const filteredArray = [];
  for (let i = 0; i < arr.length; i++) {
    if (callback(arr[i], i, arr)) {
        filteredArray.push(arr[i]);
    }
  }
  return filteredArray;
}

const words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];
const result = myFilter(words, word => word.length > 6);
console.log(result); // ['exuberant', 'destruction', 'present']

Implementa una tua versione di Array.prototype.reduce.

Spiegazione: reduce esegue una callback reducer su ogni elemento dell’array, passando ogni volta il risultato dell’iterazione precedente. Il risultato finale è un singolo valore. Gestisci anche l’argomento del valore iniziale.

function myReduce(arr, callback, initialValue) {
  let accumulator = initialValue;
  let startIndex = 0;

  if (initialValue === undefined) {
      if (arr.length === 0) throw new TypeError('Reduce of empty array with no initial value');
      accumulator = arr[0];
      startIndex = 1;
  }

  for (let i = startIndex; i < arr.length; i++) {
    accumulator = callback(accumulator, arr[i], i, arr);
  }
  return accumulator;
}

const array1 = [1, 2, 3, 4];
const sum = myReduce(array1, (acc, curr) => acc + curr, 0);
console.log(sum); // 10

Implementa una funzione Fibonacci usando la memoizzazione per ottimizzare le prestazioni.

Spiegazione: La sequenza di Fibonacci ripete molti calcoli. La memoizzazione salva i risultati delle chiamate costose e restituisce il valore in cache quando si ripresentano gli stessi input.

function memoizedFib() {
  const cache = {};

  function fib(n) {
    if (n in cache) {
      return cache[n];
    }
    if (n <= 1) {
      return n;
    }
    const result = fib(n - 1) + fib(n - 2);
    cache[n] = result;
    return result;
  }
  return fib;
}

const fibonacci = memoizedFib();
console.log(fibonacci(10)); // 55
console.log(fibonacci(40)); // 102334155 (much faster than non-memoized)

Scrivi una funzione che controlla se una stringa contenente parentesi {}[]() è bilanciata.

Spiegazione: Usa uno stack. Quando incontri una parentesi aperta, inseriscila nello stack. Quando incontri una parentesi chiusa, controlla che lo stack non sia vuoto e che l’ultimo elemento sia la parentesi aperta corrispondente. Alla fine, uno stack vuoto indica una stringa bilanciata.

function isBalanced(str) {
  const stack = [];
  const map = { '(': ')', '{': '}', '[': ']' };

  for (let char of str) {
    if (map[char]) {
      stack.push(char);
    } else if (Object.values(map).includes(char)) {
      if (stack.length === 0) return false;
      const lastOpen = stack.pop();
      if (map[lastOpen] !== char) return false;
    }
  }
  return stack.length === 0;
}

console.log(isBalanced('({[]})')); // true
console.log(isBalanced('([)]')); // false

Implementa una struttura dati Queue con i metodi enqueue (aggiunge in fondo) e dequeue (rimuove dall’inizio).

Spiegazione: Una coda segue il principio First-In, First-Out (FIFO). Puoi usare un array con push per enqueue e shift per dequeue.

class Queue {
  constructor() {
    this.items = [];
  }

  enqueue(element) {
    this.items.push(element);
  }

  dequeue() {
    if (this.isEmpty()) return 'Underflow';
    return this.items.shift();
  }

  front() {
    if (this.isEmpty()) return 'No elements in Queue';
    return this.items[0];
  }

  isEmpty() {
    return this.items.length === 0;
  }
}

const q = new Queue();
q.enqueue(10);
q.enqueue(20);
console.log(q.dequeue()); // 10
console.log(q.front()); // 20

Implementa una struttura dati Stack con i metodi push (aggiunge in cima) e pop (rimuove dalla cima).

Spiegazione: Uno stack segue il principio Last-In, First-Out (LIFO). Puoi usare un array con i metodi push e pop.

class Stack {
  constructor() {
    this.items = [];
  }

  push(element) {
    this.items.push(element);
  }

  pop() {
    if (this.isEmpty()) return 'Underflow';
    return this.items.pop();
  }

  peek() {
    return this.items[this.items.length - 1];
  }

  isEmpty() {
    return this.items.length === 0;
  }
}

const s = new Stack();
s.push(10);
s.push(20);
console.log(s.pop()); // 20
console.log(s.peek()); // 10

Dato un array con n numeri distinti presi da 0, 1, 2, ..., n, trova il numero mancante.

Spiegazione: La somma dei numeri da 0 a n si calcola con la formula n*(n+1)/2. Calcola anche la somma reale degli elementi dell’array: la differenza tra le due somme è il numero mancante.

function findMissingNumber(nums) {
  const n = nums.length;
  const expectedSum = n * (n + 1) / 2;
  const actualSum = nums.reduce((sum, num) => sum + num, 0);
  return expectedSum - actualSum;
}

console.log(findMissingNumber([3, 0, 1])); // 2
console.log(findMissingNumber([9, 6, 4, 2, 3, 5, 7, 0, 1])); // 8

Implementa una funzione debounce. Il debounce impedisce a una funzione di essere richiamata finché non è passato un certo intervallo senza nuove chiamate.

Spiegazione: Usa setTimeout e clearTimeout. A ogni chiamata della funzione debounced, cancella il timeout precedente e impostane uno nuovo. La funzione reale viene eseguita solo quando il timeout termina.

function debounce(func, delay) {
  let timeoutId;
  return function(...args) {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => {
      func.apply(this, args);
    }, delay);
  };
}

// Example usage:
const sayHello = () => console.log('Hello!');
const debouncedHello = debounce(sayHello, 1000);
debouncedHello(); // Called after 1 sec (if not called again)
debouncedHello(); // Resets timer
debouncedHello(); // Resets timer, will actually run 1 sec after this call.

Implementa una funzione throttle. Il throttle assicura che una funzione venga chiamata al massimo una volta in un intervallo specificato.

Spiegazione: Usa un flag per indicare se la chiamata è consentita. Se lo è, esegui la funzione, imposta il flag a false e usa setTimeout per ripristinarlo dopo l’intervallo.

function throttle(func, limit) {
  let inThrottle = false;
  return function(...args) {
    if (!inThrottle) {
      func.apply(this, args);
      inThrottle = true;
      setTimeout(() => inThrottle = false, limit);
    }
  };
}

// Example usage:
const logScroll = () => console.log('Scrolling...');
const throttledScroll = throttle(logScroll, 1000);
// window.addEventListener('scroll', throttledScroll); // Will log at most once per second.

Scrivi una funzione che prende una funzione con due argomenti e restituisce una versione currificata.

Spiegazione: Il currying trasforma una funzione con più argomenti in una sequenza di funzioni, ognuna con un solo argomento. f(a, b) diventa f(a)(b).

function curry(fn) {
  return function(a) {
    return function(b) {
      return fn(a, b);
    };
  };
}

function add(a, b) {
  return a + b;
}

const curriedAdd = curry(add);
const add5 = curriedAdd(5);
console.log(add5(3)); // 8
console.log(curriedAdd(10)(20)); // 30

Scrivi una funzione che esegue una deep clone di un oggetto JavaScript.

Spiegazione: Una copia superficiale copia solo le proprietà di primo livello. Una copia profonda copia ricorsivamente tutte le proprietà, inclusi oggetti e array annidati. JSON.parse(JSON.stringify(obj)) è una soluzione semplice ma limitata; un approccio ricorsivo è più solido.

function deepClone(obj) {
  // Simple version (with limitations)
  try {
      return JSON.parse(JSON.stringify(obj));
  } catch (e) {
      console.error("Cloning failed:", e);
      return null;
  }
  
  // More robust recursive (basic example):
  /*
  if (obj === null || typeof obj !== 'object') {
      return obj;
  }
  let clone = Array.isArray(obj) ? [] : {};
  for (let key in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, key)) {
          clone[key] = deepClone(obj[key]);
      }
  }
  return clone;
  */
}

const original = { a: 1, b: { c: 2 } };
const cloned = deepClone(original);
cloned.b.c = 3;
console.log(original.b.c); // 2 (proves it's a deep clone)
console.log(cloned.b.c); // 3

Come si ottiene un array di chiavi da un oggetto?

Spiegazione: Usa Object.keys(obj).

function getKeys(obj) {
  return Object.keys(obj);
}
console.log(getKeys({a: 1, b: 2})); // ['a', 'b']

Come si ottiene un array di valori da un oggetto?

Spiegazione: Usa Object.values(obj).

function getValues(obj) {
  return Object.values(obj);
}
console.log(getValues({a: 1, b: 2})); // [1, 2]

Come si controlla se un array contiene un valore specifico?

Spiegazione: Usa Array.prototype.includes(value).

function checkIncludes(arr, val) {
  return arr.includes(val);
}
console.log(checkIncludes([1, 2, 3], 2)); // true

Come si uniscono due array in uno solo?

Spiegazione: Usa lo spread operator (...) oppure Array.prototype.concat().

function mergeArrays(arr1, arr2) {
  return [...arr1, ...arr2];
}
console.log(mergeArrays([1, 2], [3, 4])); // [1, 2, 3, 4]

A cosa si riferisce this nello scope globale di un browser?

Spiegazione: Nel contesto di esecuzione globale, quindi fuori da qualsiasi funzione, this si riferisce all’oggetto globale, che nei browser è window.

console.log(this === window); // true (in a browser environment)

A cosa si riferisce this dentro un metodo di un oggetto?

Spiegazione: Quando una funzione viene chiamata come metodo di un oggetto, this si riferisce all’oggetto su cui il metodo è stato chiamato.

const myObject = {
  prop: 'Hello',
  greet() {
    return this.prop;
  }
};
console.log(myObject.greet()); // 'Hello'

Come gestiscono this le arrow function?

Spiegazione: Le arrow function non hanno un proprio contesto this. Ereditano this dallo scope lessicale in cui sono definite.

function MyClass() {
  this.value = 42;
  setTimeout(() => {
    console.log(this.value); // Logs 42 because 'this' is inherited
  }, 100);
}
new MyClass();

Quali sono le principali differenze tra let, const e var?

Spiegazione: var ha scope di funzione ed è soggetto a hoisting. let e const hanno scope di blocco e sono soggetti a hoisting, ma restano nella temporal dead zone fino alla dichiarazione. const deve essere inizializzato e non può essere riassegnato.

function scopeTest() {
  var a = 1;
  let b = 2;
  const c = 3;
  if (true) {
    var a = 10; // Re-declares and affects outer 'a'
    let b = 20; // New 'b' within block
    // const c = 30; // Would be a new 'c'
    console.log(a, b, c); // 10, 20, 3
  }
  console.log(a, b, c); // 10, 2, 3
}
scopeTest();

Spiega che cos’è una Promise in JavaScript.

Spiegazione: Una Promise è un oggetto che rappresenta il completamento, o il fallimento, di un’operazione asincrona e il suo valore finale. Può trovarsi in tre stati: pending, fulfilled o rejected.

const myPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('Success!');
    // reject('Error!');
  }, 1000);
});

myPromise
  .then(result => console.log(result))
  .catch(error => console.error(error));

In che modo async e await semplificano il lavoro con le Promise?

Spiegazione: async/await è zucchero sintattico sopra le Promise e rende il codice asincrono più simile al codice sincrono. Una funzione async restituisce sempre una Promise, mentre await sospende l’esecuzione finché la Promise non si risolve o viene rifiutata.

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function run() {
  console.log('Starting...');
  await delay(1000);
  console.log('Waited 1 second.');
  await delay(500);
  console.log('Waited another 0.5 seconds.');
  return 'Finished!';
}

run().then(console.log);

Come si converte una stringa in un numero?

Spiegazione: Usa parseInt(), parseFloat() oppure l’operatore unario più (+).

const str = '123.45';
console.log(parseInt(str)); // 123
console.log(parseFloat(str)); // 123.45
console.log(+str); // 123.45

Come si converte un numero in una stringa?

Spiegazione: Usa String(), number.toString() o la concatenazione con una stringa.

const num = 123;
console.log(String(num)); // '123'
console.log(num.toString()); // '123'
console.log('' + num); // '123'

Cosa fa JSON.stringify?

Spiegazione: Converte un oggetto o un valore JavaScript in una stringa JSON.

const obj = { name: 'Alice', age: 30 };
const jsonString = JSON.stringify(obj);
console.log(jsonString); // '{"name":"Alice","age":30}'

Cosa fa JSON.parse?

Spiegazione: Analizza una stringa JSON e costruisce il valore o l’oggetto JavaScript descritto da quella stringa.

const jsonString = '{"name":"Alice","age":30}';
const obj = JSON.parse(jsonString);
console.log(obj.name); // 'Alice'

Come si usa lo spread operator con gli array?

Spiegazione: Permette di espandere un iterabile, come un array, nei punti in cui sono attesi zero o più argomenti o elementi. È utile per copiare, unire e aggiungere elementi.

const arr1 = [1, 2];
const arr2 = [3, 4];
const combined = [...arr1, ...arr2]; // [1, 2, 3, 4]
const copy = [...arr1]; // [1, 2]

Come si usa lo spread operator con gli oggetti?

Spiegazione: Permette di copiare e unire proprietà di oggetti.

const obj1 = { a: 1, b: 2 };
const obj2 = { b: 3, c: 4 };
const merged = { ...obj1, ...obj2 }; // { a: 1, b: 3, c: 4 }
const copy = { ...obj1 }; // { a: 1, b: 2 }

Spiega il destructuring degli array con un esempio.

Spiegazione: È una sintassi che permette di estrarre valori da array e assegnarli a variabili distinte.

const [a, b] = [10, 20];
console.log(a); // 10
console.log(b); // 20

const [x, , z] = [1, 2, 3];
console.log(z); // 3

Spiega il destructuring degli oggetti con un esempio.

Spiegazione: Permette di estrarre proprietà da oggetti e assegnarle a variabili distinte.

const person = { name: 'Bob', age: 25 };
const { name, age } = person;
console.log(name); // 'Bob'
console.log(age); // 25

const { name: personName } = person;
console.log(personName); // 'Bob'

Come potresti implementare una versione base di Function.prototype.call?

Spiegazione: call invoca una funzione con un valore this specifico e argomenti passati singolarmente. Puoi collegare temporaneamente la funzione al contesto this, chiamarla e poi rimuoverla.

Function.prototype.myCall = function(context, ...args) {
  context = context || window;
  const uniqueId = Symbol(); // Use a unique key
  context[uniqueId] = this;
  const result = context[uniqueId](...args);
  delete context[uniqueId];
  return result;
}

function greet(greeting, punctuation) {
  console.log(`${greeting}, ${this.name}${punctuation}`);
}

greet.myCall({ name: 'Charlie' }, 'Hi', '!'); // Hi, Charlie!

Come potresti implementare una versione base di Function.prototype.apply?

Spiegazione: apply è simile a call, ma accetta gli argomenti come array.

Function.prototype.myApply = function(context, argsArray) {
  context = context || window;
  const uniqueId = Symbol();
  context[uniqueId] = this;
  const result = context[uniqueId](...(argsArray || []));
  delete context[uniqueId];
  return result;
}

function greet(greeting, punctuation) {
  console.log(`${greeting}, ${this.name}${punctuation}`);
}

greet.myApply({ name: 'David' }, ['Hello', '.']); // Hello, David.

Spiega brevemente l'Event Loop di JavaScript.

Spiegazione: JavaScript è a singolo thread, ma raggiunge la concorrenza usando un event loop. Lo stack di chiamate gestisce il codice sincrono. Le API web gestiscono operazioni asincrone (come setTimeout, fetch). Quando un'operazione asincrona termina, la sua callback va alla coda delle callback (o microtask queue per le Promise). L'event loop controlla costantemente se lo stack di chiamate è vuoto; se lo è, sposta la callback successiva dalla coda allo stack per l'esecuzione.

console.log('Start');

setTimeout(() => {
  console.log('Timeout Callback'); // Goes to Callback Queue
}, 0);

Promise.resolve().then(() => {
  console.log('Promise Resolved'); // Goes to Microtask Queue
});

console.log('End');

// Output Order: Start, End, Promise Resolved, Timeout Callback
// (Microtasks run before Macrotasks/Callbacks)

Implementa una funzione di ricerca binaria per un array ordinato.

Spiegazione: La ricerca binaria trova efficientemente un elemento in un array ordinato dividendo ripetutamente l'intervallo di ricerca a metà. Se il valore della chiave di ricerca è inferiore all'elemento al centro dell'intervallo, si restringe l'intervallo alla metà inferiore. Altrimenti, lo si restringe alla metà superiore. Si esegue questa operazione finché il valore non viene trovato o l'intervallo è vuoto.

function binarySearch(sortedArray, key) {
  let start = 0;
  let end = sortedArray.length - 1;

  while (start <= end) {
    let middle = Math.floor((start + end) / 2);

    if (sortedArray[middle] === key) {
      return middle; // Found
    } else if (sortedArray[middle] < key) {
      start = middle + 1; // Search right half
    } else {
      end = middle - 1; // Search left half
    }
  }
  return -1; // Not found
}

console.log(binarySearch([1, 3, 5, 7, 9, 11], 7)); // 3
console.log(binarySearch([1, 3, 5, 7, 9, 11], 2)); // -1

Implementa l'algoritmo Merge Sort.

Spiegazione: Merge Sort è un algoritmo divide-et-impera. Divide l'array di input in due metà, si richiama su entrambe le metà, quindi unisce le due metà ordinate. La funzione di unione è cruciale; combina due sottoarray ordinati in un unico array ordinato.

function mergeSort(arr) {
  if (arr.length <= 1) return arr;

  const mid = Math.floor(arr.length / 2);
  const left = mergeSort(arr.slice(0, mid));
  const right = mergeSort(arr.slice(mid));

  return merge(left, right);
}

function merge(left, right) {
  let result = [];
  let leftIndex = 0;
  let rightIndex = 0;

  while (leftIndex < left.length && rightIndex < right.length) {
    if (left[leftIndex] < right[rightIndex]) {
      result.push(left[leftIndex]);
      leftIndex++;
    } else {
      result.push(right[rightIndex]);
      rightIndex++;
    }
  }

  return result.concat(left.slice(leftIndex)).concat(right.slice(rightIndex));
}

console.log(mergeSort([38, 27, 43, 3, 9, 82, 10])); // [3, 9, 10, 27, 38, 43, 82]

Implementa l'algoritmo Quick Sort.

Spiegazione: Quick Sort è anch'esso un algoritmo divide-et-impera. Sceglie un elemento come pivot e partiziona l'array dato attorno al pivot scelto. Gli elementi più piccoli del pivot vanno a sinistra, e gli elementi più grandi vanno a destra. Quindi ordina ricorsivamente i sottoarray.

function quickSort(arr) {
  if (arr.length <= 1) return arr;

  const pivot = arr[arr.length - 1];
  const left = [];
  const right = [];

  for (let i = 0; i < arr.length - 1; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }

  return [...quickSort(left), pivot, ...quickSort(right)];
}

console.log(quickSort([10, 8, 2, 1, 6, 3, 9, 4, 7, 5])); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Implementa l'algoritmo Bubble Sort.

Spiegazione: Bubble Sort è un semplice algoritmo di ordinamento che scorre ripetutamente la lista, confronta gli elementi adiacenti e li scambia se sono nell'ordine sbagliato. Il passaggio attraverso la lista viene ripetuto finché la lista non è ordinata.

function bubbleSort(arr) {
  let n = arr.length;
  let swapped;
  do {
    swapped = false;
    for (let i = 0; i < n - 1; i++) {
      if (arr[i] > arr[i + 1]) {
        [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]]; // Swap
        swapped = true;
      }
    }
    n--; // Optimization: last element is already in place
  } while (swapped);
  return arr;
}

console.log(bubbleSort([64, 34, 25, 12, 22, 11, 90])); // [11, 12, 22, 25, 34, 64, 90]

Data una stringa, trova la lunghezza della sottostringa più lunga senza caratteri ripetuti.

Spiegazione: Utilizza la tecnica della 'finestra scorrevole'. Mantieni una finestra (sottostringa) e un set di caratteri in quella finestra. Espandi la finestra spostando il puntatore destro. Se viene trovato un carattere ripetuto, restringi la finestra da sinistra finché il carattere ripetuto non viene rimosso.

function lengthOfLongestSubstring(s) {
  let maxLength = 0;
  let start = 0;
  const charMap = {};

  for (let end = 0; end < s.length; end++) {
    const char = s[end];
    if (charMap[char] >= start) {
        start = charMap[char] + 1;
    }
    charMap[char] = end;
    maxLength = Math.max(maxLength, end - start + 1);
  }
  return maxLength;
}

console.log(lengthOfLongestSubstring('abcabcbb')); // 3 ('abc')
console.log(lengthOfLongestSubstring('bbbbb')); // 1 ('b')
console.log(lengthOfLongestSubstring('pwwkew')); // 3 ('wke')

Implementa una Lista Collegata Singolarmente con i metodi add e print.

Spiegazione: Una lista collegata è una struttura dati lineare dove gli elementi non sono memorizzati in posizioni di memoria contigue. Ogni elemento (nodo) punta al successivo. Hai bisogno di una classe Node e di una classe LinkedList per gestire la testa e l'aggiunta di nuovi nodi.

class Node {
  constructor(data, next = null) {
    this.data = data;
    this.next = next;
  }
}

class LinkedList {
  constructor() {
    this.head = null;
  }

  add(data) {
    const newNode = new Node(data);
    if (!this.head) {
      this.head = newNode;
    } else {
      let current = this.head;
      while (current.next) {
        current = current.next;
      }
      current.next = newNode;
    }
  }

  print() {
    let current = this.head;
    let list = '';
    while (current) {
      list += current.data + ' -> ';
      current = current.next;
    }
    console.log(list + 'null');
  }
}

const list = new LinkedList();
list.add(10);
list.add(20);
list.add(30);
list.print(); // 10 -> 20 -> 30 -> null

Implementa un Albero di Ricerca Binario con i metodi insert e find.

Spiegazione: Un BST è una struttura dati ad albero binario basata su nodi che ha le seguenti proprietà: il sottoalbero sinistro di un nodo contiene solo nodi con chiavi minori della chiave del nodo. Il sottoalbero destro di un nodo contiene solo nodi con chiavi maggiori della chiave del nodo. Entrambi i sottoalberi devono essere anche alberi di ricerca binari.

class Node {
  constructor(data) {
    this.data = data;
    this.left = null;
    this.right = null;
  }
}

class BST {
  constructor() {
    this.root = null;
  }

  insert(data) {
    const newNode = new Node(data);
    if (!this.root) {
      this.root = newNode;
      return;
    }
    this._insertNode(this.root, newNode);
  }

  _insertNode(node, newNode) {
    if (newNode.data < node.data) {
      if (!node.left) node.left = newNode;
      else this._insertNode(node.left, newNode);
    } else {
      if (!node.right) node.right = newNode;
      else this._insertNode(node.right, newNode);
    }
  }

  find(data) {
    return this._findNode(this.root, data);
  }

  _findNode(node, data) {
    if (!node) return null;
    if (data < node.data) return this._findNode(node.left, data);
    else if (data > node.data) return this._findNode(node.right, data);
    else return node;
  }
}

const bst = new BST();
bst.insert(10);
bst.insert(5);
bst.insert(15);
bst.insert(7);
console.log(bst.find(7)); // Node { data: 7, left: null, right: null }
console.log(bst.find(12)); // null

Scrivi una funzione per ruotare un array a destra di k passi.

Spiegazione: Ruotare un array significa spostare i suoi elementi. Per una rotazione a destra, l'ultimo elemento diventa il primo. Ripetere questo k volte funziona ma è inefficiente. Un modo migliore è usare la manipolazione dell'array o calcolare le nuove posizioni.

function rotateArray(nums, k) {
  k = k % nums.length; // Handle cases where k > length
  if (k === 0) return nums;

  const partToMove = nums.splice(nums.length - k);
  nums.unshift(...partToMove);
  return nums;
}

console.log(rotateArray([1, 2, 3, 4, 5, 6, 7], 3)); // [5, 6, 7, 1, 2, 3, 4]

Dati due array, scrivi una funzione per calcolare la loro intersezione (elementi comuni ad entrambi).

Spiegazione: Un buon approccio è convertire un array in un Set per ricerche in tempo medio O(1). Quindi, iterare attraverso il secondo array e controllare se ogni elemento esiste nel set. Raccogli le corrispondenze.

function intersection(nums1, nums2) {
  const set1 = new Set(nums1);
  const resultSet = new Set();

  for (const num of nums2) {
    if (set1.has(num)) {
      resultSet.add(num);
    }
  }

  return [...resultSet];
}

console.log(intersection([1, 2, 2, 1], [2, 2])); // [2]
console.log(intersection([4, 9, 5], [9, 4, 9, 8, 4])); // [9, 4]

Dato un array di stringhe, raggruppa gli anagrammi insieme.

Spiegazione: La chiave è trovare una firma unica per ogni gruppo di anagrammi. Un modo comune è ordinare ogni parola alfabeticamente. Le parole che risultano nella stessa stringa ordinata sono anagrammi. Usa una hash map dove le chiavi sono parole ordinate e i valori sono array di parole originali.

function groupAnagrams(strs) {
  const map = {};
  for (const str of strs) {
    const sortedStr = str.split('').sort().join('');
    if (!map[sortedStr]) {
      map[sortedStr] = [];
    }
    map[sortedStr].push(str);
  }
  return Object.values(map);
}

console.log(groupAnagrams(['eat', 'tea', 'tan', 'ate', 'nat', 'bat'])); 
// Output: [['eat', 'tea', 'ate'], ['tan', 'nat'], ['bat']]

Dato un array nums, scrivi una funzione per spostare tutti gli 0 alla fine mantenendo l'ordine relativo degli elementi non zero.

Spiegazione: Utilizza un approccio 'a due puntatori' o 'a palla di neve'. Un puntatore tiene traccia della posizione in cui dovrebbe andare il prossimo elemento non zero. Itera attraverso l'array; se un elemento non è zero, posizionalo nella posizione del puntatore e incrementa il puntatore. Infine, riempi il resto con zeri.

function moveZeroes(nums) {
  let nonZeroIndex = 0;

  // Move all non-zero elements to the front
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] !== 0) {
      nums[nonZeroIndex] = nums[i];
      nonZeroIndex++;
    }
  }

  // Fill the rest with zeros
  for (let i = nonZeroIndex; i < nums.length; i++) {
    nums[i] = 0;
  }

  return nums;
}

console.log(moveZeroes([0, 1, 0, 3, 12])); // [1, 3, 12, 0, 0]