Logical Approach to Common Problems

📄 Table of contents

  • check for prime no. in JS
  • print all prime no.s between 2 to 100
  • Fibonacci series
  • Factorial series
  • Palindrome

sum of no.s using rest operator and reduce()

sum of no.s using Recursion

  • swap two variables with & without using 3rd variable
  • reduce() in js
  • balanced parenthesis using js

▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬ ✦ ✦ ✦ ▬▬▬▬▬▬▬▬▬▬▬▬▬▬

◉ Check for Prime No.

source: https://www.w3resource.com/javascript-exercises/javascript-function-exercise-8.php

function test_prime(n) {
if (n === 1) {
return false;
} else if (n === 2) {
return true;
} else {
for (var x = 2; x <= n/2; x++) {
# we cannot start with 3 as in that case the test for 4 will fail.
if (n % x === 0) {
return false;
}
}
return true;
}
}
console.log(test_prime(37)); # true

You can also decrease the complexity of the algorithm from O(n) to O(sqrt(n)) if you run the loop until square root of a number:

With the ES6 syntax:

const isPrime = num => {
if (num === 1) return false;
for(let i = 2, s = Math.sqrt(num); i <= s; i++)
if(num % i === 0) return false;
return num > 1;
}

◉ print all prime no.s between 2 to 100

const isPrime = num => {
let count = 2;
while(count < (num / 2)+1){
if(num % count !== 0){
count++;
continue;
};
return false;
};
return true;
};
const primeBetween = (a, b) => {
let count = 0;
for(let i = Math.min(a, b); i <= Math.max(a, b); i++){
if(isPrime(i)){
count++;
};
};
return count;
};
console.log(primeBetween(2, 21));

◉ Fibonacci series

1,1,2,3,5,8,13,21,34,55,89

source:https://stackoverflow.com/questions/7944239/generating-fibonacci-sequence

var i;
var fib = [];
fib[0] = 0;
fib[1] = 1;
for (i = 2; i <= 10; i++) {
fib[i] = fib[i - 2] + fib[i - 1];
console.log(fib[i]);
}
console.log(fib);
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

◉ Factorial using Recursion

5! = 5 * 4 * 3 * 2 * 1

function factorial(num) {
if (num == 1 || num == 0) {
return 1
}
return num * factorial(num - 1)
}
console.log(factorial(5)); # 120

◉ Palindrome using For loop

