PROGRAMMING QUESTIONS ON JAVASCRIPT
1) Reverse a String
A) Using inbuilt methods:
function reverseString(str) {
return [Link]("").reverse().join("");
}
B) Using reduce method
const str = "hello";
const reversed = str
.split("")
.reduce((acc, char) => char + acc, "");
[Link](reversed); // "olleh"
C) Using Filter method
const str = "hello";
const arr = [];
[Link]("").filter((char, index, original) => {
[Link](original[[Link] - 1 - index]);
});
[Link]([Link]("")); // "olleh"
D) Using map method
const str = "hello";
const reversed = str
.split("")
.map((_, i, arr) => arr[[Link] - 1 - i])
.join("");
[Link](reversed); // "olleh"
B) Without inbuilt methods
function reverseString(str) {
let rev = "";
for (let i = [Link] - 1; i >= 0; i--) {
rev += str[i];
}
return rev;
}
2) Check if a String is Palindrome
A) Using inbuilt methods
function isPalindrome(str) {
return str === [Link]("").reverse().join("");
}
B)Using reduce methods
function isPalindrome(str) {
const reversed = str
.split("")
.reduce((acc, ch) => ch + acc, "");
return str === reversed;
}
[Link](isPalindrome("madam")); // true
[Link](isPalindrome("hello")); // false
C) Using map methods
function isPalindrome(str) {
const reversed = str
.split("")
.map((_, i, arr) => arr[[Link] - 1 - i])
.join("");
return str === reversed;
}
[Link](isPalindrome("level")); // true
[Link](isPalindrome("world")); // false
D) Using filter methods
function isPalindrome(str) {
const chars = [Link]("");
let reversed = [];
[Link]((_, i, arr) => {
[Link](arr[[Link] - 1 - i]);
return true; // just to allow iteration
});
return str === [Link]("");
}
[Link](isPalindrome("racecar")); // true
[Link](isPalindrome("chatgpt")); // false
E) Without INBUILT METHODS
function isPalindrome(str) {
let i = 0, j = [Link] - 1;
while (i < j) {
if (str[i] !== str[j]) return false;
i++;
j--;
}
return true;
}
3) Find the Largest Number in Array
A) Using inbuilt methods
function largest(arr) {
return [Link](...arr);
}
B) Using Reduce methods (BEST WAY)
const arr = [10, 50, 3, 99, 24];
const largest = [Link]((max, num) =>
num > max ? num : max
);
[Link](largest); // 99
✔ reduce() is the correct method for this problem.
C) Using Filter method
const arr = [10, 50, 3, 99, 24];
let max = arr[0];
[Link](num => {
if (num > max) max = num;
return true; // keep all elements, just using filter to iterate
});
[Link](max); // 99
D) Using Map method
const arr = [10, 50, 3, 99, 24];
let max = arr[0];
[Link](num => {
if (num > max) max = num;
});
[Link](max); // 99
E) Without inbuilt methods
function findMax(arr) {
let max = arr[0];
for (let i = 1; i < [Link]; i++) {
if (arr[i] > max) max = arr[i];
}
return max;1
4) Count Occurrence of Each Character
A) Using inbuilt methods
function countChar(str) {
return [Link]("").reduce((acc, ch) => {
acc[ch] = (acc[ch] || 0) + 1;
return acc;
}, {});
}
B) Without inbuilt method
function countChar(str) {
let freq = {};
for (let char of str) {
if (freq[char]) freq[char]++;
else freq[char] = 1;
}
return freq;
}
5) Remove Duplicates from Array
A) Using methods
function removeDuplicates(arr) {
return [...new Set(arr)];
}
B) Without Methods
let arr = [1, 2, 2, 3, 4, 4, 5];
let unique = [];
for (let i = 0; i < [Link]; i++) {
if () {
[Link](arr[i]);
}
}
[Link](unique); // [1, 2, 3, 4, 5]
C) Using filter methods
let arr = [1, 2, 2, 3, 4, 4, 5];
let unique = [Link]((value, index) => {
return [Link](value) === index;
});
[Link](unique); // [1, 2, 3, 4, 5]
D) Using reduce method
let arr = [1, 2, 2, 3, 4, 4, 5];
let unique = [Link]((acc, curr) => {
if () {
[Link](curr);
}
return acc;
}, []);
[Link](unique); // [1, 2, 3, 4, 5]
E) Using Object as Hashmap (Very Common in Interviews)
let arr = [1, 2, 2, 3, 4, 4, 5];
let obj = {};
let unique = [];
for (let num of arr) {
if (!obj[num]) {
obj[num] = true;
[Link](num);
}
}
[Link](unique); // [1, 2, 3, 4, 5]
6) Sum of Array
A) Without Methods
function sum(arr) {
let s = 0;
for (let n of arr) s += n;
return s;
}
[Link](sum([1,2,3,4]));
B) With reduce
[Link]([1,2,3,4].reduce((a,b)=>a+b,0));
7) Merge Two Arrays
Method 1: Using concat()
let arr1 = [1, 2, 3];
let arr2 = [4, 5, 6];
let merged = [Link](arr2);
[Link](merged); // [1, 2, 3, 4, 5, 6]
Method 2: Using Spread Operator …
let arr1 = [1, 2, 3];
let arr2 = [4, 5, 6];
let merged = [...arr1, ...arr2];
[Link](merged); // [1, 2, 3, 4, 5, 6]
Method 3: Using push() with Spread
let arr1 = [1, 2, 3];
let arr2 = [4, 5, 6];
[Link](...arr2);
[Link](arr1); // [1, 2, 3, 4, 5, 6]
Method 4:(WITHOUT Methods)
let arr1 = [1, 2, 3];
let arr2 = [4, 5, 6];
let merged = [];
for (let i = 0; i < [Link]; i++) {
merged[[Link]] = arr1[i];
}
for (let j = 0; j < [Link]; j++) {
merged[[Link]] = arr2[j];
}
[Link](merged); // [1, 2, 3, 4, 5, 6]
8) Sort Array
Method 1: Using sort() — Ascending
let arr = [5, 3, 8, 1, 2];
[Link]((a, b) => a - b);
[Link](arr); // [1, 2, 3, 5, 8]
Method 2: Using sort() — Descending
let arr = [5, 3, 8, 1, 2];
[Link]((a, b) => b - a);
[Link](arr); // [8, 5, 3, 2, 1]
Method 3: (WITHOUT Methods) Bubble Sort (Ascending)
let arr = [5, 3, 8, 1, 2];
for (let i = 0; i < [Link]; i++) {
for (let j = 0; j < [Link] - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
// swap
let temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
[Link](arr); // [1, 2, 3, 5, 8]
Bubble Sort (Descending)
let arr = [5, 3, 8, 1, 2];
for (let i = 0; i < [Link]; i++) {
for (let j = 0; j < [Link] - i - 1; j++) {
if (arr[j] < arr[j + 1]) {
let temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
[Link](arr); // [8, 5, 3, 2, 1]
9) Anagram Check
A) Without Methods:
function anagram(a,b){
if([Link] !== [Link]) return false;
let count = {};
for (let x of a) count[x] = (count[x]||0) + 1;
for (let x of b) {
if (!count[x]) return false;
count[x]--;
}
return true;
}
[Link](anagram("listen", "silent"));
B) With methods
function isAn(a,b){
return [Link]("").sort().join("") === [Link]("").sort().join("");
}
[Link](isAn("listen","silent"));
10) 2nd Largest Number
A) Without Methods
function secondLargest(arr) {
let max = -Infinity, sec = -Infinity;
for (let n of arr) {
if (n > max) {
sec = max;
max = n;
} else if (n > sec && n !== max) {
sec = n;
}
}
return sec;
}
[Link](secondLargest([1,5,3,9,7]));
B) With methods
let arr = [10, 5, 20, 8, 15];
let secondLargest = [Link]((a, b) => b - a)[1];
[Link](secondLargest); // 15
11) Flatten Array
Without (recursion)
function flat(arr) {
let result = [];
for (let el of arr) {
if ([Link](el)) [Link](...flat(el));
else [Link](el);
}
return result;
}
[Link](flat([1,[2,[3,4]],5]));
With
[Link]([1,[2,[3,4]],5].flat(Infinity));
12) Reverse Array
A) Without methods
function revArr(arr){
let res = [];
for (let i = [Link]-1; i >= 0; i--) {
[Link](arr[i]);
}
return res;
}
[Link](revArr([1,2,3,4]));
B) With methods
let arr =[1,2,3,4]
[Link]([Link]());
13) Capitalize First Letter of Each Word
A) Without Methods
function cap(str){
let res = "";
let words = [Link](" ");
for (let w of words) {
res += w[0].toUpperCase() + [Link](1) + " ";
}
return [Link]();
}
[Link](cap("hello world"));
B) With methods
let str = "hello world"
[Link]([Link](" ").map(w => w[0].toUpperCase() + [Link](1)).join(" "));
14) Prime Check
function prime(n){
if (n < 2) return false;
for (let i=2;i<=[Link](n);i++){
if (n % i === 0) return false;
}
return true;
}
[Link](prime(11));
15) Fibonacci
function fib(n){
let arr = [0,1];
for (let i=2;i<n;i++) arr[i] = arr[i-1] + arr[i-2];
return arr;
}
[Link](fib(7));
16) Factorial
A) Without methods
function fact(n){
let f = 1;
for (let i=1;i<=n;i++) f *= i;
return f;
}
[Link](fact(5));
B) With recursion
function factR(n){
return n === 1 ? 1 : n * factR(n-1);
}
[Link](factR(5));
17) Find the first non-repeating character in a string
A) With methods
function firstNonRepeating(str) {
for (let char of str) {
if ([Link](char) === [Link](char)) {
return char;
}
}
return null;
}
[Link](firstNonRepeating("swiss")); // w
B) Without Methods
function firstNonRepeat(str) {
for (let i = 0; i < [Link]; i++) {
let repeat = false;
for (let j = 0; j < [Link]; j++) {
if (i !== j && str[i] === str[j]) {
repeat = true;
break;
}
}
if (!repeat) return str[i];
}
return null;
}
[Link](firstNonRepeat("swiss")); // w
18) Find the longest word in a sentence
A) With methods
function longestWord(sentence) {
let words = [Link](" ");
let longest = "";
for (let w of words) {
if ([Link] > [Link]) longest = w;
}
return longest;
}
[Link](longestWord("I love JavaScript programming")); // programming
B) Without methods
function longest(sentence) {
let longestWord = "";
let current = "";
for (let i = 0; i < [Link]; i++) {
let ch = sentence[i];
if (ch !== " ") {
current += ch;
} else {
if ([Link] > [Link]) {
longestWord = current;
}
current = "";
}
}
if ([Link] > [Link]) {
longestWord = current;
}
return longestWord;
}
[Link](longest("I love javascript programming"));
19) Find common elements among 3 arrays
A) With methods
function common3(a, b, c) {
return [Link](x => [Link](x) && [Link](x));
}
[Link](common3([1,2,3], [2,3,4], [3,2,5]));
// [2,3]
B) Without Methods
function common(a, b, c) {
let result = [];
for (let i = 0; i < [Link]; i++) {
let foundInB = false;
for (let j = 0; j < [Link]; j++) {
if (a[i] === b[j]) {
foundInB = true;
break;
}
}
if (!foundInB) continue;
let foundInC = false;
for (let k = 0; k < [Link]; k++) {
if (a[i] === c[k]) {
foundInC = true;
break;
}
}
if (foundInC) result[[Link]] = a[i];
}
return result;
}
[Link](common([1,2,3], [2,3,4], [3,2,5]));
20) Remove falsy values (0, "", null, undefined, NaN, false)
A) With methods
let arr = [0, 1, "", "hello", null, undefined, NaN, 5, false];
let clean = [Link](Boolean);
[Link](clean); // [1, "hello", 5]
B) Without methods
function removeFalsy(arr) {
let result = [];
for (let i = 0; i < [Link]; i++) {
if (arr[i]) {
result[[Link]] = arr[i];
}
}
return result;
}
[Link](removeFalsy([0, "", null, undefined, NaN, false, "hi", 5]));
21) Flatten a nested object (convert to single level)
A) With methods
function flatten(obj, parentKey = "", result = {}) {
for (let key in obj) {
let newKey = parentKey ? parentKey + "." + key : key;
if (typeof obj[key] === "object" && ) {
flatten(obj[key], newKey, result);
} else {
result[newKey] = obj[key];
}
}
return result;
}
[Link](flatten({
a: { b: { c: 10 }, d: 20 },
e: 30
}));
Output
{ "a.b.c": 10, "a.d": 20, e: 30 }
B) Without methods
function flatten(obj, parent = "", result = {}) {
for (let key in obj) {
let newKey = parent ? parent + "." + key : key;
if (typeof obj[key] === "object" && obj[key] !== null
&& ) {
flatten(obj[key], newKey, result);
} else {
result[newKey] = obj[key];
}
}
return result;
}
[Link](flatten({ a:{b:{c:10}, d:20}, e:30 }));
22) Group array of objects by property (groupBy)
A) With methods
function groupBy(arr, key) {
return [Link]((acc, obj) => {
const val = obj[key];
acc[val] = acc[val] || [];
acc[val].push(obj);
return acc;
}, {});
}
let data = [
{ name: "A", category: "fruit" },
{ name: "B", category: "veg" },
{ name: "C", category: "fruit" },
];
[Link](groupBy(data, "category"));
Output
{
fruit: [{name:"A",category:"fruit"}, {name:"C",category:"fruit"}],
veg: [{name:"B",category:"veg"}]
}
B) Without methods
function groupBy(arr, prop) {
let result = {};
for (let i = 0; i < [Link]; i++) {
let key = arr[i][prop];
if (!result[key]) {
result[key] = [];
}
result[key][result[key].length] = arr[i];
}
return result;
}
[Link](groupBy([
{name:"A", category:"fruit"},
{name:"B", category:"veg"},
{name:"C", category:"fruit"}
], "category"));
23) Count vowels & consonants
A) With methods
function countVC(str) {
const vowels = "aeiouAEIOU";
let v = 0, c = 0;
for (let ch of str) {
if (/[a-zA-Z]/.test(ch)) {
if ([Link](ch)) v++;
else c++;
}
}
return { vowels: v, consonants: c };
}
[Link](countVC("Hello World"));
// { vowels: 3, consonants: 7 }
B) Without methods
function countVC(str) {
let vowels = "aeiouAEIOU";
let v = 0, c = 0;
for (let i = 0; i < [Link]; i++) {
let ch = str[i];
// check alphabet manually
if (
(ch >= "A" && ch <= "Z") ||
(ch >= "a" && ch <= "z")
) {
let isVowel = false;
for (let j = 0; j < [Link]; j++) {
if (ch === vowels[j]) {
isVowel = true;
break;
}
}
if (isVowel) v++;
else c++;
}
}
return { vowels: v, consonants: c };
}
[Link](countVC("Hello World"));
24) Rotate array by k steps
A) With methods
function rotate(arr, k) {
k = k % [Link];
return [...[Link](-k), ...[Link](0, -k)];
}
[Link](rotate([1,2,3,4,5], 2));
// [4,5,1,2,3]
B) Without methods
function rotate(arr, k) {
k = k % [Link];
let result = [];
// add last k elements
for (let i = [Link] - k; i < [Link]; i++) {
result[[Link]] = arr[i];
}
// add remaining elements
for (let i = 0; i < [Link] - k; i++) {
result[[Link]] = arr[i];
}
return result;
}
[Link](rotate([1,2,3,4,5], 2));
25) Find intersection WITHOUT using includes()
A) With methods
function intersection(a, b) {
let setb = new Set(b);
let result = [];
for (let x of a) {
if ([Link](x)) [Link](x);
}
return result;
}
[Link](intersection([1,2,3,4], [3,4,5]));
B) Without methods
function intersect(a, b) {
let result = [];
for (let i = 0; i < [Link]; i++) {
for (let j = 0; j < [Link]; j++) {
if (a[i] === b[j]) {
result[[Link]] = a[i];
break;
}
}
}
return result;
}
[Link](intersect([1,2,3,4], [3,4,5]));
26) Deep Clone an Object (WITHOUT [Link]/stringify)
function deepClone(obj) {
if (obj === null || typeof obj !== "object") return obj;
let clone = [Link](obj) ? [] : {};
for (let key in obj) {
clone[key] = deepClone(obj[key]);
}
return clone;
}
const original = { a: 1, b: { c: 2 }, d: [3,4] };
const copy = deepClone(original);
copy.b.c = 99;
[Link](original.b.c); // 2 (NOT affected)
27) Deep Compare Two Objects (Check if equal)
function deepEqual(a, b) {
if (a === b) return true;
if (typeof a !== "object" || typeof b !== "object" || a === null || b ===
null)
return false;
let keysA = [Link](a);
let keysB = [Link](b);
if ([Link] !== [Link]) return false;
for (let key of keysA) {
if (!deepEqual(a[key], b[key])) return false;
}
return true;
}
[Link](deepEqual(
{ a:1, b:{c:2} },
{ a:1, b:{c:2} }
)); // true
28)Convert array of objects → object of arrays
Input:
let arr = [
{ name: "A", age: 20, city: "BLR" },
{ name: "B", age: 25, city: "HYD" },
{ name: "C", age: 30, city: "BLR" }
];
Output:
{
name: ["A", "B", "C"],
age: [20, 25, 30],
city: ["BLR", "HYD", "BLR"]
}
Code:
function convert(arr) {
let result = {};
for (let i = 0; i < [Link]; i++) {
let obj = arr[i];
for (let key in obj) {
if (!result[key]) result[key] = [];
result[key].push(obj[key]);
}
}
return result;
}
[Link](convert(arr));
28) Print duplicate characters from a string
function duplicateChars(str) {
let freq = {};
let duplicates = [];
for (let ch of str) {
freq[ch] = (freq[ch] || 0) + 1;
}
for (let ch in freq) {
if (freq[ch] > 1) [Link](ch);
}
return duplicates;
}
[Link](duplicateChars("javascript"));
// ["a", "v"]
29) Longest Increasing Subsequence
Example
[1, 2, 2, 3, 4, 1] → LIS = [2, 3, 4]
function longestIncreasing(arr) {
let longest = [];
let current = [arr[0]];
for (let i = 1; i < [Link]; i++) {
if (arr[i] > arr[i - 1]) {
[Link](arr[i]);
} else {
if ([Link] > [Link]) longest = current;
current = [arr[i]];
}
}
if ([Link] > [Link]) longest = current;
return longest;
}
[Link](longestIncreasing([1, 2, 2, 3, 4, 1]));
// [2, 3, 4]
