What is LeetCode?
LeetCode defines itself as
LeetCode is the best platform to help you enhance your skills, expand your knowledge and prepare for technical interviews.
Is it truly the best? That's debatable (I will explain in another article) however it's very useful and it's been a standard for interviews - especially from FAANG companies (or MAANG now) - since the tech boom and the need to filter candidates.
I personally like it because I generally enjoy challenging programming problems but most people use the platform just to prepare for interviews.
LeetCode has something called "Explore Cards" so I decided to dive into Arrays
Next you will find all the problems and its solutions with comments.
The full repository is here. And you can find me on Twitter @tekbog
Given a binary array nums, return the maximum number of consecutive 1's in the array.
Solution:
var findMaxConsecutiveOnes = function(nums) {
var contmax = 0;
var cont = 0;
for(let i = 0; i < nums.length; i++){
if(nums[i]){
cont++;
} else {
console.log("it's a zero " +i)
console.log("cont is "+cont)
contmax = Math.max(cont, contmax);
cont = 0;
}
}
return cont > contmax ? cont: contmax;
};
Given an array nums of integers, return how many of them contain an even number of digits.
Solution:
var findNumbers = function(nums) {
console.log(...nums)
let count = 0;
for (let num of nums){
console.log(num.toString().split(''))
let innerNum = num.toString().split('')
if (innerNum.length % 2 === 0){
count++
}
}
return count;
};
Given an integer array nums sorted in non-decreasing order, return an array of the squares of each number sorted in non-decreasing order.
Solution:
var sortedSquares = function(nums) {
let arr = [];
for (let i of nums){
arr.push(i*i)
}
console.log(arr)
arr.sort((a,b) => a-b)
console.log(arr)
return arr
};
Given a fixed-length integer array arr, duplicate each occurrence of zero, shifting the remaining elements to the right.
Note that elements beyond the length of the original array are not written. Do the above modifications to the input array in place and do not return anything.
Solution:
var duplicateZeros = function(arr) {
for (var i=0; i<arr.length; i++) {
if (arr[i] === 0) {
arr.splice(i, 0, 0);
arr.pop();
i+=1
}
}
};
You are given two integer arrays nums1 and nums2, sorted in non-decreasing order, and two integers m and n, representing the number of elements in nums1 and nums2 respectively.
Merge nums1 and nums2 into a single array sorted in non-decreasing order.
The final sorted array should not be returned by the function, but instead be stored inside the array nums1. To accommodate this, nums1 has a length of m + n, where the first m elements denote the elements that should be merged, and the last n elements are set to 0 and should be ignored. nums2 has a length of n.
Solution:
var merge = function(nums1, m, nums2, n) {
for (let i = 0; i < n; i++){
console.log(nums1[m])
nums1[m] = nums2[i]
console.log(nums1[m])
m++
}
nums1.sort((a,b) => a - b);
console.log(nums1)
};
Given an integer array nums and an integer val, remove all occurrences of val in nums in-place. The relative order of the elements may be changed.
Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the first part of the array nums. More formally, if there are k elements after removing the duplicates, then the first k elements of nums should hold the final result. It does not matter what you leave beyond the first k elements.
Return k after placing the final result in the first k slots of nums.
Do not allocate extra space for another array. You must do this by modifying the input array in-place with O(1) extra memory.
Solution:
const removeElement = (nums, val) => {
for (let i = 0; i < nums.length; i++) {
if (nums[i] === val) {
nums.splice(i, 1);
i--;
}
}
return nums.length;
};
Given an integer array nums sorted in non-decreasing order, remove the duplicates in-place such that each unique element appears only once. The relative order of the elements should be kept the same.
Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the first part of the array nums. More formally, if there are k elements after removing the duplicates, then the first k elements of nums should hold the final result. It does not matter what you leave beyond the first k elements.
Return k after placing the final result in the first k slots of nums.
Solution:
var removeDuplicates = function(nums) {
for (let i = 0; i < nums.length; i++) {
if (nums[i] === nums[i + 1]) {
nums.splice(i, 1)
i--
}
}
};
Given an array arr of integers, check if there exists two integers N and M such that N is the double of M ( i.e. N = 2 * M).
Solution:
var checkIfExist = function(arr) {
let res = false;
console.log(`arr is ${arr}`);
arr.forEach( (e, i) => {
if(arr.indexOf(e*2) !== -1){
if(arr.lastIndexOf(e*2) !== arr.indexOf(arr[i])){
res = true
}
}
}
)
return res
};
Given an array of integers arr, return true if and only if it is a valid mountain array.
Solution:
var validMountainArray = function(arr) {
let max = Math.max(...arr);
let maxIndex = arr.indexOf(max);
console.log(`max is ${max}`);
console.log(`maxIndex is ${maxIndex}`);
if(maxIndex === 0 || maxIndex === arr.length-1){
return false;
}
for(let i = 0; i < maxIndex; i++){
console.log('first half');
console.log(`is is ${i} i+1 is ${i+1}`);
if(arr[i] > arr[i+1] || arr[i] === arr[i+1]){
return false;
}
}
for(let i = maxIndex; i < arr.length; i++){
console.log('second half');
console.log(`is is ${i} i+1 is ${i+1}`);
if(arr[i] < arr[i+1] || arr[i] === arr[i+1]){
return false;
}
}
return true;
};
Given an array arr, replace every element in that array with the greatest element among the elements to its right, and replace the last element with -1.
After doing so, return the array.
Solution:
var replaceElements = function(arr) {
console.log(arr);
for(let i = 0; i < arr.length-1; i++){
let max = arr[i+1];
for(let j = i+1; j<arr.length; j++){
if(arr[j] > max){
max = arr[j];
}
}
arr[i] = max;
}
arr[arr.length-1] = -1;
return arr;
};
Given an integer array nums sorted in non-decreasing order, remove the duplicates in-place such that each unique element appears only once. The relative order of the elements should be kept the same.
Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the first part of the array nums. More formally, if there are k elements after removing the duplicates, then the first k elements of nums should hold the final result. It does not matter what you leave beyond the first k elements.
Return k after placing the final result in the first k slots of nums.
Do not allocate extra space for another array. You must do this by modifying the input array in-place with O(1) extra memory.
Solution:
var removeDuplicates = function(nums) {
for (let i = 0; i < nums.length; i++) {
if (nums[i] === nums[i + 1]) {
nums.splice(i, 1)
i--
}
}
};
###Move Zeroes
Given an integer array nums, move all 0's to the end of it while maintaining the relative order of the non-zero elements.
Solution:
var moveZeroes = function(nums) {
console.log(nums);
if (nums.length === 0) return
let positiveEleTracker = 0, j = 0
while (j < nums.length) {
if (nums[j] !== 0) {
nums[positiveEleTracker] = nums[j]
positiveEleTracker++
}
j++
}
console.log(nums);
while (positiveEleTracker < nums.length) {
nums[positiveEleTracker] = 0
positiveEleTracker++
}
console.log(nums);
}
Given an integer array nums, move all the even integers at the beginning of the array followed by all the odd integers.
Return any array that satisfies this condition.
Solution:
var sortArrayByParity = function(nums) {
if(nums.length === 0) return nums;
let evenIndex = 0;
for(let i =0; i< nums.length; i++){
if(nums[i] % 2 == 0){
console.log(nums[i]);
let oddTempVal = nums[evenIndex];
console.log("temp is "+oddTempVal);
nums[evenIndex] = nums[i];
evenIndex++;
nums[i] = oddTempVal;
}
}
console.log(nums);
return nums;
};
Given an integer array nums and an integer val, remove all occurrences of val in nums in-place. The relative order of the elements may be changed.
Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the first part of the array nums. More formally, if there are k elements after removing the duplicates, then the first k elements of nums should hold the final result. It does not matter what you leave beyond the first k elements.
Return k after placing the final result in the first k slots of nums.
Do not allocate extra space for another array. You must do this by modifying the input array in-place with O(1) extra memory.
Solution:
const removeElement = (nums, val) => {
for (let i = 0; i < nums.length; i++) {
if (nums[i] === val) {
nums.splice(i, 1);
i--;
}
}
return nums.length;
};
A school is trying to take an annual photo of all the students. The students are asked to stand in a single file line in non-decreasing order by height. Let this ordering be represented by the integer array expected where expected[i] is the expected height of the ith student in line.
You are given an integer array heights representing the current order that the students are standing in. Each heights[i] is the height of the ith student in line (0-indexed).
Return the number of indices where heights[i] != expected[i].
Solution:
var heightChecker = function(heights) {
const sorted = [...heights].sort((a,b) => a - b)
console.log(heights);
console.log(sorted);
let diffCount = 0;
for(let i = 0; i<heights.length; i++){
if(heights[i] !== sorted[i]){
console.log("diff");
diffCount++;
}
}
console.log(diffCount);
return diffCount;
};
Given an integer array nums, return the third distinct maximum number in this array. If the third maximum does not exist, return the maximum number.
Solution:
var thirdMax = function(nums) {
const nonDupArr = [...new Set(nums)];
nonDupArr.sort((a,b) => b-a);
console.log(nonDupArr);
const thirdNum = nonDupArr[2];
return nonDupArr.length < 3 ? Math.max(...nonDupArr) : thirdNum;
};
Given an array nums of n integers where nums[i] is in the range [1, n], return an array of all the integers in the range [1, n] that do not appear in nums.
Solution:
var findDisappearedNumbers = function(nums) {
const maxRange = nums.length;
console.log(maxRange);
let res = [];
for(let i = 1; i <= maxRange; i++){
let found = false;
for(let j = 0; j < nums.length; j++){
if (i === nums[j]){
found = true;
}
}
if (!found){
res.push(i);
}
}
console.log(res);
return res;
};
Given an integer array nums sorted in non-decreasing order, return an array of the squares of each number sorted in non-decreasing order.
Solution:
var sortedSquares = function(nums) {
let arr = [];
for (let i of nums){
arr.push(i*i)
}
console.log(arr)
arr.sort((a,b) => a-b)
console.log(arr)
return arr
};
