1844.

Replace All Digits with

/**
* @param {string} s
* @return {string}
*/
var replaceDigits = function(s) {
let a = '' for(let i = 0; i < s.length; i+
+){ if(i % 2 !== 0){
a += String.fromCharCode(s[i - 1].charCodeAt() + parseInt(s[i]))
}
else{ a += s[i]
}
} return a;
};
 1365. How Many Numbers Are Smaller Than the Current

/**
*@param {number[]} nums
* @return {number[]}
*/
var smallerNumbersThanCurrent = function(nums)
{ let hash = new Map();
let sorted = nums.slice().sort((a,b) => a - b
);
sorted.forEach((number, idx) => hash.has(number)?
null: hash.set(number, idx)
);
return nums.map(x => hash.get(x));
};
1464. Maximum Product of Two Elements in an

/**
* @param {number[]} nums
* @return {number}
*/
var maxProduct = function(nums)
{ let arr =[]
let max1 =Math.max(...nums)
let ind1 =
nums.indexOf(max1) let ex1
=nums.splice(ind1,1)
arr.push(ex1)
let max2 =
Math.max(...nums) let ind2 =
nums.indexOf(max2) let ex2
= nums.splice(ind2, 1)
arr.push(ex2)
let res =(arr[0]-1)*(arr[1]-
1) return res
   922. Sort Array By Parity II

/**
 * @param {number[]} nums
 * @return {number[]}
 */
 var sortArrayByParityII = function(nums) {
    const output = new Array(nums.length);
    let cursorOdd = 1;
    let cursorEven = 0;
    for (let i = 0; i < nums.length; i++) {
        if (nums[i]%2) {
            output[cursorOdd] = nums[i];
            cursorOdd+=2;
        } else {
            output[cursorEven] = nums[i];
            cursorEven+=2;
    }
  }
    return output;
};
   977. Squares of a Sorted Array

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var sortedSquares = function(nums) {
    let start = 0;
    let end = nums.length - 1;
    let idx = end;
    let sortPowArr = [];

    while (idx > -1) {

        if (Math.abs(nums[start]) > Math.abs(nums[end])) {
            sortPowArr[idx--] = nums[start] * nums[start];
            start++;
        } else {
            sortPowArr[idx--] = nums[end] * nums[end];
            end--;
    }
  }
    return sortPowArr;
};
 349. Intersection of Two Arrays

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
var intersection = function(nums1, nums2) {
    const set = new Set(nums1);
    return [...new Set(nums2.filter(n => set.has(n)))];
};
169. Majority Element

/**
 * @param {number[]} nums
 * @return {number}
 */
var majorityElement = function (nums) {
    let candidate;
    let count = 0;
  
    for (const num of nums) {
        if (count === 0) {
            candidate = num;
    }
    
        count += (num === candidate) ? 1 : -1
  }
  
    return candidate;
};
 242. Valid Anagram

/**
 * @param {string} s
 * @param {string} t
 * @return {boolean}
 */
var isAnagram = function(s, t) {
    let map = new Map();
    for(let c of s){
        map.set(c, (map.get(c) | 0) + 1);
  }
    for(let d of t){
        if(map.has(d)){
            map.set(d, map.get(d)-1);
            if(map.get(d) === 0){
                map.delete(d)
      }
        } else {
            return false;
    }
  }
    if(map.size === 0) return true;
    else return false;
};
217. Contains Duplicate

/**
 * @param {number[]} nums
 * @return {boolean}
 */
var containsDuplicate = function(nums) {
    nums.sort((a,b) => a-b);
    for(let i = 0; i <= nums.length-1; i++){
        if(nums[i] === nums[i+1]){
            return true
    }
  }
    return false
};

268. Missing Number 

/**
 * @param {number[]} nums
 * @return {number}
 */
var missingNumber = function (nums) {
  const n = nums.length;
  const expectedSum = (n * (n + 1)) / 2;
  let actualSum = 0;

  for (let i = 0; i < nums.length; i++) {

    actualSum = actualSum + nums[i]
 }
 
  return expectedSum-actualSum
};