JavaScript Program Writing

Solution 01: ES6 only

let [a, b] = ["Hello", "World"];

[b, a] = [a, b]; // Swap variables

console.log(a, b); // World Hello

Solution 02: ES5 compatible

/**
 * 1. a = b assigns the old value of b to a and yelds it, therefore [a, a=b] will be [a, b]
 * 2. the [0] operator yelds the first element of the array, which is a, so now b = [a,b][0] turns * into b = a
 */
var a = "World";
var b = "Hello";

b = [a, (a = b)][0];

console.log(a, b); // Hello World

const findMissing = (arr) => {
  const missing = [];
  const max = Math.max(...arr); // highest number
  const min = Math.min(...arr); // lowest number

  for (let i = min; i <= max; i++) {
    if (!arr.includes(i)) {
      missing.push(i); // Adding numbers which are not in array
    }
  }
  return missing;
};

console.log(findMissing([1, 6]));

let count = 0;

function nestedCount(arr) {
  arr.forEach((val) => {
    if (Array.isArray(val)) {
      nestedCount(val);
    } else {
      count++;
    }
  });
  return count;
}

let input = [1, [2, [3, [4, [5, 6]]]]];

console.log(nestedCount(input)); // 6

// Get an array of all names
const names = characters.map((character) => {
  return character.name;
});
console.log(names);

// Get an array of all heights
const heights = characters.map((character) => {
  return character.height;
});
console.log(heights);

// Get an array of objects with just name and height properties
const objects = characters.map((character) => {
  return { name: character.name, height: character.height };
});
console.log(objects);

// Get an array of all first names
const firstNames = characters.map((character) => {
  return character.name.split(" ")[0];
});
console.log(firstNames);

// Get the total mass of all characters
const totalMass = characters.reduce((sum, character) => {
  return sum + parseInt(character.mass);
}, 0);
console.log(totalMass);

// Get the total height of all characters
const totalHeight = characters.reduce((sum, character) => {
  return sum + parseInt(character.height);
}, 0);
console.log(totalHeight);

// Get the total number of characters in all the character names
const characterCountByName = characters.reduce((result, character) => {
  if (typeof result[character.name] === "undefined") {
    result[character.name] = 1;
  } else {
    result[character.name] += 1;
  }

  return result;
}, {});
console.log(characterCountByName);

// Get the total number of characters by eye color
const characterCountByEyeColor = characters.reduce((result, character) => {
  if (typeof result[character.eye_color] === "undefined") {
    result[character.eye_color] = 1;
  } else {
    result[character.eye_color] += 1;
  }

  return result;
}, {});
console.log(characterCountByEyeColor);

// Get characters with mass greater than 100
const characterMass = characters.filter((character) => {
  return character.mass > 100;
}, {});
console.log(characterMass);

// Get characters with height less than 200
const characterHeight = characters.filter((character) => {
  return character.height < 200;
}, {});
console.log(characterHeight);

// Get all male characters
const characterMale = characters.filter((character) => {
  return character.gender === 'male';
}, {});
console.log(characterMale);

// Get all female characters
const characterFemale = characters.filter((character) => {
  return character.gender === 'female';
}, {});
console.log(characterFemale);

// Sort by Name
const sortByName = characters.sort((a, b) => {
  if (a.name < b.name) {
    return -1;
  }
});
console.log(sortByName);

// Sort by Mass
const sortByMass = characters.sort((a, b) => {
  if (parseInt(a.mass) < parseInt(b.mass)) {
    return -1;
  }
});
console.log(sortByMass);

// Sort by Height
const sortByHeight = characters.sort((a, b) => {
  if (parseInt(a.height) < parseInt(b.height)) {
    return -1;
  }
});
console.log(sortByHeight);

// Sort by Gender
const sortByGender = characters.sort((a, b) => {
  if (a.gender < b.gender) {
    return -1;
  }
});
console.log(sortByGender);