function palindrome(str) {
var re = /[^A-Za-z0-9]/g;
str = str.toLowerCase().replace(re, '');
var len = str.length;
for (var i = 0; i < len/2; i++) {
if (str.charAt(i) !== str.charAt(len - 1 - i) {
return false;
}
}
return true; # return true is at end of for loop
}
palindrome("A man, a plan, a canal. Panama");

◉ Removing Duplicates from a single Array

source: https://dev.to/mshin1995/back-to-basics-removing-duplicates-from-an-array-55he

1. Set

The easiest way in my opinion but only supported with ES6.

const arr = [2,3,4,2,3,4]
const uniqueSet = new Set(arr);
const backToArray = [...uniqueSet]

Set is a new data object introduced in ES6. Because Set only lets you store unique values. When you pass in an array, it will remove any duplicate values.

Once the duplicates are gone, we’re going to convert it back to an array by using the spread operator ...

2. forEach()

function removeDuplicates(array) {
let x = {};
array.forEach(function(i) {
if(!x[i]) {
x[i] = true
}
})
return Object.keys(x)
};

Checks to see if each element in the array is unique.

3. filter()

function removeDuplicates(array) {
return array.filter((eachItem, index) => array.indexOf(eachItem) === index)
};

4. map()

function removeDuplicates(array) {
let a = []
array.map(x =>
if(!a.includes(x) {
a.push(x)
})
return a
};

Maps through the array and adds unique elements to a new array.

◉ Remove duplicates from a array of objects JavaScript

Recommended method:

const arr = [
{
"roll_no": 1,
"name": "anil"
},
{
"roll_no": 2,
"name": "sujata"
},
{
"roll_no": 1,
"name": "anil"
},
{
"roll_no": 1,
"name": "anil"
}
];
const x = {};
const newArray = [];
arr.forEach(el => {
if(!x[JSON.stringify(el)]){
x[JSON.stringify(el)] = true;
newArray.push(el);
}
});
console.log(newArray);[
{ roll_no: 1, name: 'anil' },
{ roll_no: 2, name: 'sujata' }
]

Other method:

var values = [
{ name: 'someName1' },
{ name: 'someName2' },
{ name: 'someName4' },
{ name: 'someName2' }
];
var valueArr = values.map(function(item){ return item.name });
console.log(valueArr);
var isDuplicate = valueArr.some(function(item, idx){

return valueArr.indexOf(item) != idx
});
console.log(isDuplicate);

◉ Find if 2 arrays contain any common item ?

source: https://www.geeksforgeeks.org/how-to-find-if-two-arrays-contain-any-common-item-in-javascript/?ref=rp

✍ Method 1:

Time Complexity: O(M + N): (Recommended method)

const arr1 = ['a', 'b', 'c', 'd']; 
const arr2 = ['e', 'f', 'g'];
function findCommonElements2(arr1, arr2) {let obj = {};
for (let i = 0; i < arr1.length; i++) {
if(!obj[arr1[i]]) {
const element = arr1[i];
obj[element] = true;
console.log(obj) ;
}
}
for (let j = 0; j < arr2.length ; j++) {
if(obj[arr2[j]]) {
return true; # "duplicate found"
}
}
return false; # "NO duplicate found"
}
findCommonElements2(arr1, arr2);

✍ Method 2 :

Time Complexity: O(M * N):

const array1 = ['a', 'b', 'c', 'd']; 
const array2 = ['k', 'x', 'z'];

function findCommonElement(array1, array2) {

for(let i = 0; i < array1.length; i++) {
for(let j = 0; j < array2.length; j++) {
if(array1[i] === array2[j]) {
return true;
}
}
}
// Return if no common element exist
return false;
}
findCommonElement(array1, array2);

✍ Method 3:

array1 = array1.filter(function(val) {
return array2.indexOf(val) === -1;
});
function sorter(array)
{
var count = array.length - 1,
swap,
i,
j;
for (i = 0; i< count; i++)
{
for (j = 0; j< count; j++)
{
if (array[j] > array[j + 1])
{
swap = array[j + 1];
array[j + 1] = array[j];
array[j] = swap;
}
}
}
return array;
}
console.log(sorter([1, 0, 1, 1, 0, 0, 1]));
#Result: [0,0,0,1,1,1,1];
const months = ['March', 'Jan', 'Feb', 'Dec'];
months.sort();
console.log(months);
// expected output: Array ["Dec", "Feb", "Jan", "March"]
const array1 = [1, 30, 4, 21, 100000];
array1.sort();
console.log(array1);
// expected output: Array [1, 100000, 21, 30, 4]

To compare numbers instead of strings, the compare function can simply subtract b from a. The following function will sort the array in ascending order (if it doesn't contain Infinity and NaN):

var numbers = [4, 2, 5, 1, 3];
numbers.sort(function(a, b) {
return a - b;
});
console.log(numbers);

// [1, 2, 3, 4, 5]
# using ES6 methodlet numbers = [4, 2, 5, 1, 3];
numbers.sort((a, b) => a - b);
console.log(numbers);

// [1, 2, 3, 4, 5]
var items = [
{ name: 'AAA', value: 4 },
{ name: 'BBB', value: 3 },
{ name: 'CCC', value: 1 },
{ name: 'DDD', value: 2 }
];

// sort by value (which is integer)
items.sort(function (a, b) {
return a.value - b.value;
});
console.log(items);
// sort by name (which is string)
items.sort(function(a, b) {
var nameA = a.name.toUpperCase(); // ignore upper and lowercase
var nameB = b.name.toUpperCase(); // ignore upper and lowercase

if (nameA < nameB) {
return -1;
}
if (nameA > nameB) {
return 1;
}

// names must be equal
return 0;
});
console.log(items);
items
.filter(eachItem => eachItem.value > 2)
.sort((a, b) => a.value - b.value)
.map(eachItem => console.log(eachItem.name + ':' + eachItem.value));

Algorithm

  1. Declare an array and input the array elements.
  2. Start traversing the array and if the current element is negative, swap the current element with the first positive element and continue traversing until all the elements have been encountered.
  3. Print the re-arranged array.

OR

var t = [2, -12, 4, 46, -20, -1];var positiveArr = [];
var negativeArr = [];
t.forEach(function(item) {
if (item < 0) {
negativeArr.push(item);
} else {
positiveArr.push(item)
}
});
console.log(positiveArr) // should output [5, 6, 1]
console.log(negativeArr)

OR

var t = [2, -12, 4, 46, -20, -1];var positiveArr = t.filter((elem) => elem > 0);
var negativeArr = t.filter((elem) => elem < 0);
var result = negativeArr.concat(positiveArr);

OR

source: https://stackoverflow.com/questions/43711407/given-an-array-of-positive-and-negative-integers-rearrange-it-so-that-you-have

var arr = [2, -12, 4, 46, -20, -1],
res = arr.reduce(function(s,a) {
a <= 0 ? s.unshift(a) : s.push(a);
return s;
}, []);

console.log(res);

NOTE: Do you not realise that just sorting the array already does this “negative at the start, positive at the end” thing?

◉ Compare two JavaScript array

source: https://www.geeksforgeeks.org/how-to-compare-two-javascript-array-objects-using-jquery-javascript/?ref=rp

✍ Method 1:

var arr1 = [1, 3, 7, 5]; 
var arr2 = [1, 3, 5, 7];
function compare(arr1, arr2) {
arr1.sort();
arr2.sort();

if(arr1.length != arr2.length)
return false;

for(var i = 0; i < arr1.length; i++) {
if (arr1[i] != arr2[i])
return false;
}
return true;
}
compare(arr1, arr2)

Caveat: sort() doesn’t produce incorrect result when sorting numbers.

◉ Compare two Objects

2 objects (with same keys & same values)

  • Use JSON.stringify() function to convert object into JSON string.
  • Now compare both JSON string using comparison operator (==) to check both array objects are equal or not.
var arr1 = [ 
{id: "1", name: "GeeksforGeeks"},
{id: "2", name: "GFG"}
];

var arr2 = [
{id: "1", name: "GeeksforGeeks"},
{id: "2", name: "GFG"}
];
function compare(ar1, ar2) {
if(JSON.stringify(arr1) === JSON.stringify(arr2)){
return true;
}
else
return false;
}
compare(arr1, arr2);

Note: This method works only when both array objects sorted into the same fashion.

2 objects (with different keys & same values)

There is no direct method in javascript to check whether two objects have the same data or not. however, below is the Pseudo Code:

function hasSameData
if both objects have the same number of keys (properties)
if every key of obj1 matches with the corresponding key
of obj2 and values of the same keys of both objects match.
return true
return false
const obj1 = {
name: 'Ram',
age: 21
};

const obj2 = {
name: 'Ram',
roll_no: 21
};

const haveSameData = function (obj1, obj2) {
const obj1Length = Object.keys(obj1).length;
const obj2Length = Object.keys(obj2).length;

if (obj1Length === obj2Length) {
return Object.keys(obj1).every(
key => obj2.hasOwnProperty(key)
&& obj2[key] === obj1[key]);
}
return true;
};
console.log(haveSameData(obj1, obj2));

◉ Count the occurrence of each character in a string

source: https://stackoverflow.com/questions/19480916/count-number-of-occurrences-for-each-char-in-a-string

var str = "count number of each char in this string";var counts = {};// Misc vars
var ch, index, len, count;
for (index = 0, len = str.length; index < len; ++index) {
ch = str.charAt(index);
count = counts[ch];
console.log("count =>"+ count); // "count =>undefined"
counts[ch] = count ? count + 1 : 1;
}
for (ch in counts) {
console.log(ch + " ==>: " + counts[ch]);
}

Note: The charAt() method of the String class returns the char value at the specified index. The indexOf(int ch, int fromIndex) method of the String class returns the index within this string of the first occurrence of the specified character, starting the search at the specified index.

source:https://medium.com/@paulrohan/parenthesis-matching-problem-in-javascript-the-hacking-school-hyd-7d7708278911

let isMatchingBrackets = function (str) {
let stack = [];
let map = {
'(': ')',
'[': ']',
'{': '}'
}

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

// If character is an opening brace add it to a stack
if (str[i] === '(' || str[i] === '{' || str[i] === '[' ) {
stack.push(str[i]);
}
// If that character is a closing brace, pop from the stack, which will also reduce the length of the stack each time a closing bracket is encountered.
else {
let last = stack.pop();

//If the popped element from the stack, which is the last opening brace doesn’t match the corresponding closing brace in the map, then return false
if (str[i] !== map[last]) {return false};
}
}
// By the completion of the for loop after checking all the brackets of the str, at the end, if the stack is not empty then fail
if (stack.length !== 0) {return false};

return true;
}
console.log(isMatchingBrackets("(){}")); // returns true
console.log(isMatchingBrackets("[{()()}({[]})]({}[({})])((((((()[])){}))[]{{{({({({{{{{{}}}}}})})})}}}))[][][]")); // returns true
console.log(isMatchingBrackets("({(()))}}")); // returns false

source: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat

const arr1 = [1, 2, [3, 4]];
arr1.flat();
// [1, 2, 3, 4]

const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat();
// [1, 2, 3, 4, [5, 6]]

const arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat(2);
// [1, 2, 3, 4, 5, 6]

const arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat(Infinity);
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
const arr5 = [1, 2, , 4, 5];
arr5.flat();
// [1, 2, 4, 5]

Alternatives

const arr = [1, 2, [3, 4]];// To flat single level array
arr.flat();
// is equivalent to
arr.reduce((acc, val) => acc.concat(val), []);
// [1, 2, 3, 4]
// or with decomposition syntax
const flattened = arr => [].concat(...arr);

◉ reverse a string using inbuilt methods

function reverseString(str) {
return str.split("").reverse().join("");
}
reverseString("hello");

split() => split a string into an array of substrings, & returns a new array.

reverse()=> is ONLY applicable on Arrays ( & not String).

join() => join the elements of an array into a string:

◉ reverse an INTEGER using inbuilt methods

The first thing I’d do is to convert the number to a string by calling the inbuilt JavaScript .toString() in-built method.

let myNumber = 23;
let myChar = myNumber.toString().split('').reverse().join('');
console.log(myChar) // returns 32;
console.log(typeof(myChar)) // returns string

So we have successfully reversed the number but the output is still a string and not a number, meaning we cannot perform mathematical operations on our result. To change this back to a number, we would simply wrap this into the JavaScript parseInt() method.

const myNewNumber = parseInt(myChar);console.log(myNewNumber); // returns 32
console.log(typeof(myNewNumber)) // returns number

◉ find the max / min number in an array

const nums = [1, 2, 3]
Math.min(nums) // NaN
Math.max(nums) // NaN

That is because Math.min or Math.max functions expect distinct variables and not an array. So, in order to do that before ES6/ES2015 apply method was used.

var nums = [1, 2, 3]
Math.min.apply(Math, nums) // 1
Math.max.apply(Math, nums) // 3
Math.min.apply(null, nums) // 1
Math.max.apply(null, nums) // 3

With ES6/ES2016 destructuring assignment it becomes easier

The destructuring assignment syntax is a JavaScript expression that makes it possible to extract data from arrays or objects into distinct variables.

const nums = [1, 2, 3]
Math.min(...nums) // 1
Math.max(...nums) // 3
var arr = [3, 6, 2, 56, 32, 5, 89, 32];
var largest = arr[0];

for (var i = 0; i < arr.length; i++) {
if (largest < arr[i] ) {
largest = arr[i];
}
}
console.log(largest);

NOTE:- Above can be done using built-in functions map() + Math.max()

◉ union of 2 arrays

Method 1:

  • Store all elements in a JavaScript object.

Storing elements in JavaScript Object is going to remove the duplicate elements.

  • At the end, push all element in a JavaScript array.
function computeUnion(a, b) { 
var object = {};

for (var i = a.length-1; i >= 0; --i)
object[a[i]] = a[i];

for (var i = b.length-1; i >= 0; --i)
object[b[i]] = b[i];

var ret = []

for (var i in object) {
if (object.hasOwnProperty(i))
ret.push(object[i]);
}
return ret;
}

Method 2 :

var union = [...new Set([...A, ...B])];

◉ merge 2 or more Javascript Arrays

◉ merge 2 Javascript objects

function extend(src, dest) {
for (var key in dest) {
if (dest.hasOwnProperty(key)){
src[key] = dest[key];
}
}
return src;
}
// examplevar a = { foo: true, name: "anil", gender: "male"};
var b = { bar: false, gender: "female", age: 30 };
var c = extend(a, b);
console.log(c);
# {"foo":true,"name":"anil","gender":"female","bar":false,"age":30}
function changeAgeAndReference(person) {
person.age = 25;
person = {
name: 'John',
age: 50
};

return person;
}
var personObj1 = {
name: 'Alex',
age: 30
};
var personObj2 = changeAgeAndReference(personObj1);console.log(personObj1); // -> { name: 'Alex', age: 25 }
console.log(personObj2); // -> { name: 'John', age: 50 }

The variable person in the function contains a reference to the personObj1 object, so initially it acts directly on that object.

Once we reassign person to a new object, it stops affecting the original.

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — -

Output is : Brooke Jonas Dennis 2020 TR

Why? In JS, by default all properties of obj are sorted in following order:

ascending order for number-like keys < string keys

— — — — — — — — — — — — — — — — — — — — — — — — — — — —

◉ Sum of no.s using rest operator and reduce()

Javascript, rest parameter syntax allows us to show an indefinite number of arguments as an array and reduce method is used for reduce array to a single value.

Here, args convert all arguments passed to a function as an array, so you can use reduce() which only applies to an array.

let arr = [10,20,30,40,50];
let [a, b, c, ...d] = arr;
console.log(d); // [40, 50];

When there is a rest parameter we should pass an array as an argument so the answer is [40, 50].

The spread operator (…) allows an expression to be expanded in places where multiple elements/variables/arguments are expected.

When we use the spread operator within Math.min() it will expand, or spread out, our array and insert each variable as a separate parameter into Math.min()!

In other words:

Math.min(...[1,2,3,4]) is the same as Math.min(1,2,3,4)

— — — — — — — — — — — — — — — — — — — — — — — — — — —

◉ 3 ways to SWAP variables in JS :

Knowing how to de-structure an array, it’s easy to use it for swapping variables. Let’s swap the variables a and b using destructuring assignment:

let a = 1;
let b = 2;
[a, b] = [b, a];
a; // => 2
b; // => 1

[a, b] = [b, a] is the de-structuring assignment that swaps the variables a and b.

Let’s swap the values of variables a and b using a temporary variable temp:

let a = 1;
let b = 2;
let temp;
temp = a;
a = b;
b = temp;
a; // => 2
b; // => 1

You can swap variables without the use of additional memory (like a temporary array or variable).

let a = 1;
let b = 2;

a = a + b;
b = a - b;
a = a - b;
a; // => 2
b; // => 1
console.log((variable !== null) && (variable.constructor === Object));

above returns false for nulls, arrays, and functions, but true for objects.

variable.constructor === Array

Some other ways are:

Array.isArray(variable)
arr.slice(0);
arr.slice(-1);
//arr = ["A", "B", "C", "D"];
console.log(arr.toString()); // "A,B,C,D"
console.log(arr + ""); // "A,B,C,D"
console.log(arr.join()); // "A,B,C,D"
console.log(arr.join('+')); // A+B+C+D

Experience with Front-end Technologies and MERN / MEAN Stack. Working on all Major UI Frameworks like React, Angular.