1122. Relative Sort Array

 Given two arrays arr1 and arr2, the elements of arr2 are distinct, and all elements in arr2 are also in arr1.

Sort the elements of arr1 such that the relative ordering of items in arr1 are the same as in arr2. Elements that do not appear in arr2 should be placed at the end of arr1 in ascending order.

 

Example 1:

Input: arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]
Output: [2,2,2,1,4,3,3,9,6,7,19]

Example 2:

Input: arr1 = [28,6,22,8,44,17], arr2 = [22,28,8,6]
Output: [22,28,8,6,17,44]

 

Constraints:

• 1 <= arr1.length, arr2.length <= 1000
• 0 <= arr1[i], arr2[i] <= 1000
• All the elements of arr2 are distinct.
• Each arr2[i] is in arr1.

Soln:

In JS;

var relativeSortArray = function(arr1, arr2) {

    let result = [];

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

      let count = 0;

      for (let index = 0; index < arr1.length; index++) {

        if (arr1[index] === arr2[i]) {

          count += 1;

        }

      }

      for(let j=0; j<count; j++){

        result.push(arr2[i]);

      }

      arr1 = arr1.filter(function(item) {

        return item !== arr2[i];

      })

    }

    arr1.sort(function(a, b){return a - b});

    let final = [...result, ...arr1];

    return final;

};

832. Flipping an Image

 Given an n x n binary matrix image, flip the image horizontally, then invert it, and return the resulting image.

To flip an image horizontally means that each row of the image is reversed.

• For example, flipping [1,1,0] horizontally results in [0,1,1].

To invert an image means that each 0 is replaced by 1, and each 1 is replaced by 0.

• For example, inverting [0,1,1] results in [1,0,0].

 

Example 1:

Input: image = [[1,1,0],[1,0,1],[0,0,0]]
Output: [[1,0,0],[0,1,0],[1,1,1]]
Explanation: First reverse each row: [[0,1,1],[1,0,1],[0,0,0]].
Then, invert the image: [[1,0,0],[0,1,0],[1,1,1]]

Example 2:

Input: image = [[1,1,0,0],[1,0,0,1],[0,1,1,1],[1,0,1,0]]
Output: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]
Explanation: First reverse each row: [[0,0,1,1],[1,0,0,1],[1,1,1,0],[0,1,0,1]].
Then invert the image: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]

 

Constraints:

• n == image.length
• n == image[i].length
• 1 <= n <= 20
• images[i][j] is either 0 or 1.

Soln:

In JS:

var flipAndInvertImage = function(image) {

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

        image[i].reverse();

    }

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

      for(let j=0; j<image[i].length; j++){

        image[i][j] = image[i][j]^1;

      }

    }

    return image;

};

268. Missing Number

 Given an array nums containing n distinct numbers in the range [0, n], return the only number in the range that is missing from the array.

 

Example 1:

Input: nums = [3,0,1]
Output: 2
Explanation: n = 3 since there are 3 numbers, so all numbers are in the range [0,3]. 2 is the missing number in the range since it does not appear in nums.

Example 2:

Input: nums = [0,1]
Output: 2
Explanation: n = 2 since there are 2 numbers, so all numbers are in the range [0,2]. 2 is the missing number in the range since it does not appear in nums.

Example 3:

Input: nums = [9,6,4,2,3,5,7,0,1]
Output: 8
Explanation: n = 9 since there are 9 numbers, so all numbers are in the range [0,9]. 8 is the missing number in the range since it does not appear in nums.

 

Constraints:

• n == nums.length
• 1 <= n <= 104
• 0 <= nums[i] <= n
• All the numbers of nums are unique.

 

Follow up: Could you implement a solution using only O(1) extra space complexity and O(n) runtime complexity?

Soln:

In JS:

var missingNumber = function(nums) {

    let result;

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

      if(!nums.includes(i)){

        result = i;

      }

    }

    return result;

};

867. Transpose Matrix

 Given a 2D integer array matrix, return the transpose of matrix.

The transpose of a matrix is the matrix flipped over its main diagonal, switching the matrix's row and column indices.

 

Example 1:

Input: matrix = [[1,2,3],[4,5,6],[7,8,9]]
Output: [[1,4,7],[2,5,8],[3,6,9]]

Example 2:

Input: matrix = [[1,2,3],[4,5,6]]
Output: [[1,4],[2,5],[3,6]]

 

Constraints:

• m == matrix.length
• n == matrix[i].length
• 1 <= m, n <= 1000
• 1 <= m * n <= 105
• -109 <= matrix[i][j] <= 109