// Does every character have blue eyes
const checkBlueEye = characters.every(
  (character) => character.eye_color === "blue"
);
console.log(checkBlueEye);

// Does every character have mass more than 40
const checkMass = characters.every((character) => character.mass > 40);
console.log(checkMass);

// Is every character shorter than 200
const checkHeight = characters.every((character) => character.height < 200);
console.log(checkHeight);

// Is every character Male
const checkGender = characters.every(
  (character) => character.gender === "male"
);
console.log(checkGender);

// Is there at least one male character
const checkGender = characters.some(
  (character) => character.gender === "male"
);
console.log(checkGender);

// Is there at least one character with blue eyes
const checkEye = characters.some(
  (character) => character.eye_color === "blue"
);
console.log(checkEye);

// Is there at least one character taller than 200
const checkHeight = characters.some(
  (character) => character.height > 200
);
console.log(checkHeight);

// Is there at least one character that has mass less than 50
const checkMass = characters.some(
  (character) => character.mass < 50
);
console.log(checkMass);

let arr = ["Angular", "JavaScript", "NodeJS", "MongoDB"];

arr.splice(0, 2, "React", "Redux");
console.log(arr);

function checkPalindrome(str) {
  for (let i = 0; i < str.length / 2; i++) {
    // check if first and last character are same
    if (str[i] !== str[str.length - 1 - i]) {
      return "Not a palindrome";
    }
  }
  return "Palindrome";
}

console.log(checkPalindrome("aba"));
console.log(checkPalindrome("ABCDCBA"));
console.log(checkPalindrome("Hello"));

Solution 01: Using for Loop

function countCharacter(str, ch) {
  let count = 0;
  for (let i = 0; i < str.length; i++) {
    // check if the character is at that position
    if (str.charAt(i) === ch) {
      count += 1;
    }
  }
  return count;
}

console.log(countCharacter(str, ch));

Solution 02: Using Regex

function countCharacter(str, ch) {
  // creating a pattern
  const re = new RegExp(ch, "g");
  return str.match(re).length;
}

console.log(countCharacter(str, ch));

Solution 03: Using split() function

function countCharacter(str, ch) {
  return str.split(ch).length - 1;
}

console.log(countCharacter(str, ch));

Solution 04: Using filter() function

function countCharacter(str, ch) {
  return [...str].filter((x) => x === ch).length;
}

console.log(countCharacter(str, ch));

function nextChar(c) {
  return String.fromCharCode(c.charCodeAt(0) + 1);
}

const transform = (str) => {
  let word = "";
  for (let i = 0; i < str.length; i++) {
    word += nextChar(str[i]);
  }
  return word;
};

const input = "aaa";
console.log(transform(input)); // bbb

Solution 01: Using substring() method

function transform(str, n) {
  return str.substring(n);
}

console.log(transform("Hello World", 6));

Solution 02: Using slice() method

function transform(str, n) {
  return str.slice(n);
}

console.log(transform("Hello World", 6));

Solution 03: Using substr() method

function transform(str, n) {
  return str.substr(n);
}

console.log(transform("Hello World", 6));

const result = {};

for (let elemement of arr) {
  if (!(elemement.length in result)) {
    result[elemement.length] = [];
  }
  result[elemement.length].push(elemement);
}

console.log(result);

const groupBy = function (items, key) {
  return items.reduce(function (result, item) {
    (result[item[key]] = result[item[key]] || []).push(item);
    return result;
  }, {});
};

console.log(groupBy(arry, "Phase"));

const groupBy = (arr = []) => {
   const result = [];
   const map = {};
   for (let i = 0, j = arr.length; i < j; i++) {
      let element = arr[i];
      if (!(element.id in map)) {
         map[element.id] = {id: element.id, type: []};
         result.push(map[element.id]);
      };
      map[element.id].type.push(element.type);
   };
   return result;
};

console.log(groupBy(arr));

