Resuelvo pruebas de programación de entrevistas para trabajar como programador en Nueva Zelanda

goToNewZealand.js

// multiplicar sin utilizar el signo "*"
const multiply = ( a, b ) => a / ( 1 / b );
console.group( 'multiply' )
console.assert( multiply( 2, 5 ) === 10, "All positive" );
console.assert( multiply( 2, -5 ) === -10, "b negative" );
console.assert( multiply( -2, 5 ) === -10, 'a negative' );
console.assert( multiply( -2, -5 ) === 10, 'All negative' );
console.assert( multiply( 0, 5 ) === 0, 'a is zero' );
console.assert( multiply( 2, 0 ) === 0, 'b is zero' );
console.groupEnd()

// obtener el número más grande en un arreglo
const getBiggest = arr => arr.sort( ( a, b ) => a - b )[ arr.length - 1 ];
console.group( 'getBiggest' );
console.assert( getBiggest( [ 1, 0, -1 ] ) === 1, '1 case' );
console.assert( getBiggest( [ -Infinity, 0, Infinity ] ) === Infinity, 'Infinity case' );
console.assert( getBiggest( [ 132456, 0, -1, 50, 12345, 1234 ] ) === 132456, 'random case' );
console.groupEnd();

// limpiar todos los valores null, 0 o undefined de un array dado
const clean = arr => arr.filter(v => v);
console.group('clean array')
console.assert( clean( [ 1, 0, -1, 1, null, 2, undefined, 3 ] ).length === 5 , 'clean array'  );
console.groupEnd();

// achatar un array en un nivel
const flatten = arr => [].concat(...arr);
console.group('flatten')
console.assert( flatten( [ [1, 0, -1], 1, [null, 2, undefined], 3 ] ).length === 8 , 'flatten array'  );
console.groupEnd();

// devolver un objeto que informe la cantidad de veces que se repiten las palabras dadas en un string
const repeatedTimes = str => {
  const splitted = str.toLowerCase().split(' ');
  const repeated = {}
  for (const word of splitted) {
    repeated[word] = repeated[word] ? ++repeated[word] : 1;
  }
  return repeated;
}

const repetitions = repeatedTimes('this is a Sentence with this repeated several times in a sentence this is it it');
console.group('repetitions');
console.assert( Object.entries(repetitions).length === 10, 'repeated string');
console.groupEnd();

// verificar si un string dado es palíndrome
const removeSpaces = str => str.split(' ').join('');
const isPalindrome = str => removeSpaces(str).toLowerCase().split('').reverse().join('') === removeSpaces(str).toLowerCase();

console.group('isPalindrome');
console.assert( isPalindrome('Do geese see God') === true, 'is palindrome');
console.assert( isPalindrome('abc') === false, 'is not palindrome');
console.groupEnd();

Este Gist es una reacción al video Resuelvo pruebas de programación de entrevistas para trabajar como programador en Nueva Zelanda propuesto por Nicolás Schürmann o Nicolás Lindemann (como guste llamarse 😅)
Me pareció que su uso de reduce en el video era excesivo, es una herramienta poderosa pero podría dificultar la legibilidad y el debugging en algunos casos. Simplemente les doy mi versión.
Por otro lado, en la función isPalindrome él propuso una solución muy legible asique opté por lo contrario, oneliner-ish ("twoliner" jaja, si cabe)

1. Aunque para el de multiplicar no use la división, la idea según yo es no usar ni la multiplicación ni su inverso multiplicativo, según yo con la suma también sería muy fácil así que según yo debería ser un problema de multiplicar dos enteros con operadores binarios
2. La complejidad de ordenar mínimo es de n*log(n) entonces no es eficiente sabiendo que el problema se puede hacer en n
3. Lo veo bien
4. Lo veo bien pero se puede implementar mejor el operador se ejecuta primero y luego hacer el concat es otra pasado por que la complejidad es 2*n si bien sigue siendo lineal se podría implementar en una sola pasada
5. Lo mismo se puede mejorar la complejidad.