Skip to Content
DifficultyVery easy

Concatenation of Array 

  • Create a new array to hold the concatenated array
  • Loop through the input array and push each element to the new array twice
/**
 * @param {number[]} nums
 * @return {number[]}
 */
var getConcatenation = function (nums) {
  const concatNums = [];
 
  for (let i = 0; i < nums.length; i++) {
    concatNums.push(nums[i]);
  }
 
  for (let i = 0; i < nums.length; i++) {
    concatNums.push(nums[i]);
  }
 
  return concatNums;
};
Complexity
  • Time: O(n)
  • Space: O(n)

Missing Number 

  • The total of the first n natural numbers is n * (n + 1) / 2
  • The difference between the sum of the input array and the total should be the missing number
/**
 * @param {number[]} nums
 * @return {number}
 */
var missingNumber = function (nums) {
  const n = nums.length;
 
  var total = (n * (n + 1)) / 2;
  var sum = 0;
 
  for (var i = 0; i < n; i++) {
    sum = sum + nums[i];
  }
 
  return total - sum;
};
Complexity
  • Time: O(n)
  • Space: O(1)

Single Number 

  • Perform bitwise XOR on all elements in the array
  • The XOR operation will cancel out all duplicate numbers, leaving the single number
/**
 * @param {number[]} nums
 * @return {number}
 */
var singleNumber = function (nums) {
  return nums.reduce((x, y) => x ^ y);
};
Complexity
  • Time: O(n)
  • Space: O(1)

Kids With the Greatest Number of Candies 

  • Find the kid with the most candies & check if each kid can have the most candies by adding extra candies
  • Max can also be easily found using Math.max(...candies)
/**
 * @param {number[]} candies
 * @param {number} extraCandies
 * @return {boolean[]}
 */
var kidsWithCandies = function (candies, extraCandies) {
  // find the kid with the most candies
  let max = 0;
  for (let i = 0; i < candies.length; i++) {
    if (max < candies[i]) {
      max = candies[i];
    }
  }
 
  // check if each kid can have the most candies
  for (let i = 0; i < candies.length; i++) {
    candies[i] = candies[i] + extraCandies >= max;
  }
 
  return candies;
};
Complexity
  • Time: O(n)
  • Space: O(n)

Count Tested Devices After Test Operations 

  • Keep track of the number of devices that have been tested
  • Increment the count if the battery percentage is greater than the current count
/**
 * @param {number[]} batteryPercentages
 * @return {number}
 */
var countTestedDevices = function (batteryPercentages) {
  let count = 0;
 
  for (let i = 0; i < batteryPercentages.length; i++) {
    if (batteryPercentages[i] > count) {
      count++;
    }
  }
 
  return count;
};
Complexity
  • Time: O(n)
  • Space: O(1)

Remove Duplicates from Sorted Array 

  • Use 2 pointers to keep track of the current and next unique element
  • Iterate through the array and update the next unique element when a new unique element is found
/**
 * @param {number[]} nums
 * @return {number}
 */
var removeDuplicates = function (nums) {
  let pointer = -1;
 
  for (let i = 0; i < nums.length; i++) {
    if (nums[pointer] !== nums[i]) {
      // Found a new unique element
      pointer++;
      nums[pointer] = nums[i];
    }
  }
 
  return pointer + 1; // Return the length of the unique elements
};
Complexity
  • Time: O(n)
  • Space: O(1)

Palindrome Number 

  • Build a number starting with the last digit of the input number using modulo and division
  • Compare the reversed number with the input number
/**
 * @param {number} x
 * @return {boolean}
 */
var isPalindrome = function (x) {
  if (x < 0) {
    // if negative number
    return false;
  }
 
  let reverse = 0, value = x;
  while (value > 0) {
    const remainder = value % 10; // get the last digit
    reverse = remainder + reverse * 10; // build the reversed number
    value = Math.floor(value / 10); // remove the last digit
  }
 
  return reverse === x;
};
Complexity
  • Time: O(digits)
  • Space: O(1)

Reverse Integer 

  • Reverse the number without sign and check for overflow
  • Use the sign to return the reversed number with the correct sign
/**
 * @param {number} x
 * @return {number}
 */