function powerOf(base, exponent) {
  let result = 1;
  for (let i = 1; i <= exponent; i++) {
    result = result * base;
  }
  return result;
}

console.log(powerOf(2, 3));

function removeDuplicates(arr) {
  let result = [];
  arr.forEach((element) => {
    if (!result.includes(element)) {
      result.push(element);
    }
  });
  return result;
}

console.log(removeDuplicates(arr));

// Creating Object with number of occurance of each elements
const count = {};
for(let element of arr) {
   if(count[element]) {
      count[element] += 1;
   } else {
      count[element] = 1;
   }
}

// Iterate Unique elements
for(let key in count) {
    if(count[key] === 1) {
       console.log(key + '->' + count[key]); 
    }
}

function firstNonRepeatingCharacter(str) {
  for (let i = 0; i < str.length; i++) {
    let char = str[i];
    if (str.indexOf(char) === str.lastIndexOf(char)) {
      return char;
    }
  }
  return "_";
}

console.log(firstNonRepeatingCharacter("aabcbd")); // c

console.log(firstNonRepeatingCharacter("teeter")); // r

console.log(firstNonRepeatingCharacter("abacddbec")); // e

Solution 1:

/**
 * Sort elements using compare method
 */
let arr = [53, 11, 34, 12, 18];

arr.sort((a, b) => {
  return a - b;
});

console.log(arr);

Solution 2:

/**
 * Optimized implementation of bubble sort Algorithm
 */
function bubbleSort(arr) {
  let isSwapped = false;

  for (let i = 0; i < arr.length; i++) {
    isSwapped = false;

    for (let j = 0; j < arr.length; j++) {
      if (arr[j] > arr[j + 1]) {
        let temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
        isSwapped = true;
      }
    }

    // If no two elements were swapped by inner loop, then break
    if (!isSwapped) {
      break;
    }
  }
  return arr;
}

console.log(bubbleSort([53, 11, 34, 12, 18]));

const fs = require("fs");

// #1 count the number of words
const wordCount = (string) => string.split(" ").length;

// #2 count the number of unique words
const uniqueWords = (txt) => new Set(txt.toLowerCase().match(/\w+/g)).size;

// #3 count the search string
const searchString = (string) => {
  let count = 0;
  let words = string.split(" ");

  for (let i = 0; i < words.length; i++) {
    if (words[i].indexOf("ispsum")) {
      count++;
    }
  }
  return count;
};

fs.readFile("file.txt", "utf8", function (err, data) {
  if (err) throw err;
  console.log("The text in the file:\n\n", data, "\n");
  // store results in an object to present the log better
  let result = {
    "Word Count": wordCount(data),
    "Unique Words": uniqueWords(data),
    searchString: searchString(data),
  };
  console.table(result);
});

function mostFrequentElement(array) {
  let count = {};
  let maxElement = array[0];
  let maxCount = 1;

  for (let i = 0; i < array.length; i++) {
    let element = array[i];
    if (count[element]) {
      count[element] += 1;
    } else {
      count[element] = 1;
    }
    if (count[element] > maxCount) {
      maxElement = element;
      maxCount = count[element];
    }
  }
  return [maxElement, maxCount];
}

console.log(mostFrequentElement([12, 5, 6, 76, 23, 12, 34, 5, 23, 34, 65, 34, 22, 67, 34])); // [34, 4]

function filterUser(arr) {
  const users = [];

  for (let i = 0; i < arr.length; i++) {
    let element = arr[i];
    let user = Object.values(element).filter((key) => {
      return key.age > 15 && key.age < 30;
    });
    users.push(user);
  }
  return users;
}

function sum(x, y) {
  if (y !== undefined) {
    return x + y;
  } else {
    return function (y) {
      return x + y;
    };
  }
}

console.log(sum(10, 20));
console.log(sum(10)(20));

⚝ Try this example on CodeSandbox

