JS - Coding Challenges

function chunk(array, size, result) {
 result = result || [];
 if (array.length > 0) {
  result.push(array.splice(0, size));
  return chunk(array, size, result);
 } else {
  return result;
 }
}

// Note: The splice() method will mutate the original array, which is usually undesired.

reverse(), for loop, for-of loop, reduce(), reduceRight(), forEach()

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

function reverse(str) {
  return str.split('').reduce((reversedString, letter) => letter + reversedString, '');
}

function reverse(str) {
  return str.split('').reduceRight((reversedString, letter) => reversedString + letter, '');
}

function reverse(str) {
  let reversedString = '';
  for (let i = str.length - 1; i >= 0; i--) {
    reversedString += str[i];
  }
  return reversedString;
}

function fizzBuzz(num) {
  for (let i = 1; i <= num; i++) {
    if (i % 3 === 0 && i % 5 === 0) {
     console.log('fizzbuzz');
     continue;
    }

    if (i % 3 === 0) {
     console.log('fizz');
     continue;
    }

    if (i % 5 === 0) {
     console.log('buzz');
     continue;
    }
  
    console.log(i);
  }
}

function formatWord(word) {
 return word.replace(/[^\w]/g,'').toLowerCase();
}

function anagrams(stringA, stringB) {
 const formattedStringA = formatWord(stringA);
 const formattedStringB = formatWord(stringB);
 const sortedA = formattedStringA.split('').sort().join('');
 const sortedB = formattedStringB.split('').sort().join('');

 return sortedA === sortedB;
}

function chunk(array, size) {
  let newArray = [];
  for (let index = 0; index < array.length; index += size) {
    newArray.push(array.slice(index, index + size));
  }
  return newArray;
}

function reverse(str) {
  let reversedString = '';
  for (let letter of str) {
    reversedString = letter + reversedString;
  }
  return reversedString;
}

function chunk(array, size) {
  let newArray = [];
  let index = 0;
  while (index < array.length) {
   newArray.push(array.slice(index, index + size));
   index += size;
  }
  return newArray;
}

function chunk(array, size) {
  let newArray = [];
  while (array.length > 0) {
   newArray.push(array.splice(0, size));
  }
  return newArray;
}

// Note: The splice() method will mutate the original array, which is usually undesired.

function reverse(str) {
  let reversedString = '';
  str.split('').forEach((letter) => {
   reversedString = letter + reversedString;
  });
  return reversedString;
}

function reverseNum(num) {
  const reversedNumberString = num
    .toString()
    .split('')
    .reverse()
    .join('');

  return parseInt(reversedNumberString) * Math.sign(num);
}

// Math.sign() returns a number representing the sign of a specified number
// parseInt() returns a number from a string and removes any leading zeros as well as any negative signs that are at the end of the string after reversing it
// toString() returns a string representing a number

function formatWord(word) {
 return word.replace(/[^\w]/g,'').toLowerCase();
}

function getCharMap(word) {
 let charMap = {};
 for (letter of word) {
  charMap[letter] = charMap[letter] + 1 || 1;
 }
 return charMap;
}

function anagrams(stringA, stringB) {
 const formattedStringA = formatWord(stringA);
 const formattedStringB = formatWord(stringB);
 const charMapA = getCharMap(formattedStringA);
 const charMapB = getCharMap(formattedStringB);

 if (Object.keys(charMapA).length !== Object.keys(charMapB).length) {
  return false;
 }

 for (let letter in charMapA) {
  if (charMapA[letter] !== charMapB[letter]) {
   return false;
  }
 }

 return true;
}

function maxChar(str) {
  const charMap = {};
  let maxChar = {char: '', count: 0};

  for (let letter of str) {
    charMap[letter] = charMap[letter] + 1 || 1;
  }

  for (const letter in charMap) {
    const letterCount = charMap[letter];

    if (maxChar.count < letterCount) {
      maxChar = {
        char: letter,
        count: letterCount
      };
    }
  }

  return maxChar.char;
}

// Strategy:
// 1 - Create a character map that uses each letter for the keys and the number of times a letter appears as the values
// 2 - Loop through the character map and compare it to the previous character count

function capitalize(string) {
  return string
    .split(' ')
    .map(function(word) {
      return word[0].toUpperCase() + word.slice(1);
    })
    .join(' ');
}

function capitalize(string) {
 return string.split('').map(function(character, index) {
  if (index === 0 || str[index - 1] === ' ') {
   character.toUpperCase();
  }

  return character;
 }).join('');
}

function steps(desiredRowsNum, rowNum = 1, rowChars = '') {
  if (rowNum > desiredRowsNum) {
   return;
  }

  if (desiredRowsNum === rowChars.length) {
    console.log(rowChars);
    return steps(desiredRowsNum, rowNum + 1);
  }

  rowChars += rowChars.length < rowNum ? '#' : ' ';
  steps(desiredRowsNum, rowNum, rowChars);
}


// Strategy:

// Create a base condition that will end the recursive loop
  // Base case - If this condition is met, stop the recursive loop
  // If the current row iteration is greater than the desired number of rows, stop the loop

// If the number of characters in the built string are equal to the number of desired rows, then we know it is ready to print it
// Re-run the function and increment the row counter. The function call must be returned so the rest of the function isn't executed

// If the built string hasn't reached the number of row iteration, then another pound sign must be added
// If the built string has reached the number of row iteration, then a space sign must be added

// Re-run the function using the same row iteration counter so that the remaining pound or space characters are added

function printSteps
(desiredRowsNum) {
  for (let rowNum = 1; rowNum <= desiredRowsNum; rowNum++) {
    let rowChars = '';
    for (let columnNum = 1; columnNum <= desiredRowsNum; columnNum++) {
      rowChars += columnNum <= rowNum ? '#' : ' ';
    }
    console.log(rowChars);
  }
}

function printNumber(n) {
  if (n === 0) {
   return;
  }  

  console.log(n);
  return printNumber(n - 1);
}

function printSteps
(desiredRowsNum
) {
  for (let i = 1; i <= desiredRowsNum
; i++) {
    console.log('#'.repeat(i).padEnd(desiredRowsNum
))
  }
}

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