Soln:

In JS:

var transpose = function(matrix) {

    const result = [];

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

        for (let j = 0; j < matrix[0].length; j++) {

            if (!result[j]) result[j] = [];

            result[j].push(matrix[i][j])

        }

    }

    return result;

};

1572. Matrix Diagonal Sum

 Given a square matrix mat, return the sum of the matrix diagonals.

Only include the sum of all the elements on the primary diagonal and all the elements on the secondary diagonal that are not part of the primary diagonal.

 

Example 1:

Input: mat = [[1,2,3],
              [4,5,6],
              [7,8,9]]
Output: 25
Explanation: Diagonals sum: 1 + 5 + 9 + 3 + 7 = 25
Notice that element mat[1][1] = 5 is counted only once.

Example 2:

Input: mat = [[1,1,1,1],
              [1,1,1,1],
              [1,1,1,1],
              [1,1,1,1]]
Output: 8

Example 3:

Input: mat = [[5]]
Output: 5

 

Constraints:

• n == mat.length == mat[i].length
• 1 <= n <= 100
• 1 <= mat[i][j] <= 100

Soln:

In JS:

var diagonalSum = function(mat) {

    let sum = 0;

    let n = mat.length;

    for(let i=0; i<n; i++){

      for(let j=0; j<n; j++){

       if(i == j || (i + j) == (n - 1)){

         sum = sum + mat[i][j];

       }

      }

    }

return sum;

};

2053. Kth Distinct String in an Array

 A distinct string is a string that is present only once in an array.

Given an array of strings arr, and an integer k, return the kth distinct string present in arr. If there are fewer than k distinct strings, return an empty string "".

Note that the strings are considered in the order in which they appear in the array.

 

Example 1:

Input: arr = ["d","b","c","b","c","a"], k = 2
Output: "a"
Explanation:
The only distinct strings in arr are "d" and "a".
"d" appears 1st, so it is the 1st distinct string.
"a" appears 2nd, so it is the 2nd distinct string.
Since k == 2, "a" is returned. 

Example 2:

Input: arr = ["aaa","aa","a"], k = 1
Output: "aaa"
Explanation:
All strings in arr are distinct, so the 1st string "aaa" is returned.

Example 3:

Input: arr = ["a","b","a"], k = 3
Output: ""
Explanation:
The only distinct string is "b". Since there are fewer than 3 distinct strings, we return an empty string "".

 

Constraints:

• 1 <= k <= arr.length <= 1000
• 1 <= arr[i].length <= 5
• arr[i] consists of lowercase English letters.

In JS:

var kthDistinct = function(arr, k) {

   var res = arr.filter(function(v) {

    return arr.indexOf(v) == arr.lastIndexOf(v);

    });

    if(res.length<k) return "";

    else 

        return  result = res[k-1];

};

1295. Find Numbers with Even Number of Digits

 Given an array nums of integers, return how many of them contain an even number of digits.

 

Example 1:

Input: nums = [12,345,2,6,7896]
Output: 2
Explanation: 
12 contains 2 digits (even number of digits). 
345 contains 3 digits (odd number of digits). 
2 contains 1 digit (odd number of digits). 
6 contains 1 digit (odd number of digits). 
7896 contains 4 digits (even number of digits). 
Therefore only 12 and 7896 contain an even number of digits.

Example 2:

Input: nums = [555,901,482,1771]
Output: 1 
Explanation: 
Only 1771 contains an even number of digits.

 

Constraints:

• 1 <= nums.length <= 500
• 1 <= nums[i] <= 105

In JS:

var findNumbers = function(nums) {

    let count = 0;

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

      let value = nums[i].toString();

      if(value.length % 2 == 0) count++;

    }

    return count;

};

1351. Count Negative Numbers in a Sorted Matrix

 Given a m x n matrix grid which is sorted in non-increasing order both row-wise and column-wise, return the number of negative numbers in grid.

 

Example 1:

Input: grid = [[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]]
Output: 8
Explanation: There are 8 negatives number in the matrix.

Example 2:

Input: grid = [[3,2],[1,0]]
Output: 0

 

Constraints:

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 100
• -100 <= grid[i][j] <= 100

 

Follow up: Could you find an O(n + m) solution?

In JS:

var countNegatives = function(grid) {

    let count = 0;

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

       for(let j=0; j<grid[i].length; j++){

         if(grid[i][j] < 0) count ++;

       }

     }

     return count;

};