let arr1 = ['a', 'b'];
let arr2 = ['a', 'b', 'c', 'd'];

let difference = arr2.filter(x => !arr1.includes(x));

Array.prototype.diff = function (a) {
  return this.filter(function (i) {
    return a.indexOf(i) < 0;
  });
};

const dif1 = [1, 2, 3, 4, 5, 6].diff([3, 4, 5]);
console.log(dif1); // => [1, 2, 6]

<!DOCTYPE html>
<html>
  <head>
    <script type="text/javascript">
      function showFileSize() {
        var input, file, extension;

        input = document.getElementById("fileinput");
        file = input.files[0];
        extension = file.name.substring(file.name.lastIndexOf(".") + 1);

        let result = "File Name: " + file.name;
        result += "<br/>File Size: " + file.size + " bytes";
        result += "<br/>File Extension: " + extension;
        document.getElementById("result").innerHTML = result;
      }
    </script>
  </head>

  <body>
    <form action="#" onsubmit="return false;">
      <input type="file" id="fileinput" />
      <br /><br />
      <input
        type="button"
        id="btnLoad"
        value="Upload"
        onclick="showFileSize();"
      />
    </form>
    <div id="result"></div>
  </body>
</html>

⚝ Try this example on CodeSandbox

<!DOCTYPE html>
<html>
  <head>
    <title>JavaScript Captcha Generator</title>
  </head>
  <script>
    const randomString =
      "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ@!#$%^&*";

    function generateCaptcha() {
      let captcha = "";
      for (let i = 0; i < 6; i++) {
        captcha += randomString.charAt(Math.random() * randomString.length);
      }
      document.getElementById("captcha").value = "";
      document.getElementById("captcha").value = captcha;
    }
  </script>

  <body onload="generateCaptcha()">
    <input type="text" id="captcha" disabled /><br /><br />
    <button onclick="generateCaptcha()">Refresh</button>
  </body>
</html>

⚝ Try this example on CodeSandbox

<!DOCTYPE html>
<html>
  <head>
    <title>Stopwatch Example</title>
  </head>

  <body>
    <h4>Time: <span id="time">00:00:00</span><h4> <br /><br />
    <button id="start" onclick="start()">Start</button>
    <button id="stop" onclick="stop()">Stop</button>
    <button id="reset" onclick="reset()">Reset</button>

    <script type="text/javascript">
      const time = document.getElementById("time");
      const startBtn = document.getElementById("start");

      let timer;
      let seconds = 0;
      let hours = 0;
      let minutes = 0;
      let MINUTES_IN_HOUR = 60;
      let SECONDS_IN_MINUTE = 60;

      function updateTimer() {
        seconds++;
        if (seconds >= SECONDS_IN_MINUTE) {
          seconds = 0;
          minutes++;
          if (minutes >= MINUTES_IN_HOUR) {
            minutes = 0;
            hours++;
          }
        }

        time.textContent =
          (hours ? (hours > 9 ? hours : "0" + hours) : "00") +
          ":" +
          (minutes ? (minutes > 9 ? minutes : "0" + minutes) : "00") +
          ":" +
          (seconds > 9 ? seconds : "0" + seconds);

        // start timer again
        start();
      }

      function start() {
        timer = setTimeout(updateTimer, 1000);
        startBtn.disabled = true;
      }

      function stop() {
        clearTimeout(timer);
        startBtn.disabled = false;
      }

      function reset() {
        time.textContent = "00:00:00";
        seconds = 0;
        minutes = 0;
        hours = 0;
        startBtn.disabled = false;
      }

      window.start = start;
      window.reset = reset;
      window.stop = stop;
    </script>
  </body>
</html>

⚝ Try this example on CodeSandbox

function reverseString(str) {
  let stringRev = "";
  for (let i = str.length; i >= 0; i--) {
    stringRev = stringRev + str.charAt(i);
  }
  return stringRev;
}
console.log(reverseString("Hello"));

