A simple array method and data structure

array_data_structure.js

/**
 * Removes Duplicates from []
 */
const removeDups = (arr) => {
  return arr.filter((f, i) => arr.indexOf(f) === i).sort()
}

/**
 * Removes Duplicates from [{}]
 */
const removeDupsFromArrObj = (arrObj, key) => {
  return arrObj.filter((f, i, d) => d.findIndex((b) => b[key] === f[key]) ===i )
}
/**
 * Reverse String - Approach 1
 */
const reverseString = (value) => {
  return value.split('').reverse().join('');
}

/**
 * Reverse String - Approach 2
 */
const reverseString2 = value => {
  return value.split('').reduce((a, b, c) => b + a, '')
}

/**
 * Reverse String - Approach 3
 */
const reverseString3 = value => {
  let reversed = '';

  for (char of value.split('')) {
    reversed = char + reversed;
  }
  return reversed;
}

/**
 * Find Max Characters
 */
const findMaxChars = (value) => {
  let charMap = {};
  let maxChar = '';
  let maxVal = 0;

  for(char of value) {
    if (charMap[char]) {
      charMap[char]++
    } else {
      charMap[char] = 1
    }
  }
  for(val in charMap) {
  if (charMap[val] > maxVal) {
    maxVal = val;
    maxChar = charMap[val];
  }
}
return maxChar;
}

const arrObj = [
  {key: 1, value: "hello"}, {key: 2, value: "world"}, {key: 3, value: "yes"},   {key: 1, value: "of course"},
]

/**
 * FizzBuzz
 */
const fizzBuzz = (string) => {
  for (let k = 1; k <= string; k++) {
    if (k % 3 === 0 && k % 5 === 0) {
console.log('FizzBuzz')
    } else if (k % 3 === 0) {
console.log('Fizz')
    } else if (k%5 === 0) {
console.log('Buzz') 
    } else {
console.log(k)
    }
  }
}

/**
 * Break large array - Approach 1
 */
const chunk = (arr, size) => {
  const myArr = [];
  for(let i = 0; i<arr.length; i+=size) {
    console.log(i)
    myArr.push(arr.slice(i, i+size))
  }
  return myArr;
}

/**
 * Break large array - Approach 2
 */
const chunk2 = (arrItems, size) => {
  const chunked = [];
  let index = 0;

  while(index < arrItems.length) {
    chunked.push(arrItems.slice(index, index+size));
    index += size;
  }

  return chunked;
}

/**
 * Anagram - Approach 1
 */
const buildCharMaps = (str) => {
  const charMap = {};

  for(let char of str.replace(/[^\w]/g, '').toLowerCase()) {
    charMap[char] = charMap[char] + 1 || 1
  }
  return charMap;
}

const checkAnagram = (strA, strB) => {
  const charMapA = buildCharMaps(strA);
  const charMapB = buildCharMaps(strB);

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

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

  return true;
}

/**
 * Anagram - Approach 2
 */
const checkAnagram2 = (strA, strB) => {
  return (strA.replace(/[^\w]/g, '').toLowerCase().split('').sort().join('') === strB.replace(/[^\w]/g, '').toLowerCase().split('').sort().join(''))
}

/**
 * Capitalize - Approach 1
 */

const capitalizeFirstChar = (str) => {
  let words = [];

  for(let word of str.split(' ')) {
    words.push(word[0].toUpperCase() + word.slice(1))
  }

 return words.join(' ')
}

/**
 * Capitalize - Approach 2
 */

const capitalize2 = (str) => str[0].toUpperCase()+str.substring(1);

/**
 * Cyclic Rotation
 */

const cyclicRotation = (A, k) => {
// A = [3,6,8,9]
// K = 1
  const array = A;
  if (k<1) {
    return []
  }

  for (let i = 0; i < k; i++) {
    const last = array[array.length - 1];
    array.pop()
    array.unshift(last)
  }

  return array
}
console.log(cyclicRotation([3, 5, 8, 6, 2], 5))
// console.log(capitalize2("make "))
// console.log(chunk2([1,2,3,4], 2))
// console.log(checkAnagram2("hello", "llohe "))
// console.log(fizzBuzz(20))
// console.log(reverseString2("Hello"))
// console.log(findMaxChars("epitomeofgrace"))
// console.log(removeDups([1,2,2,4,5,5,3,4,5]))
// console.log(reverseString3("Howareyou"))
console.log(removeDupsFromArrObj(arrObj, 'value'))


function solution(s, c) {
  var totalCost = 0;
    for (var i = 0; i < s.length; i++) {
       let character = s.charAt(i);
       if(i + 1 < s.length && s.charAt(i) == s.charAt(i + 1)){            
         var j = i;            
         let maxCost = c[i];          
         let partialSumCost = 0;            
         while(character == s.charAt(j)) {                
           partialSumCost += c[j];
           if(maxCost < c[j]) {                    
             maxCost = c[j];              
           }               
           j++;           
         }            
         i = j;            
         totalCost += partialSumCost - maxCost;        
       } else {            
         i++;        
       }    
    }    
  return totalCost;
}