var reverse = function (x) {
  const limit = Math.pow(2, 31);
  const isPositive = x > 0;
 
  let value = Math.abs(x); // remove the sign
  let reverse = 0;
  while (value > 0) {
    const remainder = value % 10;
    value = Math.floor(value / 10);
    reverse = remainder + 10 * reverse;
  }
 
  // check for overflow
  if (isPositive && reverse >= limit) {
    return 0;
  } else if (!isPositive && reverse > limit) {
    return 0;
  }
 
  // return the reversed number with the correct sign
  return isPositive ? reverse : -reverse;
};
Complexity
  • Time: O(digits)
  • Space: O(1)

Reverse String 

  • Use two pointers to swap the items between left and right
  • Continue swapping until left is less than right
/**
 * @param {character[]} s
 * @return {void} Do not return anything, modify the string in-place instead
 */
var reverseString = function (s) {
  const length = s.length;
 
  for (let left = 0, right = length - 1; left < right; left++, right--) {
    // swap the items between left and right
    const temp = s[left];
    s[left] = s[right];
    s[right] = temp;
  }
};
Complexity
  • Time: O(n)
  • Space: O(1)

Running Sum of 1d Array 

  • Naive approach would be to calculate the sum of all the array elements before the current index for every element, in to a new array.
  • Simpler and better approach would be to replace the current element by its sum with the previous element
/**
 * @param {number[]} nums
 * @return {number[]}
 */
var runningSum = function (nums) {
  for (let i = 1; i < nums.length; i++) {
    nums[i] += nums[i - 1];
  }
  return nums;
};
Complexity
  • Time: O(n)
  • Space: O(1)

Shuffle the Array 

  • Simple solution would be to create a new array and shift the elements in the order given
/**
 * @param {number[]} nums
 * @param {number} n
 * @return {number[]}
 */
var shuffle = function (nums, n) {
  const newNums = [];
 
  for (let i = 0, j = n; i < n; i++, j++) {
    newNums.push(nums[i], nums[j]);
  }
 
  return newNums;
};
Complexity
  • Time: O(n)
  • Space: O(n)

Fibonacci Number 

  • A good approach would be calculate the nth fibonacci number either recursively or iteratively
  • As we know nth fibonacci number is sum of n-1 th and n-2th fibonacci numbers, we can start from 1st position till we calculate nth.
/**
 * @param {number} n
 * @return {number}
 */
var fib = function (n) {
  // initialize 0th and 1st fibonacci numbers
  let fib1 = 0, fib2 = 1;
 
  for (let i = 1; i <= n; i++) {
    temp = fib2;
    fib2 = fib1 + fib2; // next fibonacci number is sum of current and next
    fib1 = temp; // current fibonacci number is next fibonacci number
  }
 
  return fib1;
};
Complexity
  • Time: O(n)
  • Space: O(1)

  • Binary search is a search algorithm that finds the position of a target value within a sorted array
/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var search = function (nums, target) {
  let left = 0, right = nums.length - 1;
 
  while (left <= right) {
    const mid = Math.floor((left + right) / 2);
 
    if (nums[mid] === target) {
      return mid;
    } else if (nums[mid] > target) {
      right = mid - 1;
    } else {
      left = mid + 1;
    }
  }
 
  return -1;
};
Complexity
  • Time: O(log(n))
  • Space: O(1)

Check If Two String Arrays are Equivalent 

  • Having 2 array, convert array into string, with one by one check if every character matches return true else false
/**
 * @param {string[],string[]} nums
 * @return {boolean}
 */
const stringComparison = (word1, word2) => {
  let word1String = word1.join('');
  let word2String = word2.join('');
  if (word1String?.length != word2String?.length) return false;
 
  for (let i = 0; i < word1String?.length; i++) {
    if (word1String[i] != word2String[i]) {
      return false;
    }
  }
  return true;
};
Complexity
  • Time: O(n)
  • Space: O(1)

Max Consecutive Ones 

  • Use a counter to keep track of the number of consecutive ones
  • Update the maximum count when a zero is encountered
/**
 * @param {number[]} nums
 * @return {number}
 */
var findMaxConsecutiveOnes = function (nums) {
  let count = 0, max = 0;
 
  for (const num of nums) {
    if (num) {
      count++;
    } else {
      max = Math.max(max, count);
      count = 0;
    }
  }
 
  return Math.max(max, count); // Edge case when the array ends with 1
};
Complexity
  • Time: O(n)
  • Space: O(1)
Last updated on
HomeEasy