⚝ Try this example on CodeSandbox

const str = "Hello World";

let reverseEntireSentence = reverseBySeparator(str, "");

console.log(reverseBySeparator(reverseEntireSentence, " "));

function reverseBySeparator(string, separator) {
  return string.split(separator).reverse().join(separator);
}

async function myCars(name) {
  const promise = new Promise((resolve, reject) => {
    name === "Maruti Suzuki" ? resolve(name) : reject(name);
  });

  const result = await promise;
  console.log(result); // "resolved!"
}

myCars("Maruti Suzuki");

⚝ Try this example on CodeSandbox

/**
 * Using Spread Object
 */

const person = {
  name: "Tanvi",
  age: 28
};

const address = {
  addressLine1: "Some Location x",
  addressLine2: "Some Location y",
  city: "Bangalore"
};


const merged = {...person, ...address};

console.log(merged);
// {name: "Tanvi", age: 28, addressLine1: "Some Location x", addressLine2: "Some Location y", city: "Bangalore"}

⚝ Try this example on CodeSandbox

/**
 *  Find theoretical sum of the consecutive numbers using a variation of Gauss Sum.
 *  Formula: [(Max * (Max + 1)) / 2] - [(Min * (Min - 1)) / 2];
 *  Max is the upper bound and Min is the lower bound
 */
function findMissingNumber(arrayOfIntegers, upperBound, lowerBound) {
  
  var sumOfIntegers = 0;
  for (var i = 0; i < arrayOfIntegers.length; i++) {
    sumOfIntegers += arrayOfIntegers[i];
  }

  upperLimitSum = (upperBound * (upperBound + 1)) / 2;
  lowerLimitSum = (lowerBound * (lowerBound - 1)) / 2;

  theoreticalSum = upperLimitSum - lowerLimitSum;

  return theoreticalSum - sumOfIntegers;
}

1. Using set():

const names = ['John', 'Paul', 'George', 'Ringo', 'John'];

let unique = [...new Set(names)];
console.log(unique); // 'John', 'Paul', 'George', 'Ringo'

2. Using filter():

const names = ['John', 'Paul', 'George', 'Ringo', 'John'];

let x = (names) => names.filter((v,i) => names.indexOf(v) === i)
x(names); // 'John', 'Paul', 'George', 'Ringo'

3. Using forEach():

const names = ['John', 'Paul', 'George', 'Ringo', 'John'];

function removeDups(names) {
  let unique = {};
  names.forEach(function(i) {
    if(!unique[i]) {
      unique[i] = true;
    }
  });
  return Object.keys(unique);
}

removeDups(names); // 'John', 'Paul', 'George', 'Ringo'

function counter() {
  var _counter = 0;
  // return an object with several functions that allow you
  // to modify the private _counter variable
  return {
    add: function (increment) {
      _counter += increment;
    },
    retrieve: function () {
      return "The counter is currently at: " + _counter;
    },
  };
}

// error if we try to access the private variable like below
// _counter;

// usage of our counter function
var c = counter();
c.add(5);
c.add(9);

// now we can access the private variable in the following way
c.retrieve(); // => The counter is currently at: 14

const arr = [10, 20, 30, 40, 50];
let lenth = 3;

function split(len) {
  while (arr.length > 0) {
    console.log(arr.splice(0, len));
  }
}
split(lenth);

⚝ Try this example on CodeSandbox

/**
 * function to return a random number 
 * between min and max range
 */
function randomInteger(min, max) {
  return Math.floor(Math.random() * (max - min + 1) ) + min;
}

randomInteger(1, 100); // returns a random integer from 1 to 100

⚝ Try this example on CodeSandbox

function DecimalToBinary(number) {
  let bin = 0;
  let rem,
    i = 1;
  while (number !== 0) {
    rem = number % 2;
    number = parseInt(number / 2);
    bin = bin + rem * i;
    i = i * 10;
  }
  console.log(`Binary: ${bin}`);
}

