intermediate algorithm challenge - FreeCodeCamp

index.js

/*** intermediate algorithm challenge n° 4 : 

  https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/wherefore-art-thou

***/

function whatIsInAName(collection, source) {
  const srcKeys = Object.keys(source)

  return collection.filter((obj) => {
    return srcKeys.every((key) => {
      return obj.hasOwnProperty(key) && obj[key] === source[key]
    })
  })
}

whatIsInAName([
  { first: "Romeo", last: "Montague" },
  { first: "Mercutio", last: null },
  { first: "Tybalt", last: "Capulet" }
], { last: "Capulet" });

// OR

const whatIsInAName = (list, reference) => {
  const pairsToCheck = Object.entries(reference)
  
  return list.filter(entry => {
    return pairsToCheck.every(([key, value]) => entry[key] === value)
  })
}

whatIsInAName([
  { id: 1, "apple": 1, "bat": 2 }, 
  { id: 2, "apple": 1 }, 
  { id: 3, "apple": 1, "bat": 2, "cookie": [2, 8] }
], { "apple": 1, "cookie": [2, 8] })


/*** intermediate algorithm challenge n° 8 : 

  https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/dna-pairing

***/

function pairElement(str) {
  const ATCG = [['A', 'T'], ['C', 'G']]

  const splitedString = str.split('')

  const getSecondLetter = (letter, array) => {
    const currentArr = array.find(item => item.find(v => v === letter))
    
    return currentArr.find(l => l !== letter)
  }

  const pairLetters = splitedString.reduce((acc, current) => {
    const addLetter = getSecondLetter(current, ATCG)
    const total = [current, addLetter]
    return [...acc, total]
  }, [])

  return pairLetters
}

pairElement("ATCGA");




/*** intermediate algorithm challenge n° 9 : 

  https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/missing-letters

***/

function fearNotLetter(str) {
  const alpha = "abcdefghijklmnopqrstuvwxyz"

  const splittedAlpha = alpha.split('')
  const splittedStr = str.split('')
  
  const firstStrLetter = splittedStr[0]
  const lastStrLetter = splittedStr[splittedStr.length - 1]

  const findTheIndex = (letter) => letter === firstStrLetter
  const findTheLastIndex = (letter) => letter === lastStrLetter

  const firstIndex = splittedAlpha.findIndex(findTheIndex)
  const lastIndex = splittedAlpha.findIndex(findTheLastIndex)
  
  const extractStrFromAlpha = splittedAlpha.slice(firstIndex, lastIndex)

  return extractStrFromAlpha.find(v => {
    if (splittedStr.includes(v) === false) return v
  })
}

fearNotLetter("abce");




/*** intermediate algorithm challenge n° 10 : 

  https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/convert-html-entities

***/

function uniteUnique(arr, ...rest) {
  const uniqueArr = [arr, ...rest].flat()

  const removeDuplicate = (array) => {
    return array.filter((value, index) => array.indexOf(value) === index)
  }
    
  return removeDuplicate(uniqueArr);
}

uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1]);

// OR 

function uniteUnique(arr, ...rest) {
  const uniqueArr = arr.concat(...rest)
  return [...new Set(uniqueArr)]
}

uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1]);



/*** intermediate algorithm challenge n° 11 : 

  https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/convert-html-entities

***/

function convertHTML(str) {
  const cleanString = (str) => {
    return str
    .replace(/&/g, '&')
    .replace(/</g, '&lt;')
    .replace(/>/g, '&gt;')
    .replace(/"/g, '&quot;')
    .replace(/'/g,'&apos;')
  }
  return cleanString(str)
}

convertHTML("Dolce & Gabbana");

// OR

function convertHTML(str) {
  const htmlEntities = {
    '&': '&amp;',
    '<': "&lt;",
    '>': "&gt;",
    '"': "&quot;",
    "'": "&apos;",
  }

  return str
    .split('')
    .map(letter => htmlEntities[letter] || letter)
    .join('')
}

convertHTML("Dolce & Gabbana");




/*** intermediate algorithm challenge n° 12 : 

  https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-odd-fibonacci-numbers

***/

function sumFibs(num) {
  let result = 0, prevNumber = 0, currNumber = 1
  let arr = [currNumber]

  while (currNumber <= num) {
    arr.push(result)
    result = prevNumber + currNumber
    prevNumber = currNumber
    currNumber = result
  }
  return arr
    .filter(value => value %2 !== 0)
    .reduce((accum, curr) => accum + curr)
}

console.log(sumFibs(75024))




/*** intermediate algorithm challenge n° 13 : 

  https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-primes

***/

function sumPrimes(num) {
  const arr = []

  const isAPrimeNumber = (number) => {
    let array = []
    for (let i = 1; i <= number; i++) {
      Number.isInteger(number / i) ? array.push(i) : null
    }
    return array.length === 2
  }

  for (let i = 1; i <= num; i++) {
    isAPrimeNumber(i) ? arr.push(i) : null
  }
  
  return arr.reduce((accum, curr) => accum + curr)
}

sumPrimes(10);




/*** intermediate algorithm challenge n° 15 : 

  https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/drop-it

***/

function dropElements(arr, func) {
  const indexArr = []
  
  arr.map((number, index) => {
    func(number) ? indexArr.push(index) : null
  })

  return indexArr.length === 0 ? indexArr : arr.slice(indexArr[0])
}

dropElements([1, 2, 3, 4], function(n) {return n > 5;})




/*** intermediate algorithm challenge n° 16 : 

  https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/steamroller

***/

function steamrollArray(arr) {
  return arr.reduce((acc, curr) => {
    return acc.concat(Array.isArray(curr) ? steamrollArray(curr) : curr)
  }, [])
}

steamrollArray([1, [2], [3, [[4]]]]);




/*** intermediate algorithm challenge n° 17 : 

  https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/binary-agents

***/

function binaryAgent(str) {
  return str
    .split(' ')
    .map(letter => String.fromCharCode(parseInt(letter, 2)))
    .join('')
}

binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111");




/*** intermediate algorithm challenge n° 18 : 

  https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/everything-be-true

***/

function truthCheck(collection, pre) {
  return collection.every(obj => obj[pre])
}

truthCheck([
  {"user": "Tinky-Winky", "sex": "male"},
  {"user": "Dipsy", "sex": "male"},
  {"user": "Laa-Laa", "sex": "female"},
  {"user": "Po", "sex": "female"}
], "sex");




/*** intermediate algorithm challenge n° 19 : 

  https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/make-a-person

***/

function addTogether(a, b) {
  const isANumber = (num) => typeof num === 'number'

  if (!isANumber(a) || (b && !isANumber(b))) return undefined

  if (isANumber(a) && isANumber(b)) return a + b

  return function(c) {
    if (isANumber(c)) return a + c
  }
}

addTogether(2, "3")
addTogether(5)(7)