DecimalToBinary(10);

Example 02: Convert Decimal to Binary Using toString()

let val = 10;

console.log(val.toString(2)); // 1010  ==> Binary Conversion
console.log(val.toString(8)); // 12  ==> Octal Conversion
console.log(val.toString(16)); // A  ==> Hexadecimal Conversion

⚝ Try this example on CodeSandbox

You can create a function which uses chain of string methods such as charAt, toUpperCase and slice methods to generate a string with first letter in uppercase.

function capitalizeFirstLetter(string) {
  let arr = string.split(" ");
  for (let i = 0; i < arr.length; i++) {
    arr[i] = arr[i].charAt(0).toUpperCase() + arr[i].slice(1);
  }
  return arr.join(" ");
}

console.log(capitalizeFirstLetter("hello world")); // Hello World

⚝ Try this example on CodeSandbox

The typeof operator can be use to test string literal and instanceof operator to test String object.

function check(str) {
  if (str instanceof String) {
    return "It is an object of string";
  } else {
    if (typeof str === "string") {
      return "It is a string literal";
    } else {
      return "another type";
    }
  }
}

const ltrlStr = "Hi I am string literal";
const objStr = new String("Hi I am string object");

console.log(check(ltrlStr)); // It is a string literal
console.log(check(objStr)); // It is an object of string

⚝ Try this example on CodeSandbox

You can use reverse() method is used reverse the elements in an array. This method is useful to sort an array in descending order.

const fruits = ["Apple", "Banana", "Mango", "Orange"];

const reversed = fruits.reverse();
console.log(reversed); // ["Orange", "Mango", "Banana", "Apple"]

You can use Math.min and Math.max methods on array variable to find the minimum and maximum elements with in an array.

const marks = [50, 20, 70, 60, 45, 30];

function findMin(arr) {
  return Math.min.apply(null, arr);
}
function findMax(arr) {
  return Math.max.apply(null, arr);
}

console.log(findMin(marks)); // 20
console.log(findMax(marks)); // 70

const marks = [50, 20, 70, 60, 45, 30];

function findMax(arr) {
  let length = arr.length;
  let max = marks[0];
  while (length--) {
    if (arr[length] > max) {
      max = arr[length];
    }
  }
  return max;
}

console.log(findMax(marks)); // 70

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

const obj = {};
console.log(isEmpty(obj)); 

⚝ Try this example on CodeSandbox

function validateEmail(email) {
  const re = /\S+@\S+\.\S+/;
  return re.test(email);
}

console.log(validateEmail("pradeep.vwa@gmail.com")); // true

⚝ Try this example on CodeSandbox

let newPassword = "Pq5*@a{J";
const regularExpression = new RegExp(
  "^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#$%^&*])(?=.{8,})"
);

if (!regularExpression.test(newPassword)) {
  alert("Password should contain atleast one number and one special character !");
} else {
  console.log("PASS");
}

// Output
PASS

⚝ Try this example on CodeSandbox

function countCharacters(str) {
  return str.replace(/ /g, "").toLowerCase().split("").reduce((result, key) => {
      if (key in result) {
        result[key]++;
      } else {
        result[key] = 1;
      }
      return result;
    }, {});
}

console.log(countCharacters("Hello"));

function charCount(str, searchChar) {
  let count = 0;
  if (str) {
    let stripStr = str.replace(/ /g, "").toLowerCase(); //remove spaces and covert to lowercase
    for (let chr of stripStr) {
      if (chr === searchChar) {
        count++;
      }
    }
  }
  return count;
}
console.log(charCount("the brown fox jumps over the lazy dog", "o"));

// Recursive Method
function recursiveFactorial(n) {
  if (n < 1) {
    throw Error("Value of N has to be greater then 1");
  }
  if (n === 1) {
    return 1;
  } else {
    return n * recursiveFactorial(n - 1);
  }
}

console.log(recursiveFactorial(5));

// Non-Recursive Method
function factorial(n) {
  if (n < 1) {
    throw Error("Value of N has to be greater then 1");
  }
  if (n === 1) {
    return 1;
  }
  let result = 1;
  for (let i = 1; i <= n; i++) {
    result = result * i;
  }
  return result;
}

console.log(factorial(5));

// 1, 1, 2, 3, 5, 8, 13, 21, 34
// Recursive Method
function recursiveFibonacci(num) {
  if (num <= 1) {
    return 1;
  } else {
    return recursiveFibonacci(num - 1) + recursiveFibonacci(num - 2);
  }
}

console.log(recursiveFibonacci(8));

// Non-Recursive Method
function fibonnaci(num) {
  let a = 1, b = 0, temp;
  while (num >= 0) {
    temp = a;
    a = a + b;
    b = temp;
    num--;
  }
  return b;
}

console.log(fibonnaci(7));

// Memoization Method
function fibonnaci(num, memo = {}) {
  if (num in memo) {
    return memo[num];
  }
  if (num <= 1) {
    return 1;
  }
  return (memo[num] = fibonnaci(num - 1, memo) + fibonnaci(num - 2, memo));
}

console.log(fibonnaci(5)); // 8

function reverse(num) {
  let result = 0;
  while (num != 0) {
    result = result * 10;
    result = result + (num % 10);
    num = Math.floor(num / 10);
  }
  return result;
}

console.log(reverse(12345));

let a = [10, 20, 30, 40, 50];

//Approach 1:
console.log(a.reverse());

//Approach 2:
let reverse = a.reduce((prev, current) => {
  prev.unshift(current);
  return prev;
}, []);

console.log(reverse);

function topN(arr, num) {
  let sorted = arr.sort((a, b) => a - b);
  return sorted.slice(sorted.length - num, sorted.length);
}

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

function consecutiveOne(num) {
  let binaryArray = num.toString(2);

  let maxOccurence = 0, occurence = 0;
  for (let val of binaryArray) {
    if (val === "1") {
      occurence += 1;
      maxOccurence = Math.max(maxOccurence, occurence);
    } else {
      occurence = 0;
    }
  }
  return maxOccurence;
}

console.log(consecutiveOne(7)); // 3

// 13 => 1101 = 2
// 5 => 101 = 1
// 7 => 111 = 3

function mergeSortedArray(arr1, arr2) {
  return [...new Set(arr1.concat(arr2))].sort((a, b) => a - b);
}

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

const alphabetize = (word) => word.split("").sort().join("");

function groupAnagram(wordsArr) {
  return wordsArr.reduce((p, c) => {
    const sortedWord = alphabetize(c);
    if (sortedWord in p) {
      p[sortedWord].push(c);
    } else {
      p[sortedWord] = [c];
    }
    return p;
  }, {});
}

console.log(groupAnagram(["map", "art", "how", "rat", "tar", "who", "pam", "shoop"]));

let data = [
  { vid: "aaa", san: 12 },
  { vid: "aaa", san: 18 },
  { vid: "aaa", san: 2 },
  { vid: "bbb", san: 33 },
  { vid: "bbb", san: 44 },
  { vid: "aaa", san: 100 },
];

let newData = data.reduce((acc, item) => {
  acc[item.vid] = acc[item.vid] || { vid: item.vid, san: [] };
  acc[item.vid]["san"].push(item.san);
  return acc;
}, {});

console.log(Object.keys(newData).map((key) => newData[key]));

let obj = (function () {
  function getPrivateFunction() {
    console.log("this is private function");
  }
  let p = "You are accessing private variable";
  return {
    getPrivateProperty: () => {
      console.log(p);
    },
    callPrivateFunction: getPrivateFunction,
  };
})();

obj.getPrivateValue(); // You are accessing private variable
console.log("p" in obj); // false
obj.callPrivateFunction(); // this is private function